From bab88c68eefc405bce67c32517c51c48025bd540 Mon Sep 17 00:00:00 2001 From: Ozan Alpay Date: Fri, 6 Jul 2018 13:45:38 +0200 Subject: [PATCH 1/4] Docker files created in order to run infer analyze on Linux-Kernel on Docker containers. --- docker/infer-0.13.1/Dockerfile | 49 ++++++++++++++++++++++++++++++++++ docker/infer-0.14.0/Dockerfile | 47 ++++++++++++++++++++++++++++++++ docker/infer-0.15.0/Dockerfile | 46 +++++++++++++++++++++++++++++++ scripts/build-infer-docker.sh | 12 +++++++++ 4 files changed, 154 insertions(+) create mode 100644 docker/infer-0.13.1/Dockerfile create mode 100644 docker/infer-0.14.0/Dockerfile create mode 100644 docker/infer-0.15.0/Dockerfile create mode 100755 scripts/build-infer-docker.sh diff --git a/docker/infer-0.13.1/Dockerfile b/docker/infer-0.13.1/Dockerfile new file mode 100644 index 0000000..4e8416b --- /dev/null +++ b/docker/infer-0.13.1/Dockerfile @@ -0,0 +1,49 @@ +FROM debian:stretch-slim + +LABEL maintainer "Ozan Alpay " + +# mkdir the man/man1 directory due to Debian bug #863199 +RUN apt-get update && \ + mkdir -p /usr/share/man/man1 && \ + apt-get install --yes --no-install-recommends \ + autoconf \ + automake \ + bc \ + bison \ + bsdmainutils \ + ca-certificates \ + cmake \ + clang \ + curl \ + flex \ + git \ + gnupg \ + libc6-dev \ + libelf-dev \ + libsqlite3-dev \ + libssl-dev \ + make \ + opam \ + pkg-config \ + python2.7 \ + wget \ + zlib1g-dev && \ + rm -rf /var/lib/apt/lists/* + +# Download the latest Infer release +RUN INFER_VERSION=v0.13.1; \ + cd /opt && \ + curl -sL \ + https://github.com/facebook/infer/releases/download/${INFER_VERSION}/infer-linux64-${INFER_VERSION}.tar.xz | \ + tar xJ && \ + rm -f /infer && \ + ln -s ${PWD}/infer-linux64-$INFER_VERSION /infer + +# Compile Infer +RUN OCAML_VERSION=4.05.0+flambda; \ + cd /infer && ./build-infer.sh clang --opam-switch $OCAML_VERSION && rm -rf /root/.opam + +# Install Infer +ENV INFER_HOME /infer/infer +ENV PATH ${INFER_HOME}/bin:${PATH} + diff --git a/docker/infer-0.14.0/Dockerfile b/docker/infer-0.14.0/Dockerfile new file mode 100644 index 0000000..405be86 --- /dev/null +++ b/docker/infer-0.14.0/Dockerfile @@ -0,0 +1,47 @@ +FROM debian:stretch-slim + +LABEL maintainer "Ozan Alpay " + +# mkdir the man/man1 directory due to Debian bug #863199 +RUN apt-get update && \ + mkdir -p /usr/share/man/man1 && \ + apt-get install --yes --no-install-recommends \ + autoconf \ + automake \ + bc \ + bison \ + bsdmainutils \ + ca-certificates \ + cmake \ + clang \ + curl \ + flex \ + git \ + gnupg \ + libc6-dev \ + libelf-dev \ + libsqlite3-dev \ + libssl-dev \ + make \ + opam \ + pkg-config \ + python2.7 \ + wget \ + zlib1g-dev && \ + rm -rf /var/lib/apt/lists/* +# Download the latest Infer release +RUN INFER_VERSION=v0.14.0; \ + cd /opt && \ + curl -sL \ + https://github.com/facebook/infer/releases/download/${INFER_VERSION}/infer-linux64-${INFER_VERSION}.tar.xz | \ + tar xJ && \ + rm -f /infer && \ + ln -s ${PWD}/infer-linux64-$INFER_VERSION /infer + +# Compile Infer +RUN OCAML_VERSION=4.06.1+flambda; \ + cd /infer && ./build-infer.sh clang --opam-switch $OCAML_VERSION && rm -rf /root/.opam + +# Install Infer +ENV INFER_HOME /infer/infer +ENV PATH ${INFER_HOME}/bin:${PATH} diff --git a/docker/infer-0.15.0/Dockerfile b/docker/infer-0.15.0/Dockerfile new file mode 100644 index 0000000..76c58d9 --- /dev/null +++ b/docker/infer-0.15.0/Dockerfile @@ -0,0 +1,46 @@ +FROM debian:stretch-slim + +LABEL maintainer "Ozan Alpay " + +# mkdir the man/man1 directory due to Debian bug #863199 +RUN apt-get update && \ + mkdir -p /usr/share/man/man1 && \ + apt-get install --yes --no-install-recommends \ + autoconf \ + automake \ + bc \ + bison \ + bsdmainutils \ + ca-certificates \ + cmake \ + clang \ + curl \ + flex \ + git \ + gnupg \ + libc6-dev \ + libelf-dev \ + libsqlite3-dev \ + libssl-dev \ + make \ + opam \ + pkg-config \ + python2.7 \ + wget \ + zlib1g-dev && \ +rm -rf /var/lib/apt/lists/* + +# Download the latest Infer release +RUN INFER_VERSION=v0.15.0; \ + cd /opt && \ + curl -sL \ + https://github.com/facebook/infer/releases/download/${INFER_VERSION}/infer-linux64-${INFER_VERSION}.tar.xz | \ + tar xJ && \ + rm -f /infer && \ + ln -s ${PWD}/infer-linux64-$INFER_VERSION /infer + + +# Install Infer +ENV INFER_HOME /infer/infer +ENV PATH ${INFER_HOME}/bin:${PATH} + diff --git a/scripts/build-infer-docker.sh b/scripts/build-infer-docker.sh new file mode 100755 index 0000000..b37029e --- /dev/null +++ b/scripts/build-infer-docker.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" +cd "$SCRIPT_DIR/../docker/infer-0.13.1" +DOCKER_NAME="kernel-analysis-infer-0.13.1" +docker build -t $DOCKER_NAME . +cd "../infer-0.14.0" +DOCKER_NAME="kernel-analysis-infer-0.14.0" +docker build -t $DOCKER_NAME . +cd "../infer-0.15.0" +DOCKER_NAME="kernel-analysis-infer-0.15.0" +docker build -t $DOCKER_NAME . From ba877b5b662851588cc5131e90b4893bc78052bc Mon Sep 17 00:00:00 2001 From: Ozan Alpay Date: Wed, 4 Jul 2018 11:23:57 +0200 Subject: [PATCH 2/4] Analyse-kernel.sh script created in order to automatize running different infer versions on varied linux-kernel versions and configurations. Required files prepared and added to /files folder, that required for a successful infer analyze process. InferOnLinuxKernel and InferAnalyseScriptManual documents created to help users. Dockerfiles modified in order to run infer as a user. --- Documentation/InferAnalyseScriptManual.md | 79 + Documentation/InferOnLinuxKernel.md | 139 + docker/infer-0.13.1/Dockerfile | 4 +- docker/infer-0.14.0/Dockerfile | 3 +- docker/infer-0.15.0/Dockerfile | 2 +- scripts/analyse-kernel.sh | 272 + ...acklist-files-from-infer-source-code.patch | 25 + ...et-default-CC-to-Clang-from-Makefile.patch | 25 + scripts/files/0001-exofs.patch | 316 + scripts/files/0001-kasan.patch | 26 + scripts/files/analysisconfig | 5 + scripts/files/infer0131/inferconfig | 1 + scripts/files/infer0140/inferdefconfig | 13 + scripts/files/infer0140/infermaximalyesconfig | 13 + scripts/files/infer0150/inferdefconfig | 13 + scripts/files/infer0150/infermaximalyesconfig | 13 + scripts/files/inferconfig | 1 + scripts/files/v416/maximalyesconfig | 11502 ++++++++++++++++ 18 files changed, 12449 insertions(+), 3 deletions(-) create mode 100644 Documentation/InferAnalyseScriptManual.md create mode 100644 Documentation/InferOnLinuxKernel.md create mode 100755 scripts/analyse-kernel.sh create mode 100644 scripts/files/0001-Blacklist-files-from-infer-source-code.patch create mode 100644 scripts/files/0001-Set-default-CC-to-Clang-from-Makefile.patch create mode 100644 scripts/files/0001-exofs.patch create mode 100644 scripts/files/0001-kasan.patch create mode 100644 scripts/files/analysisconfig create mode 100644 scripts/files/infer0131/inferconfig create mode 100644 scripts/files/infer0140/inferdefconfig create mode 100644 scripts/files/infer0140/infermaximalyesconfig create mode 100644 scripts/files/infer0150/inferdefconfig create mode 100644 scripts/files/infer0150/infermaximalyesconfig create mode 100644 scripts/files/inferconfig create mode 100644 scripts/files/v416/maximalyesconfig diff --git a/Documentation/InferAnalyseScriptManual.md b/Documentation/InferAnalyseScriptManual.md new file mode 100644 index 0000000..dce2555 --- /dev/null +++ b/Documentation/InferAnalyseScriptManual.md @@ -0,0 +1,79 @@ +## Infer Analyse Script ## +In this document you can find how to use [analyse-kernel.sh](../scripts/analyse-kernel.sh), in order to run different infer versions(0.13.1, 0.14.0, 0.15.0) on various kernel versions(v4.15, v4.16) with using kernel-configurations(defconfig, maximalyesconfig) + +## Test System Configuration ## +**Operating-System:** Ubuntu 16.04.4 LTS 64-bit +**Docker-Version:** Docker version 18.03.0-ce, build 0520e24 +### Prerequirements ### +To be able to run ```analyse-kernel.sh``` on your system successfully, please follow these steps: +- Clone this repo +- Install Docker [Tutorial](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-docker-on-ubuntu-16-04) +- Complete Setup instructions [Setup](Setup.md) +- Build Dockerfiles that required for Infer run: ```cd scripts && build-infer-docker.sh``` + +Now you are ready to use ```analyse-kernel.sh```, to understand how to use it and parameter explanations please follow next section. + + +## Analyse-Kernel.sh Parameters ## +### Mandatory Parameters ### +**Kernel Repository Parameter ( -r ):** +Possible values are torvalds, stable and next. +Example: +```./analyse-kernel.sh -r stable``` + +**Kernel Configuration Parameter ( -c ):** +You can either pass a string or a file path for this parameter +We already prepared a maximalyesconfig for Linux-Kernel v4.16 that compiles with clang +You can find it in ```/scripts/files/v416/maximalyesconfig``` +Examples: +```./analyse-kernel.sh -c defconfig``` +```./analyse-kernel.sh -c files/v416/maximalyesconfig``` + +### Optional Parameters ### + +**Compiler Parameter ( -cc ):** +You can pass compiler parameter that will be used for infer capture and infer analyze phases: +Possible values: +Default value: ```clang``` +Example: +```./analyse-kernel.sh -cc clang-6.0``` + +! Be sure that your selected compiler is included in Dockerfile, You may need to modify and build your dockerfiles again, if you select a currently unsupported parameter ! + +**Infer Version Parameter (-infer-version):** +You can select an infer version, in order to use it for infer capture an infer analyze phases: +Possible values: 0.13.1, 0.14.0, 0.15.0 +Default value: 0.14.0 +Example: +```./analyse-kernel.sh -infer-version 0.15.0``` + +**Inferconfig File Path Parameter (-i):** +Since there are some problems about running Infer on Linux-Kernel, we need different inferconfig files to avoid crashes. +We also prepared some inferconfig files according to infer-version and kernel-configuration. +You can find them in ```scripts/files/{infer-version-number}``` +Default value: - +Examples: +```./analyse-kernel.sh -i files/infer0131/inferconfig``` +```./analyse-kernel.sh -i files/infer0150/infermaximalyesconfig``` + +**Analysis File Configuration (--analysisconfig):** +Instead of passing this parameters from command-line, you can provide a custom ```analysisconfig``` as a parameter, and ```./analyse-kernel.sh``` will read that file and set parameters according to file content. +You can find an example analysisconfig at ```scripts/files/analysisconfig``` +!This method is not tested very well, so there may some problems if you use an analysisconfig! +Default value: - +Example: +```./analyse-kernel.sh --analysisconfig files/analysisconfig``` + +**Dont Run Analyze Parameter (--no-analyze):** +Infer Analyze needs a lot of time and computing power. If you don't want to run infer analyze after infer capture finishes, you can call this script with passing --no-analyze as an parameter +Dfeault value: - +Example: +```./analyse-kernel.sh --no-analyze``` + +## Notes ## +To understand why we blacklisted some files or want to know how to build infer from source etc, please see:[Infer-On-Linux-Kernel-Documentation](InferOnLinuxKernel.md) + + + + + diff --git a/Documentation/InferOnLinuxKernel.md b/Documentation/InferOnLinuxKernel.md new file mode 100644 index 0000000..d52f9b8 --- /dev/null +++ b/Documentation/InferOnLinuxKernel.md @@ -0,0 +1,139 @@ +# Installing Infer # +We need to compile and install infer from source code , in order to be able to hack it later. +You can find facebook/infer's source code [here](https://github.com/facebook/infer) or you can use following command: +```git clone https://github.com/facebook/infer.git``` +## My current setup ## +**Host OS:** Ubuntu 64-bit 16.04 +**Kernel Version To Be Checked with Infer:** Linux 4.15 Stable +**Kernel Compilation Configuration:** defconfig +**Infer fork with HEAD commit:** 4799fb6b8226("[racerd] skeleton for testing access path stability") +**Clang:** clang version 3.8.0-2ubuntu4 (tags/RELEASE_380/final) + +## Prerequisites ## +You can find latest prerequisites for your operating system for building infer [here](https://github.com/facebook/infer/blob/master/INSTALL.md). + +## Dependency Problems I have encountered during Compilation ## +Even though I have installed this prerequisites, I had some problems with: +- sqlite3.4.3.2 ```opam depext sqlite3.4.3.2``` +- camlzip.1.0.7 ```opam depext camlzip.1.07``` +- cmake ```sudo apt-get install cmake``` + +## Compile Infer ## +After cloning infer to your computer, and installing all required files. You can start compiling with infer with ```./build_infer.sh``` command. + +## Install Infer ## +After infer build finished, you can install it with using ```make install``` command. Now you are able to run infer from your command line. + +## Packages Needed to build Linux Kernel ## +You need some extra packages, to become able to compile linux 4.15 from source code. In my case they were: +- libelf-dev ```sudo apt-get install libelf-dev``` +- libssl-dev ```sudo apt-get install libssl-dev``` + +## Prepare to Run Infer on Linux Kernel ## + +Now you can : +- Compile Linux 4.15 without getting any errors +- Call infer via command line + +To use infer with linux-kernel, first you must capture Linux 4.15 source code with ```infer capture -- make``` command , and then analyse infer-out folder with ```infer analyse```. However with current setup Infer can't capture Linux 4.15 source code. To be able to get an output you need to make some modifications. I explained required modifications below, with two solutions for each of them. + +## Modify Infer to mark problematic directories blacklisted ## +First of all, we need to mark some linux directories as blacklisted, to avoid compilation errors during ```infer capture``` phase. +To do this you have two options and I prefer second option. + +### Modify Infer source code ### +You can directly modify your infer fork, and mark directories as blacklisted with help of [patch](../scripts/files/0001-Blacklist-files-from-infer-source-code.patch), please don't forget to modify file paths which passed as parameter before applying it. + +### Add an inferconfig file ### + +Thanks to [@Evan Zhao](https://github.com/Tacinight) we have much simplier and flexible way to solve this problem. You can create an ```.inferconfig``` file in linux-kernel root directory and then mark problematics directories as blacklisted as following: (Please do not forget replace file paths with absolute paths.) +You can do it via execute ```echo $PWD``` in linux-stable root directory. Then delete first ``` \ ``` and replace ```[linux-stable-absolute-path]```'s with rest of string. +Example : +```"home/ozan/linux-stable/stable/linux-stable/mm"``` + +``` +{ +"skip-analysis-in-path": +[ +"[linux-stable-absolute-path]/arch/x86/entry/vdso", +"[linux-stable-absolute-path]/arch/x86/kernel", +"[linux-stable-absolute-path]/arch/x86/mm", +"[linux-stable-absolute-path]/arch/x86/boot", +"[linux-stable-absolute-path]/drivers/acpi", +"[linux-stable-absolute-path]/fs", +"[linux-stable-absolute-path]/kernel/bpf", +"[linux-stable-absolute-path]/mm", +"[linux-stable-absolute-path]/net/mac80211" +] +} +``` +You can find why you should these files into the blacklist; and if you dont them, add what kind of error they create at : [Blacklisted-Files-Explanations](../infer/Documentation/BlacklistExplanation) folder. + + +## Set default CC to clang for linux-kernel compilation ## + +After that, we need to set clang as a default compiler when we start infer capture phase with ```infer capture -- make``` command. Otherwise Linux Makefiles uses gcc flags, and since infer compiles with clang, we need clang compiler flags for a successfull compilation. +For this issue again we have two different solutions, and I prefer second one. + +### GCC Hack ### +It is a serious hack, which may breaks your other builds. Basically we just point ```gcc``` command to clang compiler. If you want to use this method I strongly encourage you to take a backup. + +- Open terminal +- ```cd /usr/bin``` +- ```sudo ln -sf clang gcc``` + +### Patch file for Linux ### + +Another way is applying [this patch](../scripts/files/0001-Set-default-CC-to-Clang-from-Makefile.patch), to top of linux 4.15. After that you won't have any problems about compiler flags. + +## Run Infer on Linux Kernel ## + +After all this configurations, you are ready to compile linux kernel with infer: + +- Go to Linux-kernel root directory. +- ```make clean && make defconfig``` +- ```infer capture -- make``` +After ```infer capture -- make``` completed you can observe infer creates a directory named infer-out. So now we should execute```infer analyze``` command and get output from infer-out folder. But it may take a lot of time and need huge computing power. +- Again from linux-kernel root directory, +- Execute ```infer analyze``` +- Look for results with ```cat /infer-out/bugs.txt``` +## Common problems ## + +### Base_64.S problem ### +after executing ```infer capture -- make``` command if you get error messages as: +``` :4:8: error: expected absolute expression + .skip -(((144f-143f)-(141b-140b)) > 0) * ((144f-143f)-(141b-140b)),0x90 + ^ +:4:8: error: expected absolute expression + .skip -(((144f-143f)-(141b-140b)) > 0) * ((144f-143f)-(141b-140b)),0x90 + ^ +:4:8: error: expected absolute expression + .skip -(((144f-143f)-(141b-140b)) > 0) * ((144f-143f)-(141b-140b)),0x90 + ^ +``` +during compilation of base64.S file, that means linux makefile still using wrong flags during compilation, I suggest you to look at **Set default CC to clang for linux-kernel compilation** section again. To avoid that kind of errors, Makefiles adds different compiler flags according to selected compiler. For example in this case we need -no-integrated-as flag to avoid using clang's integrated assembler. +### objcopy: 'arch/x86/entry/vdso/vdso64.so.dbg': No such file problem ### +If you get +``` +arch/x86/entry/vdso/vclock_gettime.o: In function `__vdso_time': +vclock_gettime.c:(.text+0x667): undefined reference to `memcpy' +arch/x86/entry/vdso/vclock_gettime.o: In function `gtod_read_begin': +vclock_gettime.c:(.text+0x734): undefined reference to `memcpy' +Error: the following clang command did not run successfully: +``` +error during ```infer capture``` phase, you should re-do mark problematic directories blacklisted step. Maybe you can check if your directory paths are written correctly. Please not that directories shouldn't start with ``` \ ``` +**Invalid:** +```"/home/ozan/linux-stable/stable/linux-stable/mm"``` +**Valid:** +```"home/ozan/linux-stable/stable/linux-stable/mm"``` + + +## Using Docker for Kernel-Analysis with Infer ## + +You can do all this process , with using Docker. It is the most basic and straightforward way to run infer on Linux Kernel. +To do this, please follow the instructions below. +- Clone repository ```git clone https://github.com/bulwahn/linux-kernel-analysis.git``` +- Follow [Setup](Setup.md) instructions, clone at least linux-stable to your computer and be sure that you set```KERNEL_SRC_BASE``` +- Go to scripts directory ```cd ~/linux-kernel-analysis/scripts``` +- Run ```./build_infer_docker.sh``` and build docker file. +- Run ```./analyse_kernel.sh```, That script completes all required steps that described above, then will run ```infer capture -- make``` on linux-kernel. You can call it with various parameters. Please see detailed instructions about ```analyse_kernel.sh``` script at (manual-for-infer-analyse-script)[InferAnalyseScriptManual.md] diff --git a/docker/infer-0.13.1/Dockerfile b/docker/infer-0.13.1/Dockerfile index 4e8416b..c49a488 100644 --- a/docker/infer-0.13.1/Dockerfile +++ b/docker/infer-0.13.1/Dockerfile @@ -37,7 +37,8 @@ RUN INFER_VERSION=v0.13.1; \ https://github.com/facebook/infer/releases/download/${INFER_VERSION}/infer-linux64-${INFER_VERSION}.tar.xz | \ tar xJ && \ rm -f /infer && \ - ln -s ${PWD}/infer-linux64-$INFER_VERSION /infer + ln -s ${PWD}/infer-linux64-$INFER_VERSION /infer && \ + ln -s ${PWD}/infer-linux64-$INFER_VERSION/infer/bin/infer /usr/local/bin/infer # Compile Infer RUN OCAML_VERSION=4.05.0+flambda; \ @@ -47,3 +48,4 @@ RUN OCAML_VERSION=4.05.0+flambda; \ ENV INFER_HOME /infer/infer ENV PATH ${INFER_HOME}/bin:${PATH} + diff --git a/docker/infer-0.14.0/Dockerfile b/docker/infer-0.14.0/Dockerfile index 405be86..13b2cd9 100644 --- a/docker/infer-0.14.0/Dockerfile +++ b/docker/infer-0.14.0/Dockerfile @@ -36,7 +36,8 @@ RUN INFER_VERSION=v0.14.0; \ https://github.com/facebook/infer/releases/download/${INFER_VERSION}/infer-linux64-${INFER_VERSION}.tar.xz | \ tar xJ && \ rm -f /infer && \ - ln -s ${PWD}/infer-linux64-$INFER_VERSION /infer + ln -s ${PWD}/infer-linux64-$INFER_VERSION /infer && \ + ln -s ${PWD}/infer-linux64-$INFER_VERSION/infer/bin/infer /usr/local/bin/infer # Compile Infer RUN OCAML_VERSION=4.06.1+flambda; \ diff --git a/docker/infer-0.15.0/Dockerfile b/docker/infer-0.15.0/Dockerfile index 76c58d9..ef34de1 100644 --- a/docker/infer-0.15.0/Dockerfile +++ b/docker/infer-0.15.0/Dockerfile @@ -43,4 +43,4 @@ RUN INFER_VERSION=v0.15.0; \ # Install Infer ENV INFER_HOME /infer/infer ENV PATH ${INFER_HOME}/bin:${PATH} - +RUN ln -s /infer/bin/infer /usr/local/bin/infer diff --git a/scripts/analyse-kernel.sh b/scripts/analyse-kernel.sh new file mode 100755 index 0000000..2dd25f6 --- /dev/null +++ b/scripts/analyse-kernel.sh @@ -0,0 +1,272 @@ +#!/bin/bash + +help() { + echo "Usage: $0 [-r] [-c]" + echo "Or you can directly provide a analysisconfig file with [--analysisconfig]" + echo " -r, kernel-repository" + echo " -c, kernel-configuration , provide a kernel-config or configfile location" # Add extra explanation,after be sure about works well. + echo " -cc, compiler" #Maybe a better name? + echo " -infer-version, select a infer version to run, default value is 0.14.0" + echo " optional -i, inferconfig-file location" + echo " optional --analysisconfig, analysisconfig file for build" + echo " optional --no-analyze, don't run infer analyze after infer capture completed" + echo "Example: $0 -r stable -c defconfig -i [absolute-path-to-file]" + echo "Example with analysisconfig file: $0 --configfile files/analysisconfig" + echo "$0 --configfile [full-path-to-file] example: ./analyse-kernel --analysisconfig /home/x/y/z/analysisconfig" + echo "Before use it, please be sure you set KERNEL_SRC_BASE variable correctly" + exit 1 +} +set_kernel_repository() { + if [ ! -z "$1" ]; then + case $1 in + torvalds | stable | next ) + if [ "$1" == "torvalds" ]; then + KERNEL_REPOSITORY="$KERNEL_SRC_BASE/torvalds/linux" + elif [ "$1" == "stable" ]; then + KERNEL_REPOSITORY="$KERNEL_SRC_BASE/stable/linux-stable" + elif [ "$1" == "next" ]; then + KERNEL_REPOSITORY="$KERNEL_SRC_BASE/next/linux-next" + else #Look for file repository + echo "Invalid Kernel Repository Parameter!" + echo "You can pass -> torvalds | stable | next" + exit 1; + fi + esac + else + echo "You provided an empty KERNEL_REPOSITORY parameter!" + echo "Acceptable parameters are = torvalds | stable | next" + exit 1; + fi +} +set_compiler() { #TODO after checking it works well, add some extra warnings for user + COMPILER="$1" +} +set_kernel_config() { + case $1 in + allnoconfig | allmodconfig | allyesconfig | defconfig | randconfig ) + KERNEL_CONFIG="$1" + ;; + *) + if [ -f "$1" ]; then + cp "$1" "$KERNEL_REPOSITORY/.config" + elif [ -f "$KERNEL_REPOSITORY/.config" ]; then #Use .config file, that already exists in repository + echo "Script will use .config file, that already exists in $KERNEL_REPOSITORY" + else + echo "You didn't provide any kernel-configuration, and there isn't any .config file in repository" + echo "Valid Parameters are = allnoconfig | allmodconfig | allyesconfig | defconfig | randconfig" + echo "OR you can give a config file directly" + exit 1; + fi + esac +} +set_inferconfig_file_location() { + if [ -f "$SCRIPTS_DIRECTORY/$1" ]; then + INFERCONFIG_LOCATION="$SCRIPTS_DIRECTORY/$1" + elif [ -f "$1" ]; then + INFERCONFIG_LOCATION="$1" + fi +} +set_scripts_directory() { + SCRIPTS_DIRECTORY="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" +} +set_analyze() { + DONT_RUN_ANALYZE=1 +} +set_default_compiler_to_clang() { + COMPILER="clang" +} +set_infer_version() { + echo "set_infer_version called, parameter is $1" + case $1 in + 0.13.1 | 0.14.0 | 0.15.0 ) #TODO 0.15.0 Doesn't work properly, look at it more detailed! + DOCKER_INFER_VERSION="$1" + ;; + *) + echo "You have selected an invalid infer version, script will run with 0.14.0" + esac +} +finalize_command() { + if [ "$DONT_RUN_ANALYZE" == "1" ]; then + RUN_COMMAND=${RUN_COMMAND/" && infer analyze"} + fi + if [ -z "$KERNEL_CONFIG" ]; then ## User didn't provide any kernel-configuration parameter + echo "You didnt provided a Kernel Configuration Parameter!" + echo "Script will use .config file, that inside $KERNEL_REPOSITORY" + RUN_COMMAND=${RUN_COMMAND/"make &&"} + fi + if [ -z "$COMPILER" ]; then ##User didn't pass any compiler parameter + RUN_COMMAND=${RUN_COMMAND//"CC="} + RUN_COMMAND=${RUN_COMMAND//"HOST"} + fi + echo "RUN COMMAND is = $RUN_COMMAND" +} +finalize_docker_name() { + if [ ! -z "$DOCKER_INFER_VERSION" ]; then + DOCKER_NAME+="-infer-$DOCKER_INFER_VERSION" + else #Use infer 0.14.0 by default + DOCKER_NAME+="-infer-0.14.0" + DOCKER_INFER_VERSION="0.14.0" + fi + echo "DOCKER_NAME is = $DOCKER_NAME" +} +read_and_set_variables_from_analysisconfig() { + if [ -f "$1" ]; then + source $1 + else + echo "Couldn't read analysisconfig file!" + exit 1; + fi +} +check_kernel_src_base_valid() { + if [ -z "$KERNEL_SRC_BASE" ]; then + echo "Please set KERNEL_SRC_BASE first" + help + exit 1 + elif [ ! -d "$KERNEL_SRC_BASE" ]; then + echo "KERNEL_SRC_BASE does not point to a directory" + help + exit 1 + fi +} +check_kernel_repository_valid() { + if [ -z "$KERNEL_REPOSITORY" ]; then + echo "You must provide a target kernel repository" + echo "Valid parameters are = torvalds | stable | next" + exit 1; + elif [ ! -d "$KERNEL_REPOSITORY" ]; then # Check KERNEL_REPOSITORY is a directory or not + set_kernel_repository "$KERNEL_REPOSITORY" + fi +} +check_kernel_configuration_valid() { + if [ -z "$KERNEL_CONFIG" ]; then # Check KERNEL_CONFIG variable is set + if [ ! -f "$KERNEL_REPOSITORY/.config" ]; then + echo "You must provide a valid kernel configuration keyword or provide a kernel-configuration file" + echo "Valid Parameters are = allnoconfig | allmodconfig | allyesconfig | defconfig | randconfig" + exit 1; + fi + fi +} +check_inferconfig_exists() { + if [ -f "$INFERCONFIG_LOCATION" ]; then # Highest priority is parameter + cp "$INFERCONFIG_LOCATION" "$KERNEL_REPOSITORY/.inferconfig" + elif [ -f "$SCRIPTS_DIRECTORY/$INFERCONFIG_LOCATION" ]; then #Second priority is analysisconfig file + cp "$SCRIPTS_DIRECTORY/$INFERCONFIG_LOCATION" "$KERNEL_REPOSITORY/.inferconfig" + elif [ -f "$KERNEL_REPOSITORY/.inferconfig" ]; then #If still we couldn't a valid inferconfig file, but there is a .inferconfig in source-repository use it instead of raising an error + echo "Script will use .inferconfig file, that already exists in $KERNEL_REPOSITORY" + else + echo "You should provide a .inferconfig file in the root of linux-source repository" + echo "Or you must provide a valid inferconfig file path" + exit 1; + fi +} +can_checkout_successfully() { + CHECKOUT_RESULT=$(git checkout "$KERNEL_HEAD_SHA" 2>&1 | grep "error") + if [ -n "$CHECKOUT_RESULT" ]; then #Dont force to anything just raise an error to avoid any previous work-loss + echo "Failed to checkout to $KERNEL_HEAD_SHA successfull successfully" + echo "Please check your linux source directory!" + exit 1; + fi +} +does_user_need_help() { + if [[ "$1" == "-h" || "$1" == "--help" ]]; then + help + exit 0 + fi +} +apply_patches_if_needed() { + KERNEL_VERSION=$(git describe --abbrev=0 --tags) + TAG=${KERNEL_VERSION:0:5} + echo "KERNEL TAG is = $TAG" + if [ "$TAG" = "v4.16" ]; then + echo "Applying Patches!" + apply_exofs_patch + apply_v014_kasan_patch + APPLIED=1 + else + APPLIED=0 + fi +} + + +revert_patches_if_applied() { + if [ $APPLIED -eq 1 ]; then + revert_exofs_patch + revert_v014_kasan_patch + fi +} +apply_exofs_patch() { + APPLY_RESULT=$(git apply "$SCRIPTS_DIRECTORY/files/0001-exofs.patch" 2>&1 ) + if [ -n "$APPLY_RESULT" ]; then + echo "$APPLY_RESULT" + echo "Failed to Apply Exofs Fix patch." + echo "Please check your linux source directory" + exit 1; + fi +} +apply_v014_kasan_patch() { + APPLY_RESULT=$(git apply "$SCRIPTS_DIRECTORY/files/0001-kasan.patch" 2>&1 ) + if [ -n "$APPLY_RESULT" ]; then + echo "$APPLY_RESULT" + echo "Failed to Apply Kasan Fix patch." + echo "Please check your linux source directory" + exit 1; + fi +} +revert_exofs_patch() { + git apply -R "$SCRIPTS_DIRECTORY/files/0001-exofs.patch" +} +revert_v014_kasan_patch() { + git apply -R "$SCRIPTS_DIRECTORY/files/0001-kasan.patch" +} +set_user_and_group_infos() { +USER_ID=$(id -u) +GROUP_ID=$(id -g) +USER_NAME=$(whoami) +GROUP_NAME=$(id -g -n $USER_NAME) +} +## MAIN ## +# Check KERNEL_SRC_BASE +check_kernel_src_base_valid +set_scripts_directory +set_default_compiler_to_clang +does_user_need_help "$1" +DOCKER_NAME="kernel-analysis" +# Get Parameters, validate them, assign them variables. +while [[ "$#" > 0 ]]; do case $1 in + -r) set_kernel_repository "$2"; shift; shift;; + -c) set_kernel_config "$2"; shift; shift;; + -cc) set_compiler "$2"; shift; shift;; + -i) set_inferconfig_file_location "$2"; shift; shift;; + -infer-version) set_infer_version "$2"; shift; shift;; + --analysisconfig) read_and_set_variables_from_analysisconfig "$2"; shift; shift;; + --no-analyze) set_analyze "$2"; shift; shift;; + *) help; shift; shift; exit 1;; +esac; done +set_user_and_group_infos +RUN_COMMAND="cd linux && \ + groupadd --gid $GROUP_ID $GROUP_NAME && \ + adduser --uid $USER_ID --gid $GROUP_ID --disabled-password --no-create-home --gecos '' $USER_NAME && \ + su -p $USER_NAME -c 'make clean CC="$COMPILER" HOSTCC="$COMPILER" && make "$KERNEL_CONFIG" && infer capture -- make CC="$COMPILER" HOSTCC="$COMPILER" -j32 && infer analyze --jobs 1 && make clean CC="$COMPILER" HOSTCC="$COMPILER"'" +# Check KERNEL_REPOSITORY variable is set +check_kernel_repository_valid +check_kernel_configuration_valid +check_inferconfig_exists +finalize_command +finalize_docker_name +cd $KERNEL_REPOSITORY +if [ ! -z "$KERNEL_HEAD_SHA" ]; then + can_checkout_successfully +fi +apply_patches_if_needed +#if [ ! "$DOCKER_INFER_VERSION" = "0.13.1" ]; then + #apply_exofs_patch + #apply_v014_kasan_patch +#fi +docker run -v "$KERNEL_REPOSITORY:/linux/" \ + --interactive --tty $DOCKER_NAME \ + /bin/sh -c "infer --version && $RUN_COMMAND" +revert_patches_if_applied +#if [ ! "$DOCKER_INFER_VERSION" = "0.13.1" ]; then + #revert_exofs_patch + #revert_v014_kasan_patch +#fi diff --git a/scripts/files/0001-Blacklist-files-from-infer-source-code.patch b/scripts/files/0001-Blacklist-files-from-infer-source-code.patch new file mode 100644 index 0000000..0d0850f --- /dev/null +++ b/scripts/files/0001-Blacklist-files-from-infer-source-code.patch @@ -0,0 +1,25 @@ +From 5fd5327a22e9269493136e9d7599c9d4cafc2b80 Mon Sep 17 00:00:00 2001 +From: Ozan Alpay +Date: Thu, 5 Apr 2018 14:47:05 +0200 +Subject: [PATCH] Blacklist files from infer source-code + +--- + infer/src/clang/cLocation.ml | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/infer/src/clang/cLocation.ml b/infer/src/clang/cLocation.ml +index 6b0d9e8..01e9a51 100644 +--- a/infer/src/clang/cLocation.ml ++++ b/infer/src/clang/cLocation.ml +@@ -82,7 +82,7 @@ let should_translate_lib trans_unit_ctx source_range decl_trans_context ~transla + + + let is_file_blacklisted file = +- let paths = Config.skip_analysis_in_path in ++ let paths = ["home/ozan/linux-stable/stable/linux-stable/arch/x86";"home/ozan/linux-stable/stable/linux-stable/arch";"home/ozan/linux-stable/stable/linux-stable/mm";"home/ozan/linux-stable/stable/linux-stable/drivers/acpi";"home/ozan/linux-stable/stable/linux-stable/fs";"home/ozan/linux-stable/stable/linux-stable/kernel/bpf";"home/ozan/linux-stable/stable/linux-stable/net/mac80211"] in + let is_file_blacklisted = + List.exists ~f:(fun path -> Str.string_match (Str.regexp ("^.*/" ^ path)) file 0) paths + in +-- +2.7.4 + diff --git a/scripts/files/0001-Set-default-CC-to-Clang-from-Makefile.patch b/scripts/files/0001-Set-default-CC-to-Clang-from-Makefile.patch new file mode 100644 index 0000000..eb432ec --- /dev/null +++ b/scripts/files/0001-Set-default-CC-to-Clang-from-Makefile.patch @@ -0,0 +1,25 @@ +From d2b7e0598cb6c44fbdffcd2ac70f18f77b5a522f Mon Sep 17 00:00:00 2001 +From: Ozan Alpay +Date: Thu, 5 Apr 2018 11:17:55 +0200 +Subject: [PATCH] Set default CC to Clang from Makefile + +--- + Makefile | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/Makefile b/Makefile +index c8b8e90..148fdc2 100644 +--- a/Makefile ++++ b/Makefile +@@ -14,7 +14,8 @@ NAME = Fearless Coyote + # That's our default target when none is given on the command line + PHONY := _all + _all: +- ++override CC=clang ++override HOSTCC=clang + # o Do not use make's built-in rules and variables + # (this increases performance and avoids hard-to-debug behaviour); + # o Look for make include files relative to root of kernel src +-- +2.7.4 diff --git a/scripts/files/0001-exofs.patch b/scripts/files/0001-exofs.patch new file mode 100644 index 0000000..2ca54ca --- /dev/null +++ b/scripts/files/0001-exofs.patch @@ -0,0 +1,316 @@ +From fb02fe0a29282d755276da23a516a9cfb9d89e9f Mon Sep 17 00:00:00 2001 +From: Kees Cook +Date: Fri, 4 May 2018 09:06:37 +1000 +Subject: [PATCH 1/7] exofs: avoid VLA in structures + +On the quest to remove all VLAs from the kernel[1] this adjusts several +cases where allocation is made after an array of structures that points +back into the allocation. The allocations are changed to perform explicit +calculations instead of using a Variable Length Array in a structure. +Additionally, this lets Clang compile this code now, since Clang does not +support VLAIS[2]. + +[1] https://lkml.kernel.org/r/CA+55aFzCG-zNmZwX4A2FQpadafLfEzK6CC=qPXydAacU1RqZWA@mail.gmail.com +[2] https://lkml.kernel.org/r/CA+55aFy6h1c3_rP_bXFedsTXzwW+9Q9MfJaW7GUmMBrAp-fJ9A@mail.gmail.com + +Link: http://lkml.kernel.org/r/20180327203904.GA1151@beast +Signed-off-by: Kees Cook +Reviewed-by: Nick Desaulniers +Cc: Boaz Harrosh +Signed-off-by: Andrew Morton +Signed-off-by: Stephen Rothwell +--- + fs/exofs/ore.c | 84 +++++++++++++++++++++++++++++++---------------------- + fs/exofs/ore_raid.c | 73 ++++++++++++++++++++++++++++++++++------------ + fs/exofs/super.c | 23 +++++++-------- + 3 files changed, 114 insertions(+), 66 deletions(-) + +diff --git a/fs/exofs/ore.c b/fs/exofs/ore.c +index 3c6a9c1..cfa862e 100644 +--- a/fs/exofs/ore.c ++++ b/fs/exofs/ore.c +@@ -146,68 +146,82 @@ int _ore_get_io_state(struct ore_layout *layout, + struct ore_io_state **pios) + { + struct ore_io_state *ios; +- struct page **pages; +- struct osd_sg_entry *sgilist; ++ size_t size_ios, size_extra, size_total; ++ void *ios_extra; ++ ++ /* ++ * The desired layout looks like this, with the extra_allocation ++ * items pointed at from fields within ios or per_dev: ++ + struct __alloc_all_io_state { + struct ore_io_state ios; + struct ore_per_dev_state per_dev[numdevs]; + union { + struct osd_sg_entry sglist[sgs_per_dev * numdevs]; + struct page *pages[num_par_pages]; +- }; +- } *_aios; +- +- if (likely(sizeof(*_aios) <= PAGE_SIZE)) { +- _aios = kzalloc(sizeof(*_aios), GFP_KERNEL); +- if (unlikely(!_aios)) { +- ORE_DBGMSG("Failed kzalloc bytes=%zd\n", +- sizeof(*_aios)); ++ } extra_allocation; ++ } whole_allocation; ++ ++ */ ++ ++ /* This should never happen, so abort early if it ever does. */ ++ if (sgs_per_dev && num_par_pages) { ++ ORE_DBGMSG("Tried to use both pages and sglist\n"); ++ *pios = NULL; ++ return -EINVAL; ++ } ++ ++ if (numdevs > (INT_MAX - sizeof(*ios)) / ++ sizeof(struct ore_per_dev_state)) ++ return -ENOMEM; ++ size_ios = sizeof(*ios) + sizeof(struct ore_per_dev_state) * numdevs; ++ ++ if (sgs_per_dev * numdevs > INT_MAX / sizeof(struct osd_sg_entry)) ++ return -ENOMEM; ++ if (num_par_pages > INT_MAX / sizeof(struct page *)) ++ return -ENOMEM; ++ size_extra = max(sizeof(struct osd_sg_entry) * (sgs_per_dev * numdevs), ++ sizeof(struct page *) * num_par_pages); ++ ++ size_total = size_ios + size_extra; ++ ++ if (likely(size_total <= PAGE_SIZE)) { ++ ios = kzalloc(size_total, GFP_KERNEL); ++ if (unlikely(!ios)) { ++ ORE_DBGMSG("Failed kzalloc bytes=%zd\n", size_total); + *pios = NULL; + return -ENOMEM; + } +- pages = num_par_pages ? _aios->pages : NULL; +- sgilist = sgs_per_dev ? _aios->sglist : NULL; +- ios = &_aios->ios; ++ ios_extra = (char *)ios + size_ios; + } else { +- struct __alloc_small_io_state { +- struct ore_io_state ios; +- struct ore_per_dev_state per_dev[numdevs]; +- } *_aio_small; +- union __extra_part { +- struct osd_sg_entry sglist[sgs_per_dev * numdevs]; +- struct page *pages[num_par_pages]; +- } *extra_part; +- +- _aio_small = kzalloc(sizeof(*_aio_small), GFP_KERNEL); +- if (unlikely(!_aio_small)) { ++ ios = kzalloc(size_ios, GFP_KERNEL); ++ if (unlikely(!ios)) { + ORE_DBGMSG("Failed alloc first part bytes=%zd\n", +- sizeof(*_aio_small)); ++ size_ios); + *pios = NULL; + return -ENOMEM; + } +- extra_part = kzalloc(sizeof(*extra_part), GFP_KERNEL); +- if (unlikely(!extra_part)) { ++ ios_extra = kzalloc(size_extra, GFP_KERNEL); ++ if (unlikely(!ios_extra)) { + ORE_DBGMSG("Failed alloc second part bytes=%zd\n", +- sizeof(*extra_part)); +- kfree(_aio_small); ++ size_extra); ++ kfree(ios); + *pios = NULL; + return -ENOMEM; + } + +- pages = num_par_pages ? extra_part->pages : NULL; +- sgilist = sgs_per_dev ? extra_part->sglist : NULL; + /* In this case the per_dev[0].sgilist holds the pointer to + * be freed + */ +- ios = &_aio_small->ios; + ios->extra_part_alloc = true; + } + +- if (pages) { +- ios->parity_pages = pages; ++ if (num_par_pages) { ++ ios->parity_pages = ios_extra; + ios->max_par_pages = num_par_pages; + } +- if (sgilist) { ++ if (sgs_per_dev) { ++ struct osd_sg_entry *sgilist = ios_extra; + unsigned d; + + for (d = 0; d < numdevs; ++d) { +diff --git a/fs/exofs/ore_raid.c b/fs/exofs/ore_raid.c +index 27cbdb6..659129d 100644 +--- a/fs/exofs/ore_raid.c ++++ b/fs/exofs/ore_raid.c +@@ -71,6 +71,11 @@ static int _sp2d_alloc(unsigned pages_in_unit, unsigned group_width, + { + struct __stripe_pages_2d *sp2d; + unsigned data_devs = group_width - parity; ++ ++ /* ++ * Desired allocation layout is, though when larger than PAGE_SIZE, ++ * each struct __alloc_1p_arrays is separately allocated: ++ + struct _alloc_all_bytes { + struct __alloc_stripe_pages_2d { + struct __stripe_pages_2d sp2d; +@@ -82,55 +87,85 @@ static int _sp2d_alloc(unsigned pages_in_unit, unsigned group_width, + char page_is_read[data_devs]; + } __a1pa[pages_in_unit]; + } *_aab; ++ + struct __alloc_1p_arrays *__a1pa; + struct __alloc_1p_arrays *__a1pa_end; +- const unsigned sizeof__a1pa = sizeof(_aab->__a1pa[0]); ++ ++ */ ++ ++ char *__a1pa; ++ char *__a1pa_end; ++ ++ const size_t sizeof_stripe_pages_2d = ++ sizeof(struct __stripe_pages_2d) + ++ sizeof(struct __1_page_stripe) * pages_in_unit; ++ const size_t sizeof__a1pa = ++ ALIGN(sizeof(struct page *) * (2 * group_width) + data_devs, ++ sizeof(void *)); ++ const size_t sizeof__a1pa_arrays = sizeof__a1pa * pages_in_unit; ++ const size_t alloc_total = sizeof_stripe_pages_2d + ++ sizeof__a1pa_arrays; ++ + unsigned num_a1pa, alloc_size, i; + + /* FIXME: check these numbers in ore_verify_layout */ +- BUG_ON(sizeof(_aab->__asp2d) > PAGE_SIZE); ++ BUG_ON(sizeof_stripe_pages_2d > PAGE_SIZE); + BUG_ON(sizeof__a1pa > PAGE_SIZE); + +- if (sizeof(*_aab) > PAGE_SIZE) { +- num_a1pa = (PAGE_SIZE - sizeof(_aab->__asp2d)) / sizeof__a1pa; +- alloc_size = sizeof(_aab->__asp2d) + sizeof__a1pa * num_a1pa; ++ /* ++ * If alloc_total would be larger than PAGE_SIZE, only allocate ++ * as many a1pa items as would fill the rest of the page, instead ++ * of the full pages_in_unit count. ++ */ ++ if (alloc_total > PAGE_SIZE) { ++ num_a1pa = (PAGE_SIZE - sizeof_stripe_pages_2d) / sizeof__a1pa; ++ alloc_size = sizeof_stripe_pages_2d + sizeof__a1pa * num_a1pa; + } else { + num_a1pa = pages_in_unit; +- alloc_size = sizeof(*_aab); ++ alloc_size = alloc_total; + } + +- _aab = kzalloc(alloc_size, GFP_KERNEL); +- if (unlikely(!_aab)) { ++ *psp2d = sp2d = kzalloc(alloc_size, GFP_KERNEL); ++ if (unlikely(!sp2d)) { + ORE_DBGMSG("!! Failed to alloc sp2d size=%d\n", alloc_size); + return -ENOMEM; + } ++ /* From here Just call _sp2d_free */ + +- sp2d = &_aab->__asp2d.sp2d; +- *psp2d = sp2d; /* From here Just call _sp2d_free */ +- +- __a1pa = _aab->__a1pa; +- __a1pa_end = __a1pa + num_a1pa; ++ /* Find start of a1pa area. */ ++ __a1pa = (char *)sp2d + sizeof_stripe_pages_2d; ++ /* Find end of the _allocated_ a1pa area. */ ++ __a1pa_end = __a1pa + alloc_size; + ++ /* Allocate additionally needed a1pa items in PAGE_SIZE chunks. */ + for (i = 0; i < pages_in_unit; ++i) { + if (unlikely(__a1pa >= __a1pa_end)) { + num_a1pa = min_t(unsigned, PAGE_SIZE / sizeof__a1pa, + pages_in_unit - i); ++ alloc_size = sizeof__a1pa * num_a1pa; + +- __a1pa = kcalloc(num_a1pa, sizeof__a1pa, GFP_KERNEL); ++ __a1pa = kzalloc(alloc_size, GFP_KERNEL); + if (unlikely(!__a1pa)) { + ORE_DBGMSG("!! Failed to _alloc_1p_arrays=%d\n", + num_a1pa); + return -ENOMEM; + } +- __a1pa_end = __a1pa + num_a1pa; ++ __a1pa_end = __a1pa + alloc_size; + /* First *pages is marked for kfree of the buffer */ + sp2d->_1p_stripes[i].alloc = true; + } + +- sp2d->_1p_stripes[i].pages = __a1pa->pages; +- sp2d->_1p_stripes[i].scribble = __a1pa->scribble ; +- sp2d->_1p_stripes[i].page_is_read = __a1pa->page_is_read; +- ++__a1pa; ++ /* ++ * Attach all _lp_stripes pointers to the allocation for ++ * it which was either part of the original PAGE_SIZE ++ * allocation or the subsequent allocation in this loop. ++ */ ++ sp2d->_1p_stripes[i].pages = (void *)__a1pa; ++ sp2d->_1p_stripes[i].scribble = ++ sp2d->_1p_stripes[i].pages + group_width; ++ sp2d->_1p_stripes[i].page_is_read = ++ (char *)(sp2d->_1p_stripes[i].scribble + group_width); ++ __a1pa += sizeof__a1pa; + } + + sp2d->parity = parity; +diff --git a/fs/exofs/super.c b/fs/exofs/super.c +index 179cd5c..f3c29e9 100644 +--- a/fs/exofs/super.c ++++ b/fs/exofs/super.c +@@ -549,27 +549,26 @@ static int exofs_devs_2_odi(struct exofs_dt_device_info *dt_dev, + static int __alloc_dev_table(struct exofs_sb_info *sbi, unsigned numdevs, + struct exofs_dev **peds) + { +- struct __alloc_ore_devs_and_exofs_devs { +- /* Twice bigger table: See exofs_init_comps() and comment at +- * exofs_read_lookup_dev_table() +- */ +- struct ore_dev *oreds[numdevs * 2 - 1]; +- struct exofs_dev eds[numdevs]; +- } *aoded; ++ /* Twice bigger table: See exofs_init_comps() and comment at ++ * exofs_read_lookup_dev_table() ++ */ ++ size_t numores = numdevs * 2 - 1; + struct exofs_dev *eds; + unsigned i; + +- aoded = kzalloc(sizeof(*aoded), GFP_KERNEL); +- if (unlikely(!aoded)) { ++ sbi->oc.ods = kzalloc(numores * sizeof(struct ore_dev *) + ++ numdevs * sizeof(struct exofs_dev), GFP_KERNEL); ++ if (unlikely(!sbi->oc.ods)) { + EXOFS_ERR("ERROR: failed allocating Device array[%d]\n", + numdevs); + return -ENOMEM; + } + +- sbi->oc.ods = aoded->oreds; +- *peds = eds = aoded->eds; ++ /* Start of allocated struct exofs_dev entries */ ++ *peds = eds = (void *)sbi->oc.ods[numores]; ++ /* Initialize pointers into struct exofs_dev */ + for (i = 0; i < numdevs; ++i) +- aoded->oreds[i] = &eds[i].ored; ++ sbi->oc.ods[i] = &eds[i].ored; + return 0; + } + +-- +2.7.4 + diff --git a/scripts/files/0001-kasan.patch b/scripts/files/0001-kasan.patch new file mode 100644 index 0000000..faf757d --- /dev/null +++ b/scripts/files/0001-kasan.patch @@ -0,0 +1,26 @@ +From 35aced4aa2f8c79fcce8397f4f530b6e31abce55 Mon Sep 17 00:00:00 2001 +From: Ozan Alpay +Date: Fri, 25 May 2018 09:17:58 +0200 +Subject: [PATCH 1/6] Makefile.kasan change for infer + +--- + scripts/Makefile.kasan | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/scripts/Makefile.kasan b/scripts/Makefile.kasan +index 69552a3..b4b69c8 100644 +--- a/scripts/Makefile.kasan ++++ b/scripts/Makefile.kasan +@@ -32,8 +32,7 @@ else + $(call cc-param,asan-globals=1) \ + $(call cc-param,asan-instrumentation-with-call-threshold=$(call_threshold)) \ + $(call cc-param,asan-stack=1) \ +- $(call cc-param,asan-use-after-scope=1) \ +- $(call cc-param,asan-instrument-allocas=1) ++ $(call cc-param,asan-use-after-scope=1) + endif + + endif +-- +2.7.4 + diff --git a/scripts/files/analysisconfig b/scripts/files/analysisconfig new file mode 100644 index 0000000..b128781 --- /dev/null +++ b/scripts/files/analysisconfig @@ -0,0 +1,5 @@ +KERNEL_HEAD_SHA="d8a5b80568a9" +KERNEL_CONFIG="defconfig" +INFERCONFIG_LOCATION="/home/ozan/githubRepos/linux-kernel-analysis-fork/linux-kernel-analysis/scripts/files/inferconfig" +KERNEL_REPOSITORY="/home/ozan/repositories/kernel.org/pub/scm/linux/kernel/git/torvalds/linux/" +RUN_ANALYZE=0 diff --git a/scripts/files/infer0131/inferconfig b/scripts/files/infer0131/inferconfig new file mode 100644 index 0000000..c603e2d --- /dev/null +++ b/scripts/files/infer0131/inferconfig @@ -0,0 +1 @@ +{"skip-analysis-in-path": ["linux/arch/x86/entry/vdso", "linux/arch/x86/kernel", "linux/arch/x86/mm", "linux/arch/x86/boot", "linux/drivers/acpi", "linux/fs", "linux/kernel/bpf", "linux/mm", "linux/net/mac80211"]} diff --git a/scripts/files/infer0140/inferdefconfig b/scripts/files/infer0140/inferdefconfig new file mode 100644 index 0000000..a4c81c6 --- /dev/null +++ b/scripts/files/infer0140/inferdefconfig @@ -0,0 +1,13 @@ +{"skip-analysis-in-path": [ +"linux/arch/x86/entry/vdso", +"linux/arch/x86/boot", +"linux/arch/x86/kernel", +"linux/arch/x86/mm", +"linux/arch/x86/boot/compressed", +"linux/drivers/acpi", +"linux/kernel/bpf", +"linux/mm", +"linux/fs", +"linux/net/mac80211" +] +} diff --git a/scripts/files/infer0140/infermaximalyesconfig b/scripts/files/infer0140/infermaximalyesconfig new file mode 100644 index 0000000..0835b2a --- /dev/null +++ b/scripts/files/infer0140/infermaximalyesconfig @@ -0,0 +1,13 @@ +{"skip-analysis-in-path": [ +"linux/arch/x86/entry/vdso", +"linux/arch/x86/kernel", +"linux/arch/x86/boot", +"linux/arch/x86/include/asm", +"linux/drivers/char/mwave", +"linux/drivers/acpi", +"linux/drivers/edac", +"linux/drivers/firmware/efi", +"linux/drivers/media/pci", +"linux/drivers/xen", +"linux/drivers/staging/rtl8723bs"] +} diff --git a/scripts/files/infer0150/inferdefconfig b/scripts/files/infer0150/inferdefconfig new file mode 100644 index 0000000..a4c81c6 --- /dev/null +++ b/scripts/files/infer0150/inferdefconfig @@ -0,0 +1,13 @@ +{"skip-analysis-in-path": [ +"linux/arch/x86/entry/vdso", +"linux/arch/x86/boot", +"linux/arch/x86/kernel", +"linux/arch/x86/mm", +"linux/arch/x86/boot/compressed", +"linux/drivers/acpi", +"linux/kernel/bpf", +"linux/mm", +"linux/fs", +"linux/net/mac80211" +] +} diff --git a/scripts/files/infer0150/infermaximalyesconfig b/scripts/files/infer0150/infermaximalyesconfig new file mode 100644 index 0000000..0835b2a --- /dev/null +++ b/scripts/files/infer0150/infermaximalyesconfig @@ -0,0 +1,13 @@ +{"skip-analysis-in-path": [ +"linux/arch/x86/entry/vdso", +"linux/arch/x86/kernel", +"linux/arch/x86/boot", +"linux/arch/x86/include/asm", +"linux/drivers/char/mwave", +"linux/drivers/acpi", +"linux/drivers/edac", +"linux/drivers/firmware/efi", +"linux/drivers/media/pci", +"linux/drivers/xen", +"linux/drivers/staging/rtl8723bs"] +} diff --git a/scripts/files/inferconfig b/scripts/files/inferconfig new file mode 100644 index 0000000..c603e2d --- /dev/null +++ b/scripts/files/inferconfig @@ -0,0 +1 @@ +{"skip-analysis-in-path": ["linux/arch/x86/entry/vdso", "linux/arch/x86/kernel", "linux/arch/x86/mm", "linux/arch/x86/boot", "linux/drivers/acpi", "linux/fs", "linux/kernel/bpf", "linux/mm", "linux/net/mac80211"]} diff --git a/scripts/files/v416/maximalyesconfig b/scripts/files/v416/maximalyesconfig new file mode 100644 index 0000000..04ccaf9 --- /dev/null +++ b/scripts/files/v416/maximalyesconfig @@ -0,0 +1,11502 @@ +# +# Automatically generated file; DO NOT EDIT. +# Linux/x86 4.16.0 Kernel Configuration +# +CONFIG_64BIT=y +CONFIG_X86_64=y +CONFIG_X86=y +CONFIG_INSTRUCTION_DECODER=y +CONFIG_OUTPUT_FORMAT="elf64-x86-64" +CONFIG_ARCH_DEFCONFIG="arch/x86/configs/x86_64_defconfig" +CONFIG_LOCKDEP_SUPPORT=y +CONFIG_STACKTRACE_SUPPORT=y +CONFIG_MMU=y +CONFIG_ARCH_MMAP_RND_BITS_MIN=28 +CONFIG_ARCH_MMAP_RND_BITS_MAX=32 +CONFIG_ARCH_MMAP_RND_COMPAT_BITS_MIN=8 +CONFIG_ARCH_MMAP_RND_COMPAT_BITS_MAX=16 +CONFIG_NEED_DMA_MAP_STATE=y +CONFIG_NEED_SG_DMA_LENGTH=y +CONFIG_GENERIC_ISA_DMA=y +CONFIG_GENERIC_BUG=y +CONFIG_GENERIC_BUG_RELATIVE_POINTERS=y +CONFIG_GENERIC_HWEIGHT=y +CONFIG_ARCH_MAY_HAVE_PC_FDC=y +CONFIG_RWSEM_XCHGADD_ALGORITHM=y +CONFIG_GENERIC_CALIBRATE_DELAY=y +CONFIG_ARCH_HAS_CPU_RELAX=y +CONFIG_ARCH_HAS_CACHE_LINE_SIZE=y +CONFIG_HAVE_SETUP_PER_CPU_AREA=y +CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK=y +CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK=y +CONFIG_ARCH_HIBERNATION_POSSIBLE=y +CONFIG_ARCH_SUSPEND_POSSIBLE=y +CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y +CONFIG_ARCH_WANT_GENERAL_HUGETLB=y +CONFIG_ZONE_DMA32=y +CONFIG_AUDIT_ARCH=y +CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING=y +CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y +CONFIG_KASAN_SHADOW_OFFSET=0xdffffc0000000000 +CONFIG_HAVE_INTEL_TXT=y +CONFIG_X86_64_SMP=y +CONFIG_ARCH_SUPPORTS_UPROBES=y +CONFIG_FIX_EARLYCON_MEM=y +CONFIG_PGTABLE_LEVELS=5 +CONFIG_CONSTRUCTORS=y +CONFIG_IRQ_WORK=y +CONFIG_BUILDTIME_EXTABLE_SORT=y +CONFIG_THREAD_INFO_IN_TASK=y + +# +# General setup +# +CONFIG_INIT_ENV_ARG_LIMIT=32 +CONFIG_CROSS_COMPILE="" +CONFIG_COMPILE_TEST=y +CONFIG_LOCALVERSION="" +CONFIG_HAVE_KERNEL_GZIP=y +CONFIG_HAVE_KERNEL_BZIP2=y +CONFIG_HAVE_KERNEL_LZMA=y +CONFIG_HAVE_KERNEL_XZ=y +CONFIG_HAVE_KERNEL_LZO=y +CONFIG_HAVE_KERNEL_LZ4=y +CONFIG_KERNEL_GZIP=y +# CONFIG_KERNEL_BZIP2 is not set +# CONFIG_KERNEL_LZMA is not set +# CONFIG_KERNEL_XZ is not set +# CONFIG_KERNEL_LZO is not set +# CONFIG_KERNEL_LZ4 is not set +CONFIG_DEFAULT_HOSTNAME="(none)" +CONFIG_SWAP=y +CONFIG_SYSVIPC=y +CONFIG_SYSVIPC_SYSCTL=y +CONFIG_POSIX_MQUEUE=y +CONFIG_POSIX_MQUEUE_SYSCTL=y +CONFIG_CROSS_MEMORY_ATTACH=y +CONFIG_USELIB=y +CONFIG_AUDIT=y +CONFIG_HAVE_ARCH_AUDITSYSCALL=y +CONFIG_AUDITSYSCALL=y +CONFIG_AUDIT_WATCH=y +CONFIG_AUDIT_TREE=y + +# +# IRQ subsystem +# +CONFIG_GENERIC_IRQ_PROBE=y +CONFIG_GENERIC_IRQ_SHOW=y +CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK=y +CONFIG_GENERIC_PENDING_IRQ=y +CONFIG_GENERIC_IRQ_MIGRATION=y +CONFIG_GENERIC_IRQ_CHIP=y +CONFIG_IRQ_DOMAIN=y +CONFIG_IRQ_SIM=y +CONFIG_IRQ_DOMAIN_HIERARCHY=y +CONFIG_IRQ_FASTEOI_HIERARCHY_HANDLERS=y +CONFIG_GENERIC_MSI_IRQ=y +CONFIG_GENERIC_MSI_IRQ_DOMAIN=y +CONFIG_GENERIC_IRQ_MATRIX_ALLOCATOR=y +CONFIG_GENERIC_IRQ_RESERVATION_MODE=y +CONFIG_IRQ_FORCED_THREADING=y +CONFIG_SPARSE_IRQ=y +CONFIG_GENERIC_IRQ_DEBUGFS=y +CONFIG_CLOCKSOURCE_WATCHDOG=y +CONFIG_ARCH_CLOCKSOURCE_DATA=y +CONFIG_CLOCKSOURCE_VALIDATE_LAST_CYCLE=y +CONFIG_GENERIC_TIME_VSYSCALL=y +CONFIG_GENERIC_CLOCKEVENTS=y +CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y +CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST=y +CONFIG_GENERIC_CMOS_UPDATE=y + +# +# Timers subsystem +# +CONFIG_TICK_ONESHOT=y +CONFIG_NO_HZ_COMMON=y +# CONFIG_HZ_PERIODIC is not set +CONFIG_NO_HZ_IDLE=y +# CONFIG_NO_HZ_FULL is not set +CONFIG_NO_HZ=y +CONFIG_HIGH_RES_TIMERS=y + +# +# CPU/Task time and stats accounting +# +CONFIG_TICK_CPU_ACCOUNTING=y +# CONFIG_VIRT_CPU_ACCOUNTING_GEN is not set +CONFIG_IRQ_TIME_ACCOUNTING=y +CONFIG_BSD_PROCESS_ACCT=y +CONFIG_BSD_PROCESS_ACCT_V3=y +CONFIG_TASKSTATS=y +CONFIG_TASK_DELAY_ACCT=y +CONFIG_TASK_XACCT=y +CONFIG_TASK_IO_ACCOUNTING=y +CONFIG_CPU_ISOLATION=y + +# +# RCU Subsystem +# +CONFIG_TREE_RCU=y +CONFIG_RCU_EXPERT=y +CONFIG_SRCU=y +CONFIG_TREE_SRCU=y +CONFIG_TASKS_RCU=y +CONFIG_RCU_STALL_COMMON=y +CONFIG_RCU_NEED_SEGCBLIST=y +CONFIG_RCU_FANOUT=64 +CONFIG_RCU_FANOUT_LEAF=16 +CONFIG_RCU_FAST_NO_HZ=y +CONFIG_RCU_NOCB_CPU=y +CONFIG_BUILD_BIN2C=y +CONFIG_IKCONFIG=y +CONFIG_IKCONFIG_PROC=y +CONFIG_LOG_BUF_SHIFT=17 +CONFIG_LOG_CPU_MAX_BUF_SHIFT=12 +CONFIG_PRINTK_SAFE_LOG_BUF_SHIFT=13 +CONFIG_HAVE_UNSTABLE_SCHED_CLOCK=y +CONFIG_ARCH_SUPPORTS_NUMA_BALANCING=y +CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH=y +CONFIG_ARCH_SUPPORTS_INT128=y +CONFIG_NUMA_BALANCING=y +CONFIG_NUMA_BALANCING_DEFAULT_ENABLED=y +CONFIG_CGROUPS=y +CONFIG_PAGE_COUNTER=y +CONFIG_MEMCG=y +CONFIG_MEMCG_SWAP=y +CONFIG_MEMCG_SWAP_ENABLED=y +CONFIG_BLK_CGROUP=y +CONFIG_DEBUG_BLK_CGROUP=y +CONFIG_CGROUP_WRITEBACK=y +CONFIG_CGROUP_SCHED=y +CONFIG_FAIR_GROUP_SCHED=y +CONFIG_CFS_BANDWIDTH=y +CONFIG_RT_GROUP_SCHED=y +CONFIG_CGROUP_PIDS=y +CONFIG_CGROUP_RDMA=y +CONFIG_CGROUP_FREEZER=y +CONFIG_CGROUP_HUGETLB=y +CONFIG_CPUSETS=y +CONFIG_PROC_PID_CPUSET=y +CONFIG_CGROUP_DEVICE=y +CONFIG_CGROUP_CPUACCT=y +CONFIG_CGROUP_PERF=y +CONFIG_CGROUP_BPF=y +CONFIG_CGROUP_DEBUG=y +CONFIG_SOCK_CGROUP_DATA=y +CONFIG_NAMESPACES=y +CONFIG_UTS_NS=y +CONFIG_IPC_NS=y +CONFIG_USER_NS=y +CONFIG_PID_NS=y +CONFIG_NET_NS=y +CONFIG_SCHED_AUTOGROUP=y +CONFIG_SYSFS_DEPRECATED=y +CONFIG_SYSFS_DEPRECATED_V2=y +CONFIG_RELAY=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_INITRAMFS_SOURCE="" +CONFIG_RD_GZIP=y +CONFIG_RD_BZIP2=y +CONFIG_RD_LZMA=y +CONFIG_RD_XZ=y +CONFIG_RD_LZO=y +CONFIG_RD_LZ4=y +CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y +# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set +CONFIG_SYSCTL=y +CONFIG_ANON_INODES=y +CONFIG_HAVE_UID16=y +CONFIG_SYSCTL_EXCEPTION_TRACE=y +CONFIG_HAVE_PCSPKR_PLATFORM=y +CONFIG_BPF=y +CONFIG_EXPERT=y +CONFIG_UID16=y +CONFIG_MULTIUSER=y +CONFIG_SGETMASK_SYSCALL=y +CONFIG_SYSFS_SYSCALL=y +CONFIG_SYSCTL_SYSCALL=y +CONFIG_FHANDLE=y +CONFIG_POSIX_TIMERS=y +CONFIG_PRINTK=y +CONFIG_PRINTK_NMI=y +CONFIG_BUG=y +CONFIG_ELF_CORE=y +CONFIG_PCSPKR_PLATFORM=y +CONFIG_BASE_FULL=y +CONFIG_FUTEX=y +CONFIG_FUTEX_PI=y +CONFIG_EPOLL=y +CONFIG_SIGNALFD=y +CONFIG_TIMERFD=y +CONFIG_EVENTFD=y +CONFIG_SHMEM=y +CONFIG_AIO=y +CONFIG_ADVISE_SYSCALLS=y +CONFIG_MEMBARRIER=y +CONFIG_CHECKPOINT_RESTORE=y +CONFIG_KALLSYMS=y +CONFIG_KALLSYMS_ALL=y +CONFIG_KALLSYMS_ABSOLUTE_PERCPU=y +CONFIG_KALLSYMS_BASE_RELATIVE=y +CONFIG_BPF_SYSCALL=y +CONFIG_BPF_JIT_ALWAYS_ON=y +CONFIG_USERFAULTFD=y +CONFIG_ARCH_HAS_MEMBARRIER_SYNC_CORE=y +CONFIG_EMBEDDED=y +CONFIG_HAVE_PERF_EVENTS=y +CONFIG_PERF_USE_VMALLOC=y +CONFIG_PC104=y + +# +# Kernel Performance Events And Counters +# +CONFIG_PERF_EVENTS=y +CONFIG_DEBUG_PERF_USE_VMALLOC=y +CONFIG_VM_EVENT_COUNTERS=y +CONFIG_SLUB_DEBUG=y +CONFIG_SLUB_MEMCG_SYSFS_ON=y +CONFIG_COMPAT_BRK=y +# CONFIG_SLAB is not set +CONFIG_SLUB=y +# CONFIG_SLOB is not set +CONFIG_SLAB_MERGE_DEFAULT=y +CONFIG_SLAB_FREELIST_RANDOM=y +CONFIG_SLAB_FREELIST_HARDENED=y +CONFIG_SLUB_CPU_PARTIAL=y +CONFIG_SYSTEM_DATA_VERIFICATION=y +CONFIG_PROFILING=y +CONFIG_TRACEPOINTS=y +CONFIG_CRASH_CORE=y +CONFIG_KEXEC_CORE=y +CONFIG_OPROFILE=y +CONFIG_OPROFILE_EVENT_MULTIPLEX=y +CONFIG_HAVE_OPROFILE=y +CONFIG_OPROFILE_NMI_TIMER=y +CONFIG_KPROBES=y +CONFIG_JUMP_LABEL=y +CONFIG_STATIC_KEYS_SELFTEST=y +CONFIG_OPTPROBES=y +CONFIG_KPROBES_ON_FTRACE=y +CONFIG_UPROBES=y +# CONFIG_HAVE_64BIT_ALIGNED_ACCESS is not set +CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y +CONFIG_ARCH_USE_BUILTIN_BSWAP=y +CONFIG_KRETPROBES=y +CONFIG_USER_RETURN_NOTIFIER=y +CONFIG_HAVE_IOREMAP_PROT=y +CONFIG_HAVE_KPROBES=y +CONFIG_HAVE_KRETPROBES=y +CONFIG_HAVE_OPTPROBES=y +CONFIG_HAVE_KPROBES_ON_FTRACE=y +CONFIG_HAVE_FUNCTION_ERROR_INJECTION=y +CONFIG_HAVE_NMI=y +CONFIG_HAVE_ARCH_TRACEHOOK=y +CONFIG_HAVE_DMA_CONTIGUOUS=y +CONFIG_GENERIC_SMP_IDLE_THREAD=y +CONFIG_ARCH_HAS_FORTIFY_SOURCE=y +CONFIG_ARCH_HAS_SET_MEMORY=y +CONFIG_HAVE_ARCH_THREAD_STRUCT_WHITELIST=y +CONFIG_ARCH_WANTS_DYNAMIC_TASK_STRUCT=y +CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y +CONFIG_HAVE_CLK=y +CONFIG_HAVE_DMA_API_DEBUG=y +CONFIG_HAVE_HW_BREAKPOINT=y +CONFIG_HAVE_MIXED_BREAKPOINTS_REGS=y +CONFIG_HAVE_USER_RETURN_NOTIFIER=y +CONFIG_HAVE_PERF_EVENTS_NMI=y +CONFIG_HAVE_HARDLOCKUP_DETECTOR_PERF=y +CONFIG_HAVE_PERF_REGS=y +CONFIG_HAVE_PERF_USER_STACK_DUMP=y +CONFIG_HAVE_ARCH_JUMP_LABEL=y +CONFIG_HAVE_RCU_TABLE_FREE=y +CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG=y +CONFIG_HAVE_ALIGNED_STRUCT_PAGE=y +CONFIG_HAVE_CMPXCHG_LOCAL=y +CONFIG_HAVE_CMPXCHG_DOUBLE=y +CONFIG_ARCH_WANT_COMPAT_IPC_PARSE_VERSION=y +CONFIG_ARCH_WANT_OLD_COMPAT_IPC=y +CONFIG_HAVE_ARCH_SECCOMP_FILTER=y +CONFIG_SECCOMP_FILTER=y +CONFIG_HAVE_GCC_PLUGINS=y +CONFIG_HAVE_CC_STACKPROTECTOR=y +# CONFIG_CC_STACKPROTECTOR_NONE is not set +# CONFIG_CC_STACKPROTECTOR_REGULAR is not set +# CONFIG_CC_STACKPROTECTOR_STRONG is not set +CONFIG_CC_STACKPROTECTOR_AUTO=y +CONFIG_THIN_ARCHIVES=y +CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES=y +CONFIG_HAVE_CONTEXT_TRACKING=y +CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y +CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y +CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y +CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD=y +CONFIG_HAVE_ARCH_HUGE_VMAP=y +CONFIG_HAVE_ARCH_SOFT_DIRTY=y +CONFIG_HAVE_MOD_ARCH_SPECIFIC=y +CONFIG_MODULES_USE_ELF_RELA=y +CONFIG_HAVE_IRQ_EXIT_ON_IRQ_STACK=y +CONFIG_ARCH_HAS_ELF_RANDOMIZE=y +CONFIG_HAVE_ARCH_MMAP_RND_BITS=y +CONFIG_HAVE_EXIT_THREAD=y +CONFIG_ARCH_MMAP_RND_BITS=28 +CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS=y +CONFIG_ARCH_MMAP_RND_COMPAT_BITS=8 +CONFIG_HAVE_ARCH_COMPAT_MMAP_BASES=y +CONFIG_HAVE_COPY_THREAD_TLS=y +CONFIG_HAVE_STACK_VALIDATION=y +# CONFIG_HAVE_ARCH_HASH is not set +CONFIG_ISA_BUS_API=y +CONFIG_OLD_SIGSUSPEND3=y +CONFIG_COMPAT_OLD_SIGACTION=y +# CONFIG_CPU_NO_EFFICIENT_FFS is not set +CONFIG_HAVE_ARCH_VMAP_STACK=y +# CONFIG_ARCH_OPTIONAL_KERNEL_RWX is not set +# CONFIG_ARCH_OPTIONAL_KERNEL_RWX_DEFAULT is not set +CONFIG_ARCH_HAS_STRICT_KERNEL_RWX=y +CONFIG_STRICT_KERNEL_RWX=y +CONFIG_ARCH_HAS_STRICT_MODULE_RWX=y +CONFIG_STRICT_MODULE_RWX=y +CONFIG_ARCH_HAS_PHYS_TO_DMA=y +CONFIG_ARCH_HAS_REFCOUNT=y +CONFIG_REFCOUNT_FULL=y + +# +# GCOV-based kernel profiling +# +CONFIG_GCOV_KERNEL=y +CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y +CONFIG_GCOV_FORMAT_AUTODETECT=y +# CONFIG_GCOV_FORMAT_3_4 is not set +# CONFIG_GCOV_FORMAT_4_7 is not set +# CONFIG_HAVE_GENERIC_DMA_COHERENT is not set +CONFIG_RT_MUTEXES=y +CONFIG_BASE_SMALL=0 +CONFIG_MODULES=y +CONFIG_MODULE_FORCE_LOAD=y +CONFIG_MODULE_UNLOAD=y +CONFIG_MODULE_FORCE_UNLOAD=y +CONFIG_MODVERSIONS=y +CONFIG_MODULE_SRCVERSION_ALL=y +CONFIG_MODULE_SIG=y +CONFIG_MODULE_SIG_FORCE=y +CONFIG_MODULE_SIG_ALL=y +CONFIG_MODULE_SIG_SHA1=y +# CONFIG_MODULE_SIG_SHA224 is not set +# CONFIG_MODULE_SIG_SHA256 is not set +# CONFIG_MODULE_SIG_SHA384 is not set +# CONFIG_MODULE_SIG_SHA512 is not set +CONFIG_MODULE_SIG_HASH="sha1" +CONFIG_MODULE_COMPRESS=y +CONFIG_MODULE_COMPRESS_GZIP=y +# CONFIG_MODULE_COMPRESS_XZ is not set +CONFIG_MODULES_TREE_LOOKUP=y +CONFIG_BLOCK=y +CONFIG_BLK_SCSI_REQUEST=y +CONFIG_BLK_DEV_BSG=y +CONFIG_BLK_DEV_BSGLIB=y +CONFIG_BLK_DEV_INTEGRITY=y +CONFIG_BLK_DEV_ZONED=y +CONFIG_BLK_DEV_THROTTLING=y +CONFIG_BLK_DEV_THROTTLING_LOW=y +CONFIG_BLK_CMDLINE_PARSER=y +CONFIG_BLK_WBT=y +CONFIG_BLK_WBT_SQ=y +CONFIG_BLK_WBT_MQ=y +CONFIG_BLK_DEBUG_FS=y +CONFIG_BLK_SED_OPAL=y + +# +# Partition Types +# +CONFIG_PARTITION_ADVANCED=y +CONFIG_ACORN_PARTITION=y +CONFIG_ACORN_PARTITION_CUMANA=y +CONFIG_ACORN_PARTITION_EESOX=y +CONFIG_ACORN_PARTITION_ICS=y +CONFIG_ACORN_PARTITION_ADFS=y +CONFIG_ACORN_PARTITION_POWERTEC=y +CONFIG_ACORN_PARTITION_RISCIX=y +CONFIG_AIX_PARTITION=y +CONFIG_OSF_PARTITION=y +CONFIG_AMIGA_PARTITION=y +CONFIG_ATARI_PARTITION=y +CONFIG_MAC_PARTITION=y +CONFIG_MSDOS_PARTITION=y +CONFIG_BSD_DISKLABEL=y +CONFIG_MINIX_SUBPARTITION=y +CONFIG_SOLARIS_X86_PARTITION=y +CONFIG_UNIXWARE_DISKLABEL=y +CONFIG_LDM_PARTITION=y +CONFIG_LDM_DEBUG=y +CONFIG_SGI_PARTITION=y +CONFIG_ULTRIX_PARTITION=y +CONFIG_SUN_PARTITION=y +CONFIG_KARMA_PARTITION=y +CONFIG_EFI_PARTITION=y +CONFIG_SYSV68_PARTITION=y +CONFIG_CMDLINE_PARTITION=y +CONFIG_BLOCK_COMPAT=y +CONFIG_BLK_MQ_PCI=y +CONFIG_BLK_MQ_VIRTIO=y +CONFIG_BLK_MQ_RDMA=y + +# +# IO Schedulers +# +CONFIG_IOSCHED_NOOP=y +CONFIG_IOSCHED_DEADLINE=y +CONFIG_IOSCHED_CFQ=y +CONFIG_CFQ_GROUP_IOSCHED=y +# CONFIG_DEFAULT_DEADLINE is not set +CONFIG_DEFAULT_CFQ=y +# CONFIG_DEFAULT_NOOP is not set +CONFIG_DEFAULT_IOSCHED="cfq" +CONFIG_MQ_IOSCHED_DEADLINE=y +CONFIG_MQ_IOSCHED_KYBER=y +CONFIG_IOSCHED_BFQ=y +CONFIG_BFQ_GROUP_IOSCHED=y +CONFIG_PREEMPT_NOTIFIERS=y +CONFIG_PADATA=y +CONFIG_ASN1=y +CONFIG_UNINLINE_SPIN_UNLOCK=y +CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y +CONFIG_MUTEX_SPIN_ON_OWNER=y +CONFIG_RWSEM_SPIN_ON_OWNER=y +CONFIG_LOCK_SPIN_ON_OWNER=y +CONFIG_ARCH_USE_QUEUED_SPINLOCKS=y +CONFIG_QUEUED_SPINLOCKS=y +CONFIG_ARCH_USE_QUEUED_RWLOCKS=y +CONFIG_QUEUED_RWLOCKS=y +CONFIG_ARCH_HAS_SYNC_CORE_BEFORE_USERMODE=y +CONFIG_FREEZER=y + +# +# Processor type and features +# +CONFIG_ZONE_DMA=y +CONFIG_SMP=y +CONFIG_X86_FEATURE_NAMES=y +CONFIG_X86_FAST_FEATURE_TESTS=y +CONFIG_X86_X2APIC=y +CONFIG_X86_MPPARSE=y +CONFIG_GOLDFISH=y +CONFIG_RETPOLINE=y +CONFIG_INTEL_RDT=y +CONFIG_X86_EXTENDED_PLATFORM=y +CONFIG_X86_NUMACHIP=y +CONFIG_X86_VSMP=y +CONFIG_X86_UV=y +CONFIG_X86_GOLDFISH=y +CONFIG_X86_INTEL_MID=y +CONFIG_X86_INTEL_LPSS=y +CONFIG_X86_AMD_PLATFORM_DEVICE=y +CONFIG_IOSF_MBI=y +CONFIG_IOSF_MBI_DEBUG=y +CONFIG_X86_SUPPORTS_MEMORY_FAILURE=y +CONFIG_SCHED_OMIT_FRAME_POINTER=y +CONFIG_HYPERVISOR_GUEST=y +CONFIG_PARAVIRT=y +CONFIG_PARAVIRT_DEBUG=y +CONFIG_PARAVIRT_SPINLOCKS=y +CONFIG_QUEUED_LOCK_STAT=y +CONFIG_XEN=y +CONFIG_XEN_PVHVM=y +CONFIG_XEN_PVHVM_SMP=y +CONFIG_XEN_SAVE_RESTORE=y +CONFIG_XEN_DEBUG_FS=y +CONFIG_KVM_GUEST=y +CONFIG_KVM_DEBUG_FS=y +CONFIG_PARAVIRT_TIME_ACCOUNTING=y +CONFIG_PARAVIRT_CLOCK=y +CONFIG_JAILHOUSE_GUEST=y +CONFIG_NO_BOOTMEM=y +# CONFIG_MK8 is not set +# CONFIG_MPSC is not set +# CONFIG_MCORE2 is not set +# CONFIG_MATOM is not set +CONFIG_GENERIC_CPU=y +CONFIG_X86_INTERNODE_CACHE_SHIFT=12 +CONFIG_X86_L1_CACHE_SHIFT=6 +CONFIG_X86_TSC=y +CONFIG_X86_CMPXCHG64=y +CONFIG_X86_CMOV=y +CONFIG_X86_MINIMUM_CPU_FAMILY=64 +CONFIG_X86_DEBUGCTLMSR=y +CONFIG_PROCESSOR_SELECT=y +CONFIG_CPU_SUP_INTEL=y +CONFIG_CPU_SUP_AMD=y +CONFIG_CPU_SUP_CENTAUR=y +CONFIG_HPET_TIMER=y +CONFIG_HPET_EMULATE_RTC=y +CONFIG_APB_TIMER=y +CONFIG_DMI=y +CONFIG_GART_IOMMU=y +CONFIG_CALGARY_IOMMU=y +CONFIG_CALGARY_IOMMU_ENABLED_BY_DEFAULT=y +CONFIG_SWIOTLB=y +CONFIG_IOMMU_HELPER=y +CONFIG_MAXSMP=y +CONFIG_NR_CPUS_RANGE_BEGIN=8192 +CONFIG_NR_CPUS_RANGE_END=8192 +CONFIG_NR_CPUS_DEFAULT=8192 +CONFIG_NR_CPUS=8192 +CONFIG_SCHED_SMT=y +CONFIG_SCHED_MC=y +CONFIG_SCHED_MC_PRIO=y +CONFIG_PREEMPT_NONE=y +# CONFIG_PREEMPT_VOLUNTARY is not set +# CONFIG_PREEMPT is not set +CONFIG_PREEMPT_COUNT=y +CONFIG_X86_LOCAL_APIC=y +CONFIG_X86_IO_APIC=y +CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS=y +CONFIG_X86_MCE=y +CONFIG_X86_MCELOG_LEGACY=y +CONFIG_X86_MCE_INTEL=y +CONFIG_X86_MCE_AMD=y +CONFIG_X86_MCE_THRESHOLD=y +CONFIG_X86_MCE_INJECT=y +CONFIG_X86_THERMAL_VECTOR=y + +# +# Performance monitoring +# +CONFIG_PERF_EVENTS_INTEL_UNCORE=y +CONFIG_PERF_EVENTS_INTEL_RAPL=y +CONFIG_PERF_EVENTS_INTEL_CSTATE=y +CONFIG_PERF_EVENTS_AMD_POWER=y +# CONFIG_VM86 is not set +CONFIG_X86_16BIT=y +CONFIG_X86_ESPFIX64=y +CONFIG_X86_VSYSCALL_EMULATION=y +CONFIG_I8K=y +CONFIG_MICROCODE=y +CONFIG_MICROCODE_INTEL=y +CONFIG_MICROCODE_AMD=y +CONFIG_MICROCODE_OLD_INTERFACE=y +CONFIG_X86_MSR=y +CONFIG_X86_CPUID=y +CONFIG_X86_5LEVEL=y +CONFIG_ARCH_PHYS_ADDR_T_64BIT=y +CONFIG_ARCH_DMA_ADDR_T_64BIT=y +CONFIG_ARCH_HAS_MEM_ENCRYPT=y +CONFIG_AMD_MEM_ENCRYPT=y +CONFIG_AMD_MEM_ENCRYPT_ACTIVE_BY_DEFAULT=y +CONFIG_ARCH_USE_MEMREMAP_PROT=y +CONFIG_NUMA=y +CONFIG_AMD_NUMA=y +CONFIG_X86_64_ACPI_NUMA=y +CONFIG_NODES_SPAN_OTHER_NODES=y +CONFIG_NUMA_EMU=y +CONFIG_NODES_SHIFT=10 +CONFIG_ARCH_SPARSEMEM_ENABLE=y +CONFIG_ARCH_SPARSEMEM_DEFAULT=y +CONFIG_ARCH_SELECT_MEMORY_MODEL=y +CONFIG_ARCH_MEMORY_PROBE=y +CONFIG_ARCH_PROC_KCORE_TEXT=y +CONFIG_ILLEGAL_POINTER_VALUE=0xdead000000000000 +CONFIG_SELECT_MEMORY_MODEL=y +CONFIG_SPARSEMEM_MANUAL=y +CONFIG_SPARSEMEM=y +CONFIG_NEED_MULTIPLE_NODES=y +CONFIG_HAVE_MEMORY_PRESENT=y +CONFIG_SPARSEMEM_EXTREME=y +CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y +CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER=y +CONFIG_SPARSEMEM_VMEMMAP=y +CONFIG_HAVE_MEMBLOCK=y +CONFIG_HAVE_MEMBLOCK_NODE_MAP=y +CONFIG_HAVE_GENERIC_GUP=y +CONFIG_ARCH_DISCARD_MEMBLOCK=y +CONFIG_MEMORY_ISOLATION=y +CONFIG_HAVE_BOOTMEM_INFO_NODE=y +CONFIG_MEMORY_HOTPLUG=y +CONFIG_MEMORY_HOTPLUG_SPARSE=y +CONFIG_MEMORY_HOTPLUG_DEFAULT_ONLINE=y +CONFIG_MEMORY_HOTREMOVE=y +CONFIG_SPLIT_PTLOCK_CPUS=4 +CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK=y +CONFIG_MEMORY_BALLOON=y +CONFIG_BALLOON_COMPACTION=y +CONFIG_COMPACTION=y +CONFIG_MIGRATION=y +CONFIG_ARCH_ENABLE_HUGEPAGE_MIGRATION=y +CONFIG_ARCH_ENABLE_THP_MIGRATION=y +CONFIG_PHYS_ADDR_T_64BIT=y +CONFIG_BOUNCE=y +CONFIG_VIRT_TO_BUS=y +CONFIG_MMU_NOTIFIER=y +CONFIG_KSM=y +CONFIG_DEFAULT_MMAP_MIN_ADDR=4096 +CONFIG_ARCH_SUPPORTS_MEMORY_FAILURE=y +CONFIG_MEMORY_FAILURE=y +CONFIG_HWPOISON_INJECT=y +CONFIG_TRANSPARENT_HUGEPAGE=y +CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y +# CONFIG_TRANSPARENT_HUGEPAGE_MADVISE is not set +CONFIG_ARCH_WANTS_THP_SWAP=y +CONFIG_THP_SWAP=y +CONFIG_TRANSPARENT_HUGE_PAGECACHE=y +CONFIG_CLEANCACHE=y +CONFIG_FRONTSWAP=y +CONFIG_CMA=y +CONFIG_CMA_DEBUG=y +CONFIG_CMA_DEBUGFS=y +CONFIG_CMA_AREAS=7 +CONFIG_MEM_SOFT_DIRTY=y +CONFIG_ZSWAP=y +CONFIG_ZPOOL=y +CONFIG_ZBUD=y +CONFIG_Z3FOLD=y +CONFIG_ZSMALLOC=y +CONFIG_PGTABLE_MAPPING=y +CONFIG_ZSMALLOC_STAT=y +CONFIG_GENERIC_EARLY_IOREMAP=y +CONFIG_DEFERRED_STRUCT_PAGE_INIT=y +CONFIG_IDLE_PAGE_TRACKING=y +CONFIG_ARCH_HAS_ZONE_DEVICE=y +CONFIG_ZONE_DEVICE=y +CONFIG_ARCH_HAS_HMM=y +CONFIG_MIGRATE_VMA_HELPER=y +CONFIG_HMM=y +CONFIG_HMM_MIRROR=y +CONFIG_DEVICE_PRIVATE=y +CONFIG_DEVICE_PUBLIC=y +CONFIG_FRAME_VECTOR=y +CONFIG_ARCH_USES_HIGH_VMA_FLAGS=y +CONFIG_ARCH_HAS_PKEYS=y +CONFIG_PERCPU_STATS=y +CONFIG_GUP_BENCHMARK=y +CONFIG_X86_PMEM_LEGACY_DEVICE=y +CONFIG_X86_PMEM_LEGACY=y +CONFIG_X86_CHECK_BIOS_CORRUPTION=y +CONFIG_X86_BOOTPARAM_MEMORY_CORRUPTION_CHECK=y +CONFIG_X86_RESERVE_LOW=64 +CONFIG_MTRR=y +CONFIG_MTRR_SANITIZER=y +CONFIG_MTRR_SANITIZER_ENABLE_DEFAULT=0 +CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT=1 +CONFIG_X86_PAT=y +CONFIG_ARCH_USES_PG_UNCACHED=y +CONFIG_ARCH_RANDOM=y +CONFIG_X86_SMAP=y +CONFIG_X86_INTEL_UMIP=y +CONFIG_X86_INTEL_MPX=y +CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS=y +CONFIG_EFI=y +CONFIG_EFI_STUB=y +CONFIG_EFI_MIXED=y +CONFIG_SECCOMP=y +# CONFIG_HZ_100 is not set +CONFIG_HZ_250=y +# CONFIG_HZ_300 is not set +# CONFIG_HZ_1000 is not set +CONFIG_HZ=250 +CONFIG_SCHED_HRTICK=y +CONFIG_KEXEC=y +CONFIG_KEXEC_FILE=y +CONFIG_KEXEC_VERIFY_SIG=y +CONFIG_KEXEC_BZIMAGE_VERIFY_SIG=y +CONFIG_CRASH_DUMP=y +CONFIG_KEXEC_JUMP=y +CONFIG_PHYSICAL_START=0x1000000 +CONFIG_RELOCATABLE=y +CONFIG_RANDOMIZE_BASE=y +CONFIG_X86_NEED_RELOCS=y +CONFIG_PHYSICAL_ALIGN=0x200000 +CONFIG_RANDOMIZE_MEMORY=y +CONFIG_RANDOMIZE_MEMORY_PHYSICAL_PADDING=0xa +CONFIG_HOTPLUG_CPU=y +CONFIG_BOOTPARAM_HOTPLUG_CPU0=y +CONFIG_DEBUG_HOTPLUG_CPU0=y +CONFIG_COMPAT_VDSO=y +CONFIG_LEGACY_VSYSCALL_EMULATE=y +# CONFIG_LEGACY_VSYSCALL_NONE is not set +CONFIG_CMDLINE_BOOL=y +CONFIG_CMDLINE="" +CONFIG_CMDLINE_OVERRIDE=y +CONFIG_MODIFY_LDT_SYSCALL=y +CONFIG_HAVE_LIVEPATCH=y +CONFIG_LIVEPATCH=y +CONFIG_ARCH_HAS_ADD_PAGES=y +CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y +CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y +CONFIG_USE_PERCPU_NUMA_NODE_ID=y + +# +# Power management and ACPI options +# +CONFIG_ARCH_HIBERNATION_HEADER=y +CONFIG_SUSPEND=y +CONFIG_SUSPEND_FREEZER=y +CONFIG_SUSPEND_SKIP_SYNC=y +CONFIG_HIBERNATE_CALLBACKS=y +CONFIG_HIBERNATION=y +CONFIG_PM_STD_PARTITION="" +CONFIG_PM_SLEEP=y +CONFIG_PM_SLEEP_SMP=y +CONFIG_PM_AUTOSLEEP=y +CONFIG_PM_WAKELOCKS=y +CONFIG_PM_WAKELOCKS_LIMIT=100 +CONFIG_PM_WAKELOCKS_GC=y +CONFIG_PM=y +CONFIG_PM_DEBUG=y +CONFIG_PM_ADVANCED_DEBUG=y +CONFIG_PM_TEST_SUSPEND=y +CONFIG_PM_SLEEP_DEBUG=y +CONFIG_DPM_WATCHDOG=y +CONFIG_DPM_WATCHDOG_TIMEOUT=120 +CONFIG_PM_TRACE=y +CONFIG_PM_TRACE_RTC=y +CONFIG_PM_CLK=y +CONFIG_PM_GENERIC_DOMAINS=y +CONFIG_WQ_POWER_EFFICIENT_DEFAULT=y +CONFIG_PM_GENERIC_DOMAINS_SLEEP=y +CONFIG_PM_GENERIC_DOMAINS_OF=y +CONFIG_ACPI=y +CONFIG_ACPI_LEGACY_TABLES_LOOKUP=y +CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC=y +CONFIG_ACPI_SYSTEM_POWER_STATES_SUPPORT=y +CONFIG_ACPI_DEBUGGER=y +CONFIG_ACPI_DEBUGGER_USER=y +CONFIG_ACPI_SPCR_TABLE=y +CONFIG_ACPI_LPIT=y +CONFIG_ACPI_SLEEP=y +CONFIG_ACPI_PROCFS_POWER=y +CONFIG_ACPI_REV_OVERRIDE_POSSIBLE=y +CONFIG_ACPI_EC_DEBUGFS=y +CONFIG_ACPI_AC=y +CONFIG_ACPI_BATTERY=y +CONFIG_ACPI_BUTTON=y +CONFIG_ACPI_VIDEO=y +CONFIG_ACPI_FAN=y +CONFIG_ACPI_DOCK=y +CONFIG_ACPI_CPU_FREQ_PSS=y +CONFIG_ACPI_PROCESSOR_CSTATE=y +CONFIG_ACPI_PROCESSOR_IDLE=y +CONFIG_ACPI_CPPC_LIB=y +CONFIG_ACPI_PROCESSOR=y +CONFIG_ACPI_IPMI=y +CONFIG_ACPI_HOTPLUG_CPU=y +CONFIG_ACPI_PROCESSOR_AGGREGATOR=y +CONFIG_ACPI_THERMAL=y +CONFIG_ACPI_NUMA=y +# CONFIG_ACPI_CUSTOM_DSDT is not set +CONFIG_ARCH_HAS_ACPI_TABLE_UPGRADE=y +CONFIG_ACPI_TABLE_UPGRADE=y +CONFIG_ACPI_DEBUG=y +CONFIG_ACPI_PCI_SLOT=y +CONFIG_ACPI_CONTAINER=y +CONFIG_ACPI_HOTPLUG_MEMORY=y +CONFIG_ACPI_HOTPLUG_IOAPIC=y +CONFIG_ACPI_SBS=y +CONFIG_ACPI_HED=y +CONFIG_ACPI_CUSTOM_METHOD=y +CONFIG_ACPI_BGRT=y +CONFIG_ACPI_REDUCED_HARDWARE_ONLY=y +CONFIG_ACPI_NFIT=y +CONFIG_HAVE_ACPI_APEI=y +CONFIG_HAVE_ACPI_APEI_NMI=y +CONFIG_ACPI_APEI=y +CONFIG_ACPI_APEI_GHES=y +CONFIG_ACPI_APEI_PCIEAER=y +CONFIG_ACPI_APEI_MEMORY_FAILURE=y +CONFIG_ACPI_APEI_EINJ=y +CONFIG_ACPI_APEI_ERST_DEBUG=y +CONFIG_DPTF_POWER=y +CONFIG_ACPI_WATCHDOG=y +CONFIG_ACPI_EXTLOG=y +CONFIG_PMIC_OPREGION=y +CONFIG_CRC_PMIC_OPREGION=y +CONFIG_XPOWER_PMIC_OPREGION=y +CONFIG_BXT_WC_PMIC_OPREGION=y +CONFIG_CHT_WC_PMIC_OPREGION=y +CONFIG_CHT_DC_TI_PMIC_OPREGION=y +CONFIG_ACPI_CONFIGFS=y +CONFIG_TPS68470_PMIC_OPREGION=y +CONFIG_X86_PM_TIMER=y +CONFIG_SFI=y + +# +# CPU Frequency scaling +# +CONFIG_CPU_FREQ=y +CONFIG_CPU_FREQ_GOV_ATTR_SET=y +CONFIG_CPU_FREQ_GOV_COMMON=y +CONFIG_CPU_FREQ_STAT=y +CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y +# CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_SCHEDUTIL is not set +CONFIG_CPU_FREQ_GOV_PERFORMANCE=y +CONFIG_CPU_FREQ_GOV_POWERSAVE=y +CONFIG_CPU_FREQ_GOV_USERSPACE=y +CONFIG_CPU_FREQ_GOV_ONDEMAND=y +CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y +CONFIG_CPU_FREQ_GOV_SCHEDUTIL=y + +# +# CPU frequency scaling drivers +# +CONFIG_CPUFREQ_DT=y +CONFIG_CPUFREQ_DT_PLATDEV=y +CONFIG_X86_INTEL_PSTATE=y +CONFIG_X86_PCC_CPUFREQ=y +CONFIG_X86_ACPI_CPUFREQ=y +CONFIG_X86_ACPI_CPUFREQ_CPB=y +CONFIG_X86_SFI_CPUFREQ=y +CONFIG_X86_POWERNOW_K8=y +CONFIG_X86_AMD_FREQ_SENSITIVITY=y +CONFIG_X86_SPEEDSTEP_CENTRINO=y +CONFIG_X86_P4_CLOCKMOD=y + +# +# shared options +# +CONFIG_X86_SPEEDSTEP_LIB=y + +# +# CPU Idle +# +CONFIG_CPU_IDLE=y +CONFIG_CPU_IDLE_GOV_LADDER=y +CONFIG_CPU_IDLE_GOV_MENU=y +# CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED is not set +CONFIG_INTEL_IDLE=y + +# +# Bus options (PCI etc.) +# +CONFIG_PCI=y +CONFIG_PCI_DIRECT=y +CONFIG_PCI_MMCONFIG=y +CONFIG_PCI_XEN=y +CONFIG_PCI_DOMAINS=y +CONFIG_PCI_CNB20LE_QUIRK=y +CONFIG_PCIEPORTBUS=y +CONFIG_HOTPLUG_PCI_PCIE=y +CONFIG_PCIEAER=y +CONFIG_PCIE_ECRC=y +CONFIG_PCIEAER_INJECT=y +CONFIG_PCIEASPM=y +CONFIG_PCIEASPM_DEBUG=y +CONFIG_PCIEASPM_DEFAULT=y +# CONFIG_PCIEASPM_POWERSAVE is not set +# CONFIG_PCIEASPM_POWER_SUPERSAVE is not set +# CONFIG_PCIEASPM_PERFORMANCE is not set +CONFIG_PCIE_PME=y +CONFIG_PCIE_DPC=y +CONFIG_PCIE_PTM=y +CONFIG_PCI_BUS_ADDR_T_64BIT=y +CONFIG_PCI_MSI=y +CONFIG_PCI_MSI_IRQ_DOMAIN=y +CONFIG_PCI_QUIRKS=y +CONFIG_PCI_DEBUG=y +CONFIG_PCI_REALLOC_ENABLE_AUTO=y +CONFIG_PCI_STUB=y +CONFIG_XEN_PCIDEV_FRONTEND=y +CONFIG_PCI_ATS=y +CONFIG_PCI_LOCKLESS_CONFIG=y +CONFIG_PCI_IOV=y +CONFIG_PCI_PRI=y +CONFIG_PCI_PASID=y +CONFIG_PCI_LABEL=y +CONFIG_PCI_HYPERV=y +CONFIG_HOTPLUG_PCI=y +CONFIG_HOTPLUG_PCI_ACPI=y +CONFIG_HOTPLUG_PCI_ACPI_IBM=y +CONFIG_HOTPLUG_PCI_CPCI=y +CONFIG_HOTPLUG_PCI_CPCI_ZT5550=y +CONFIG_HOTPLUG_PCI_CPCI_GENERIC=y +CONFIG_HOTPLUG_PCI_SHPC=y + +# +# Cadence PCIe controllers support +# +CONFIG_PCIE_CADENCE=y +CONFIG_PCIE_CADENCE_HOST=y +CONFIG_PCIE_CADENCE_EP=y + +# +# DesignWare PCI Core Support +# +CONFIG_PCIE_DW=y +CONFIG_PCIE_DW_HOST=y +CONFIG_PCIE_DW_PLAT=y + +# +# PCI host controller drivers +# +CONFIG_PCIE_ROCKCHIP=y +CONFIG_VMD=y + +# +# PCI Endpoint +# +CONFIG_PCI_ENDPOINT=y +CONFIG_PCI_ENDPOINT_CONFIGFS=y +CONFIG_PCI_EPF_TEST=y + +# +# PCI switch controller drivers +# +CONFIG_PCI_SW_SWITCHTEC=y +CONFIG_ISA_BUS=y +CONFIG_ISA_DMA_API=y +CONFIG_AMD_NB=y +CONFIG_PCCARD=y +CONFIG_PCMCIA=y +CONFIG_PCMCIA_LOAD_CIS=y +CONFIG_CARDBUS=y + +# +# PC-card bridges +# +CONFIG_YENTA=y +CONFIG_YENTA_O2=y +CONFIG_YENTA_RICOH=y +CONFIG_YENTA_TI=y +CONFIG_YENTA_ENE_TUNE=y +CONFIG_YENTA_TOSHIBA=y +CONFIG_PD6729=y +CONFIG_I82092=y +CONFIG_PCCARD_NONSTATIC=y +CONFIG_RAPIDIO=y +CONFIG_RAPIDIO_TSI721=y +CONFIG_RAPIDIO_DISC_TIMEOUT=30 +CONFIG_RAPIDIO_ENABLE_RX_TX_PORTS=y +CONFIG_RAPIDIO_DMA_ENGINE=y +CONFIG_RAPIDIO_DEBUG=y +CONFIG_RAPIDIO_ENUM_BASIC=y +CONFIG_RAPIDIO_CHMAN=y +CONFIG_RAPIDIO_MPORT_CDEV=y + +# +# RapidIO Switch drivers +# +CONFIG_RAPIDIO_TSI57X=y +CONFIG_RAPIDIO_CPS_XX=y +CONFIG_RAPIDIO_TSI568=y +CONFIG_RAPIDIO_CPS_GEN2=y +CONFIG_RAPIDIO_RXS_GEN3=y +CONFIG_X86_SYSFB=y + +# +# Executable file formats / Emulations +# +CONFIG_BINFMT_ELF=y +CONFIG_COMPAT_BINFMT_ELF=y +CONFIG_ELFCORE=y +CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y +CONFIG_BINFMT_SCRIPT=y +# CONFIG_HAVE_AOUT is not set +CONFIG_BINFMT_MISC=y +CONFIG_COREDUMP=y +CONFIG_IA32_EMULATION=y +CONFIG_IA32_AOUT=y +CONFIG_X86_X32=y +CONFIG_COMPAT_32=y +CONFIG_COMPAT=y +CONFIG_COMPAT_FOR_U64_ALIGNMENT=y +CONFIG_SYSVIPC_COMPAT=y +CONFIG_X86_DEV_DMA_OPS=y +CONFIG_NET=y +CONFIG_COMPAT_NETLINK_MESSAGES=y +CONFIG_NET_INGRESS=y +CONFIG_NET_EGRESS=y + +# +# Networking options +# +CONFIG_PACKET=y +CONFIG_PACKET_DIAG=y +CONFIG_UNIX=y +CONFIG_UNIX_DIAG=y +CONFIG_TLS=y +CONFIG_XFRM=y +CONFIG_XFRM_OFFLOAD=y +CONFIG_XFRM_ALGO=y +CONFIG_XFRM_USER=y +CONFIG_XFRM_SUB_POLICY=y +CONFIG_XFRM_MIGRATE=y +CONFIG_XFRM_STATISTICS=y +CONFIG_XFRM_IPCOMP=y +CONFIG_NET_KEY=y +CONFIG_NET_KEY_MIGRATE=y +CONFIG_SMC=y +CONFIG_SMC_DIAG=y +CONFIG_INET=y +CONFIG_IP_MULTICAST=y +CONFIG_IP_ADVANCED_ROUTER=y +CONFIG_IP_FIB_TRIE_STATS=y +CONFIG_IP_MULTIPLE_TABLES=y +CONFIG_IP_ROUTE_MULTIPATH=y +CONFIG_IP_ROUTE_VERBOSE=y +CONFIG_IP_ROUTE_CLASSID=y +CONFIG_IP_PNP=y +CONFIG_IP_PNP_DHCP=y +CONFIG_IP_PNP_BOOTP=y +CONFIG_IP_PNP_RARP=y +CONFIG_NET_IPIP=y +CONFIG_NET_IPGRE_DEMUX=y +CONFIG_NET_IP_TUNNEL=y +CONFIG_NET_IPGRE=y +CONFIG_NET_IPGRE_BROADCAST=y +CONFIG_IP_MROUTE=y +CONFIG_IP_MROUTE_MULTIPLE_TABLES=y +CONFIG_IP_PIMSM_V1=y +CONFIG_IP_PIMSM_V2=y +CONFIG_SYN_COOKIES=y +CONFIG_NET_IPVTI=y +CONFIG_NET_UDP_TUNNEL=y +CONFIG_NET_FOU=y +CONFIG_NET_FOU_IP_TUNNELS=y +CONFIG_INET_AH=y +CONFIG_INET_ESP=y +CONFIG_INET_ESP_OFFLOAD=y +CONFIG_INET_IPCOMP=y +CONFIG_INET_XFRM_TUNNEL=y +CONFIG_INET_TUNNEL=y +CONFIG_INET_XFRM_MODE_TRANSPORT=y +CONFIG_INET_XFRM_MODE_TUNNEL=y +CONFIG_INET_XFRM_MODE_BEET=y +CONFIG_INET_DIAG=y +CONFIG_INET_TCP_DIAG=y +CONFIG_INET_UDP_DIAG=y +CONFIG_INET_RAW_DIAG=y +CONFIG_INET_DIAG_DESTROY=y +CONFIG_TCP_CONG_ADVANCED=y +CONFIG_TCP_CONG_BIC=y +CONFIG_TCP_CONG_CUBIC=y +CONFIG_TCP_CONG_WESTWOOD=y +CONFIG_TCP_CONG_HTCP=y +CONFIG_TCP_CONG_HSTCP=y +CONFIG_TCP_CONG_HYBLA=y +CONFIG_TCP_CONG_VEGAS=y +CONFIG_TCP_CONG_NV=y +CONFIG_TCP_CONG_SCALABLE=y +CONFIG_TCP_CONG_LP=y +CONFIG_TCP_CONG_VENO=y +CONFIG_TCP_CONG_YEAH=y +CONFIG_TCP_CONG_ILLINOIS=y +CONFIG_TCP_CONG_DCTCP=y +CONFIG_TCP_CONG_CDG=y +CONFIG_TCP_CONG_BBR=y +# CONFIG_DEFAULT_BIC is not set +CONFIG_DEFAULT_CUBIC=y +# CONFIG_DEFAULT_HTCP is not set +# CONFIG_DEFAULT_HYBLA is not set +# CONFIG_DEFAULT_VEGAS is not set +# CONFIG_DEFAULT_VENO is not set +# CONFIG_DEFAULT_WESTWOOD is not set +# CONFIG_DEFAULT_DCTCP is not set +# CONFIG_DEFAULT_CDG is not set +# CONFIG_DEFAULT_BBR is not set +# CONFIG_DEFAULT_RENO is not set +CONFIG_DEFAULT_TCP_CONG="cubic" +CONFIG_TCP_MD5SIG=y +CONFIG_IPV6=y +CONFIG_IPV6_ROUTER_PREF=y +CONFIG_IPV6_ROUTE_INFO=y +CONFIG_IPV6_OPTIMISTIC_DAD=y +CONFIG_INET6_AH=y +CONFIG_INET6_ESP=y +CONFIG_INET6_ESP_OFFLOAD=y +CONFIG_INET6_IPCOMP=y +CONFIG_IPV6_MIP6=y +CONFIG_IPV6_ILA=y +CONFIG_INET6_XFRM_TUNNEL=y +CONFIG_INET6_TUNNEL=y +CONFIG_INET6_XFRM_MODE_TRANSPORT=y +CONFIG_INET6_XFRM_MODE_TUNNEL=y +CONFIG_INET6_XFRM_MODE_BEET=y +CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION=y +CONFIG_IPV6_VTI=y +CONFIG_IPV6_SIT=y +CONFIG_IPV6_SIT_6RD=y +CONFIG_IPV6_NDISC_NODETYPE=y +CONFIG_IPV6_TUNNEL=y +CONFIG_IPV6_GRE=y +CONFIG_IPV6_FOU=y +CONFIG_IPV6_FOU_TUNNEL=y +CONFIG_IPV6_MULTIPLE_TABLES=y +CONFIG_IPV6_SUBTREES=y +CONFIG_IPV6_MROUTE=y +CONFIG_IPV6_MROUTE_MULTIPLE_TABLES=y +CONFIG_IPV6_PIMSM_V2=y +CONFIG_IPV6_SEG6_LWTUNNEL=y +CONFIG_IPV6_SEG6_HMAC=y +CONFIG_NETLABEL=y +CONFIG_NETWORK_SECMARK=y +CONFIG_NET_PTP_CLASSIFY=y +CONFIG_NETWORK_PHY_TIMESTAMPING=y +CONFIG_NETFILTER=y +CONFIG_NETFILTER_ADVANCED=y +CONFIG_BRIDGE_NETFILTER=y + +# +# Core Netfilter Configuration +# +CONFIG_NETFILTER_INGRESS=y +CONFIG_NETFILTER_NETLINK=y +CONFIG_NETFILTER_FAMILY_BRIDGE=y +CONFIG_NETFILTER_FAMILY_ARP=y +CONFIG_NETFILTER_NETLINK_ACCT=y +CONFIG_NETFILTER_NETLINK_QUEUE=y +CONFIG_NETFILTER_NETLINK_LOG=y +CONFIG_NF_CONNTRACK=y +CONFIG_NF_LOG_COMMON=y +CONFIG_NF_LOG_NETDEV=y +CONFIG_NETFILTER_CONNCOUNT=y +CONFIG_NF_CONNTRACK_MARK=y +CONFIG_NF_CONNTRACK_SECMARK=y +CONFIG_NF_CONNTRACK_ZONES=y +CONFIG_NF_CONNTRACK_PROCFS=y +CONFIG_NF_CONNTRACK_EVENTS=y +CONFIG_NF_CONNTRACK_TIMEOUT=y +CONFIG_NF_CONNTRACK_TIMESTAMP=y +CONFIG_NF_CONNTRACK_LABELS=y +CONFIG_NF_CT_PROTO_DCCP=y +CONFIG_NF_CT_PROTO_GRE=y +CONFIG_NF_CT_PROTO_SCTP=y +CONFIG_NF_CT_PROTO_UDPLITE=y +CONFIG_NF_CONNTRACK_AMANDA=y +CONFIG_NF_CONNTRACK_FTP=y +CONFIG_NF_CONNTRACK_H323=y +CONFIG_NF_CONNTRACK_IRC=y +CONFIG_NF_CONNTRACK_BROADCAST=y +CONFIG_NF_CONNTRACK_NETBIOS_NS=y +CONFIG_NF_CONNTRACK_SNMP=y +CONFIG_NF_CONNTRACK_PPTP=y +CONFIG_NF_CONNTRACK_SANE=y +CONFIG_NF_CONNTRACK_SIP=y +CONFIG_NF_CONNTRACK_TFTP=y +CONFIG_NF_CT_NETLINK=y +CONFIG_NF_CT_NETLINK_TIMEOUT=y +CONFIG_NF_CT_NETLINK_HELPER=y +CONFIG_NETFILTER_NETLINK_GLUE_CT=y +CONFIG_NF_NAT=y +CONFIG_NF_NAT_NEEDED=y +CONFIG_NF_NAT_PROTO_DCCP=y +CONFIG_NF_NAT_PROTO_UDPLITE=y +CONFIG_NF_NAT_PROTO_SCTP=y +CONFIG_NF_NAT_AMANDA=y +CONFIG_NF_NAT_FTP=y +CONFIG_NF_NAT_IRC=y +CONFIG_NF_NAT_SIP=y +CONFIG_NF_NAT_TFTP=y +CONFIG_NF_NAT_REDIRECT=y +CONFIG_NETFILTER_SYNPROXY=y +CONFIG_NF_TABLES=y +CONFIG_NF_TABLES_INET=y +CONFIG_NF_TABLES_NETDEV=y +CONFIG_NFT_EXTHDR=y +CONFIG_NFT_META=y +CONFIG_NFT_RT=y +CONFIG_NFT_NUMGEN=y +CONFIG_NFT_CT=y +CONFIG_NFT_FLOW_OFFLOAD=y +CONFIG_NFT_SET_RBTREE=y +CONFIG_NFT_SET_HASH=y +CONFIG_NFT_SET_BITMAP=y +CONFIG_NFT_COUNTER=y +CONFIG_NFT_LOG=y +CONFIG_NFT_LIMIT=y +CONFIG_NFT_MASQ=y +CONFIG_NFT_REDIR=y +CONFIG_NFT_NAT=y +CONFIG_NFT_OBJREF=y +CONFIG_NFT_QUEUE=y +CONFIG_NFT_QUOTA=y +CONFIG_NFT_REJECT=y +CONFIG_NFT_REJECT_INET=y +CONFIG_NFT_COMPAT=y +CONFIG_NFT_HASH=y +CONFIG_NFT_FIB=y +CONFIG_NFT_FIB_INET=y +CONFIG_NF_DUP_NETDEV=y +CONFIG_NFT_DUP_NETDEV=y +CONFIG_NFT_FWD_NETDEV=y +CONFIG_NFT_FIB_NETDEV=y +CONFIG_NF_FLOW_TABLE_INET=y +CONFIG_NF_FLOW_TABLE=y +CONFIG_NETFILTER_XTABLES=y + +# +# Xtables combined modules +# +CONFIG_NETFILTER_XT_MARK=y +CONFIG_NETFILTER_XT_CONNMARK=y +CONFIG_NETFILTER_XT_SET=y + +# +# Xtables targets +# +CONFIG_NETFILTER_XT_TARGET_AUDIT=y +CONFIG_NETFILTER_XT_TARGET_CHECKSUM=y +CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y +CONFIG_NETFILTER_XT_TARGET_CONNMARK=y +CONFIG_NETFILTER_XT_TARGET_CONNSECMARK=y +CONFIG_NETFILTER_XT_TARGET_CT=y +CONFIG_NETFILTER_XT_TARGET_DSCP=y +CONFIG_NETFILTER_XT_TARGET_HL=y +CONFIG_NETFILTER_XT_TARGET_HMARK=y +CONFIG_NETFILTER_XT_TARGET_IDLETIMER=y +CONFIG_NETFILTER_XT_TARGET_LED=y +CONFIG_NETFILTER_XT_TARGET_LOG=y +CONFIG_NETFILTER_XT_TARGET_MARK=y +CONFIG_NETFILTER_XT_NAT=y +CONFIG_NETFILTER_XT_TARGET_NETMAP=y +CONFIG_NETFILTER_XT_TARGET_NFLOG=y +CONFIG_NETFILTER_XT_TARGET_NFQUEUE=y +CONFIG_NETFILTER_XT_TARGET_NOTRACK=y +CONFIG_NETFILTER_XT_TARGET_RATEEST=y +CONFIG_NETFILTER_XT_TARGET_REDIRECT=y +CONFIG_NETFILTER_XT_TARGET_TEE=y +CONFIG_NETFILTER_XT_TARGET_TPROXY=y +CONFIG_NETFILTER_XT_TARGET_TRACE=y +CONFIG_NETFILTER_XT_TARGET_SECMARK=y +CONFIG_NETFILTER_XT_TARGET_TCPMSS=y +CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP=y + +# +# Xtables matches +# +CONFIG_NETFILTER_XT_MATCH_ADDRTYPE=y +CONFIG_NETFILTER_XT_MATCH_BPF=y +CONFIG_NETFILTER_XT_MATCH_CGROUP=y +CONFIG_NETFILTER_XT_MATCH_CLUSTER=y +CONFIG_NETFILTER_XT_MATCH_COMMENT=y +CONFIG_NETFILTER_XT_MATCH_CONNBYTES=y +CONFIG_NETFILTER_XT_MATCH_CONNLABEL=y +CONFIG_NETFILTER_XT_MATCH_CONNLIMIT=y +CONFIG_NETFILTER_XT_MATCH_CONNMARK=y +CONFIG_NETFILTER_XT_MATCH_CONNTRACK=y +CONFIG_NETFILTER_XT_MATCH_CPU=y +CONFIG_NETFILTER_XT_MATCH_DCCP=y +CONFIG_NETFILTER_XT_MATCH_DEVGROUP=y +CONFIG_NETFILTER_XT_MATCH_DSCP=y +CONFIG_NETFILTER_XT_MATCH_ECN=y +CONFIG_NETFILTER_XT_MATCH_ESP=y +CONFIG_NETFILTER_XT_MATCH_HASHLIMIT=y +CONFIG_NETFILTER_XT_MATCH_HELPER=y +CONFIG_NETFILTER_XT_MATCH_HL=y +CONFIG_NETFILTER_XT_MATCH_IPCOMP=y +CONFIG_NETFILTER_XT_MATCH_IPRANGE=y +CONFIG_NETFILTER_XT_MATCH_IPVS=y +CONFIG_NETFILTER_XT_MATCH_L2TP=y +CONFIG_NETFILTER_XT_MATCH_LENGTH=y +CONFIG_NETFILTER_XT_MATCH_LIMIT=y +CONFIG_NETFILTER_XT_MATCH_MAC=y +CONFIG_NETFILTER_XT_MATCH_MARK=y +CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y +CONFIG_NETFILTER_XT_MATCH_NFACCT=y +CONFIG_NETFILTER_XT_MATCH_OSF=y +CONFIG_NETFILTER_XT_MATCH_OWNER=y +CONFIG_NETFILTER_XT_MATCH_POLICY=y +CONFIG_NETFILTER_XT_MATCH_PHYSDEV=y +CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y +CONFIG_NETFILTER_XT_MATCH_QUOTA=y +CONFIG_NETFILTER_XT_MATCH_RATEEST=y +CONFIG_NETFILTER_XT_MATCH_REALM=y +CONFIG_NETFILTER_XT_MATCH_RECENT=y +CONFIG_NETFILTER_XT_MATCH_SCTP=y +CONFIG_NETFILTER_XT_MATCH_SOCKET=y +CONFIG_NETFILTER_XT_MATCH_STATE=y +CONFIG_NETFILTER_XT_MATCH_STATISTIC=y +CONFIG_NETFILTER_XT_MATCH_STRING=y +CONFIG_NETFILTER_XT_MATCH_TCPMSS=y +CONFIG_NETFILTER_XT_MATCH_TIME=y +CONFIG_NETFILTER_XT_MATCH_U32=y +CONFIG_IP_SET=y +CONFIG_IP_SET_MAX=256 +CONFIG_IP_SET_BITMAP_IP=y +CONFIG_IP_SET_BITMAP_IPMAC=y +CONFIG_IP_SET_BITMAP_PORT=y +CONFIG_IP_SET_HASH_IP=y +CONFIG_IP_SET_HASH_IPMARK=y +CONFIG_IP_SET_HASH_IPPORT=y +CONFIG_IP_SET_HASH_IPPORTIP=y +CONFIG_IP_SET_HASH_IPPORTNET=y +CONFIG_IP_SET_HASH_IPMAC=y +CONFIG_IP_SET_HASH_MAC=y +CONFIG_IP_SET_HASH_NETPORTNET=y +CONFIG_IP_SET_HASH_NET=y +CONFIG_IP_SET_HASH_NETNET=y +CONFIG_IP_SET_HASH_NETPORT=y +CONFIG_IP_SET_HASH_NETIFACE=y +CONFIG_IP_SET_LIST_SET=y +CONFIG_IP_VS=y +CONFIG_IP_VS_IPV6=y +CONFIG_IP_VS_DEBUG=y +CONFIG_IP_VS_TAB_BITS=12 + +# +# IPVS transport protocol load balancing support +# +CONFIG_IP_VS_PROTO_TCP=y +CONFIG_IP_VS_PROTO_UDP=y +CONFIG_IP_VS_PROTO_AH_ESP=y +CONFIG_IP_VS_PROTO_ESP=y +CONFIG_IP_VS_PROTO_AH=y +CONFIG_IP_VS_PROTO_SCTP=y + +# +# IPVS scheduler +# +CONFIG_IP_VS_RR=y +CONFIG_IP_VS_WRR=y +CONFIG_IP_VS_LC=y +CONFIG_IP_VS_WLC=y +CONFIG_IP_VS_FO=y +CONFIG_IP_VS_OVF=y +CONFIG_IP_VS_LBLC=y +CONFIG_IP_VS_LBLCR=y +CONFIG_IP_VS_DH=y +CONFIG_IP_VS_SH=y +CONFIG_IP_VS_SED=y +CONFIG_IP_VS_NQ=y + +# +# IPVS SH scheduler +# +CONFIG_IP_VS_SH_TAB_BITS=8 + +# +# IPVS application helper +# +CONFIG_IP_VS_FTP=y +CONFIG_IP_VS_NFCT=y +CONFIG_IP_VS_PE_SIP=y + +# +# IP: Netfilter Configuration +# +CONFIG_NF_DEFRAG_IPV4=y +CONFIG_NF_CONNTRACK_IPV4=y +CONFIG_NF_SOCKET_IPV4=y +CONFIG_NF_TABLES_IPV4=y +CONFIG_NFT_CHAIN_ROUTE_IPV4=y +CONFIG_NFT_REJECT_IPV4=y +CONFIG_NFT_DUP_IPV4=y +CONFIG_NFT_FIB_IPV4=y +CONFIG_NF_TABLES_ARP=y +CONFIG_NF_FLOW_TABLE_IPV4=y +CONFIG_NF_DUP_IPV4=y +CONFIG_NF_LOG_ARP=y +CONFIG_NF_LOG_IPV4=y +CONFIG_NF_REJECT_IPV4=y +CONFIG_NF_NAT_IPV4=y +CONFIG_NFT_CHAIN_NAT_IPV4=y +CONFIG_NF_NAT_MASQUERADE_IPV4=y +CONFIG_NFT_MASQ_IPV4=y +CONFIG_NFT_REDIR_IPV4=y +CONFIG_NF_NAT_SNMP_BASIC=y +CONFIG_NF_NAT_PROTO_GRE=y +CONFIG_NF_NAT_PPTP=y +CONFIG_NF_NAT_H323=y +CONFIG_IP_NF_IPTABLES=y +CONFIG_IP_NF_MATCH_AH=y +CONFIG_IP_NF_MATCH_ECN=y +CONFIG_IP_NF_MATCH_RPFILTER=y +CONFIG_IP_NF_MATCH_TTL=y +CONFIG_IP_NF_FILTER=y +CONFIG_IP_NF_TARGET_REJECT=y +CONFIG_IP_NF_TARGET_SYNPROXY=y +CONFIG_IP_NF_NAT=y +CONFIG_IP_NF_TARGET_MASQUERADE=y +CONFIG_IP_NF_TARGET_NETMAP=y +CONFIG_IP_NF_TARGET_REDIRECT=y +CONFIG_IP_NF_MANGLE=y +CONFIG_IP_NF_TARGET_CLUSTERIP=y +CONFIG_IP_NF_TARGET_ECN=y +CONFIG_IP_NF_TARGET_TTL=y +CONFIG_IP_NF_RAW=y +CONFIG_IP_NF_SECURITY=y +CONFIG_IP_NF_ARPTABLES=y +CONFIG_IP_NF_ARPFILTER=y +CONFIG_IP_NF_ARP_MANGLE=y + +# +# IPv6: Netfilter Configuration +# +CONFIG_NF_DEFRAG_IPV6=y +CONFIG_NF_CONNTRACK_IPV6=y +CONFIG_NF_SOCKET_IPV6=y +CONFIG_NF_TABLES_IPV6=y +CONFIG_NFT_CHAIN_ROUTE_IPV6=y +CONFIG_NFT_REJECT_IPV6=y +CONFIG_NFT_DUP_IPV6=y +CONFIG_NFT_FIB_IPV6=y +CONFIG_NF_FLOW_TABLE_IPV6=y +CONFIG_NF_DUP_IPV6=y +CONFIG_NF_REJECT_IPV6=y +CONFIG_NF_LOG_IPV6=y +CONFIG_NF_NAT_IPV6=y +CONFIG_NFT_CHAIN_NAT_IPV6=y +CONFIG_NF_NAT_MASQUERADE_IPV6=y +CONFIG_NFT_MASQ_IPV6=y +CONFIG_NFT_REDIR_IPV6=y +CONFIG_IP6_NF_IPTABLES=y +CONFIG_IP6_NF_MATCH_AH=y +CONFIG_IP6_NF_MATCH_EUI64=y +CONFIG_IP6_NF_MATCH_FRAG=y +CONFIG_IP6_NF_MATCH_OPTS=y +CONFIG_IP6_NF_MATCH_HL=y +CONFIG_IP6_NF_MATCH_IPV6HEADER=y +CONFIG_IP6_NF_MATCH_MH=y +CONFIG_IP6_NF_MATCH_RPFILTER=y +CONFIG_IP6_NF_MATCH_RT=y +CONFIG_IP6_NF_MATCH_SRH=y +CONFIG_IP6_NF_TARGET_HL=y +CONFIG_IP6_NF_FILTER=y +CONFIG_IP6_NF_TARGET_REJECT=y +CONFIG_IP6_NF_TARGET_SYNPROXY=y +CONFIG_IP6_NF_MANGLE=y +CONFIG_IP6_NF_RAW=y +CONFIG_IP6_NF_SECURITY=y +CONFIG_IP6_NF_NAT=y +CONFIG_IP6_NF_TARGET_MASQUERADE=y +CONFIG_IP6_NF_TARGET_NPT=y + +# +# DECnet: Netfilter Configuration +# +CONFIG_DECNET_NF_GRABULATOR=y +CONFIG_NF_TABLES_BRIDGE=y +CONFIG_NFT_BRIDGE_META=y +CONFIG_NFT_BRIDGE_REJECT=y +CONFIG_NF_LOG_BRIDGE=y +CONFIG_BRIDGE_NF_EBTABLES=y +CONFIG_BRIDGE_EBT_BROUTE=y +CONFIG_BRIDGE_EBT_T_FILTER=y +CONFIG_BRIDGE_EBT_T_NAT=y +CONFIG_BRIDGE_EBT_802_3=y +CONFIG_BRIDGE_EBT_AMONG=y +CONFIG_BRIDGE_EBT_ARP=y +CONFIG_BRIDGE_EBT_IP=y +CONFIG_BRIDGE_EBT_IP6=y +CONFIG_BRIDGE_EBT_LIMIT=y +CONFIG_BRIDGE_EBT_MARK=y +CONFIG_BRIDGE_EBT_PKTTYPE=y +CONFIG_BRIDGE_EBT_STP=y +CONFIG_BRIDGE_EBT_VLAN=y +CONFIG_BRIDGE_EBT_ARPREPLY=y +CONFIG_BRIDGE_EBT_DNAT=y +CONFIG_BRIDGE_EBT_MARK_T=y +CONFIG_BRIDGE_EBT_REDIRECT=y +CONFIG_BRIDGE_EBT_SNAT=y +CONFIG_BRIDGE_EBT_LOG=y +CONFIG_BRIDGE_EBT_NFLOG=y +CONFIG_IP_DCCP=y +CONFIG_INET_DCCP_DIAG=y + +# +# DCCP CCIDs Configuration +# +CONFIG_IP_DCCP_CCID2_DEBUG=y +CONFIG_IP_DCCP_CCID3=y +CONFIG_IP_DCCP_CCID3_DEBUG=y +CONFIG_IP_DCCP_TFRC_LIB=y +CONFIG_IP_DCCP_TFRC_DEBUG=y + +# +# DCCP Kernel Hacking +# +CONFIG_IP_DCCP_DEBUG=y +CONFIG_IP_SCTP=y +CONFIG_SCTP_DBG_OBJCNT=y +CONFIG_SCTP_DEFAULT_COOKIE_HMAC_MD5=y +# CONFIG_SCTP_DEFAULT_COOKIE_HMAC_SHA1 is not set +# CONFIG_SCTP_DEFAULT_COOKIE_HMAC_NONE is not set +CONFIG_SCTP_COOKIE_HMAC_MD5=y +CONFIG_SCTP_COOKIE_HMAC_SHA1=y +CONFIG_INET_SCTP_DIAG=y +CONFIG_RDS=y +CONFIG_RDS_RDMA=y +CONFIG_RDS_TCP=y +CONFIG_RDS_DEBUG=y +CONFIG_TIPC=y +CONFIG_TIPC_MEDIA_IB=y +CONFIG_TIPC_MEDIA_UDP=y +CONFIG_ATM=y +CONFIG_ATM_CLIP=y +CONFIG_ATM_CLIP_NO_ICMP=y +CONFIG_ATM_LANE=y +CONFIG_ATM_MPOA=y +CONFIG_ATM_BR2684=y +CONFIG_ATM_BR2684_IPFILTER=y +CONFIG_L2TP=y +CONFIG_L2TP_DEBUGFS=y +CONFIG_L2TP_V3=y +CONFIG_L2TP_IP=y +CONFIG_L2TP_ETH=y +CONFIG_STP=y +CONFIG_GARP=y +CONFIG_MRP=y +CONFIG_BRIDGE=y +CONFIG_BRIDGE_IGMP_SNOOPING=y +CONFIG_BRIDGE_VLAN_FILTERING=y +CONFIG_HAVE_NET_DSA=y +CONFIG_NET_DSA=y +CONFIG_NET_DSA_LEGACY=y +CONFIG_NET_DSA_TAG_BRCM=y +CONFIG_NET_DSA_TAG_BRCM_PREPEND=y +CONFIG_NET_DSA_TAG_DSA=y +CONFIG_NET_DSA_TAG_EDSA=y +CONFIG_NET_DSA_TAG_KSZ=y +CONFIG_NET_DSA_TAG_LAN9303=y +CONFIG_NET_DSA_TAG_MTK=y +CONFIG_NET_DSA_TAG_TRAILER=y +CONFIG_NET_DSA_TAG_QCA=y +CONFIG_VLAN_8021Q=y +CONFIG_VLAN_8021Q_GVRP=y +CONFIG_VLAN_8021Q_MVRP=y +CONFIG_DECNET=y +CONFIG_DECNET_ROUTER=y +CONFIG_LLC=y +CONFIG_LLC2=y +CONFIG_ATALK=y +CONFIG_DEV_APPLETALK=y +CONFIG_IPDDP=y +CONFIG_IPDDP_ENCAP=y +CONFIG_X25=y +CONFIG_LAPB=y +CONFIG_PHONET=y +CONFIG_6LOWPAN=y +CONFIG_6LOWPAN_DEBUGFS=y +CONFIG_6LOWPAN_NHC=y +CONFIG_6LOWPAN_NHC_DEST=y +CONFIG_6LOWPAN_NHC_FRAGMENT=y +CONFIG_6LOWPAN_NHC_HOP=y +CONFIG_6LOWPAN_NHC_IPV6=y +CONFIG_6LOWPAN_NHC_MOBILITY=y +CONFIG_6LOWPAN_NHC_ROUTING=y +CONFIG_6LOWPAN_NHC_UDP=y +CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=y +CONFIG_6LOWPAN_GHC_UDP=y +CONFIG_6LOWPAN_GHC_ICMPV6=y +CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=y +CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=y +CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=y +CONFIG_IEEE802154=y +CONFIG_IEEE802154_NL802154_EXPERIMENTAL=y +CONFIG_IEEE802154_SOCKET=y +CONFIG_IEEE802154_6LOWPAN=y +CONFIG_MAC802154=y +CONFIG_NET_SCHED=y + +# +# Queueing/Scheduling +# +CONFIG_NET_SCH_CBQ=y +CONFIG_NET_SCH_HTB=y +CONFIG_NET_SCH_HFSC=y +CONFIG_NET_SCH_ATM=y +CONFIG_NET_SCH_PRIO=y +CONFIG_NET_SCH_MULTIQ=y +CONFIG_NET_SCH_RED=y +CONFIG_NET_SCH_SFB=y +CONFIG_NET_SCH_SFQ=y +CONFIG_NET_SCH_TEQL=y +CONFIG_NET_SCH_TBF=y +CONFIG_NET_SCH_CBS=y +CONFIG_NET_SCH_GRED=y +CONFIG_NET_SCH_DSMARK=y +CONFIG_NET_SCH_NETEM=y +CONFIG_NET_SCH_DRR=y +CONFIG_NET_SCH_MQPRIO=y +CONFIG_NET_SCH_CHOKE=y +CONFIG_NET_SCH_QFQ=y +CONFIG_NET_SCH_CODEL=y +CONFIG_NET_SCH_FQ_CODEL=y +CONFIG_NET_SCH_FQ=y +CONFIG_NET_SCH_HHF=y +CONFIG_NET_SCH_PIE=y +CONFIG_NET_SCH_INGRESS=y +CONFIG_NET_SCH_PLUG=y +CONFIG_NET_SCH_DEFAULT=y +# CONFIG_DEFAULT_FQ is not set +# CONFIG_DEFAULT_CODEL is not set +# CONFIG_DEFAULT_FQ_CODEL is not set +# CONFIG_DEFAULT_SFQ is not set +CONFIG_DEFAULT_PFIFO_FAST=y +CONFIG_DEFAULT_NET_SCH="pfifo_fast" + +# +# Classification +# +CONFIG_NET_CLS=y +CONFIG_NET_CLS_BASIC=y +CONFIG_NET_CLS_TCINDEX=y +CONFIG_NET_CLS_ROUTE4=y +CONFIG_NET_CLS_FW=y +CONFIG_NET_CLS_U32=y +CONFIG_CLS_U32_PERF=y +CONFIG_CLS_U32_MARK=y +CONFIG_NET_CLS_RSVP=y +CONFIG_NET_CLS_RSVP6=y +CONFIG_NET_CLS_FLOW=y +CONFIG_NET_CLS_CGROUP=y +CONFIG_NET_CLS_BPF=y +CONFIG_NET_CLS_FLOWER=y +CONFIG_NET_CLS_MATCHALL=y +CONFIG_NET_EMATCH=y +CONFIG_NET_EMATCH_STACK=32 +CONFIG_NET_EMATCH_CMP=y +CONFIG_NET_EMATCH_NBYTE=y +CONFIG_NET_EMATCH_U32=y +CONFIG_NET_EMATCH_META=y +CONFIG_NET_EMATCH_TEXT=y +CONFIG_NET_EMATCH_CANID=y +CONFIG_NET_EMATCH_IPSET=y +CONFIG_NET_CLS_ACT=y +CONFIG_NET_ACT_POLICE=y +CONFIG_NET_ACT_GACT=y +CONFIG_GACT_PROB=y +CONFIG_NET_ACT_MIRRED=y +CONFIG_NET_ACT_SAMPLE=y +CONFIG_NET_ACT_IPT=y +CONFIG_NET_ACT_NAT=y +CONFIG_NET_ACT_PEDIT=y +CONFIG_NET_ACT_SIMP=y +CONFIG_NET_ACT_SKBEDIT=y +CONFIG_NET_ACT_CSUM=y +CONFIG_NET_ACT_VLAN=y +CONFIG_NET_ACT_BPF=y +CONFIG_NET_ACT_CONNMARK=y +CONFIG_NET_ACT_SKBMOD=y +CONFIG_NET_ACT_IFE=y +CONFIG_NET_ACT_TUNNEL_KEY=y +CONFIG_NET_IFE_SKBMARK=y +CONFIG_NET_IFE_SKBPRIO=y +CONFIG_NET_IFE_SKBTCINDEX=y +CONFIG_NET_CLS_IND=y +CONFIG_NET_SCH_FIFO=y +CONFIG_DCB=y +CONFIG_DNS_RESOLVER=y +CONFIG_BATMAN_ADV=y +CONFIG_BATMAN_ADV_BATMAN_V=y +CONFIG_BATMAN_ADV_BLA=y +CONFIG_BATMAN_ADV_DAT=y +CONFIG_BATMAN_ADV_NC=y +CONFIG_BATMAN_ADV_MCAST=y +CONFIG_BATMAN_ADV_DEBUGFS=y +CONFIG_BATMAN_ADV_DEBUG=y +CONFIG_OPENVSWITCH=y +CONFIG_OPENVSWITCH_GRE=y +CONFIG_OPENVSWITCH_VXLAN=y +CONFIG_OPENVSWITCH_GENEVE=y +CONFIG_VSOCKETS=y +CONFIG_VSOCKETS_DIAG=y +CONFIG_VMWARE_VMCI_VSOCKETS=y +CONFIG_VIRTIO_VSOCKETS=y +CONFIG_VIRTIO_VSOCKETS_COMMON=y +CONFIG_HYPERV_VSOCKETS=y +CONFIG_NETLINK_DIAG=y +CONFIG_MPLS=y +CONFIG_NET_MPLS_GSO=y +CONFIG_MPLS_ROUTING=y +CONFIG_MPLS_IPTUNNEL=y +CONFIG_NET_NSH=y +CONFIG_HSR=y +CONFIG_NET_SWITCHDEV=y +CONFIG_NET_L3_MASTER_DEV=y +CONFIG_QRTR=y +CONFIG_QRTR_SMD=y +CONFIG_NET_NCSI=y +CONFIG_RPS=y +CONFIG_RFS_ACCEL=y +CONFIG_XPS=y +CONFIG_CGROUP_NET_PRIO=y +CONFIG_CGROUP_NET_CLASSID=y +CONFIG_NET_RX_BUSY_POLL=y +CONFIG_BQL=y +CONFIG_BPF_JIT=y +CONFIG_BPF_STREAM_PARSER=y +CONFIG_NET_FLOW_LIMIT=y + +# +# Network testing +# +CONFIG_NET_PKTGEN=y +CONFIG_NET_DROP_MONITOR=y +CONFIG_HAMRADIO=y + +# +# Packet Radio protocols +# +CONFIG_AX25=y +CONFIG_AX25_DAMA_SLAVE=y +CONFIG_NETROM=y +CONFIG_ROSE=y + +# +# AX.25 network device drivers +# +CONFIG_MKISS=y +CONFIG_6PACK=y +CONFIG_BPQETHER=y +CONFIG_BAYCOM_SER_FDX=y +CONFIG_BAYCOM_SER_HDX=y +CONFIG_BAYCOM_PAR=y +CONFIG_YAM=y +CONFIG_CAN=y +CONFIG_CAN_RAW=y +CONFIG_CAN_BCM=y +CONFIG_CAN_GW=y + +# +# CAN Device Drivers +# +CONFIG_CAN_VCAN=y +CONFIG_CAN_VXCAN=y +CONFIG_CAN_SLCAN=y +CONFIG_CAN_DEV=y +CONFIG_CAN_CALC_BITTIMING=y +CONFIG_CAN_LEDS=y +CONFIG_CAN_AT91=y +CONFIG_CAN_GRCAN=y +CONFIG_CAN_JANZ_ICAN3=y +CONFIG_CAN_SUN4I=y +CONFIG_CAN_XILINXCAN=y +CONFIG_PCH_CAN=y +CONFIG_CAN_C_CAN=y +CONFIG_CAN_C_CAN_PLATFORM=y +CONFIG_CAN_C_CAN_PCI=y +CONFIG_CAN_CC770=y +CONFIG_CAN_CC770_ISA=y +CONFIG_CAN_CC770_PLATFORM=y +CONFIG_CAN_IFI_CANFD=y +CONFIG_CAN_M_CAN=y +CONFIG_CAN_PEAK_PCIEFD=y +CONFIG_CAN_SJA1000=y +CONFIG_CAN_SJA1000_ISA=y +CONFIG_CAN_SJA1000_PLATFORM=y +CONFIG_CAN_EMS_PCMCIA=y +CONFIG_CAN_EMS_PCI=y +CONFIG_CAN_PEAK_PCMCIA=y +CONFIG_CAN_PEAK_PCI=y +CONFIG_CAN_PEAK_PCIEC=y +CONFIG_CAN_KVASER_PCI=y +CONFIG_CAN_PLX_PCI=y +CONFIG_CAN_SOFTING=y +CONFIG_CAN_SOFTING_CS=y + +# +# CAN SPI interfaces +# +CONFIG_CAN_HI311X=y +CONFIG_CAN_MCP251X=y + +# +# CAN USB interfaces +# +CONFIG_CAN_EMS_USB=y +CONFIG_CAN_ESD_USB2=y +CONFIG_CAN_GS_USB=y +CONFIG_CAN_KVASER_USB=y +CONFIG_CAN_PEAK_USB=y +CONFIG_CAN_8DEV_USB=y +CONFIG_CAN_MCBA_USB=y +CONFIG_CAN_DEBUG_DEVICES=y +CONFIG_BT=y +CONFIG_BT_BREDR=y +CONFIG_BT_RFCOMM=y +CONFIG_BT_RFCOMM_TTY=y +CONFIG_BT_BNEP=y +CONFIG_BT_BNEP_MC_FILTER=y +CONFIG_BT_BNEP_PROTO_FILTER=y +CONFIG_BT_CMTP=y +CONFIG_BT_HIDP=y +CONFIG_BT_HS=y +CONFIG_BT_LE=y +CONFIG_BT_6LOWPAN=y +CONFIG_BT_LEDS=y +CONFIG_BT_SELFTEST=y +CONFIG_BT_SELFTEST_ECDH=y +CONFIG_BT_SELFTEST_SMP=y +CONFIG_BT_DEBUGFS=y + +# +# Bluetooth device drivers +# +CONFIG_BT_INTEL=y +CONFIG_BT_BCM=y +CONFIG_BT_RTL=y +CONFIG_BT_QCA=y +CONFIG_BT_HCIBTUSB=y +CONFIG_BT_HCIBTUSB_AUTOSUSPEND=y +CONFIG_BT_HCIBTUSB_BCM=y +CONFIG_BT_HCIBTUSB_RTL=y +CONFIG_BT_HCIBTSDIO=y +CONFIG_BT_HCIUART=y +CONFIG_BT_HCIUART_SERDEV=y +CONFIG_BT_HCIUART_H4=y +CONFIG_BT_HCIUART_NOKIA=y +CONFIG_BT_HCIUART_BCSP=y +CONFIG_BT_HCIUART_ATH3K=y +CONFIG_BT_HCIUART_LL=y +CONFIG_BT_HCIUART_3WIRE=y +CONFIG_BT_HCIUART_INTEL=y +CONFIG_BT_HCIUART_BCM=y +CONFIG_BT_HCIUART_QCA=y +CONFIG_BT_HCIUART_AG6XX=y +CONFIG_BT_HCIUART_MRVL=y +CONFIG_BT_HCIBCM203X=y +CONFIG_BT_HCIBPA10X=y +CONFIG_BT_HCIBFUSB=y +CONFIG_BT_HCIDTL1=y +CONFIG_BT_HCIBT3C=y +CONFIG_BT_HCIBLUECARD=y +CONFIG_BT_HCIBTUART=y +CONFIG_BT_HCIVHCI=y +CONFIG_BT_MRVL=y +CONFIG_BT_MRVL_SDIO=y +CONFIG_BT_ATH3K=y +CONFIG_BT_WILINK=y +CONFIG_BT_QCOMSMD=y +CONFIG_AF_RXRPC=y +CONFIG_AF_RXRPC_IPV6=y +CONFIG_AF_RXRPC_INJECT_LOSS=y +CONFIG_AF_RXRPC_DEBUG=y +CONFIG_RXKAD=y +CONFIG_AF_KCM=y +CONFIG_STREAM_PARSER=y +CONFIG_FIB_RULES=y +CONFIG_WIRELESS=y +CONFIG_WIRELESS_EXT=y +CONFIG_WEXT_CORE=y +CONFIG_WEXT_PROC=y +CONFIG_WEXT_SPY=y +CONFIG_WEXT_PRIV=y +CONFIG_CFG80211=y +CONFIG_NL80211_TESTMODE=y +CONFIG_CFG80211_DEVELOPER_WARNINGS=y +CONFIG_CFG80211_CERTIFICATION_ONUS=y +CONFIG_CFG80211_REQUIRE_SIGNED_REGDB=y +CONFIG_CFG80211_USE_KERNEL_REGDB_KEYS=y +CONFIG_CFG80211_EXTRA_REGDB_KEYDIR="" +CONFIG_CFG80211_REG_CELLULAR_HINTS=y +CONFIG_CFG80211_REG_RELAX_NO_IR=y +CONFIG_CFG80211_DEFAULT_PS=y +CONFIG_CFG80211_DEBUGFS=y +CONFIG_CFG80211_CRDA_SUPPORT=y +CONFIG_CFG80211_WEXT=y +CONFIG_CFG80211_WEXT_EXPORT=y +CONFIG_LIB80211=y +CONFIG_LIB80211_CRYPT_WEP=y +CONFIG_LIB80211_CRYPT_CCMP=y +CONFIG_LIB80211_CRYPT_TKIP=y +CONFIG_LIB80211_DEBUG=y +CONFIG_MAC80211=y +CONFIG_MAC80211_HAS_RC=y +CONFIG_MAC80211_RC_MINSTREL=y +CONFIG_MAC80211_RC_MINSTREL_HT=y +CONFIG_MAC80211_RC_MINSTREL_VHT=y +CONFIG_MAC80211_RC_DEFAULT_MINSTREL=y +CONFIG_MAC80211_RC_DEFAULT="minstrel_ht" +CONFIG_MAC80211_MESH=y +CONFIG_MAC80211_LEDS=y +CONFIG_MAC80211_DEBUGFS=y +CONFIG_MAC80211_MESSAGE_TRACING=y +CONFIG_MAC80211_DEBUG_MENU=y +CONFIG_MAC80211_NOINLINE=y +CONFIG_MAC80211_VERBOSE_DEBUG=y +CONFIG_MAC80211_MLME_DEBUG=y +CONFIG_MAC80211_STA_DEBUG=y +CONFIG_MAC80211_HT_DEBUG=y +CONFIG_MAC80211_OCB_DEBUG=y +CONFIG_MAC80211_IBSS_DEBUG=y +CONFIG_MAC80211_PS_DEBUG=y +CONFIG_MAC80211_MPL_DEBUG=y +CONFIG_MAC80211_MPATH_DEBUG=y +CONFIG_MAC80211_MHWMP_DEBUG=y +CONFIG_MAC80211_MESH_SYNC_DEBUG=y +CONFIG_MAC80211_MESH_CSA_DEBUG=y +CONFIG_MAC80211_MESH_PS_DEBUG=y +CONFIG_MAC80211_TDLS_DEBUG=y +CONFIG_MAC80211_DEBUG_COUNTERS=y +CONFIG_MAC80211_STA_HASH_MAX_SIZE=0 +CONFIG_WIMAX=y +CONFIG_WIMAX_DEBUG_LEVEL=8 +CONFIG_RFKILL=y +CONFIG_RFKILL_LEDS=y +CONFIG_RFKILL_INPUT=y +CONFIG_RFKILL_GPIO=y +CONFIG_NET_9P=y +CONFIG_NET_9P_VIRTIO=y +CONFIG_NET_9P_XEN=y +CONFIG_NET_9P_RDMA=y +CONFIG_NET_9P_DEBUG=y +CONFIG_CAIF=y +CONFIG_CAIF_DEBUG=y +CONFIG_CAIF_NETDEV=y +CONFIG_CAIF_USB=y +CONFIG_CEPH_LIB=y +CONFIG_CEPH_LIB_PRETTYDEBUG=y +CONFIG_CEPH_LIB_USE_DNS_RESOLVER=y +CONFIG_NFC=y +CONFIG_NFC_DIGITAL=y +CONFIG_NFC_NCI=y +CONFIG_NFC_NCI_SPI=y +CONFIG_NFC_NCI_UART=y +CONFIG_NFC_HCI=y +CONFIG_NFC_SHDLC=y + +# +# Near Field Communication (NFC) devices +# +CONFIG_NFC_TRF7970A=y +CONFIG_NFC_MEI_PHY=y +CONFIG_NFC_SIM=y +CONFIG_NFC_PORT100=y +CONFIG_NFC_FDP=y +CONFIG_NFC_FDP_I2C=y +CONFIG_NFC_PN544=y +CONFIG_NFC_PN544_I2C=y +CONFIG_NFC_PN544_MEI=y +CONFIG_NFC_PN533=y +CONFIG_NFC_PN533_USB=y +CONFIG_NFC_PN533_I2C=y +CONFIG_NFC_MICROREAD=y +CONFIG_NFC_MICROREAD_I2C=y +CONFIG_NFC_MICROREAD_MEI=y +CONFIG_NFC_MRVL=y +CONFIG_NFC_MRVL_USB=y +CONFIG_NFC_MRVL_UART=y +CONFIG_NFC_MRVL_I2C=y +CONFIG_NFC_MRVL_SPI=y +CONFIG_NFC_ST21NFCA=y +CONFIG_NFC_ST21NFCA_I2C=y +CONFIG_NFC_ST_NCI=y +CONFIG_NFC_ST_NCI_I2C=y +CONFIG_NFC_ST_NCI_SPI=y +CONFIG_NFC_NXP_NCI=y +CONFIG_NFC_NXP_NCI_I2C=y +CONFIG_NFC_S3FWRN5=y +CONFIG_NFC_S3FWRN5_I2C=y +CONFIG_NFC_ST95HF=y +CONFIG_PSAMPLE=y +CONFIG_NET_IFE=y +CONFIG_LWTUNNEL=y +CONFIG_LWTUNNEL_BPF=y +CONFIG_DST_CACHE=y +CONFIG_GRO_CELLS=y +CONFIG_NET_DEVLINK=y +CONFIG_MAY_USE_DEVLINK=y +CONFIG_HAVE_EBPF_JIT=y + +# +# Device Drivers +# + +# +# Generic Driver Options +# +CONFIG_UEVENT_HELPER=y +CONFIG_UEVENT_HELPER_PATH="" +CONFIG_DEVTMPFS=y +CONFIG_DEVTMPFS_MOUNT=y +CONFIG_STANDALONE=y +CONFIG_PREVENT_FIRMWARE_BUILD=y +CONFIG_FW_LOADER=y +CONFIG_EXTRA_FIRMWARE="" +CONFIG_FW_LOADER_USER_HELPER=y +CONFIG_FW_LOADER_USER_HELPER_FALLBACK=y +CONFIG_WANT_DEV_COREDUMP=y +CONFIG_ALLOW_DEV_COREDUMP=y +CONFIG_DEV_COREDUMP=y +CONFIG_DEBUG_DRIVER=y +CONFIG_DEBUG_DEVRES=y +CONFIG_DEBUG_TEST_DRIVER_REMOVE=y +CONFIG_TEST_ASYNC_DRIVER_PROBE=m +CONFIG_SYS_HYPERVISOR=y +# CONFIG_GENERIC_CPU_DEVICES is not set +CONFIG_GENERIC_CPU_AUTOPROBE=y +CONFIG_GENERIC_CPU_VULNERABILITIES=y +CONFIG_SOC_BUS=y +CONFIG_REGMAP=y +CONFIG_REGMAP_AC97=y +CONFIG_REGMAP_I2C=y +CONFIG_REGMAP_SPI=y +CONFIG_REGMAP_SPMI=y +CONFIG_REGMAP_W1=y +CONFIG_REGMAP_MMIO=y +CONFIG_REGMAP_IRQ=y +CONFIG_REGMAP_SOUNDWIRE=y +CONFIG_DMA_SHARED_BUFFER=y +CONFIG_DMA_FENCE_TRACE=y +CONFIG_DMA_CMA=y + +# +# Default contiguous memory area size: +# +CONFIG_CMA_SIZE_MBYTES=0 +CONFIG_CMA_SIZE_SEL_MBYTES=y +# CONFIG_CMA_SIZE_SEL_PERCENTAGE is not set +# CONFIG_CMA_SIZE_SEL_MIN is not set +# CONFIG_CMA_SIZE_SEL_MAX is not set +CONFIG_CMA_ALIGNMENT=8 + +# +# Bus devices +# +CONFIG_QCOM_EBI2=y +CONFIG_SIMPLE_PM_BUS=y +CONFIG_CONNECTOR=y +CONFIG_PROC_EVENTS=y +CONFIG_MTD=y +CONFIG_MTD_TESTS=m +CONFIG_MTD_REDBOOT_PARTS=y +CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1 +CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED=y +CONFIG_MTD_REDBOOT_PARTS_READONLY=y +CONFIG_MTD_CMDLINE_PARTS=y +CONFIG_MTD_OF_PARTS=y +CONFIG_MTD_AR7_PARTS=y +CONFIG_MTD_BCM63XX_PARTS=y + +# +# Partition parsers +# +CONFIG_MTD_PARSER_TRX=y +CONFIG_MTD_SHARPSL_PARTS=y + +# +# User Modules And Translation Layers +# +CONFIG_MTD_BLKDEVS=y +CONFIG_MTD_BLOCK=y +CONFIG_FTL=y +CONFIG_NFTL=y +CONFIG_NFTL_RW=y +CONFIG_INFTL=y +CONFIG_RFD_FTL=y +CONFIG_SSFDC=y +CONFIG_SM_FTL=y +CONFIG_MTD_OOPS=y +CONFIG_MTD_SWAP=y +CONFIG_MTD_PARTITIONED_MASTER=y + +# +# RAM/ROM/Flash chip drivers +# +CONFIG_MTD_CFI=y +CONFIG_MTD_JEDECPROBE=y +CONFIG_MTD_GEN_PROBE=y +CONFIG_MTD_CFI_ADV_OPTIONS=y +CONFIG_MTD_CFI_NOSWAP=y +# CONFIG_MTD_CFI_BE_BYTE_SWAP is not set +# CONFIG_MTD_CFI_LE_BYTE_SWAP is not set +CONFIG_MTD_CFI_GEOMETRY=y +CONFIG_MTD_MAP_BANK_WIDTH_1=y +CONFIG_MTD_MAP_BANK_WIDTH_2=y +CONFIG_MTD_MAP_BANK_WIDTH_4=y +CONFIG_MTD_MAP_BANK_WIDTH_8=y +CONFIG_MTD_MAP_BANK_WIDTH_16=y +CONFIG_MTD_MAP_BANK_WIDTH_32=y +CONFIG_MTD_CFI_I1=y +CONFIG_MTD_CFI_I2=y +CONFIG_MTD_CFI_I4=y +CONFIG_MTD_CFI_I8=y +CONFIG_MTD_OTP=y +CONFIG_MTD_CFI_INTELEXT=y +CONFIG_MTD_CFI_AMDSTD=y +CONFIG_MTD_CFI_STAA=y +CONFIG_MTD_CFI_UTIL=y +CONFIG_MTD_RAM=y +CONFIG_MTD_ROM=y +CONFIG_MTD_ABSENT=y + +# +# Mapping drivers for chip access +# +CONFIG_MTD_COMPLEX_MAPPINGS=y +CONFIG_MTD_PHYSMAP=y +CONFIG_MTD_PHYSMAP_COMPAT=y +CONFIG_MTD_PHYSMAP_START=0x8000000 +CONFIG_MTD_PHYSMAP_LEN=0 +CONFIG_MTD_PHYSMAP_BANKWIDTH=2 +CONFIG_MTD_PHYSMAP_OF=y +CONFIG_MTD_PHYSMAP_OF_VERSATILE=y +CONFIG_MTD_PHYSMAP_OF_GEMINI=y +CONFIG_MTD_SC520CDP=y +CONFIG_MTD_NETSC520=y +CONFIG_MTD_TS5500=y +CONFIG_MTD_SBC_GXX=y +CONFIG_MTD_AMD76XROM=y +CONFIG_MTD_ICHXROM=y +CONFIG_MTD_ESB2ROM=y +CONFIG_MTD_CK804XROM=y +CONFIG_MTD_SCB2_FLASH=y +CONFIG_MTD_NETtel=y +CONFIG_MTD_L440GX=y +CONFIG_MTD_PCI=y +CONFIG_MTD_PCMCIA=y +CONFIG_MTD_PCMCIA_ANONYMOUS=y +CONFIG_MTD_GPIO_ADDR=y +CONFIG_MTD_INTEL_VR_NOR=y +CONFIG_MTD_PLATRAM=y +CONFIG_MTD_LATCH_ADDR=y + +# +# Self-contained MTD device drivers +# +CONFIG_MTD_PMC551=y +CONFIG_MTD_PMC551_BUGFIX=y +CONFIG_MTD_PMC551_DEBUG=y +CONFIG_MTD_DATAFLASH=y +CONFIG_MTD_DATAFLASH_WRITE_VERIFY=y +CONFIG_MTD_DATAFLASH_OTP=y +CONFIG_MTD_M25P80=y +CONFIG_MTD_MCHP23K256=y +CONFIG_MTD_SST25L=y +CONFIG_MTD_SLRAM=y +CONFIG_MTD_PHRAM=y +CONFIG_MTD_MTDRAM=y +CONFIG_MTDRAM_TOTAL_SIZE=4096 +CONFIG_MTDRAM_ERASE_SIZE=128 +CONFIG_MTD_BLOCK2MTD=y + +# +# Disk-On-Chip Device Drivers +# +CONFIG_MTD_DOCG3=y +CONFIG_BCH_CONST_M=14 +CONFIG_BCH_CONST_T=4 +CONFIG_MTD_NAND_ECC=y +CONFIG_MTD_NAND_ECC_SMC=y +CONFIG_MTD_NAND=y +CONFIG_MTD_NAND_BCH=y +CONFIG_MTD_NAND_ECC_BCH=y +CONFIG_MTD_SM_COMMON=y +CONFIG_MTD_NAND_DENALI=y +CONFIG_MTD_NAND_DENALI_PCI=y +CONFIG_MTD_NAND_DENALI_DT=y +CONFIG_MTD_NAND_GPIO=y +# CONFIG_MTD_NAND_OMAP_BCH_BUILD is not set +CONFIG_MTD_NAND_RICOH=y +CONFIG_MTD_NAND_TANGO=y +CONFIG_MTD_NAND_DISKONCHIP=y +CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADVANCED=y +CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS=0 +CONFIG_MTD_NAND_DISKONCHIP_PROBE_HIGH=y +CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE=y +CONFIG_MTD_NAND_DOCG4=y +CONFIG_MTD_NAND_CAFE=y +CONFIG_MTD_NAND_MARVELL=y +CONFIG_MTD_NAND_NANDSIM=y +CONFIG_MTD_NAND_GPMI_NAND=y +CONFIG_MTD_NAND_PLATFORM=y +CONFIG_MTD_NAND_OXNAS=y +CONFIG_MTD_NAND_VF610_NFC=y +CONFIG_MTD_NAND_SH_FLCTL=y +CONFIG_MTD_NAND_HISI504=y +CONFIG_MTD_NAND_MTK=y +CONFIG_MTD_ONENAND=y +CONFIG_MTD_ONENAND_VERIFY_WRITE=y +CONFIG_MTD_ONENAND_GENERIC=y +CONFIG_MTD_ONENAND_OTP=y +CONFIG_MTD_ONENAND_2X_PROGRAM=y + +# +# LPDDR & LPDDR2 PCM memory drivers +# +CONFIG_MTD_LPDDR=y +CONFIG_MTD_QINFO_PROBE=y +CONFIG_MTD_SPI_NOR=y +CONFIG_MTD_MT81xx_NOR=y +CONFIG_MTD_SPI_NOR_USE_4K_SECTORS=y +CONFIG_SPI_ASPEED_SMC=y +CONFIG_SPI_CADENCE_QUADSPI=y +CONFIG_SPI_FSL_QUADSPI=y +CONFIG_SPI_HISI_SFC=y +CONFIG_SPI_NXP_SPIFI=y +CONFIG_SPI_INTEL_SPI=y +CONFIG_SPI_INTEL_SPI_PCI=y +CONFIG_SPI_INTEL_SPI_PLATFORM=y +CONFIG_SPI_STM32_QUADSPI=y +CONFIG_MTD_UBI=y +CONFIG_MTD_UBI_WL_THRESHOLD=4096 +CONFIG_MTD_UBI_BEB_LIMIT=20 +CONFIG_MTD_UBI_FASTMAP=y +CONFIG_MTD_UBI_GLUEBI=y +CONFIG_MTD_UBI_BLOCK=y +CONFIG_DTC=y +CONFIG_OF=y +CONFIG_OF_UNITTEST=y +CONFIG_OF_ALL_DTBS=y +CONFIG_OF_FLATTREE=y +CONFIG_OF_EARLY_FLATTREE=y +CONFIG_OF_KOBJ=y +CONFIG_OF_DYNAMIC=y +CONFIG_OF_ADDRESS=y +CONFIG_OF_IRQ=y +CONFIG_OF_NET=y +CONFIG_OF_MDIO=y +CONFIG_OF_RESOLVE=y +CONFIG_OF_OVERLAY=y +CONFIG_ARCH_MIGHT_HAVE_PC_PARPORT=y +CONFIG_PARPORT=y +CONFIG_PARPORT_PC=y +CONFIG_PARPORT_SERIAL=y +CONFIG_PARPORT_PC_FIFO=y +CONFIG_PARPORT_PC_SUPERIO=y +CONFIG_PARPORT_PC_PCMCIA=y +# CONFIG_PARPORT_GSC is not set +CONFIG_PARPORT_AX88796=y +CONFIG_PARPORT_1284=y +CONFIG_PARPORT_NOT_PC=y +CONFIG_PNP=y +CONFIG_PNP_DEBUG_MESSAGES=y + +# +# Protocols +# +CONFIG_PNPACPI=y +CONFIG_BLK_DEV=y +CONFIG_BLK_DEV_NULL_BLK=y +CONFIG_BLK_DEV_NULL_BLK_FAULT_INJECTION=y +CONFIG_BLK_DEV_FD=y +CONFIG_CDROM=y +CONFIG_PARIDE=y + +# +# Parallel IDE high-level drivers +# +CONFIG_PARIDE_PD=y +CONFIG_PARIDE_PCD=y +CONFIG_PARIDE_PF=y +CONFIG_PARIDE_PT=y +CONFIG_PARIDE_PG=y + +# +# Parallel IDE protocol modules +# +CONFIG_PARIDE_ATEN=y +CONFIG_PARIDE_BPCK=y +CONFIG_PARIDE_COMM=y +CONFIG_PARIDE_DSTR=y +CONFIG_PARIDE_FIT2=y +CONFIG_PARIDE_FIT3=y +CONFIG_PARIDE_EPAT=y +CONFIG_PARIDE_EPATC8=y +CONFIG_PARIDE_EPIA=y +CONFIG_PARIDE_FRIQ=y +CONFIG_PARIDE_FRPW=y +CONFIG_PARIDE_KBIC=y +CONFIG_PARIDE_KTTI=y +CONFIG_PARIDE_ON20=y +CONFIG_PARIDE_ON26=y +CONFIG_BLK_DEV_PCIESSD_MTIP32XX=y +CONFIG_ZRAM=y +CONFIG_ZRAM_WRITEBACK=y +CONFIG_BLK_DEV_DAC960=y +CONFIG_BLK_DEV_UMEM=y +# CONFIG_BLK_DEV_COW_COMMON is not set +CONFIG_BLK_DEV_LOOP=y +CONFIG_BLK_DEV_LOOP_MIN_COUNT=8 +CONFIG_BLK_DEV_CRYPTOLOOP=y +CONFIG_BLK_DEV_DRBD=y +CONFIG_DRBD_FAULT_INJECTION=y +CONFIG_BLK_DEV_NBD=y +CONFIG_BLK_DEV_SKD=y +CONFIG_BLK_DEV_SX8=y +CONFIG_BLK_DEV_RAM=y +CONFIG_BLK_DEV_RAM_COUNT=16 +CONFIG_BLK_DEV_RAM_SIZE=4096 +CONFIG_CDROM_PKTCDVD=y +CONFIG_CDROM_PKTCDVD_BUFFERS=8 +CONFIG_CDROM_PKTCDVD_WCACHE=y +CONFIG_ATA_OVER_ETH=y +CONFIG_XEN_BLKDEV_FRONTEND=y +CONFIG_VIRTIO_BLK=y +CONFIG_VIRTIO_BLK_SCSI=y +CONFIG_BLK_DEV_RBD=y +CONFIG_BLK_DEV_RSXX=y + +# +# NVME Support +# +CONFIG_NVME_CORE=y +CONFIG_BLK_DEV_NVME=y +CONFIG_NVME_MULTIPATH=y +CONFIG_NVME_FABRICS=y +CONFIG_NVME_RDMA=y +CONFIG_NVME_FC=y +CONFIG_NVME_TARGET=y +CONFIG_NVME_TARGET_LOOP=y +CONFIG_NVME_TARGET_RDMA=y +CONFIG_NVME_TARGET_FC=y +CONFIG_NVME_TARGET_FCLOOP=y + +# +# Misc devices +# +CONFIG_SENSORS_LIS3LV02D=y +CONFIG_AD525X_DPOT=y +CONFIG_AD525X_DPOT_I2C=y +CONFIG_AD525X_DPOT_SPI=y +CONFIG_DUMMY_IRQ=y +CONFIG_IBM_ASM=y +CONFIG_PHANTOM=y +CONFIG_INTEL_MID_PTI=y +CONFIG_SGI_IOC4=y +CONFIG_TIFM_CORE=y +CONFIG_TIFM_7XX1=y +CONFIG_ICS932S401=y +CONFIG_ATMEL_SSC=y +CONFIG_ENCLOSURE_SERVICES=y +CONFIG_SGI_XP=y +CONFIG_CS5535_MFGPT=y +CONFIG_CS5535_MFGPT_DEFAULT_IRQ=7 +CONFIG_CS5535_CLOCK_EVENT_SRC=y +CONFIG_HP_ILO=y +CONFIG_QCOM_COINCELL=y +CONFIG_SGI_GRU=y +CONFIG_SGI_GRU_DEBUG=y +CONFIG_APDS9802ALS=y +CONFIG_ISL29003=y +CONFIG_ISL29020=y +CONFIG_SENSORS_TSL2550=y +CONFIG_SENSORS_BH1770=y +CONFIG_SENSORS_APDS990X=y +CONFIG_HMC6352=y +CONFIG_DS1682=y +CONFIG_VMWARE_BALLOON=y +CONFIG_PCH_PHUB=y +CONFIG_USB_SWITCH_FSA9480=y +CONFIG_LATTICE_ECP3_CONFIG=y +CONFIG_SRAM=y +CONFIG_ASPEED_LPC_CTRL=y +CONFIG_ASPEED_LPC_SNOOP=y +CONFIG_PCI_ENDPOINT_TEST=y +CONFIG_MISC_RTSX=y +CONFIG_C2PORT=y +CONFIG_C2PORT_DURAMAR_2150=y + +# +# EEPROM support +# +CONFIG_EEPROM_AT24=y +CONFIG_EEPROM_AT25=y +CONFIG_EEPROM_LEGACY=y +CONFIG_EEPROM_MAX6875=y +CONFIG_EEPROM_93CX6=y +CONFIG_EEPROM_93XX46=y +CONFIG_EEPROM_IDT_89HPESX=y +CONFIG_CB710_CORE=y +CONFIG_CB710_DEBUG=y +CONFIG_CB710_DEBUG_ASSUMPTIONS=y + +# +# Texas Instruments shared transport line discipline +# +CONFIG_TI_ST=y +CONFIG_SENSORS_LIS3_I2C=y +CONFIG_ALTERA_STAPL=y +CONFIG_INTEL_MEI=y +CONFIG_INTEL_MEI_ME=y +CONFIG_INTEL_MEI_TXE=y +CONFIG_VMWARE_VMCI=y + +# +# Intel MIC & related support +# + +# +# Intel MIC Bus Driver +# +CONFIG_INTEL_MIC_BUS=y + +# +# SCIF Bus Driver +# +CONFIG_SCIF_BUS=y + +# +# VOP Bus Driver +# +CONFIG_VOP_BUS=y + +# +# Intel MIC Host Driver +# +CONFIG_INTEL_MIC_HOST=y + +# +# Intel MIC Card Driver +# +CONFIG_INTEL_MIC_CARD=y + +# +# SCIF Driver +# +CONFIG_SCIF=y + +# +# Intel MIC Coprocessor State Management (COSM) Drivers +# +CONFIG_MIC_COSM=y + +# +# VOP Driver +# +CONFIG_VOP=y +CONFIG_VHOST_RING=y +CONFIG_GENWQE=y +CONFIG_GENWQE_PLATFORM_ERROR_RECOVERY=0 +CONFIG_ECHO=y +# CONFIG_CXL_BASE is not set +# CONFIG_CXL_AFU_DRIVER_OPS is not set +# CONFIG_CXL_LIB is not set +# CONFIG_OCXL_BASE is not set +CONFIG_MISC_RTSX_PCI=y +CONFIG_MISC_RTSX_USB=y +CONFIG_HAVE_IDE=y +CONFIG_IDE=y + +# +# Please see Documentation/ide/ide.txt for help/info on IDE drives +# +CONFIG_IDE_XFER_MODE=y +CONFIG_IDE_TIMINGS=y +CONFIG_IDE_ATAPI=y +CONFIG_BLK_DEV_IDE_SATA=y +CONFIG_IDE_GD=y +CONFIG_IDE_GD_ATA=y +CONFIG_IDE_GD_ATAPI=y +CONFIG_BLK_DEV_IDECS=y +CONFIG_BLK_DEV_DELKIN=y +CONFIG_BLK_DEV_IDECD=y +CONFIG_BLK_DEV_IDECD_VERBOSE_ERRORS=y +CONFIG_BLK_DEV_IDETAPE=y +CONFIG_BLK_DEV_IDEACPI=y +CONFIG_IDE_TASK_IOCTL=y +CONFIG_IDE_PROC_FS=y + +# +# IDE chipset support/bugfixes +# +CONFIG_IDE_GENERIC=y +CONFIG_BLK_DEV_PLATFORM=y +CONFIG_BLK_DEV_CMD640=y +CONFIG_BLK_DEV_CMD640_ENHANCED=y +CONFIG_BLK_DEV_IDEPNP=y +CONFIG_BLK_DEV_IDEDMA_SFF=y + +# +# PCI IDE chipsets support +# +CONFIG_BLK_DEV_IDEPCI=y +CONFIG_IDEPCI_PCIBUS_ORDER=y +CONFIG_BLK_DEV_OFFBOARD=y +CONFIG_BLK_DEV_GENERIC=y +CONFIG_BLK_DEV_OPTI621=y +CONFIG_BLK_DEV_RZ1000=y +CONFIG_BLK_DEV_IDEDMA_PCI=y +CONFIG_BLK_DEV_AEC62XX=y +CONFIG_BLK_DEV_ALI15X3=y +CONFIG_BLK_DEV_AMD74XX=y +CONFIG_BLK_DEV_ATIIXP=y +CONFIG_BLK_DEV_CMD64X=y +CONFIG_BLK_DEV_TRIFLEX=y +CONFIG_BLK_DEV_CS5520=y +CONFIG_BLK_DEV_CS5530=y +CONFIG_BLK_DEV_HPT366=y +CONFIG_BLK_DEV_JMICRON=y +CONFIG_BLK_DEV_SC1200=y +CONFIG_BLK_DEV_PIIX=y +CONFIG_BLK_DEV_IT8172=y +CONFIG_BLK_DEV_IT8213=y +CONFIG_BLK_DEV_IT821X=y +CONFIG_BLK_DEV_NS87415=y +CONFIG_BLK_DEV_PDC202XX_OLD=y +CONFIG_BLK_DEV_PDC202XX_NEW=y +CONFIG_BLK_DEV_SVWKS=y +CONFIG_BLK_DEV_SIIMAGE=y +CONFIG_BLK_DEV_SIS5513=y +CONFIG_BLK_DEV_SLC90E66=y +CONFIG_BLK_DEV_TRM290=y +CONFIG_BLK_DEV_VIA82CXXX=y +CONFIG_BLK_DEV_TC86C001=y +CONFIG_BLK_DEV_IDEDMA=y + +# +# SCSI device support +# +CONFIG_SCSI_MOD=y +CONFIG_RAID_ATTRS=y +CONFIG_SCSI=y +CONFIG_SCSI_DMA=y +CONFIG_SCSI_NETLINK=y +CONFIG_SCSI_MQ_DEFAULT=y +CONFIG_SCSI_PROC_FS=y + +# +# SCSI support type (disk, tape, CD-ROM) +# +CONFIG_BLK_DEV_SD=y +CONFIG_CHR_DEV_ST=y +CONFIG_CHR_DEV_OSST=y +CONFIG_BLK_DEV_SR=y +CONFIG_BLK_DEV_SR_VENDOR=y +CONFIG_CHR_DEV_SG=y +CONFIG_CHR_DEV_SCH=y +CONFIG_SCSI_ENCLOSURE=y +CONFIG_SCSI_CONSTANTS=y +CONFIG_SCSI_LOGGING=y +CONFIG_SCSI_SCAN_ASYNC=y + +# +# SCSI Transports +# +CONFIG_SCSI_SPI_ATTRS=y +CONFIG_SCSI_FC_ATTRS=y +CONFIG_SCSI_ISCSI_ATTRS=y +CONFIG_SCSI_SAS_ATTRS=y +CONFIG_SCSI_SAS_LIBSAS=y +CONFIG_SCSI_SAS_ATA=y +CONFIG_SCSI_SAS_HOST_SMP=y +CONFIG_SCSI_SRP_ATTRS=y +CONFIG_SCSI_LOWLEVEL=y +CONFIG_ISCSI_TCP=y +CONFIG_ISCSI_BOOT_SYSFS=y +CONFIG_SCSI_CXGB3_ISCSI=y +CONFIG_SCSI_CXGB4_ISCSI=y +CONFIG_SCSI_BNX2_ISCSI=y +CONFIG_SCSI_BNX2X_FCOE=y +CONFIG_BE2ISCSI=y +CONFIG_BLK_DEV_3W_XXXX_RAID=y +CONFIG_SCSI_HPSA=y +CONFIG_SCSI_3W_9XXX=y +CONFIG_SCSI_3W_SAS=y +CONFIG_SCSI_ACARD=y +CONFIG_SCSI_AACRAID=y +CONFIG_SCSI_AIC7XXX=y +CONFIG_AIC7XXX_CMDS_PER_DEVICE=32 +CONFIG_AIC7XXX_RESET_DELAY_MS=5000 +CONFIG_AIC7XXX_DEBUG_ENABLE=y +CONFIG_AIC7XXX_DEBUG_MASK=0 +CONFIG_AIC7XXX_REG_PRETTY_PRINT=y +CONFIG_SCSI_AIC79XX=y +CONFIG_AIC79XX_CMDS_PER_DEVICE=32 +CONFIG_AIC79XX_RESET_DELAY_MS=5000 +CONFIG_AIC79XX_DEBUG_ENABLE=y +CONFIG_AIC79XX_DEBUG_MASK=0 +CONFIG_AIC79XX_REG_PRETTY_PRINT=y +CONFIG_SCSI_AIC94XX=y +CONFIG_AIC94XX_DEBUG=y +CONFIG_SCSI_HISI_SAS=y +CONFIG_SCSI_HISI_SAS_PCI=y +CONFIG_SCSI_MVSAS=y +CONFIG_SCSI_MVSAS_DEBUG=y +CONFIG_SCSI_MVSAS_TASKLET=y +CONFIG_SCSI_MVUMI=y +CONFIG_SCSI_DPT_I2O=y +CONFIG_SCSI_ADVANSYS=y +CONFIG_SCSI_ARCMSR=y +CONFIG_SCSI_ESAS2R=y +CONFIG_MEGARAID_NEWGEN=y +CONFIG_MEGARAID_MM=y +CONFIG_MEGARAID_MAILBOX=y +CONFIG_MEGARAID_LEGACY=y +CONFIG_MEGARAID_SAS=y +CONFIG_SCSI_MPT3SAS=y +CONFIG_SCSI_MPT2SAS_MAX_SGE=128 +CONFIG_SCSI_MPT3SAS_MAX_SGE=128 +CONFIG_SCSI_MPT2SAS=y +CONFIG_SCSI_SMARTPQI=y +CONFIG_SCSI_UFSHCD=y +CONFIG_SCSI_UFSHCD_PCI=y +CONFIG_SCSI_UFS_DWC_TC_PCI=y +CONFIG_SCSI_UFSHCD_PLATFORM=y +CONFIG_SCSI_UFS_DWC_TC_PLATFORM=y +CONFIG_SCSI_HPTIOP=y +CONFIG_SCSI_BUSLOGIC=y +CONFIG_SCSI_FLASHPOINT=y +CONFIG_VMWARE_PVSCSI=y +CONFIG_XEN_SCSI_FRONTEND=y +CONFIG_HYPERV_STORAGE=y +CONFIG_LIBFC=y +CONFIG_LIBFCOE=y +CONFIG_FCOE=y +CONFIG_FCOE_FNIC=y +CONFIG_SCSI_SNIC=y +CONFIG_SCSI_SNIC_DEBUG_FS=y +CONFIG_SCSI_DMX3191D=y +CONFIG_SCSI_EATA=y +CONFIG_SCSI_EATA_TAGGED_QUEUE=y +CONFIG_SCSI_EATA_LINKED_COMMANDS=y +CONFIG_SCSI_EATA_MAX_TAGS=16 +CONFIG_SCSI_FUTURE_DOMAIN=y +CONFIG_SCSI_GDTH=y +CONFIG_SCSI_ISCI=y +CONFIG_SCSI_IPS=y +CONFIG_SCSI_INITIO=y +CONFIG_SCSI_INIA100=y +CONFIG_SCSI_PPA=y +CONFIG_SCSI_IMM=y +CONFIG_SCSI_IZIP_EPP16=y +CONFIG_SCSI_IZIP_SLOW_CTR=y +CONFIG_SCSI_STEX=y +CONFIG_SCSI_SYM53C8XX_2=y +CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=1 +CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16 +CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64 +CONFIG_SCSI_SYM53C8XX_MMIO=y +CONFIG_SCSI_IPR=y +CONFIG_SCSI_IPR_TRACE=y +CONFIG_SCSI_IPR_DUMP=y +CONFIG_SCSI_QLOGIC_1280=y +CONFIG_SCSI_QLA_FC=y +CONFIG_TCM_QLA2XXX=y +CONFIG_TCM_QLA2XXX_DEBUG=y +CONFIG_SCSI_QLA_ISCSI=y +CONFIG_QEDI=y +CONFIG_QEDF=y +CONFIG_SCSI_LPFC=y +CONFIG_SCSI_LPFC_DEBUG_FS=y +CONFIG_SCSI_DC395x=y +CONFIG_SCSI_AM53C974=y +CONFIG_SCSI_WD719X=y +CONFIG_SCSI_DEBUG=y +CONFIG_SCSI_PMCRAID=y +CONFIG_SCSI_PM8001=y +CONFIG_SCSI_BFA_FC=y +CONFIG_SCSI_VIRTIO=y +CONFIG_SCSI_CHELSIO_FCOE=y +CONFIG_SCSI_LOWLEVEL_PCMCIA=y +CONFIG_PCMCIA_AHA152X=m +CONFIG_PCMCIA_FDOMAIN=m +CONFIG_PCMCIA_QLOGIC=m +CONFIG_PCMCIA_SYM53C500=m +CONFIG_SCSI_DH=y +CONFIG_SCSI_DH_RDAC=y +CONFIG_SCSI_DH_HP_SW=y +CONFIG_SCSI_DH_EMC=y +CONFIG_SCSI_DH_ALUA=y +CONFIG_SCSI_OSD_INITIATOR=y +CONFIG_SCSI_OSD_ULD=y +CONFIG_SCSI_OSD_DPRINT_SENSE=1 +CONFIG_SCSI_OSD_DEBUG=y +CONFIG_ATA=y +# CONFIG_ATA_NONSTANDARD is not set +CONFIG_ATA_VERBOSE_ERROR=y +CONFIG_ATA_ACPI=y +CONFIG_SATA_ZPODD=y +CONFIG_SATA_PMP=y + +# +# Controllers with non-SFF native interface +# +CONFIG_SATA_AHCI=y +CONFIG_SATA_MOBILE_LPM_POLICY=0 +CONFIG_SATA_AHCI_PLATFORM=y +CONFIG_AHCI_IMX=y +CONFIG_AHCI_CEVA=y +CONFIG_AHCI_XGENE=y +CONFIG_AHCI_QORIQ=y +CONFIG_SATA_GEMINI=y +CONFIG_SATA_INIC162X=y +CONFIG_SATA_ACARD_AHCI=y +CONFIG_SATA_SIL24=y +CONFIG_ATA_SFF=y + +# +# SFF controllers with custom DMA interface +# +CONFIG_PDC_ADMA=y +CONFIG_SATA_QSTOR=y +CONFIG_SATA_SX4=y +CONFIG_ATA_BMDMA=y + +# +# SATA SFF controllers with BMDMA +# +CONFIG_ATA_PIIX=y +CONFIG_SATA_DWC=y +CONFIG_SATA_DWC_OLD_DMA=y +CONFIG_SATA_DWC_DEBUG=y +CONFIG_SATA_DWC_VDEBUG=y +CONFIG_SATA_HIGHBANK=y +CONFIG_SATA_MV=y +CONFIG_SATA_NV=y +CONFIG_SATA_PROMISE=y +CONFIG_SATA_RCAR=y +CONFIG_SATA_SIL=y +CONFIG_SATA_SIS=y +CONFIG_SATA_SVW=y +CONFIG_SATA_ULI=y +CONFIG_SATA_VIA=y +CONFIG_SATA_VITESSE=y + +# +# PATA SFF controllers with BMDMA +# +CONFIG_PATA_ALI=y +CONFIG_PATA_AMD=y +CONFIG_PATA_ARASAN_CF=y +CONFIG_PATA_ARTOP=y +CONFIG_PATA_ATIIXP=y +CONFIG_PATA_ATP867X=y +CONFIG_PATA_CMD64X=y +CONFIG_PATA_CS5520=y +CONFIG_PATA_CS5530=y +CONFIG_PATA_CS5536=y +CONFIG_PATA_CYPRESS=y +CONFIG_PATA_EFAR=y +CONFIG_PATA_HPT366=y +CONFIG_PATA_HPT37X=y +CONFIG_PATA_HPT3X2N=y +CONFIG_PATA_HPT3X3=y +CONFIG_PATA_HPT3X3_DMA=y +CONFIG_PATA_IT8213=y +CONFIG_PATA_IT821X=y +CONFIG_PATA_JMICRON=y +CONFIG_PATA_MARVELL=y +CONFIG_PATA_NETCELL=y +CONFIG_PATA_NINJA32=y +CONFIG_PATA_NS87415=y +CONFIG_PATA_OLDPIIX=y +CONFIG_PATA_OPTIDMA=y +CONFIG_PATA_PDC2027X=y +CONFIG_PATA_PDC_OLD=y +CONFIG_PATA_RADISYS=y +CONFIG_PATA_RDC=y +CONFIG_PATA_SC1200=y +CONFIG_PATA_SCH=y +CONFIG_PATA_SERVERWORKS=y +CONFIG_PATA_SIL680=y +CONFIG_PATA_SIS=y +CONFIG_PATA_TOSHIBA=y +CONFIG_PATA_TRIFLEX=y +CONFIG_PATA_VIA=y +CONFIG_PATA_WINBOND=y + +# +# PIO-only SFF controllers +# +CONFIG_PATA_CMD640_PCI=y +CONFIG_PATA_MPIIX=y +CONFIG_PATA_NS87410=y +CONFIG_PATA_OPTI=y +CONFIG_PATA_PCMCIA=y +CONFIG_PATA_PLATFORM=y +CONFIG_PATA_OF_PLATFORM=y +CONFIG_PATA_RZ1000=y + +# +# Generic fallback / legacy drivers +# +CONFIG_PATA_ACPI=y +CONFIG_ATA_GENERIC=y +CONFIG_PATA_LEGACY=y +CONFIG_MD=y +CONFIG_BLK_DEV_MD=y +CONFIG_MD_AUTODETECT=y +CONFIG_MD_LINEAR=y +CONFIG_MD_RAID0=y +CONFIG_MD_RAID1=y +CONFIG_MD_RAID10=y +CONFIG_MD_RAID456=y +CONFIG_MD_MULTIPATH=y +CONFIG_MD_FAULTY=y +CONFIG_MD_CLUSTER=y +CONFIG_BCACHE=y +CONFIG_BCACHE_DEBUG=y +CONFIG_BCACHE_CLOSURES_DEBUG=y +CONFIG_BLK_DEV_DM_BUILTIN=y +CONFIG_BLK_DEV_DM=y +CONFIG_DM_MQ_DEFAULT=y +CONFIG_DM_DEBUG=y +CONFIG_DM_BUFIO=y +CONFIG_DM_DEBUG_BLOCK_MANAGER_LOCKING=y +CONFIG_DM_DEBUG_BLOCK_STACK_TRACING=y +CONFIG_DM_BIO_PRISON=y +CONFIG_DM_PERSISTENT_DATA=y +CONFIG_DM_UNSTRIPED=y +CONFIG_DM_CRYPT=y +CONFIG_DM_SNAPSHOT=y +CONFIG_DM_THIN_PROVISIONING=y +CONFIG_DM_CACHE=y +CONFIG_DM_CACHE_SMQ=y +CONFIG_DM_ERA=y +CONFIG_DM_MIRROR=y +CONFIG_DM_LOG_USERSPACE=y +CONFIG_DM_RAID=y +CONFIG_DM_ZERO=y +CONFIG_DM_MULTIPATH=y +CONFIG_DM_MULTIPATH_QL=y +CONFIG_DM_MULTIPATH_ST=y +CONFIG_DM_DELAY=y +CONFIG_DM_UEVENT=y +CONFIG_DM_FLAKEY=y +CONFIG_DM_VERITY=y +CONFIG_DM_VERITY_FEC=y +CONFIG_DM_SWITCH=y +CONFIG_DM_LOG_WRITES=y +CONFIG_DM_INTEGRITY=y +CONFIG_DM_ZONED=y +CONFIG_TARGET_CORE=y +CONFIG_TCM_IBLOCK=y +CONFIG_TCM_FILEIO=y +CONFIG_TCM_PSCSI=y +CONFIG_TCM_USER2=y +CONFIG_LOOPBACK_TARGET=y +CONFIG_TCM_FC=y +CONFIG_ISCSI_TARGET=y +CONFIG_ISCSI_TARGET_CXGB4=y +CONFIG_SBP_TARGET=y +CONFIG_FUSION=y +CONFIG_FUSION_SPI=y +CONFIG_FUSION_FC=y +CONFIG_FUSION_SAS=y +CONFIG_FUSION_MAX_SGE=128 +CONFIG_FUSION_CTL=y +CONFIG_FUSION_LAN=y +CONFIG_FUSION_LOGGING=y + +# +# IEEE 1394 (FireWire) support +# +CONFIG_FIREWIRE=y +CONFIG_FIREWIRE_OHCI=y +CONFIG_FIREWIRE_SBP2=y +CONFIG_FIREWIRE_NET=y +CONFIG_FIREWIRE_NOSY=y +CONFIG_MACINTOSH_DRIVERS=y +CONFIG_MAC_EMUMOUSEBTN=y +CONFIG_NETDEVICES=y +CONFIG_MII=y +CONFIG_NET_CORE=y +CONFIG_BONDING=y +CONFIG_DUMMY=y +CONFIG_EQUALIZER=y +CONFIG_NET_FC=y +CONFIG_IFB=y +CONFIG_NET_TEAM=y +CONFIG_NET_TEAM_MODE_BROADCAST=y +CONFIG_NET_TEAM_MODE_ROUNDROBIN=y +CONFIG_NET_TEAM_MODE_RANDOM=y +CONFIG_NET_TEAM_MODE_ACTIVEBACKUP=y +CONFIG_NET_TEAM_MODE_LOADBALANCE=y +CONFIG_MACVLAN=y +CONFIG_MACVTAP=y +CONFIG_IPVLAN=y +CONFIG_IPVTAP=y +CONFIG_VXLAN=y +CONFIG_GENEVE=y +CONFIG_GTP=y +CONFIG_MACSEC=y +CONFIG_NETCONSOLE=y +CONFIG_NETCONSOLE_DYNAMIC=y +CONFIG_NETPOLL=y +CONFIG_NET_POLL_CONTROLLER=y +CONFIG_NTB_NETDEV=y +CONFIG_RIONET=y +CONFIG_RIONET_TX_SIZE=128 +CONFIG_RIONET_RX_SIZE=128 +CONFIG_TUN=y +CONFIG_TAP=y +CONFIG_TUN_VNET_CROSS_LE=y +CONFIG_VETH=y +CONFIG_VIRTIO_NET=y +CONFIG_NLMON=y +CONFIG_NET_VRF=y +CONFIG_VSOCKMON=y +CONFIG_SUNGEM_PHY=y +CONFIG_ARCNET=y +CONFIG_ARCNET_1201=y +CONFIG_ARCNET_1051=y +CONFIG_ARCNET_RAW=y +CONFIG_ARCNET_CAP=y +CONFIG_ARCNET_COM90xx=y +CONFIG_ARCNET_COM90xxIO=y +CONFIG_ARCNET_RIM_I=y +CONFIG_ARCNET_COM20020=y +CONFIG_ARCNET_COM20020_PCI=y +CONFIG_ARCNET_COM20020_CS=y +CONFIG_ATM_DRIVERS=y +CONFIG_ATM_DUMMY=y +CONFIG_ATM_TCP=y +CONFIG_ATM_LANAI=y +CONFIG_ATM_ENI=y +CONFIG_ATM_ENI_DEBUG=y +CONFIG_ATM_ENI_TUNE_BURST=y +CONFIG_ATM_ENI_BURST_TX_16W=y +CONFIG_ATM_ENI_BURST_TX_8W=y +CONFIG_ATM_ENI_BURST_TX_4W=y +CONFIG_ATM_ENI_BURST_TX_2W=y +CONFIG_ATM_ENI_BURST_RX_16W=y +CONFIG_ATM_ENI_BURST_RX_8W=y +CONFIG_ATM_ENI_BURST_RX_4W=y +CONFIG_ATM_ENI_BURST_RX_2W=y +CONFIG_ATM_FIRESTREAM=y +CONFIG_ATM_ZATM=y +CONFIG_ATM_ZATM_DEBUG=y +CONFIG_ATM_NICSTAR=y +CONFIG_ATM_NICSTAR_USE_SUNI=y +CONFIG_ATM_NICSTAR_USE_IDT77105=y +CONFIG_ATM_IDT77252=y +CONFIG_ATM_IDT77252_DEBUG=y +CONFIG_ATM_IDT77252_RCV_ALL=y +CONFIG_ATM_IDT77252_USE_SUNI=y +CONFIG_ATM_AMBASSADOR=y +CONFIG_ATM_AMBASSADOR_DEBUG=y +CONFIG_ATM_HORIZON=y +CONFIG_ATM_HORIZON_DEBUG=y +CONFIG_ATM_IA=y +CONFIG_ATM_IA_DEBUG=y +CONFIG_ATM_FORE200E=y +CONFIG_ATM_FORE200E_USE_TASKLET=y +CONFIG_ATM_FORE200E_TX_RETRY=16 +CONFIG_ATM_FORE200E_DEBUG=0 +CONFIG_ATM_HE=y +CONFIG_ATM_HE_USE_SUNI=y +CONFIG_ATM_SOLOS=y + +# +# CAIF transport drivers +# +CONFIG_CAIF_TTY=y +CONFIG_CAIF_SPI_SLAVE=y +CONFIG_CAIF_SPI_SYNC=y +CONFIG_CAIF_HSI=y +CONFIG_CAIF_VIRTIO=y + +# +# Distributed Switch Architecture drivers +# +CONFIG_B53=y +CONFIG_B53_SPI_DRIVER=y +CONFIG_B53_MDIO_DRIVER=y +CONFIG_B53_MMAP_DRIVER=y +CONFIG_B53_SRAB_DRIVER=y +CONFIG_NET_DSA_BCM_SF2=y +CONFIG_NET_DSA_LOOP=y +CONFIG_NET_DSA_MT7530=y +CONFIG_NET_DSA_MV88E6060=y +CONFIG_MICROCHIP_KSZ=y +CONFIG_MICROCHIP_KSZ_SPI_DRIVER=y +CONFIG_NET_DSA_MV88E6XXX=y +CONFIG_NET_DSA_MV88E6XXX_GLOBAL2=y +CONFIG_NET_DSA_QCA8K=y +CONFIG_NET_DSA_SMSC_LAN9303=y +CONFIG_NET_DSA_SMSC_LAN9303_I2C=y +CONFIG_NET_DSA_SMSC_LAN9303_MDIO=y +CONFIG_ETHERNET=y +CONFIG_MDIO=y +CONFIG_NET_VENDOR_3COM=y +CONFIG_PCMCIA_3C574=y +CONFIG_PCMCIA_3C589=y +CONFIG_VORTEX=y +CONFIG_TYPHOON=y +CONFIG_NET_VENDOR_ADAPTEC=y +CONFIG_ADAPTEC_STARFIRE=y +CONFIG_NET_VENDOR_AGERE=y +CONFIG_ET131X=y +CONFIG_NET_VENDOR_ALACRITECH=y +CONFIG_SLICOSS=y +CONFIG_NET_VENDOR_ALTEON=y +CONFIG_ACENIC=y +CONFIG_ACENIC_OMIT_TIGON_I=y +CONFIG_ALTERA_TSE=y +CONFIG_NET_VENDOR_AMAZON=y +CONFIG_ENA_ETHERNET=y +CONFIG_NET_VENDOR_AMD=y +CONFIG_AMD8111_ETH=y +CONFIG_PCNET32=y +CONFIG_PCMCIA_NMCLAN=y +CONFIG_AMD_XGBE=y +CONFIG_AMD_XGBE_DCB=y +CONFIG_AMD_XGBE_HAVE_ECC=y +CONFIG_NET_XGENE=y +CONFIG_NET_XGENE_V2=y +CONFIG_NET_VENDOR_AQUANTIA=y +CONFIG_AQTION=y +CONFIG_NET_VENDOR_ARC=y +CONFIG_ARC_EMAC_CORE=y +CONFIG_ARC_EMAC=y +CONFIG_EMAC_ROCKCHIP=y +CONFIG_NET_VENDOR_ATHEROS=y +CONFIG_ATL2=y +CONFIG_ATL1=y +CONFIG_ATL1E=y +CONFIG_ATL1C=y +CONFIG_ALX=y +CONFIG_NET_VENDOR_AURORA=y +CONFIG_AURORA_NB8800=y +CONFIG_NET_CADENCE=y +CONFIG_MACB=y +CONFIG_MACB_USE_HWSTAMP=y +CONFIG_MACB_PCI=y +CONFIG_NET_VENDOR_BROADCOM=y +CONFIG_B44=y +CONFIG_B44_PCI_AUTOSELECT=y +CONFIG_B44_PCICORE_AUTOSELECT=y +CONFIG_B44_PCI=y +CONFIG_BCMGENET=y +CONFIG_BNX2=y +CONFIG_CNIC=y +CONFIG_TIGON3=y +CONFIG_TIGON3_HWMON=y +CONFIG_BNX2X=y +CONFIG_BNX2X_SRIOV=y +CONFIG_BGMAC=y +CONFIG_BGMAC_BCMA=y +CONFIG_BGMAC_PLATFORM=y +CONFIG_SYSTEMPORT=y +CONFIG_BNXT=y +CONFIG_BNXT_SRIOV=y +CONFIG_BNXT_FLOWER_OFFLOAD=y +CONFIG_BNXT_DCB=y +CONFIG_NET_VENDOR_BROCADE=y +CONFIG_BNA=y +CONFIG_NET_CALXEDA_XGMAC=y +CONFIG_NET_VENDOR_CAVIUM=y +CONFIG_THUNDER_NIC_PF=y +CONFIG_THUNDER_NIC_VF=y +CONFIG_THUNDER_NIC_BGX=y +CONFIG_THUNDER_NIC_RGX=y +CONFIG_CAVIUM_PTP=y +CONFIG_LIQUIDIO=y +CONFIG_LIQUIDIO_VF=y +CONFIG_NET_VENDOR_CHELSIO=y +CONFIG_CHELSIO_T1=y +CONFIG_CHELSIO_T1_1G=y +CONFIG_CHELSIO_T3=y +CONFIG_CHELSIO_T4=y +CONFIG_CHELSIO_T4_DCB=y +CONFIG_CHELSIO_T4_FCOE=y +CONFIG_CHELSIO_T4VF=y +CONFIG_CHELSIO_LIB=y +CONFIG_NET_VENDOR_CISCO=y +CONFIG_ENIC=y +CONFIG_NET_VENDOR_CORTINA=y +CONFIG_GEMINI_ETHERNET=y +CONFIG_CX_ECAT=y +CONFIG_DNET=y +CONFIG_NET_VENDOR_DEC=y +CONFIG_NET_TULIP=y +CONFIG_DE2104X=y +CONFIG_DE2104X_DSL=0 +CONFIG_TULIP=y +CONFIG_TULIP_MWI=y +CONFIG_TULIP_MMIO=y +CONFIG_TULIP_NAPI=y +CONFIG_TULIP_NAPI_HW_MITIGATION=y +CONFIG_DE4X5=y +CONFIG_WINBOND_840=y +CONFIG_DM9102=y +CONFIG_ULI526X=y +CONFIG_PCMCIA_XIRCOM=y +CONFIG_NET_VENDOR_DLINK=y +CONFIG_DL2K=y +CONFIG_SUNDANCE=y +CONFIG_SUNDANCE_MMIO=y +CONFIG_NET_VENDOR_EMULEX=y +CONFIG_BE2NET=y +CONFIG_BE2NET_HWMON=y +CONFIG_NET_VENDOR_EZCHIP=y +CONFIG_EZCHIP_NPS_MANAGEMENT_ENET=y +CONFIG_NET_VENDOR_EXAR=y +CONFIG_S2IO=y +CONFIG_VXGE=y +CONFIG_VXGE_DEBUG_TRACE_ALL=y +CONFIG_NET_VENDOR_FREESCALE=y +CONFIG_FSL_FMAN=y +CONFIG_FSL_PQ_MDIO=y +CONFIG_FSL_XGMAC_MDIO=y +CONFIG_GIANFAR=y +CONFIG_NET_VENDOR_FUJITSU=y +CONFIG_PCMCIA_FMVJ18X=y +CONFIG_NET_VENDOR_HISILICON=y +CONFIG_HIX5HD2_GMAC=y +CONFIG_HISI_FEMAC=y +CONFIG_HIP04_ETH=y +CONFIG_HNS_MDIO=y +CONFIG_HNS=y +CONFIG_HNS_DSAF=y +CONFIG_HNS_ENET=y +CONFIG_HNS3=y +CONFIG_HNS3_HCLGE=y +CONFIG_HNS3_DCB=y +CONFIG_HNS3_HCLGEVF=y +CONFIG_HNS3_ENET=y +CONFIG_NET_VENDOR_HP=y +CONFIG_HP100=y +CONFIG_NET_VENDOR_HUAWEI=y +CONFIG_HINIC=y +CONFIG_NET_VENDOR_INTEL=y +CONFIG_E100=y +CONFIG_E1000=y +CONFIG_E1000E=y +CONFIG_E1000E_HWTS=y +CONFIG_IGB=y +CONFIG_IGB_HWMON=y +CONFIG_IGB_DCA=y +CONFIG_IGBVF=y +CONFIG_IXGB=y +CONFIG_IXGBE=y +CONFIG_IXGBE_HWMON=y +CONFIG_IXGBE_DCA=y +CONFIG_IXGBE_DCB=y +CONFIG_IXGBEVF=y +CONFIG_I40E=y +CONFIG_I40E_DCB=y +CONFIG_I40EVF=y +CONFIG_FM10K=y +CONFIG_NET_VENDOR_I825XX=y +CONFIG_JME=y +CONFIG_NET_VENDOR_MARVELL=y +CONFIG_MV643XX_ETH=y +CONFIG_MVMDIO=y +CONFIG_MVNETA=y +CONFIG_MVPP2=y +CONFIG_PXA168_ETH=y +CONFIG_SKGE=y +CONFIG_SKGE_DEBUG=y +CONFIG_SKGE_GENESIS=y +CONFIG_SKY2=y +CONFIG_SKY2_DEBUG=y +CONFIG_NET_VENDOR_MELLANOX=y +CONFIG_MLX4_EN=y +CONFIG_MLX4_EN_DCB=y +CONFIG_MLX4_CORE=y +CONFIG_MLX4_DEBUG=y +CONFIG_MLX4_CORE_GEN2=y +CONFIG_MLX5_CORE=y +CONFIG_MLX5_ACCEL=y +CONFIG_MLX5_FPGA=y +CONFIG_MLX5_CORE_EN=y +CONFIG_MLX5_MPFS=y +CONFIG_MLX5_ESWITCH=y +CONFIG_MLX5_CORE_EN_DCB=y +CONFIG_MLX5_CORE_IPOIB=y +CONFIG_MLX5_EN_IPSEC=y +CONFIG_MLXSW_CORE=y +CONFIG_MLXSW_CORE_HWMON=y +CONFIG_MLXSW_CORE_THERMAL=y +CONFIG_MLXSW_PCI=y +CONFIG_MLXSW_I2C=y +CONFIG_MLXSW_SWITCHIB=y +CONFIG_MLXSW_SWITCHX2=y +CONFIG_MLXSW_SPECTRUM=y +CONFIG_MLXSW_SPECTRUM_DCB=y +CONFIG_MLXSW_MINIMAL=y +CONFIG_MLXFW=y +CONFIG_NET_VENDOR_MICREL=y +CONFIG_KS8842=y +CONFIG_KS8851=y +CONFIG_KS8851_MLL=y +CONFIG_KSZ884X_PCI=y +CONFIG_NET_VENDOR_MICROCHIP=y +CONFIG_ENC28J60=y +CONFIG_ENC28J60_WRITEVERIFY=y +CONFIG_ENCX24J600=y +CONFIG_NET_VENDOR_MYRI=y +CONFIG_MYRI10GE=y +CONFIG_MYRI10GE_DCA=y +CONFIG_FEALNX=y +CONFIG_NET_VENDOR_NATSEMI=y +CONFIG_NATSEMI=y +CONFIG_NS83820=y +CONFIG_NET_VENDOR_NETRONOME=y +CONFIG_NFP=y +CONFIG_NFP_APP_FLOWER=y +CONFIG_NFP_DEBUG=y +CONFIG_NET_VENDOR_8390=y +CONFIG_PCMCIA_AXNET=y +CONFIG_NE2K_PCI=y +CONFIG_PCMCIA_PCNET=y +CONFIG_NET_VENDOR_NVIDIA=y +CONFIG_FORCEDETH=y +CONFIG_NET_VENDOR_OKI=y +CONFIG_PCH_GBE=y +CONFIG_ETHOC=y +CONFIG_NET_PACKET_ENGINE=y +CONFIG_HAMACHI=y +CONFIG_YELLOWFIN=y +CONFIG_NET_VENDOR_QLOGIC=y +CONFIG_QLA3XXX=y +CONFIG_QLCNIC=y +CONFIG_QLCNIC_SRIOV=y +CONFIG_QLCNIC_DCB=y +CONFIG_QLCNIC_HWMON=y +CONFIG_QLGE=y +CONFIG_NETXEN_NIC=y +CONFIG_QED=y +CONFIG_QED_LL2=y +CONFIG_QED_SRIOV=y +CONFIG_QEDE=y +CONFIG_QED_RDMA=y +CONFIG_QED_ISCSI=y +CONFIG_QED_FCOE=y +CONFIG_QED_OOO=y +CONFIG_NET_VENDOR_QUALCOMM=y +CONFIG_QCA7000=y +CONFIG_QCA7000_SPI=y +CONFIG_QCA7000_UART=y +CONFIG_QCOM_EMAC=y +CONFIG_RMNET=y +CONFIG_NET_VENDOR_REALTEK=y +CONFIG_ATP=y +CONFIG_8139CP=y +CONFIG_8139TOO=y +CONFIG_8139TOO_PIO=y +CONFIG_8139TOO_TUNE_TWISTER=y +CONFIG_8139TOO_8129=y +CONFIG_8139_OLD_RX_RESET=y +CONFIG_R8169=y +CONFIG_NET_VENDOR_RENESAS=y +CONFIG_SH_ETH=y +CONFIG_RAVB=y +CONFIG_NET_VENDOR_RDC=y +CONFIG_R6040=y +CONFIG_NET_VENDOR_ROCKER=y +CONFIG_ROCKER=y +CONFIG_NET_VENDOR_SAMSUNG=y +CONFIG_SXGBE_ETH=y +CONFIG_NET_VENDOR_SEEQ=y +CONFIG_NET_VENDOR_SILAN=y +CONFIG_SC92031=y +CONFIG_NET_VENDOR_SIS=y +CONFIG_SIS900=y +CONFIG_SIS190=y +CONFIG_NET_VENDOR_SOLARFLARE=y +CONFIG_SFC=y +CONFIG_SFC_MTD=y +CONFIG_SFC_MCDI_MON=y +CONFIG_SFC_SRIOV=y +CONFIG_SFC_MCDI_LOGGING=y +CONFIG_SFC_FALCON=y +CONFIG_SFC_FALCON_MTD=y +CONFIG_NET_VENDOR_SMSC=y +CONFIG_PCMCIA_SMC91C92=y +CONFIG_EPIC100=y +CONFIG_SMSC911X=y +# CONFIG_SMSC911X_ARCH_HOOKS is not set +CONFIG_SMSC9420=y +CONFIG_NET_VENDOR_SOCIONEXT=y +CONFIG_SNI_AVE=y +CONFIG_SNI_NETSEC=y +CONFIG_NET_VENDOR_STMICRO=y +CONFIG_STMMAC_ETH=y +CONFIG_STMMAC_PLATFORM=y +CONFIG_DWMAC_DWC_QOS_ETH=y +CONFIG_DWMAC_GENERIC=y +CONFIG_DWMAC_ANARION=y +CONFIG_DWMAC_IPQ806X=y +CONFIG_DWMAC_LPC18XX=y +CONFIG_DWMAC_MESON=y +CONFIG_DWMAC_OXNAS=y +CONFIG_DWMAC_ROCKCHIP=y +CONFIG_DWMAC_SOCFPGA=y +CONFIG_DWMAC_STI=y +CONFIG_DWMAC_STM32=y +CONFIG_DWMAC_SUNXI=y +CONFIG_DWMAC_SUN8I=y +CONFIG_STMMAC_PCI=y +CONFIG_NET_VENDOR_SUN=y +CONFIG_HAPPYMEAL=y +CONFIG_SUNGEM=y +CONFIG_CASSINI=y +CONFIG_NIU=y +CONFIG_NET_VENDOR_TEHUTI=y +CONFIG_TEHUTI=y +CONFIG_NET_VENDOR_TI=y +CONFIG_TI_CPSW_ALE=y +CONFIG_TLAN=y +CONFIG_NET_VENDOR_VIA=y +CONFIG_VIA_RHINE=y +CONFIG_VIA_RHINE_MMIO=y +CONFIG_VIA_VELOCITY=y +CONFIG_NET_VENDOR_WIZNET=y +CONFIG_WIZNET_W5100=y +CONFIG_WIZNET_W5300=y +# CONFIG_WIZNET_BUS_DIRECT is not set +# CONFIG_WIZNET_BUS_INDIRECT is not set +CONFIG_WIZNET_BUS_ANY=y +CONFIG_WIZNET_W5100_SPI=y +CONFIG_NET_VENDOR_XIRCOM=y +CONFIG_PCMCIA_XIRC2PS=y +CONFIG_NET_VENDOR_SYNOPSYS=y +CONFIG_DWC_XLGMAC=y +CONFIG_DWC_XLGMAC_PCI=y +CONFIG_FDDI=y +CONFIG_DEFXX=y +CONFIG_DEFXX_MMIO=y +CONFIG_SKFP=y +CONFIG_HIPPI=y +CONFIG_ROADRUNNER=y +CONFIG_ROADRUNNER_LARGE_RINGS=y +CONFIG_NET_SB1000=y +CONFIG_MDIO_DEVICE=y +CONFIG_MDIO_BUS=y +CONFIG_MDIO_BCM_IPROC=y +CONFIG_MDIO_BCM_UNIMAC=y +CONFIG_MDIO_BITBANG=y +CONFIG_MDIO_BUS_MUX=y +CONFIG_MDIO_BUS_MUX_BCM_IPROC=y +CONFIG_MDIO_BUS_MUX_GPIO=y +CONFIG_MDIO_BUS_MUX_MMIOREG=y +CONFIG_MDIO_CAVIUM=y +CONFIG_MDIO_GPIO=y +CONFIG_MDIO_HISI_FEMAC=y +CONFIG_MDIO_I2C=y +CONFIG_MDIO_OCTEON=y +CONFIG_MDIO_THUNDER=y +CONFIG_MDIO_XGENE=y +CONFIG_PHYLINK=y +CONFIG_PHYLIB=y +CONFIG_SWPHY=y +CONFIG_LED_TRIGGER_PHY=y + +# +# MII PHY device drivers +# +CONFIG_SFP=y +CONFIG_AMD_PHY=y +CONFIG_AQUANTIA_PHY=y +CONFIG_AT803X_PHY=y +CONFIG_BCM7XXX_PHY=y +CONFIG_BCM87XX_PHY=y +CONFIG_BCM_CYGNUS_PHY=y +CONFIG_BCM_NET_PHYLIB=y +CONFIG_BROADCOM_PHY=y +CONFIG_CICADA_PHY=y +CONFIG_CORTINA_PHY=y +CONFIG_DAVICOM_PHY=y +CONFIG_DP83822_PHY=y +CONFIG_DP83848_PHY=y +CONFIG_DP83867_PHY=y +CONFIG_FIXED_PHY=y +CONFIG_ICPLUS_PHY=y +CONFIG_INTEL_XWAY_PHY=y +CONFIG_LSI_ET1011C_PHY=y +CONFIG_LXT_PHY=y +CONFIG_MARVELL_PHY=y +CONFIG_MARVELL_10G_PHY=y +CONFIG_MESON_GXL_PHY=y +CONFIG_MICREL_PHY=y +CONFIG_MICROCHIP_PHY=y +CONFIG_MICROSEMI_PHY=y +CONFIG_NATIONAL_PHY=y +CONFIG_QSEMI_PHY=y +CONFIG_REALTEK_PHY=y +CONFIG_RENESAS_PHY=y +CONFIG_ROCKCHIP_PHY=y +CONFIG_SMSC_PHY=y +CONFIG_STE10XP=y +CONFIG_TERANETICS_PHY=y +CONFIG_VITESSE_PHY=y +CONFIG_XILINX_GMII2RGMII=y +CONFIG_MICREL_KS8995MA=y +CONFIG_PLIP=y +CONFIG_PPP=y +CONFIG_PPP_BSDCOMP=y +CONFIG_PPP_DEFLATE=y +CONFIG_PPP_FILTER=y +CONFIG_PPP_MPPE=y +CONFIG_PPP_MULTILINK=y +CONFIG_PPPOATM=y +CONFIG_PPPOE=y +CONFIG_PPTP=y +CONFIG_PPPOL2TP=y +CONFIG_PPP_ASYNC=y +CONFIG_PPP_SYNC_TTY=y +CONFIG_SLIP=y +CONFIG_SLHC=y +CONFIG_SLIP_COMPRESSED=y +CONFIG_SLIP_SMART=y +CONFIG_SLIP_MODE_SLIP6=y +CONFIG_USB_NET_DRIVERS=y +CONFIG_USB_CATC=y +CONFIG_USB_KAWETH=y +CONFIG_USB_PEGASUS=y +CONFIG_USB_RTL8150=y +CONFIG_USB_RTL8152=y +CONFIG_USB_LAN78XX=y +CONFIG_USB_USBNET=y +CONFIG_USB_NET_AX8817X=y +CONFIG_USB_NET_AX88179_178A=y +CONFIG_USB_NET_CDCETHER=y +CONFIG_USB_NET_CDC_EEM=y +CONFIG_USB_NET_CDC_NCM=y +CONFIG_USB_NET_HUAWEI_CDC_NCM=y +CONFIG_USB_NET_CDC_MBIM=y +CONFIG_USB_NET_DM9601=y +CONFIG_USB_NET_SR9700=y +CONFIG_USB_NET_SR9800=y +CONFIG_USB_NET_SMSC75XX=y +CONFIG_USB_NET_SMSC95XX=y +CONFIG_USB_NET_GL620A=y +CONFIG_USB_NET_NET1080=y +CONFIG_USB_NET_PLUSB=y +CONFIG_USB_NET_MCS7830=y +CONFIG_USB_NET_RNDIS_HOST=y +CONFIG_USB_NET_CDC_SUBSET_ENABLE=y +CONFIG_USB_NET_CDC_SUBSET=y +CONFIG_USB_ALI_M5632=y +CONFIG_USB_AN2720=y +CONFIG_USB_BELKIN=y +CONFIG_USB_ARMLINUX=y +CONFIG_USB_EPSON2888=y +CONFIG_USB_KC2190=y +CONFIG_USB_NET_ZAURUS=y +CONFIG_USB_NET_CX82310_ETH=y +CONFIG_USB_NET_KALMIA=y +CONFIG_USB_NET_QMI_WWAN=y +CONFIG_USB_HSO=y +CONFIG_USB_NET_INT51X1=y +CONFIG_USB_CDC_PHONET=y +CONFIG_USB_IPHETH=y +CONFIG_USB_SIERRA_NET=y +CONFIG_USB_VL600=y +CONFIG_USB_NET_CH9200=y +CONFIG_WLAN=y +CONFIG_WIRELESS_WDS=y +CONFIG_WLAN_VENDOR_ADMTEK=y +CONFIG_ADM8211=y +CONFIG_ATH_COMMON=y +CONFIG_WLAN_VENDOR_ATH=y +CONFIG_ATH_DEBUG=y +CONFIG_ATH_TRACEPOINTS=y +CONFIG_ATH_REG_DYNAMIC_USER_REG_HINTS=y +CONFIG_ATH_REG_DYNAMIC_USER_CERT_TESTING=y +CONFIG_ATH5K=y +CONFIG_ATH5K_DEBUG=y +CONFIG_ATH5K_TRACER=y +CONFIG_ATH5K_PCI=y +CONFIG_ATH5K_TEST_CHANNELS=y +CONFIG_ATH9K_HW=y +CONFIG_ATH9K_COMMON=y +CONFIG_ATH9K_COMMON_DEBUG=y +CONFIG_ATH9K_DFS_DEBUGFS=y +CONFIG_ATH9K_BTCOEX_SUPPORT=y +CONFIG_ATH9K=y +CONFIG_ATH9K_PCI=y +CONFIG_ATH9K_AHB=y +CONFIG_ATH9K_DEBUGFS=y +CONFIG_ATH9K_STATION_STATISTICS=y +CONFIG_ATH9K_TX99=y +CONFIG_ATH9K_DFS_CERTIFIED=y +CONFIG_ATH9K_DYNACK=y +CONFIG_ATH9K_WOW=y +CONFIG_ATH9K_RFKILL=y +CONFIG_ATH9K_CHANNEL_CONTEXT=y +CONFIG_ATH9K_PCOEM=y +CONFIG_ATH9K_HTC=y +CONFIG_ATH9K_HTC_DEBUGFS=y +CONFIG_ATH9K_HWRNG=y +CONFIG_ATH9K_COMMON_SPECTRAL=y +CONFIG_CARL9170=y +CONFIG_CARL9170_LEDS=y +CONFIG_CARL9170_DEBUGFS=y +CONFIG_CARL9170_WPC=y +CONFIG_CARL9170_HWRNG=y +CONFIG_ATH6KL=y +CONFIG_ATH6KL_SDIO=y +CONFIG_ATH6KL_USB=y +CONFIG_ATH6KL_DEBUG=y +CONFIG_ATH6KL_TRACING=y +CONFIG_ATH6KL_REGDOMAIN=y +CONFIG_AR5523=y +CONFIG_WIL6210=y +CONFIG_WIL6210_ISR_COR=y +CONFIG_WIL6210_TRACING=y +CONFIG_WIL6210_DEBUGFS=y +CONFIG_ATH10K=y +CONFIG_ATH10K_PCI=y +CONFIG_ATH10K_AHB=y +CONFIG_ATH10K_SDIO=y +CONFIG_ATH10K_USB=y +CONFIG_ATH10K_DEBUG=y +CONFIG_ATH10K_DEBUGFS=y +CONFIG_ATH10K_SPECTRAL=y +CONFIG_ATH10K_TRACING=y +CONFIG_ATH10K_DFS_CERTIFIED=y +CONFIG_WCN36XX=y +CONFIG_WCN36XX_DEBUGFS=y +CONFIG_WLAN_VENDOR_ATMEL=y +CONFIG_ATMEL=y +CONFIG_PCI_ATMEL=y +CONFIG_PCMCIA_ATMEL=y +CONFIG_AT76C50X_USB=y +CONFIG_WLAN_VENDOR_BROADCOM=y +CONFIG_B43=y +CONFIG_B43_BCMA=y +CONFIG_B43_SSB=y +CONFIG_B43_BUSES_BCMA_AND_SSB=y +# CONFIG_B43_BUSES_BCMA is not set +# CONFIG_B43_BUSES_SSB is not set +CONFIG_B43_PCI_AUTOSELECT=y +CONFIG_B43_PCICORE_AUTOSELECT=y +CONFIG_B43_SDIO=y +CONFIG_B43_BCMA_PIO=y +CONFIG_B43_PIO=y +CONFIG_B43_PHY_G=y +CONFIG_B43_PHY_N=y +CONFIG_B43_PHY_LP=y +CONFIG_B43_PHY_HT=y +CONFIG_B43_LEDS=y +CONFIG_B43_HWRNG=y +CONFIG_B43_DEBUG=y +CONFIG_B43LEGACY=y +CONFIG_B43LEGACY_PCI_AUTOSELECT=y +CONFIG_B43LEGACY_PCICORE_AUTOSELECT=y +CONFIG_B43LEGACY_LEDS=y +CONFIG_B43LEGACY_HWRNG=y +CONFIG_B43LEGACY_DEBUG=y +CONFIG_B43LEGACY_DMA=y +CONFIG_B43LEGACY_PIO=y +CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y +# CONFIG_B43LEGACY_DMA_MODE is not set +# CONFIG_B43LEGACY_PIO_MODE is not set +CONFIG_BRCMUTIL=y +CONFIG_BRCMSMAC=y +CONFIG_BRCMFMAC=y +CONFIG_BRCMFMAC_PROTO_BCDC=y +CONFIG_BRCMFMAC_PROTO_MSGBUF=y +CONFIG_BRCMFMAC_SDIO=y +CONFIG_BRCMFMAC_USB=y +CONFIG_BRCMFMAC_PCIE=y +CONFIG_BRCM_TRACING=y +CONFIG_BRCMDBG=y +CONFIG_WLAN_VENDOR_CISCO=y +CONFIG_AIRO=y +CONFIG_AIRO_CS=y +CONFIG_WLAN_VENDOR_INTEL=y +CONFIG_IPW2100=y +CONFIG_IPW2100_MONITOR=y +CONFIG_IPW2100_DEBUG=y +CONFIG_IPW2200=y +CONFIG_IPW2200_MONITOR=y +CONFIG_IPW2200_RADIOTAP=y +CONFIG_IPW2200_PROMISCUOUS=y +CONFIG_IPW2200_QOS=y +CONFIG_IPW2200_DEBUG=y +CONFIG_LIBIPW=y +CONFIG_LIBIPW_DEBUG=y +CONFIG_IWLEGACY=y +CONFIG_IWL4965=y +CONFIG_IWL3945=y + +# +# iwl3945 / iwl4965 Debugging Options +# +CONFIG_IWLEGACY_DEBUG=y +CONFIG_IWLEGACY_DEBUGFS=y +CONFIG_IWLWIFI=y +CONFIG_IWLWIFI_LEDS=y +CONFIG_IWLDVM=y +CONFIG_IWLMVM=y +CONFIG_IWLWIFI_BCAST_FILTERING=y +CONFIG_IWLWIFI_PCIE_RTPM=y + +# +# Debugging Options +# +CONFIG_IWLWIFI_DEBUG=y +CONFIG_IWLWIFI_DEBUGFS=y +CONFIG_IWLWIFI_DEVICE_TRACING=y +CONFIG_WLAN_VENDOR_INTERSIL=y +CONFIG_HOSTAP=y +CONFIG_HOSTAP_FIRMWARE=y +CONFIG_HOSTAP_FIRMWARE_NVRAM=y +CONFIG_HOSTAP_PLX=y +CONFIG_HOSTAP_PCI=y +CONFIG_HOSTAP_CS=y +CONFIG_HERMES=y +CONFIG_HERMES_PRISM=y +CONFIG_HERMES_CACHE_FW_ON_INIT=y +CONFIG_PLX_HERMES=y +CONFIG_TMD_HERMES=y +CONFIG_NORTEL_HERMES=y +CONFIG_PCI_HERMES=y +CONFIG_PCMCIA_HERMES=y +CONFIG_PCMCIA_SPECTRUM=y +CONFIG_ORINOCO_USB=y +CONFIG_P54_COMMON=y +CONFIG_P54_USB=y +CONFIG_P54_PCI=y +CONFIG_P54_SPI=y +CONFIG_P54_SPI_DEFAULT_EEPROM=y +CONFIG_P54_LEDS=y +CONFIG_PRISM54=y +CONFIG_WLAN_VENDOR_MARVELL=y +CONFIG_LIBERTAS=y +CONFIG_LIBERTAS_USB=y +CONFIG_LIBERTAS_CS=y +CONFIG_LIBERTAS_SDIO=y +CONFIG_LIBERTAS_SPI=y +CONFIG_LIBERTAS_DEBUG=y +CONFIG_LIBERTAS_MESH=y +CONFIG_LIBERTAS_THINFIRM=y +CONFIG_LIBERTAS_THINFIRM_DEBUG=y +CONFIG_LIBERTAS_THINFIRM_USB=y +CONFIG_MWIFIEX=y +CONFIG_MWIFIEX_SDIO=y +CONFIG_MWIFIEX_PCIE=y +CONFIG_MWIFIEX_USB=y +CONFIG_MWL8K=y +CONFIG_WLAN_VENDOR_MEDIATEK=y +CONFIG_MT7601U=y +CONFIG_MT76_CORE=y +CONFIG_MT76x2E=y +CONFIG_WLAN_VENDOR_RALINK=y +CONFIG_RT2X00=y +CONFIG_RT2400PCI=y +CONFIG_RT2500PCI=y +CONFIG_RT61PCI=y +CONFIG_RT2800PCI=y +CONFIG_RT2800PCI_RT33XX=y +CONFIG_RT2800PCI_RT35XX=y +CONFIG_RT2800PCI_RT53XX=y +CONFIG_RT2800PCI_RT3290=y +CONFIG_RT2500USB=y +CONFIG_RT73USB=y +CONFIG_RT2800USB=y +CONFIG_RT2800USB_RT33XX=y +CONFIG_RT2800USB_RT35XX=y +CONFIG_RT2800USB_RT3573=y +CONFIG_RT2800USB_RT53XX=y +CONFIG_RT2800USB_RT55XX=y +CONFIG_RT2800USB_UNKNOWN=y +CONFIG_RT2800_LIB=y +CONFIG_RT2800_LIB_MMIO=y +CONFIG_RT2X00_LIB_MMIO=y +CONFIG_RT2X00_LIB_PCI=y +CONFIG_RT2X00_LIB_USB=y +CONFIG_RT2X00_LIB=y +CONFIG_RT2X00_LIB_FIRMWARE=y +CONFIG_RT2X00_LIB_CRYPTO=y +CONFIG_RT2X00_LIB_LEDS=y +CONFIG_RT2X00_LIB_DEBUGFS=y +CONFIG_RT2X00_DEBUG=y +CONFIG_WLAN_VENDOR_REALTEK=y +CONFIG_RTL8180=y +CONFIG_RTL8187=y +CONFIG_RTL8187_LEDS=y +CONFIG_RTL_CARDS=y +CONFIG_RTL8192CE=y +CONFIG_RTL8192SE=y +CONFIG_RTL8192DE=y +CONFIG_RTL8723AE=y +CONFIG_RTL8723BE=y +CONFIG_RTL8188EE=y +CONFIG_RTL8192EE=y +CONFIG_RTL8821AE=y +CONFIG_RTL8192CU=y +CONFIG_RTLWIFI=y +CONFIG_RTLWIFI_PCI=y +CONFIG_RTLWIFI_USB=y +CONFIG_RTLWIFI_DEBUG=y +CONFIG_RTL8192C_COMMON=y +CONFIG_RTL8723_COMMON=y +CONFIG_RTLBTCOEXIST=y +CONFIG_RTL8XXXU=y +CONFIG_RTL8XXXU_UNTESTED=y +CONFIG_WLAN_VENDOR_RSI=y +CONFIG_RSI_91X=y +CONFIG_RSI_DEBUGFS=y +CONFIG_RSI_SDIO=y +CONFIG_RSI_USB=y +CONFIG_WLAN_VENDOR_ST=y +CONFIG_CW1200=y +CONFIG_CW1200_WLAN_SDIO=y +CONFIG_CW1200_WLAN_SPI=y +CONFIG_WLAN_VENDOR_TI=y +CONFIG_WL1251=y +CONFIG_WL1251_SPI=y +CONFIG_WL1251_SDIO=y +CONFIG_WL12XX=y +CONFIG_WL18XX=y +CONFIG_WLCORE=y +CONFIG_WLCORE_SPI=y +CONFIG_WLCORE_SDIO=y +CONFIG_WILINK_PLATFORM_DATA=y +CONFIG_WLAN_VENDOR_ZYDAS=y +CONFIG_USB_ZD1201=y +CONFIG_ZD1211RW=y +CONFIG_ZD1211RW_DEBUG=y +CONFIG_WLAN_VENDOR_QUANTENNA=y +CONFIG_QTNFMAC=y +CONFIG_QTNFMAC_PEARL_PCIE=y +CONFIG_PCMCIA_RAYCS=y +CONFIG_PCMCIA_WL3501=y +CONFIG_MAC80211_HWSIM=y +CONFIG_USB_NET_RNDIS_WLAN=y + +# +# WiMAX Wireless Broadband devices +# +CONFIG_WIMAX_I2400M=y +CONFIG_WIMAX_I2400M_USB=y +CONFIG_WIMAX_I2400M_DEBUG_LEVEL=8 +CONFIG_WAN=y +CONFIG_LANMEDIA=y +CONFIG_HDLC=y +CONFIG_HDLC_RAW=y +CONFIG_HDLC_RAW_ETH=y +CONFIG_HDLC_CISCO=y +CONFIG_HDLC_FR=y +CONFIG_HDLC_PPP=y +CONFIG_HDLC_X25=y +CONFIG_PCI200SYN=y +CONFIG_WANXL=y +CONFIG_PC300TOO=y +CONFIG_FARSYNC=y +CONFIG_DSCC4=m +CONFIG_SLIC_DS26522=y +CONFIG_DSCC4_PCISYNC=y +CONFIG_DSCC4_PCI_RST=y +CONFIG_DLCI=y +CONFIG_DLCI_MAX=8 +CONFIG_LAPBETHER=y +CONFIG_X25_ASY=y +CONFIG_SBNI=y +CONFIG_SBNI_MULTILINE=y +CONFIG_IEEE802154_DRIVERS=y +CONFIG_IEEE802154_FAKELB=y +CONFIG_IEEE802154_AT86RF230=y +CONFIG_IEEE802154_AT86RF230_DEBUGFS=y +CONFIG_IEEE802154_MRF24J40=y +CONFIG_IEEE802154_CC2520=y +CONFIG_IEEE802154_ATUSB=y +CONFIG_IEEE802154_ADF7242=y +CONFIG_IEEE802154_CA8210=y +CONFIG_IEEE802154_CA8210_DEBUGFS=y +CONFIG_XEN_NETDEV_FRONTEND=y +CONFIG_VMXNET3=y +CONFIG_FUJITSU_ES=y +CONFIG_THUNDERBOLT_NET=y +CONFIG_HYPERV_NET=y +CONFIG_NETDEVSIM=y +CONFIG_ISDN=y +CONFIG_ISDN_I4L=y +CONFIG_ISDN_PPP=y +CONFIG_ISDN_PPP_VJ=y +CONFIG_ISDN_MPP=y +CONFIG_IPPP_FILTER=y +CONFIG_ISDN_PPP_BSDCOMP=y +CONFIG_ISDN_AUDIO=y +CONFIG_ISDN_TTY_FAX=y +CONFIG_ISDN_X25=y + +# +# ISDN feature submodules +# +CONFIG_ISDN_DIVERSION=y + +# +# ISDN4Linux hardware drivers +# + +# +# Passive cards +# +CONFIG_ISDN_DRV_HISAX=y + +# +# D-channel protocol features +# +CONFIG_HISAX_EURO=y +CONFIG_DE_AOC=y +CONFIG_HISAX_NO_SENDCOMPLETE=y +CONFIG_HISAX_NO_LLC=y +CONFIG_HISAX_NO_KEYPAD=y +CONFIG_HISAX_1TR6=y +CONFIG_HISAX_NI1=y +CONFIG_HISAX_MAX_CARDS=8 + +# +# HiSax supported cards +# +CONFIG_HISAX_16_3=y +CONFIG_HISAX_TELESPCI=y +CONFIG_HISAX_S0BOX=y +CONFIG_HISAX_FRITZPCI=y +CONFIG_HISAX_AVM_A1_PCMCIA=y +CONFIG_HISAX_ELSA=y +CONFIG_HISAX_DIEHLDIVA=y +CONFIG_HISAX_SEDLBAUER=y +CONFIG_HISAX_NETJET=y +CONFIG_HISAX_NETJET_U=y +CONFIG_HISAX_NICCY=y +CONFIG_HISAX_BKM_A4T=y +CONFIG_HISAX_SCT_QUADRO=y +CONFIG_HISAX_GAZEL=y +CONFIG_HISAX_HFC_PCI=y +CONFIG_HISAX_W6692=y +CONFIG_HISAX_HFC_SX=y +CONFIG_HISAX_ENTERNOW_PCI=y +CONFIG_HISAX_DEBUG=y + +# +# HiSax PCMCIA card service modules +# +CONFIG_HISAX_SEDLBAUER_CS=y +CONFIG_HISAX_ELSA_CS=y +CONFIG_HISAX_AVM_A1_CS=y +CONFIG_HISAX_TELES_CS=y + +# +# HiSax sub driver modules +# +CONFIG_HISAX_ST5481=y +CONFIG_HISAX_HFCUSB=y +CONFIG_HISAX_HFC4S8S=y +CONFIG_HISAX_FRITZ_PCIPNP=y +CONFIG_ISDN_CAPI=y +CONFIG_CAPI_TRACE=y +CONFIG_ISDN_CAPI_CAPI20=y +CONFIG_ISDN_CAPI_MIDDLEWARE=y +CONFIG_ISDN_CAPI_CAPIDRV=y +CONFIG_ISDN_CAPI_CAPIDRV_VERBOSE=y + +# +# CAPI hardware drivers +# +CONFIG_CAPI_AVM=y +CONFIG_ISDN_DRV_AVMB1_B1PCI=y +CONFIG_ISDN_DRV_AVMB1_B1PCIV4=y +CONFIG_ISDN_DRV_AVMB1_B1PCMCIA=y +CONFIG_ISDN_DRV_AVMB1_AVM_CS=y +CONFIG_ISDN_DRV_AVMB1_T1PCI=y +CONFIG_ISDN_DRV_AVMB1_C4=y +CONFIG_CAPI_EICON=y +CONFIG_ISDN_DIVAS=y +CONFIG_ISDN_DIVAS_BRIPCI=y +CONFIG_ISDN_DIVAS_PRIPCI=y +CONFIG_ISDN_DIVAS_DIVACAPI=y +CONFIG_ISDN_DIVAS_USERIDI=y +CONFIG_ISDN_DIVAS_MAINT=m +CONFIG_ISDN_DRV_GIGASET=y +CONFIG_GIGASET_CAPI=y +# CONFIG_GIGASET_I4L is not set +# CONFIG_GIGASET_DUMMYLL is not set +CONFIG_GIGASET_BASE=y +CONFIG_GIGASET_M105=y +CONFIG_GIGASET_M101=y +CONFIG_GIGASET_DEBUG=y +CONFIG_HYSDN=m +CONFIG_HYSDN_CAPI=y +CONFIG_MISDN=y +CONFIG_MISDN_DSP=y +CONFIG_MISDN_L1OIP=y + +# +# mISDN hardware drivers +# +CONFIG_MISDN_HFCPCI=y +CONFIG_MISDN_HFCMULTI=y +CONFIG_MISDN_HFCUSB=y +CONFIG_MISDN_AVMFRITZ=y +CONFIG_MISDN_SPEEDFAX=y +CONFIG_MISDN_INFINEON=y +CONFIG_MISDN_W6692=y +CONFIG_MISDN_NETJET=y +CONFIG_MISDN_IPAC=y +CONFIG_MISDN_ISAR=y +CONFIG_ISDN_HDLC=y +CONFIG_NVM=y +CONFIG_NVM_DEBUG=y +CONFIG_NVM_PBLK=y + +# +# Input device support +# +CONFIG_INPUT=y +CONFIG_INPUT_LEDS=y +CONFIG_INPUT_FF_MEMLESS=y +CONFIG_INPUT_POLLDEV=y +CONFIG_INPUT_SPARSEKMAP=y +CONFIG_INPUT_MATRIXKMAP=y + +# +# Userland interfaces +# +CONFIG_INPUT_MOUSEDEV=y +CONFIG_INPUT_MOUSEDEV_PSAUX=y +CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024 +CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768 +CONFIG_INPUT_JOYDEV=y +CONFIG_INPUT_EVDEV=y +CONFIG_INPUT_EVBUG=y + +# +# Input Device Drivers +# +CONFIG_INPUT_KEYBOARD=y +CONFIG_KEYBOARD_ADC=y +CONFIG_KEYBOARD_ADP5520=y +CONFIG_KEYBOARD_ADP5588=y +CONFIG_KEYBOARD_ADP5589=y +CONFIG_KEYBOARD_ATKBD=y +CONFIG_KEYBOARD_QT1070=y +CONFIG_KEYBOARD_QT2160=y +CONFIG_KEYBOARD_CLPS711X=y +CONFIG_KEYBOARD_DLINK_DIR685=y +CONFIG_KEYBOARD_LKKBD=y +CONFIG_KEYBOARD_GPIO=y +CONFIG_KEYBOARD_GPIO_POLLED=y +CONFIG_KEYBOARD_TCA6416=y +CONFIG_KEYBOARD_TCA8418=y +CONFIG_KEYBOARD_MATRIX=y +CONFIG_KEYBOARD_LM8323=y +CONFIG_KEYBOARD_LM8333=y +CONFIG_KEYBOARD_MAX7359=y +CONFIG_KEYBOARD_MCS=y +CONFIG_KEYBOARD_MPR121=y +CONFIG_KEYBOARD_NEWTON=y +CONFIG_KEYBOARD_OPENCORES=y +CONFIG_KEYBOARD_PMIC8XXX=y +CONFIG_KEYBOARD_SAMSUNG=y +CONFIG_KEYBOARD_GOLDFISH_EVENTS=y +CONFIG_KEYBOARD_STOWAWAY=y +CONFIG_KEYBOARD_ST_KEYSCAN=y +CONFIG_KEYBOARD_SUNKBD=y +CONFIG_KEYBOARD_SH_KEYSC=y +CONFIG_KEYBOARD_STMPE=y +CONFIG_KEYBOARD_OMAP4=y +CONFIG_KEYBOARD_TC3589X=y +CONFIG_KEYBOARD_TM2_TOUCHKEY=y +CONFIG_KEYBOARD_TWL4030=y +CONFIG_KEYBOARD_XTKBD=y +CONFIG_KEYBOARD_CROS_EC=y +CONFIG_KEYBOARD_CAP11XX=y +CONFIG_KEYBOARD_BCM=y +CONFIG_INPUT_MOUSE=y +CONFIG_MOUSE_PS2=y +CONFIG_MOUSE_PS2_ALPS=y +CONFIG_MOUSE_PS2_BYD=y +CONFIG_MOUSE_PS2_LOGIPS2PP=y +CONFIG_MOUSE_PS2_SYNAPTICS=y +CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS=y +CONFIG_MOUSE_PS2_CYPRESS=y +CONFIG_MOUSE_PS2_LIFEBOOK=y +CONFIG_MOUSE_PS2_TRACKPOINT=y +CONFIG_MOUSE_PS2_ELANTECH=y +CONFIG_MOUSE_PS2_SENTELIC=y +CONFIG_MOUSE_PS2_TOUCHKIT=y +CONFIG_MOUSE_PS2_FOCALTECH=y +CONFIG_MOUSE_PS2_VMMOUSE=y +CONFIG_MOUSE_PS2_SMBUS=y +CONFIG_MOUSE_SERIAL=y +CONFIG_MOUSE_APPLETOUCH=y +CONFIG_MOUSE_BCM5974=y +CONFIG_MOUSE_CYAPA=y +CONFIG_MOUSE_ELAN_I2C=y +CONFIG_MOUSE_ELAN_I2C_I2C=y +CONFIG_MOUSE_ELAN_I2C_SMBUS=y +CONFIG_MOUSE_VSXXXAA=y +CONFIG_MOUSE_GPIO=y +CONFIG_MOUSE_SYNAPTICS_I2C=y +CONFIG_MOUSE_SYNAPTICS_USB=y +CONFIG_INPUT_JOYSTICK=y +CONFIG_JOYSTICK_ANALOG=y +CONFIG_JOYSTICK_A3D=y +CONFIG_JOYSTICK_ADI=y +CONFIG_JOYSTICK_COBRA=y +CONFIG_JOYSTICK_GF2K=y +CONFIG_JOYSTICK_GRIP=y +CONFIG_JOYSTICK_GRIP_MP=y +CONFIG_JOYSTICK_GUILLEMOT=y +CONFIG_JOYSTICK_INTERACT=y +CONFIG_JOYSTICK_SIDEWINDER=y +CONFIG_JOYSTICK_TMDC=y +CONFIG_JOYSTICK_IFORCE=y +CONFIG_JOYSTICK_IFORCE_USB=y +CONFIG_JOYSTICK_IFORCE_232=y +CONFIG_JOYSTICK_WARRIOR=y +CONFIG_JOYSTICK_MAGELLAN=y +CONFIG_JOYSTICK_SPACEORB=y +CONFIG_JOYSTICK_SPACEBALL=y +CONFIG_JOYSTICK_STINGER=y +CONFIG_JOYSTICK_TWIDJOY=y +CONFIG_JOYSTICK_ZHENHUA=y +CONFIG_JOYSTICK_DB9=y +CONFIG_JOYSTICK_GAMECON=y +CONFIG_JOYSTICK_TURBOGRAFX=y +CONFIG_JOYSTICK_AS5011=y +CONFIG_JOYSTICK_JOYDUMP=y +CONFIG_JOYSTICK_XPAD=y +CONFIG_JOYSTICK_XPAD_FF=y +CONFIG_JOYSTICK_XPAD_LEDS=y +CONFIG_JOYSTICK_WALKERA0701=y +CONFIG_JOYSTICK_PSXPAD_SPI=y +CONFIG_JOYSTICK_PSXPAD_SPI_FF=y +CONFIG_INPUT_TABLET=y +CONFIG_TABLET_USB_ACECAD=y +CONFIG_TABLET_USB_AIPTEK=y +CONFIG_TABLET_USB_GTCO=y +CONFIG_TABLET_USB_HANWANG=y +CONFIG_TABLET_USB_KBTAB=y +CONFIG_TABLET_USB_PEGASUS=y +CONFIG_TABLET_SERIAL_WACOM4=y +CONFIG_INPUT_TOUCHSCREEN=y +CONFIG_TOUCHSCREEN_PROPERTIES=y +CONFIG_TOUCHSCREEN_88PM860X=y +CONFIG_TOUCHSCREEN_ADS7846=y +CONFIG_TOUCHSCREEN_AD7877=y +CONFIG_TOUCHSCREEN_AD7879=y +CONFIG_TOUCHSCREEN_AD7879_I2C=y +CONFIG_TOUCHSCREEN_AD7879_SPI=y +CONFIG_TOUCHSCREEN_AR1021_I2C=y +CONFIG_TOUCHSCREEN_ATMEL_MXT=y +CONFIG_TOUCHSCREEN_ATMEL_MXT_T37=y +CONFIG_TOUCHSCREEN_AUO_PIXCIR=y +CONFIG_TOUCHSCREEN_BU21013=y +CONFIG_TOUCHSCREEN_CHIPONE_ICN8318=y +CONFIG_TOUCHSCREEN_CY8CTMG110=y +CONFIG_TOUCHSCREEN_CYTTSP_CORE=y +CONFIG_TOUCHSCREEN_CYTTSP_I2C=y +CONFIG_TOUCHSCREEN_CYTTSP_SPI=y +CONFIG_TOUCHSCREEN_CYTTSP4_CORE=y +CONFIG_TOUCHSCREEN_CYTTSP4_I2C=y +CONFIG_TOUCHSCREEN_CYTTSP4_SPI=y +CONFIG_TOUCHSCREEN_DA9034=y +CONFIG_TOUCHSCREEN_DA9052=y +CONFIG_TOUCHSCREEN_DYNAPRO=y +CONFIG_TOUCHSCREEN_HAMPSHIRE=y +CONFIG_TOUCHSCREEN_EETI=y +CONFIG_TOUCHSCREEN_EGALAX=y +CONFIG_TOUCHSCREEN_EGALAX_SERIAL=y +CONFIG_TOUCHSCREEN_EXC3000=y +CONFIG_TOUCHSCREEN_FUJITSU=y +CONFIG_TOUCHSCREEN_GOODIX=y +CONFIG_TOUCHSCREEN_HIDEEP=y +CONFIG_TOUCHSCREEN_ILI210X=y +CONFIG_TOUCHSCREEN_IPROC=y +CONFIG_TOUCHSCREEN_S6SY761=y +CONFIG_TOUCHSCREEN_GUNZE=y +CONFIG_TOUCHSCREEN_EKTF2127=y +CONFIG_TOUCHSCREEN_ELAN=y +CONFIG_TOUCHSCREEN_ELO=y +CONFIG_TOUCHSCREEN_WACOM_W8001=y +CONFIG_TOUCHSCREEN_WACOM_I2C=y +CONFIG_TOUCHSCREEN_MAX11801=y +CONFIG_TOUCHSCREEN_MCS5000=y +CONFIG_TOUCHSCREEN_MMS114=y +CONFIG_TOUCHSCREEN_MELFAS_MIP4=y +CONFIG_TOUCHSCREEN_MTOUCH=y +CONFIG_TOUCHSCREEN_IMX6UL_TSC=y +CONFIG_TOUCHSCREEN_INEXIO=y +CONFIG_TOUCHSCREEN_MK712=y +CONFIG_TOUCHSCREEN_PENMOUNT=y +CONFIG_TOUCHSCREEN_EDT_FT5X06=y +CONFIG_TOUCHSCREEN_MIGOR=y +CONFIG_TOUCHSCREEN_TOUCHRIGHT=y +CONFIG_TOUCHSCREEN_TOUCHWIN=y +CONFIG_TOUCHSCREEN_TI_AM335X_TSC=y +CONFIG_TOUCHSCREEN_UCB1400=y +CONFIG_TOUCHSCREEN_PIXCIR=y +CONFIG_TOUCHSCREEN_WDT87XX_I2C=y +CONFIG_TOUCHSCREEN_WM831X=y +CONFIG_TOUCHSCREEN_WM97XX=y +CONFIG_TOUCHSCREEN_WM9705=y +CONFIG_TOUCHSCREEN_WM9712=y +CONFIG_TOUCHSCREEN_WM9713=y +CONFIG_TOUCHSCREEN_USB_COMPOSITE=y +CONFIG_TOUCHSCREEN_MXS_LRADC=y +CONFIG_TOUCHSCREEN_MX25=y +CONFIG_TOUCHSCREEN_MC13783=y +CONFIG_TOUCHSCREEN_USB_EGALAX=y +CONFIG_TOUCHSCREEN_USB_PANJIT=y +CONFIG_TOUCHSCREEN_USB_3M=y +CONFIG_TOUCHSCREEN_USB_ITM=y +CONFIG_TOUCHSCREEN_USB_ETURBO=y +CONFIG_TOUCHSCREEN_USB_GUNZE=y +CONFIG_TOUCHSCREEN_USB_DMC_TSC10=y +CONFIG_TOUCHSCREEN_USB_IRTOUCH=y +CONFIG_TOUCHSCREEN_USB_IDEALTEK=y +CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH=y +CONFIG_TOUCHSCREEN_USB_GOTOP=y +CONFIG_TOUCHSCREEN_USB_JASTEC=y +CONFIG_TOUCHSCREEN_USB_ELO=y +CONFIG_TOUCHSCREEN_USB_E2I=y +CONFIG_TOUCHSCREEN_USB_ZYTRONIC=y +CONFIG_TOUCHSCREEN_USB_ETT_TC45USB=y +CONFIG_TOUCHSCREEN_USB_NEXIO=y +CONFIG_TOUCHSCREEN_USB_EASYTOUCH=y +CONFIG_TOUCHSCREEN_TOUCHIT213=y +CONFIG_TOUCHSCREEN_TS4800=y +CONFIG_TOUCHSCREEN_TSC_SERIO=y +CONFIG_TOUCHSCREEN_TSC200X_CORE=y +CONFIG_TOUCHSCREEN_TSC2004=y +CONFIG_TOUCHSCREEN_TSC2005=y +CONFIG_TOUCHSCREEN_TSC2007=y +CONFIG_TOUCHSCREEN_TSC2007_IIO=y +CONFIG_TOUCHSCREEN_PCAP=y +CONFIG_TOUCHSCREEN_RM_TS=y +CONFIG_TOUCHSCREEN_SILEAD=y +CONFIG_TOUCHSCREEN_SIS_I2C=y +CONFIG_TOUCHSCREEN_ST1232=y +CONFIG_TOUCHSCREEN_STMFTS=y +CONFIG_TOUCHSCREEN_STMPE=y +CONFIG_TOUCHSCREEN_SUN4I=y +CONFIG_TOUCHSCREEN_SUR40=y +CONFIG_TOUCHSCREEN_SURFACE3_SPI=y +CONFIG_TOUCHSCREEN_SX8654=y +CONFIG_TOUCHSCREEN_TPS6507X=y +CONFIG_TOUCHSCREEN_ZET6223=y +CONFIG_TOUCHSCREEN_ZFORCE=y +CONFIG_TOUCHSCREEN_COLIBRI_VF50=y +CONFIG_TOUCHSCREEN_ROHM_BU21023=y +CONFIG_INPUT_MISC=y +CONFIG_INPUT_88PM860X_ONKEY=y +CONFIG_INPUT_88PM80X_ONKEY=y +CONFIG_INPUT_AD714X=y +CONFIG_INPUT_AD714X_I2C=y +CONFIG_INPUT_AD714X_SPI=y +CONFIG_INPUT_ARIZONA_HAPTICS=y +CONFIG_INPUT_ATMEL_CAPTOUCH=y +CONFIG_INPUT_BMA150=y +CONFIG_INPUT_E3X0_BUTTON=y +CONFIG_INPUT_PCSPKR=y +CONFIG_INPUT_PM8941_PWRKEY=y +CONFIG_INPUT_PM8XXX_VIBRATOR=y +CONFIG_INPUT_PMIC8XXX_PWRKEY=y +CONFIG_INPUT_MAX77693_HAPTIC=y +CONFIG_INPUT_MAX8925_ONKEY=y +CONFIG_INPUT_MAX8997_HAPTIC=y +CONFIG_INPUT_MC13783_PWRBUTTON=y +CONFIG_INPUT_MMA8450=y +CONFIG_INPUT_APANEL=y +CONFIG_INPUT_GP2A=y +CONFIG_INPUT_GPIO_BEEPER=y +CONFIG_INPUT_GPIO_DECODER=y +CONFIG_INPUT_CPCAP_PWRBUTTON=y +CONFIG_INPUT_ATLAS_BTNS=y +CONFIG_INPUT_ATI_REMOTE2=y +CONFIG_INPUT_KEYSPAN_REMOTE=y +CONFIG_INPUT_KXTJ9=y +CONFIG_INPUT_KXTJ9_POLLED_MODE=y +CONFIG_INPUT_POWERMATE=y +CONFIG_INPUT_YEALINK=y +CONFIG_INPUT_CM109=y +CONFIG_INPUT_REGULATOR_HAPTIC=y +CONFIG_INPUT_RETU_PWRBUTTON=y +CONFIG_INPUT_TPS65218_PWRBUTTON=y +CONFIG_INPUT_AXP20X_PEK=y +CONFIG_INPUT_TWL4030_PWRBUTTON=y +CONFIG_INPUT_TWL4030_VIBRA=y +CONFIG_INPUT_TWL6040_VIBRA=y +CONFIG_INPUT_UINPUT=y +CONFIG_INPUT_PALMAS_PWRBUTTON=y +CONFIG_INPUT_PCF50633_PMU=y +CONFIG_INPUT_PCF8574=y +CONFIG_INPUT_PWM_BEEPER=y +CONFIG_INPUT_PWM_VIBRA=y +CONFIG_INPUT_RK805_PWRKEY=y +CONFIG_INPUT_GPIO_ROTARY_ENCODER=y +CONFIG_INPUT_DA9052_ONKEY=y +CONFIG_INPUT_DA9055_ONKEY=y +CONFIG_INPUT_DA9063_ONKEY=y +CONFIG_INPUT_WM831X_ON=y +CONFIG_INPUT_PCAP=y +CONFIG_INPUT_ADXL34X=y +CONFIG_INPUT_ADXL34X_I2C=y +CONFIG_INPUT_ADXL34X_SPI=y +CONFIG_INPUT_IMS_PCU=y +CONFIG_INPUT_CMA3000=y +CONFIG_INPUT_CMA3000_I2C=y +CONFIG_INPUT_XEN_KBDDEV_FRONTEND=y +CONFIG_INPUT_IDEAPAD_SLIDEBAR=y +CONFIG_INPUT_SOC_BUTTON_ARRAY=y +CONFIG_INPUT_DRV260X_HAPTICS=y +CONFIG_INPUT_DRV2665_HAPTICS=y +CONFIG_INPUT_DRV2667_HAPTICS=y +CONFIG_INPUT_HISI_POWERKEY=y +CONFIG_RMI4_CORE=y +CONFIG_RMI4_I2C=y +CONFIG_RMI4_SPI=y +CONFIG_RMI4_SMB=y +CONFIG_RMI4_F03=y +CONFIG_RMI4_F03_SERIO=y +CONFIG_RMI4_2D_SENSOR=y +CONFIG_RMI4_F11=y +CONFIG_RMI4_F12=y +CONFIG_RMI4_F30=y +CONFIG_RMI4_F34=y +CONFIG_RMI4_F54=y +CONFIG_RMI4_F55=y + +# +# Hardware I/O ports +# +CONFIG_SERIO=y +CONFIG_ARCH_MIGHT_HAVE_PC_SERIO=y +CONFIG_SERIO_I8042=y +CONFIG_SERIO_SERPORT=y +CONFIG_SERIO_CT82C710=y +CONFIG_SERIO_PARKBD=y +CONFIG_SERIO_PCIPS2=y +CONFIG_SERIO_LIBPS2=y +CONFIG_SERIO_RAW=y +CONFIG_SERIO_ALTERA_PS2=y +CONFIG_SERIO_PS2MULT=y +CONFIG_SERIO_ARC_PS2=y +CONFIG_SERIO_APBPS2=y +CONFIG_SERIO_OLPC_APSP=y +CONFIG_HYPERV_KEYBOARD=y +CONFIG_SERIO_SUN4I_PS2=y +CONFIG_SERIO_GPIO_PS2=y +CONFIG_USERIO=y +CONFIG_GAMEPORT=y +CONFIG_GAMEPORT_NS558=y +CONFIG_GAMEPORT_L4=y +CONFIG_GAMEPORT_EMU10K1=y +CONFIG_GAMEPORT_FM801=y + +# +# Character devices +# +CONFIG_TTY=y +CONFIG_VT=y +CONFIG_CONSOLE_TRANSLATIONS=y +CONFIG_VT_CONSOLE=y +CONFIG_VT_CONSOLE_SLEEP=y +CONFIG_HW_CONSOLE=y +CONFIG_VT_HW_CONSOLE_BINDING=y +CONFIG_UNIX98_PTYS=y +CONFIG_LEGACY_PTYS=y +CONFIG_LEGACY_PTY_COUNT=256 +CONFIG_SERIAL_NONSTANDARD=y +CONFIG_ROCKETPORT=y +CONFIG_CYCLADES=y +CONFIG_CYZ_INTR=y +CONFIG_MOXA_INTELLIO=y +CONFIG_MOXA_SMARTIO=y +CONFIG_SYNCLINK=y +CONFIG_SYNCLINKMP=y +CONFIG_SYNCLINK_GT=y +CONFIG_NOZOMI=y +CONFIG_ISI=y +CONFIG_N_HDLC=y +CONFIG_N_GSM=y +CONFIG_TRACE_ROUTER=y +CONFIG_TRACE_SINK=y +CONFIG_GOLDFISH_TTY=y +CONFIG_GOLDFISH_TTY_EARLY_CONSOLE=y +CONFIG_DEVMEM=y +CONFIG_DEVKMEM=y + +# +# Serial drivers +# +CONFIG_SERIAL_EARLYCON=y +CONFIG_SERIAL_8250=y +CONFIG_SERIAL_8250_DEPRECATED_OPTIONS=y +CONFIG_SERIAL_8250_PNP=y +CONFIG_SERIAL_8250_FINTEK=y +CONFIG_SERIAL_8250_CONSOLE=y +CONFIG_SERIAL_8250_DMA=y +CONFIG_SERIAL_8250_PCI=y +CONFIG_SERIAL_8250_EXAR=y +CONFIG_SERIAL_8250_CS=y +CONFIG_SERIAL_8250_MEN_MCB=y +CONFIG_SERIAL_8250_NR_UARTS=4 +CONFIG_SERIAL_8250_RUNTIME_UARTS=4 +CONFIG_SERIAL_8250_EXTENDED=y +CONFIG_SERIAL_8250_MANY_PORTS=y +CONFIG_SERIAL_8250_ASPEED_VUART=y +CONFIG_SERIAL_8250_SHARE_IRQ=y +CONFIG_SERIAL_8250_DETECT_IRQ=y +CONFIG_SERIAL_8250_RSA=y +CONFIG_SERIAL_8250_BCM2835AUX=y +# CONFIG_SERIAL_8250_FSL is not set +CONFIG_SERIAL_8250_DW=y +CONFIG_SERIAL_8250_RT288X=y +CONFIG_SERIAL_8250_LPC18XX=y +CONFIG_SERIAL_8250_UNIPHIER=y +CONFIG_SERIAL_8250_INGENIC=y +CONFIG_SERIAL_8250_LPSS=y +CONFIG_SERIAL_8250_MID=y +CONFIG_SERIAL_8250_MOXA=y +CONFIG_SERIAL_OF_PLATFORM=y + +# +# Non-8250 serial port support +# +CONFIG_SERIAL_ATMEL=y +CONFIG_SERIAL_ATMEL_CONSOLE=y +CONFIG_SERIAL_ATMEL_PDC=y +CONFIG_SERIAL_ATMEL_TTYAT=y +CONFIG_SERIAL_KGDB_NMI=y +CONFIG_SERIAL_CLPS711X=y +CONFIG_SERIAL_CLPS711X_CONSOLE=y +CONFIG_SERIAL_MAX3100=y +CONFIG_SERIAL_MAX310X=y +CONFIG_SERIAL_IMX=y +CONFIG_SERIAL_IMX_CONSOLE=y +CONFIG_SERIAL_UARTLITE=y +CONFIG_SERIAL_UARTLITE_CONSOLE=y +CONFIG_SERIAL_UARTLITE_NR_UARTS=1 +CONFIG_SERIAL_SH_SCI=y +CONFIG_SERIAL_SH_SCI_NR_UARTS=2 +CONFIG_SERIAL_SH_SCI_CONSOLE=y +CONFIG_SERIAL_SH_SCI_EARLYCON=y +CONFIG_SERIAL_SH_SCI_DMA=y +CONFIG_SERIAL_CORE=y +CONFIG_SERIAL_CORE_CONSOLE=y +CONFIG_CONSOLE_POLL=y +CONFIG_SERIAL_JSM=y +CONFIG_SERIAL_SCCNXP=y +CONFIG_SERIAL_SCCNXP_CONSOLE=y +CONFIG_SERIAL_SC16IS7XX_CORE=y +CONFIG_SERIAL_SC16IS7XX=y +CONFIG_SERIAL_SC16IS7XX_I2C=y +CONFIG_SERIAL_SC16IS7XX_SPI=y +CONFIG_SERIAL_TIMBERDALE=y +CONFIG_SERIAL_BCM63XX=y +CONFIG_SERIAL_BCM63XX_CONSOLE=y +CONFIG_SERIAL_ALTERA_JTAGUART=y +CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE=y +CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE_BYPASS=y +CONFIG_SERIAL_ALTERA_UART=y +CONFIG_SERIAL_ALTERA_UART_MAXPORTS=4 +CONFIG_SERIAL_ALTERA_UART_BAUDRATE=115200 +CONFIG_SERIAL_ALTERA_UART_CONSOLE=y +CONFIG_SERIAL_IFX6X60=y +CONFIG_SERIAL_PCH_UART=y +CONFIG_SERIAL_PCH_UART_CONSOLE=y +CONFIG_SERIAL_MXS_AUART=y +CONFIG_SERIAL_MXS_AUART_CONSOLE=y +CONFIG_SERIAL_XILINX_PS_UART=y +CONFIG_SERIAL_XILINX_PS_UART_CONSOLE=y +CONFIG_SERIAL_MPS2_UART_CONSOLE=y +CONFIG_SERIAL_MPS2_UART=y +CONFIG_SERIAL_ARC=y +CONFIG_SERIAL_ARC_CONSOLE=y +CONFIG_SERIAL_ARC_NR_PORTS=1 +CONFIG_SERIAL_RP2=y +CONFIG_SERIAL_RP2_NR_UARTS=32 +CONFIG_SERIAL_FSL_LPUART=y +CONFIG_SERIAL_FSL_LPUART_CONSOLE=y +CONFIG_SERIAL_CONEXANT_DIGICOLOR=y +CONFIG_SERIAL_CONEXANT_DIGICOLOR_CONSOLE=y +CONFIG_SERIAL_ST_ASC=y +CONFIG_SERIAL_ST_ASC_CONSOLE=y +CONFIG_SERIAL_MEN_Z135=y +CONFIG_SERIAL_STM32=y +CONFIG_SERIAL_STM32_CONSOLE=y +CONFIG_SERIAL_MVEBU_UART=y +CONFIG_SERIAL_MVEBU_CONSOLE=y +CONFIG_SERIAL_OWL=y +CONFIG_SERIAL_OWL_CONSOLE=y +CONFIG_SERIAL_MCTRL_GPIO=y +CONFIG_SERIAL_DEV_BUS=y +CONFIG_SERIAL_DEV_CTRL_TTYPORT=y +CONFIG_TTY_PRINTK=y +CONFIG_PRINTER=y +CONFIG_LP_CONSOLE=y +CONFIG_PPDEV=y +CONFIG_HVC_DRIVER=y +CONFIG_HVC_IRQ=y +CONFIG_HVC_XEN=y +CONFIG_HVC_XEN_FRONTEND=y +CONFIG_VIRTIO_CONSOLE=y +CONFIG_IPMI_HANDLER=y +CONFIG_IPMI_DMI_DECODE=y +CONFIG_IPMI_PROC_INTERFACE=y +CONFIG_IPMI_PANIC_EVENT=y +CONFIG_IPMI_PANIC_STRING=y +CONFIG_IPMI_DEVICE_INTERFACE=y +CONFIG_IPMI_SI=y +CONFIG_IPMI_SSIF=y +CONFIG_IPMI_WATCHDOG=y +CONFIG_IPMI_POWEROFF=y +CONFIG_ASPEED_BT_IPMI_BMC=y +CONFIG_HW_RANDOM=y +CONFIG_HW_RANDOM_TIMERIOMEM=y +CONFIG_HW_RANDOM_INTEL=y +CONFIG_HW_RANDOM_AMD=y +CONFIG_HW_RANDOM_VIA=y +CONFIG_HW_RANDOM_VIRTIO=y +CONFIG_HW_RANDOM_STM32=y +CONFIG_HW_RANDOM_MESON=y +CONFIG_HW_RANDOM_CAVIUM=y +CONFIG_HW_RANDOM_MTK=y +CONFIG_HW_RANDOM_EXYNOS=y +CONFIG_NVRAM=y +CONFIG_R3964=y +CONFIG_APPLICOM=y + +# +# PCMCIA character devices +# +CONFIG_SYNCLINK_CS=y +CONFIG_CARDMAN_4000=y +CONFIG_CARDMAN_4040=y +CONFIG_SCR24X=y +CONFIG_IPWIRELESS=y +CONFIG_MWAVE=y +CONFIG_RAW_DRIVER=y +CONFIG_MAX_RAW_DEVS=256 +CONFIG_HPET=y +CONFIG_HPET_MMAP=y +CONFIG_HPET_MMAP_DEFAULT=y +CONFIG_HANGCHECK_TIMER=y +CONFIG_UV_MMTIMER=y +CONFIG_TCG_TPM=y +CONFIG_HW_RANDOM_TPM=y +CONFIG_TCG_TIS_CORE=y +CONFIG_TCG_TIS=y +CONFIG_TCG_TIS_SPI=y +CONFIG_TCG_TIS_I2C_ATMEL=y +CONFIG_TCG_TIS_I2C_INFINEON=y +CONFIG_TCG_TIS_I2C_NUVOTON=y +CONFIG_TCG_NSC=y +CONFIG_TCG_ATMEL=y +CONFIG_TCG_INFINEON=y +CONFIG_TCG_XEN=y +CONFIG_TCG_CRB=y +CONFIG_TCG_VTPM_PROXY=y +CONFIG_TCG_TIS_ST33ZP24=y +CONFIG_TCG_TIS_ST33ZP24_I2C=y +CONFIG_TCG_TIS_ST33ZP24_SPI=y +CONFIG_TELCLOCK=y +CONFIG_DEVPORT=y +CONFIG_XILLYBUS=y +CONFIG_XILLYBUS_PCIE=y +CONFIG_XILLYBUS_OF=y + +# +# I2C support +# +CONFIG_I2C=y +CONFIG_ACPI_I2C_OPREGION=y +CONFIG_I2C_BOARDINFO=y +CONFIG_I2C_COMPAT=y +CONFIG_I2C_CHARDEV=y +CONFIG_I2C_MUX=y + +# +# Multiplexer I2C Chip support +# +CONFIG_I2C_ARB_GPIO_CHALLENGE=y +CONFIG_I2C_MUX_GPIO=y +CONFIG_I2C_MUX_GPMUX=y +CONFIG_I2C_MUX_LTC4306=y +CONFIG_I2C_MUX_PCA9541=y +CONFIG_I2C_MUX_PCA954x=y +CONFIG_I2C_MUX_PINCTRL=y +CONFIG_I2C_MUX_REG=y +CONFIG_I2C_DEMUX_PINCTRL=y +CONFIG_I2C_MUX_MLXCPLD=y +CONFIG_I2C_HELPER_AUTO=y +CONFIG_I2C_SMBUS=y +CONFIG_I2C_ALGOBIT=y +CONFIG_I2C_ALGOPCA=y + +# +# I2C Hardware Bus support +# + +# +# PC SMBus host controller drivers +# +CONFIG_I2C_ALI1535=y +CONFIG_I2C_ALI1563=y +CONFIG_I2C_ALI15X3=y +CONFIG_I2C_AMD756=y +CONFIG_I2C_AMD756_S4882=y +CONFIG_I2C_AMD8111=y +CONFIG_I2C_HIX5HD2=y +CONFIG_I2C_I801=y +CONFIG_I2C_ISCH=y +CONFIG_I2C_ISMT=y +CONFIG_I2C_PIIX4=y +CONFIG_I2C_CHT_WC=y +CONFIG_I2C_NFORCE2=y +CONFIG_I2C_NFORCE2_S4985=y +CONFIG_I2C_SIS5595=y +CONFIG_I2C_SIS630=y +CONFIG_I2C_SIS96X=y +CONFIG_I2C_VIA=y +CONFIG_I2C_VIAPRO=y + +# +# ACPI drivers +# +CONFIG_I2C_SCMI=y + +# +# I2C system bus drivers (mostly embedded / system-on-chip) +# +CONFIG_I2C_ASPEED=y +CONFIG_I2C_AXXIA=y +CONFIG_I2C_BCM_IPROC=y +CONFIG_I2C_BRCMSTB=y +CONFIG_I2C_CBUS_GPIO=y +CONFIG_I2C_DESIGNWARE_CORE=y +CONFIG_I2C_DESIGNWARE_PLATFORM=y +CONFIG_I2C_DESIGNWARE_SLAVE=y +CONFIG_I2C_DESIGNWARE_PCI=y +CONFIG_I2C_DESIGNWARE_BAYTRAIL=y +CONFIG_I2C_EFM32=y +CONFIG_I2C_EG20T=y +CONFIG_I2C_EMEV2=y +CONFIG_I2C_GPIO=y +CONFIG_I2C_GPIO_FAULT_INJECTOR=y +CONFIG_I2C_IMG=y +CONFIG_I2C_IMX_LPI2C=y +CONFIG_I2C_JZ4780=y +CONFIG_I2C_KEMPLD=y +CONFIG_I2C_LPC2K=y +CONFIG_I2C_MESON=y +CONFIG_I2C_MT65XX=y +CONFIG_I2C_OCORES=y +CONFIG_I2C_PCA_PLATFORM=y +# CONFIG_I2C_PXA_PCI is not set +CONFIG_I2C_RIIC=y +CONFIG_I2C_RK3X=y +CONFIG_I2C_SH_MOBILE=y +CONFIG_I2C_SIMTEC=y +CONFIG_I2C_STM32F4=y +CONFIG_I2C_STM32F7=y +CONFIG_I2C_SUN6I_P2WI=y +CONFIG_I2C_UNIPHIER=y +CONFIG_I2C_UNIPHIER_F=y +CONFIG_I2C_VERSATILE=y +CONFIG_I2C_THUNDERX=y +CONFIG_I2C_XILINX=y +CONFIG_I2C_XLP9XX=y +CONFIG_I2C_RCAR=y + +# +# External I2C/SMBus adapter drivers +# +CONFIG_I2C_DIOLAN_U2C=y +CONFIG_I2C_DLN2=y +CONFIG_I2C_PARPORT=y +CONFIG_I2C_PARPORT_LIGHT=y +CONFIG_I2C_ROBOTFUZZ_OSIF=y +CONFIG_I2C_TAOS_EVM=y +CONFIG_I2C_TINY_USB=y +CONFIG_I2C_VIPERBOARD=y + +# +# Other I2C/SMBus bus drivers +# +CONFIG_I2C_MLXCPLD=y +CONFIG_I2C_CROS_EC_TUNNEL=y +CONFIG_I2C_STUB=m +CONFIG_I2C_SLAVE=y +CONFIG_I2C_SLAVE_EEPROM=y +CONFIG_I2C_DEBUG_CORE=y +CONFIG_I2C_DEBUG_ALGO=y +CONFIG_I2C_DEBUG_BUS=y +CONFIG_SPI=y +CONFIG_SPI_DEBUG=y +CONFIG_SPI_MASTER=y + +# +# SPI Master Controller Drivers +# +CONFIG_SPI_ALTERA=y +CONFIG_SPI_ARMADA_3700=y +CONFIG_SPI_ATMEL=y +CONFIG_SPI_AXI_SPI_ENGINE=y +CONFIG_SPI_BCM2835=y +CONFIG_SPI_BCM2835AUX=y +CONFIG_SPI_BCM63XX=y +CONFIG_SPI_BCM63XX_HSSPI=y +CONFIG_SPI_BCM_QSPI=y +CONFIG_SPI_BITBANG=y +CONFIG_SPI_BUTTERFLY=y +CONFIG_SPI_CADENCE=y +CONFIG_SPI_CLPS711X=y +CONFIG_SPI_DESIGNWARE=y +CONFIG_SPI_DW_PCI=y +CONFIG_SPI_DW_MID_DMA=y +CONFIG_SPI_DW_MMIO=y +CONFIG_SPI_DLN2=y +CONFIG_SPI_EP93XX=y +CONFIG_SPI_FSL_LPSPI=y +CONFIG_SPI_GPIO=y +CONFIG_SPI_IMG_SPFI=y +CONFIG_SPI_IMX=y +CONFIG_SPI_JCORE=y +CONFIG_SPI_LM70_LLP=y +CONFIG_SPI_LP8841_RTC=y +CONFIG_SPI_FSL_LIB=y +CONFIG_SPI_FSL_SPI=y +CONFIG_SPI_FSL_DSPI=y +CONFIG_SPI_MESON_SPICC=y +CONFIG_SPI_MESON_SPIFC=y +CONFIG_SPI_MT65XX=y +CONFIG_SPI_LANTIQ_SSC=y +CONFIG_SPI_OC_TINY=y +CONFIG_SPI_OMAP24XX=y +CONFIG_SPI_TI_QSPI=y +CONFIG_SPI_OMAP_100K=y +CONFIG_SPI_ORION=y +CONFIG_SPI_PIC32=y +CONFIG_SPI_PIC32_SQI=y +CONFIG_SPI_PXA2XX=y +CONFIG_SPI_PXA2XX_PCI=y +CONFIG_SPI_ROCKCHIP=y +CONFIG_SPI_RSPI=y +CONFIG_SPI_S3C64XX=y +CONFIG_SPI_SC18IS602=y +CONFIG_SPI_SH_MSIOF=y +CONFIG_SPI_SH=y +CONFIG_SPI_SH_HSPI=y +CONFIG_SPI_SPRD_ADI=y +CONFIG_SPI_STM32=y +CONFIG_SPI_ST_SSC4=y +CONFIG_SPI_SUN4I=y +CONFIG_SPI_SUN6I=y +CONFIG_SPI_TEGRA114=y +CONFIG_SPI_TEGRA20_SFLASH=y +CONFIG_SPI_TEGRA20_SLINK=y +CONFIG_SPI_THUNDERX=y +CONFIG_SPI_TOPCLIFF_PCH=y +CONFIG_SPI_TXX9=y +CONFIG_SPI_XCOMM=y +CONFIG_SPI_XILINX=y +CONFIG_SPI_XLP=y +CONFIG_SPI_XTENSA_XTFPGA=y +CONFIG_SPI_ZYNQMP_GQSPI=y + +# +# SPI Protocol Masters +# +CONFIG_SPI_SPIDEV=y +CONFIG_SPI_LOOPBACK_TEST=m +CONFIG_SPI_TLE62X0=y +CONFIG_SPI_SLAVE=y +CONFIG_SPI_SLAVE_TIME=y +CONFIG_SPI_SLAVE_SYSTEM_CONTROL=y +CONFIG_SPMI=y +CONFIG_SPMI_MSM_PMIC_ARB=y +CONFIG_HSI=y +CONFIG_HSI_BOARDINFO=y + +# +# HSI controllers +# + +# +# HSI clients +# +CONFIG_HSI_CHAR=y +CONFIG_PPS=y +CONFIG_PPS_DEBUG=y + +# +# PPS clients support +# +CONFIG_PPS_CLIENT_KTIMER=y +CONFIG_PPS_CLIENT_LDISC=y +CONFIG_PPS_CLIENT_PARPORT=y +CONFIG_PPS_CLIENT_GPIO=y + +# +# PPS generators support +# + +# +# PTP clock support +# +CONFIG_PTP_1588_CLOCK=y +CONFIG_PTP_1588_CLOCK_DTE=y +CONFIG_PTP_1588_CLOCK_GIANFAR=y +CONFIG_DP83640_PHY=y +CONFIG_PTP_1588_CLOCK_PCH=y +CONFIG_PTP_1588_CLOCK_KVM=y +CONFIG_PINCTRL=y +CONFIG_GENERIC_PINCTRL_GROUPS=y +CONFIG_PINMUX=y +CONFIG_GENERIC_PINMUX_FUNCTIONS=y +CONFIG_PINCONF=y +CONFIG_GENERIC_PINCONF=y +CONFIG_DEBUG_PINCTRL=y +CONFIG_PINCTRL_AS3722=y +CONFIG_PINCTRL_AXP209=y +CONFIG_PINCTRL_AMD=y +CONFIG_PINCTRL_DA850_PUPD=y +CONFIG_PINCTRL_LPC18XX=y +CONFIG_PINCTRL_MCP23S08=y +CONFIG_PINCTRL_RZA1=y +CONFIG_PINCTRL_SINGLE=y +CONFIG_PINCTRL_SX150X=y +CONFIG_PINCTRL_MAX77620=y +CONFIG_PINCTRL_PALMAS=y +CONFIG_PINCTRL_INGENIC=y +CONFIG_PINCTRL_RK805=y +CONFIG_PINCTRL_OCELOT=y +CONFIG_PINCTRL_ASPEED=y +CONFIG_PINCTRL_ASPEED_G4=y +CONFIG_PINCTRL_ASPEED_G5=y +CONFIG_PINCTRL_BCM281XX=y +CONFIG_PINCTRL_IPROC_GPIO=y +CONFIG_PINCTRL_CYGNUS_MUX=y +CONFIG_PINCTRL_NSP_GPIO=y +CONFIG_PINCTRL_NS2_MUX=y +CONFIG_PINCTRL_NSP_MUX=y +CONFIG_PINCTRL_BERLIN=y +# CONFIG_PINCTRL_BERLIN_BG2 is not set +# CONFIG_PINCTRL_BERLIN_BG2CD is not set +# CONFIG_PINCTRL_BERLIN_BG2Q is not set +CONFIG_PINCTRL_BERLIN_BG4CT=y +CONFIG_PINCTRL_BAYTRAIL=y +CONFIG_PINCTRL_CHERRYVIEW=y +CONFIG_PINCTRL_MERRIFIELD=y +CONFIG_PINCTRL_INTEL=y +CONFIG_PINCTRL_BROXTON=y +CONFIG_PINCTRL_CANNONLAKE=y +CONFIG_PINCTRL_CEDARFORK=y +CONFIG_PINCTRL_DENVERTON=y +CONFIG_PINCTRL_GEMINILAKE=y +CONFIG_PINCTRL_LEWISBURG=y +CONFIG_PINCTRL_SUNRISEPOINT=y +CONFIG_PINCTRL_PXA=y +CONFIG_PINCTRL_PXA25X=y +CONFIG_PINCTRL_PXA27X=y +CONFIG_PINCTRL_MSM=y +CONFIG_PINCTRL_APQ8064=y +CONFIG_PINCTRL_APQ8084=y +CONFIG_PINCTRL_IPQ4019=y +CONFIG_PINCTRL_IPQ8064=y +CONFIG_PINCTRL_IPQ8074=y +CONFIG_PINCTRL_MSM8660=y +CONFIG_PINCTRL_MSM8960=y +CONFIG_PINCTRL_MDM9615=y +CONFIG_PINCTRL_MSM8X74=y +CONFIG_PINCTRL_MSM8916=y +CONFIG_PINCTRL_MSM8994=y +CONFIG_PINCTRL_MSM8996=y +CONFIG_PINCTRL_MSM8998=y +CONFIG_PINCTRL_QDF2XXX=y +CONFIG_PINCTRL_QCOM_SPMI_PMIC=y +CONFIG_PINCTRL_QCOM_SSBI_PMIC=y +CONFIG_PINCTRL_SPRD=y +CONFIG_PINCTRL_SPRD_SC9860=y +CONFIG_PINCTRL_STM32=y +CONFIG_PINCTRL_STM32F429=y +CONFIG_PINCTRL_STM32F469=y +CONFIG_PINCTRL_STM32F746=y +CONFIG_PINCTRL_STM32F769=y +CONFIG_PINCTRL_STM32H743=y +CONFIG_PINCTRL_STM32MP157=y +CONFIG_PINCTRL_TI_IODELAY=y +CONFIG_PINCTRL_UNIPHIER=y +CONFIG_PINCTRL_UNIPHIER_LD4=y +CONFIG_PINCTRL_UNIPHIER_PRO4=y +CONFIG_PINCTRL_UNIPHIER_SLD8=y +CONFIG_PINCTRL_UNIPHIER_PRO5=y +CONFIG_PINCTRL_UNIPHIER_PXS2=y +CONFIG_PINCTRL_UNIPHIER_LD6B=y +CONFIG_PINCTRL_UNIPHIER_LD11=y +CONFIG_PINCTRL_UNIPHIER_LD20=y +CONFIG_PINCTRL_UNIPHIER_PXS3=y + +# +# MediaTek pinctrl drivers +# +CONFIG_PINCTRL_MTK=y +CONFIG_PINCTRL_MT2701=y +CONFIG_PINCTRL_MT8135=y +CONFIG_PINCTRL_MT8127=y +CONFIG_PINCTRL_MT7622=y +CONFIG_PINCTRL_MT8173=y +CONFIG_PINCTRL_MT6397=y +CONFIG_GPIOLIB=y +CONFIG_OF_GPIO=y +CONFIG_GPIO_ACPI=y +CONFIG_GPIOLIB_IRQCHIP=y +CONFIG_DEBUG_GPIO=y +CONFIG_GPIO_SYSFS=y +CONFIG_GPIO_GENERIC=y +CONFIG_GPIO_MAX730X=y + +# +# Memory mapped GPIO drivers +# +CONFIG_GPIO_74XX_MMIO=y +CONFIG_GPIO_ALTERA=y +CONFIG_GPIO_AMDPT=y +CONFIG_GPIO_ASPEED=y +CONFIG_GPIO_ATH79=y +CONFIG_GPIO_BCM_KONA=y +CONFIG_GPIO_BRCMSTB=y +CONFIG_GPIO_CLPS711X=y +CONFIG_GPIO_DWAPB=y +CONFIG_GPIO_EM=y +CONFIG_GPIO_ETRAXFS=y +CONFIG_GPIO_EXAR=y +CONFIG_GPIO_FTGPIO010=y +CONFIG_GPIO_GENERIC_PLATFORM=y +CONFIG_GPIO_GRGPIO=y +CONFIG_GPIO_ICH=y +CONFIG_GPIO_INGENIC=y +CONFIG_GPIO_IOP=y +CONFIG_GPIO_LPC18XX=y +CONFIG_GPIO_LYNXPOINT=y +CONFIG_GPIO_MB86S7X=y +CONFIG_GPIO_MENZ127=y +CONFIG_GPIO_MOCKUP=y +CONFIG_GPIO_MPC8XXX=y +CONFIG_GPIO_RCAR=y +CONFIG_GPIO_SYSCON=y +CONFIG_GPIO_TEGRA=y +CONFIG_GPIO_TEGRA186=y +CONFIG_GPIO_TS4800=y +CONFIG_GPIO_THUNDERX=y +CONFIG_GPIO_UNIPHIER=y +CONFIG_GPIO_VX855=y +CONFIG_GPIO_XILINX=y +CONFIG_GPIO_XLP=y +CONFIG_GPIO_ZX=y + +# +# Port-mapped I/O GPIO drivers +# +CONFIG_GPIO_104_DIO_48E=y +CONFIG_GPIO_104_IDIO_16=y +CONFIG_GPIO_104_IDI_48=y +CONFIG_GPIO_F7188X=y +CONFIG_GPIO_GPIO_MM=y +CONFIG_GPIO_IT87=y +CONFIG_GPIO_SCH=y +CONFIG_GPIO_SCH311X=y +CONFIG_GPIO_TS5500=y +CONFIG_GPIO_WINBOND=y +CONFIG_GPIO_WS16C48=y + +# +# I2C GPIO expanders +# +CONFIG_GPIO_ADP5588=y +CONFIG_GPIO_ADP5588_IRQ=y +CONFIG_GPIO_ADNP=y +CONFIG_GPIO_MAX7300=y +CONFIG_GPIO_MAX732X=y +CONFIG_GPIO_MAX732X_IRQ=y +CONFIG_GPIO_PCA953X=y +CONFIG_GPIO_PCA953X_IRQ=y +CONFIG_GPIO_PCF857X=y +CONFIG_GPIO_TPIC2810=y +CONFIG_GPIO_TS4900=y + +# +# MFD GPIO expanders +# +CONFIG_GPIO_ADP5520=y +CONFIG_GPIO_ARIZONA=y +CONFIG_GPIO_BD9571MWV=y +CONFIG_GPIO_CRYSTAL_COVE=y +CONFIG_GPIO_CS5535=y +CONFIG_GPIO_DA9052=y +CONFIG_GPIO_DA9055=y +CONFIG_GPIO_DLN2=y +CONFIG_GPIO_JANZ_TTL=y +CONFIG_GPIO_KEMPLD=y +CONFIG_GPIO_LP3943=y +CONFIG_GPIO_LP873X=y +CONFIG_GPIO_LP87565=y +CONFIG_GPIO_MAX77620=y +CONFIG_GPIO_MSIC=y +CONFIG_GPIO_PALMAS=y +CONFIG_GPIO_RC5T583=y +CONFIG_GPIO_STMPE=y +CONFIG_GPIO_TC3589X=y +CONFIG_GPIO_TIMBERDALE=y +CONFIG_GPIO_TPS65086=y +CONFIG_GPIO_TPS65218=y +CONFIG_GPIO_TPS6586X=y +CONFIG_GPIO_TPS65910=y +CONFIG_GPIO_TPS65912=y +CONFIG_GPIO_TPS68470=y +CONFIG_GPIO_TWL4030=y +CONFIG_GPIO_TWL6040=y +CONFIG_GPIO_UCB1400=y +CONFIG_GPIO_WHISKEY_COVE=y +CONFIG_GPIO_WM831X=y +CONFIG_GPIO_WM8350=y +CONFIG_GPIO_WM8994=y + +# +# PCI GPIO expanders +# +CONFIG_GPIO_AMD8111=y +CONFIG_GPIO_INTEL_MID=y +CONFIG_GPIO_MERRIFIELD=y +CONFIG_GPIO_ML_IOH=y +CONFIG_GPIO_PCH=y +CONFIG_GPIO_PCI_IDIO_16=y +CONFIG_GPIO_PCIE_IDIO_24=y +CONFIG_GPIO_RDC321X=y +CONFIG_GPIO_SODAVILLE=y + +# +# SPI GPIO expanders +# +CONFIG_GPIO_74X164=y +CONFIG_GPIO_MAX3191X=y +CONFIG_GPIO_MAX7301=y +CONFIG_GPIO_MC33880=y +CONFIG_GPIO_PISOSR=y +CONFIG_GPIO_XRA1403=y + +# +# USB GPIO expanders +# +CONFIG_GPIO_VIPERBOARD=y +CONFIG_W1=y +CONFIG_W1_CON=y + +# +# 1-wire Bus Masters +# +CONFIG_W1_MASTER_MATROX=y +CONFIG_W1_MASTER_DS2490=y +CONFIG_W1_MASTER_DS2482=y +CONFIG_W1_MASTER_MXC=y +CONFIG_W1_MASTER_DS1WM=y +CONFIG_W1_MASTER_GPIO=y + +# +# 1-wire Slaves +# +CONFIG_W1_SLAVE_THERM=y +CONFIG_W1_SLAVE_SMEM=y +CONFIG_W1_SLAVE_DS2405=y +CONFIG_W1_SLAVE_DS2408=y +CONFIG_W1_SLAVE_DS2408_READBACK=y +CONFIG_W1_SLAVE_DS2413=y +CONFIG_W1_SLAVE_DS2406=y +CONFIG_W1_SLAVE_DS2423=y +CONFIG_W1_SLAVE_DS2805=y +CONFIG_W1_SLAVE_DS2431=y +CONFIG_W1_SLAVE_DS2433=y +CONFIG_W1_SLAVE_DS2433_CRC=y +CONFIG_W1_SLAVE_DS2438=y +CONFIG_W1_SLAVE_DS2760=y +CONFIG_W1_SLAVE_DS2780=y +CONFIG_W1_SLAVE_DS2781=y +CONFIG_W1_SLAVE_DS28E04=y +CONFIG_W1_SLAVE_DS28E17=y +CONFIG_POWER_AVS=y +CONFIG_POWER_RESET=y +CONFIG_POWER_RESET_AS3722=y +CONFIG_POWER_RESET_BRCMKONA=y +CONFIG_POWER_RESET_BRCMSTB=y +CONFIG_POWER_RESET_GEMINI_POWEROFF=y +CONFIG_POWER_RESET_GPIO=y +CONFIG_POWER_RESET_GPIO_RESTART=y +CONFIG_POWER_RESET_PIIX4_POWEROFF=y +CONFIG_POWER_RESET_LTC2952=y +CONFIG_POWER_RESET_RESTART=y +CONFIG_POWER_RESET_KEYSTONE=y +CONFIG_POWER_RESET_SYSCON=y +CONFIG_POWER_RESET_SYSCON_POWEROFF=y +CONFIG_POWER_RESET_RMOBILE=y +CONFIG_POWER_RESET_ZX=y +CONFIG_REBOOT_MODE=y +CONFIG_SYSCON_REBOOT_MODE=y +CONFIG_POWER_SUPPLY=y +CONFIG_POWER_SUPPLY_DEBUG=y +CONFIG_PDA_POWER=y +CONFIG_GENERIC_ADC_BATTERY=y +CONFIG_MAX8925_POWER=y +CONFIG_WM831X_BACKUP=y +CONFIG_WM831X_POWER=y +CONFIG_WM8350_POWER=y +CONFIG_TEST_POWER=y +CONFIG_BATTERY_88PM860X=y +CONFIG_BATTERY_ACT8945A=y +CONFIG_BATTERY_CPCAP=y +CONFIG_BATTERY_DS2760=y +CONFIG_BATTERY_DS2780=y +CONFIG_BATTERY_DS2781=y +CONFIG_BATTERY_DS2782=y +CONFIG_BATTERY_LEGO_EV3=y +CONFIG_BATTERY_WM97XX=y +CONFIG_BATTERY_SBS=y +CONFIG_CHARGER_SBS=y +CONFIG_MANAGER_SBS=y +CONFIG_BATTERY_BQ27XXX=y +CONFIG_BATTERY_BQ27XXX_I2C=y +CONFIG_BATTERY_BQ27XXX_HDQ=y +CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM=y +CONFIG_BATTERY_DA9030=y +CONFIG_BATTERY_DA9052=y +CONFIG_CHARGER_DA9150=y +CONFIG_BATTERY_DA9150=y +CONFIG_CHARGER_AXP20X=y +CONFIG_BATTERY_AXP20X=y +CONFIG_AXP20X_POWER=y +CONFIG_AXP288_CHARGER=y +CONFIG_AXP288_FUEL_GAUGE=y +CONFIG_BATTERY_MAX17040=y +CONFIG_BATTERY_MAX17042=y +CONFIG_BATTERY_MAX1721X=y +CONFIG_BATTERY_TWL4030_MADC=y +CONFIG_CHARGER_88PM860X=y +CONFIG_CHARGER_PCF50633=y +CONFIG_BATTERY_RX51=y +CONFIG_CHARGER_CPCAP=y +CONFIG_CHARGER_ISP1704=y +CONFIG_CHARGER_MAX8903=y +CONFIG_CHARGER_TWL4030=y +CONFIG_CHARGER_LP8727=y +CONFIG_CHARGER_LP8788=y +CONFIG_CHARGER_GPIO=y +CONFIG_CHARGER_MANAGER=y +CONFIG_CHARGER_LTC3651=y +CONFIG_CHARGER_MAX14577=y +CONFIG_CHARGER_DETECTOR_MAX14656=y +CONFIG_CHARGER_MAX77693=y +CONFIG_CHARGER_MAX8997=y +CONFIG_CHARGER_MAX8998=y +CONFIG_CHARGER_QCOM_SMBB=y +CONFIG_CHARGER_BQ2415X=y +CONFIG_CHARGER_BQ24190=y +CONFIG_CHARGER_BQ24257=y +CONFIG_CHARGER_BQ24735=y +CONFIG_CHARGER_BQ25890=y +CONFIG_CHARGER_SMB347=y +CONFIG_CHARGER_TPS65090=y +CONFIG_CHARGER_TPS65217=y +CONFIG_BATTERY_GAUGE_LTC2941=y +CONFIG_BATTERY_GOLDFISH=y +CONFIG_BATTERY_RT5033=y +CONFIG_CHARGER_RT9455=y +CONFIG_HWMON=y +CONFIG_HWMON_VID=y +CONFIG_HWMON_DEBUG_CHIP=y + +# +# Native drivers +# +CONFIG_SENSORS_ABITUGURU=y +CONFIG_SENSORS_ABITUGURU3=y +CONFIG_SENSORS_AD7314=y +CONFIG_SENSORS_AD7414=y +CONFIG_SENSORS_AD7418=y +CONFIG_SENSORS_ADM1021=y +CONFIG_SENSORS_ADM1025=y +CONFIG_SENSORS_ADM1026=y +CONFIG_SENSORS_ADM1029=y +CONFIG_SENSORS_ADM1031=y +CONFIG_SENSORS_ADM9240=y +CONFIG_SENSORS_ADT7X10=y +CONFIG_SENSORS_ADT7310=y +CONFIG_SENSORS_ADT7410=y +CONFIG_SENSORS_ADT7411=y +CONFIG_SENSORS_ADT7462=y +CONFIG_SENSORS_ADT7470=y +CONFIG_SENSORS_ADT7475=y +CONFIG_SENSORS_ASC7621=y +CONFIG_SENSORS_K8TEMP=y +CONFIG_SENSORS_K10TEMP=y +CONFIG_SENSORS_FAM15H_POWER=y +CONFIG_SENSORS_APPLESMC=y +CONFIG_SENSORS_ARM_SCPI=y +CONFIG_SENSORS_ASB100=y +CONFIG_SENSORS_ASPEED=y +CONFIG_SENSORS_ATXP1=y +CONFIG_SENSORS_DS620=y +CONFIG_SENSORS_DS1621=y +CONFIG_SENSORS_DELL_SMM=y +CONFIG_SENSORS_DA9052_ADC=y +CONFIG_SENSORS_DA9055=y +CONFIG_SENSORS_I5K_AMB=y +CONFIG_SENSORS_F71805F=y +CONFIG_SENSORS_F71882FG=y +CONFIG_SENSORS_F75375S=y +CONFIG_SENSORS_MC13783_ADC=y +CONFIG_SENSORS_FSCHMD=y +CONFIG_SENSORS_FTSTEUTATES=y +CONFIG_SENSORS_GL518SM=y +CONFIG_SENSORS_GL520SM=y +CONFIG_SENSORS_G760A=y +CONFIG_SENSORS_G762=y +CONFIG_SENSORS_GPIO_FAN=y +CONFIG_SENSORS_HIH6130=y +CONFIG_SENSORS_IBMAEM=y +CONFIG_SENSORS_IBMPEX=y +CONFIG_SENSORS_IIO_HWMON=y +CONFIG_SENSORS_I5500=y +CONFIG_SENSORS_CORETEMP=y +CONFIG_SENSORS_IT87=y +CONFIG_SENSORS_JC42=y +CONFIG_SENSORS_POWR1220=y +CONFIG_SENSORS_LINEAGE=y +CONFIG_SENSORS_LTC2945=y +CONFIG_SENSORS_LTC2990=y +CONFIG_SENSORS_LTC4151=y +CONFIG_SENSORS_LTC4215=y +CONFIG_SENSORS_LTC4222=y +CONFIG_SENSORS_LTC4245=y +CONFIG_SENSORS_LTC4260=y +CONFIG_SENSORS_LTC4261=y +CONFIG_SENSORS_MAX1111=y +CONFIG_SENSORS_MAX16065=y +CONFIG_SENSORS_MAX1619=y +CONFIG_SENSORS_MAX1668=y +CONFIG_SENSORS_MAX197=y +CONFIG_SENSORS_MAX31722=y +CONFIG_SENSORS_MAX6621=y +CONFIG_SENSORS_MAX6639=y +CONFIG_SENSORS_MAX6642=y +CONFIG_SENSORS_MAX6650=y +CONFIG_SENSORS_MAX6697=y +CONFIG_SENSORS_MAX31790=y +CONFIG_SENSORS_MCP3021=y +CONFIG_SENSORS_TC654=y +CONFIG_SENSORS_MENF21BMC_HWMON=y +CONFIG_SENSORS_ADCXX=y +CONFIG_SENSORS_LM63=y +CONFIG_SENSORS_LM70=y +CONFIG_SENSORS_LM73=y +CONFIG_SENSORS_LM75=y +CONFIG_SENSORS_LM77=y +CONFIG_SENSORS_LM78=y +CONFIG_SENSORS_LM80=y +CONFIG_SENSORS_LM83=y +CONFIG_SENSORS_LM85=y +CONFIG_SENSORS_LM87=y +CONFIG_SENSORS_LM90=y +CONFIG_SENSORS_LM92=y +CONFIG_SENSORS_LM93=y +CONFIG_SENSORS_LM95234=y +CONFIG_SENSORS_LM95241=y +CONFIG_SENSORS_LM95245=y +CONFIG_SENSORS_PC87360=y +CONFIG_SENSORS_PC87427=y +CONFIG_SENSORS_NTC_THERMISTOR=y +CONFIG_SENSORS_NCT6683=y +CONFIG_SENSORS_NCT6775=y +CONFIG_SENSORS_NCT7802=y +CONFIG_SENSORS_NCT7904=y +CONFIG_SENSORS_NSA320=y +CONFIG_SENSORS_PCF8591=y +CONFIG_PMBUS=y +CONFIG_SENSORS_PMBUS=y +CONFIG_SENSORS_ADM1275=y +CONFIG_SENSORS_IBM_CFFPS=y +CONFIG_SENSORS_IR35221=y +CONFIG_SENSORS_LM25066=y +CONFIG_SENSORS_LTC2978=y +CONFIG_SENSORS_LTC2978_REGULATOR=y +CONFIG_SENSORS_LTC3815=y +CONFIG_SENSORS_MAX16064=y +CONFIG_SENSORS_MAX20751=y +CONFIG_SENSORS_MAX31785=y +CONFIG_SENSORS_MAX34440=y +CONFIG_SENSORS_MAX8688=y +CONFIG_SENSORS_TPS40422=y +CONFIG_SENSORS_TPS53679=y +CONFIG_SENSORS_UCD9000=y +CONFIG_SENSORS_UCD9200=y +CONFIG_SENSORS_ZL6100=y +CONFIG_SENSORS_PWM_FAN=y +CONFIG_SENSORS_SHT15=y +CONFIG_SENSORS_SHT21=y +CONFIG_SENSORS_SHT3x=y +CONFIG_SENSORS_SHTC1=y +CONFIG_SENSORS_SIS5595=y +CONFIG_SENSORS_DME1737=y +CONFIG_SENSORS_EMC1403=y +CONFIG_SENSORS_EMC2103=y +CONFIG_SENSORS_EMC6W201=y +CONFIG_SENSORS_SMSC47M1=y +CONFIG_SENSORS_SMSC47M192=y +CONFIG_SENSORS_SMSC47B397=y +CONFIG_SENSORS_SCH56XX_COMMON=y +CONFIG_SENSORS_SCH5627=y +CONFIG_SENSORS_SCH5636=y +CONFIG_SENSORS_STTS751=y +CONFIG_SENSORS_SMM665=y +CONFIG_SENSORS_ADC128D818=y +CONFIG_SENSORS_ADS1015=y +CONFIG_SENSORS_ADS7828=y +CONFIG_SENSORS_ADS7871=y +CONFIG_SENSORS_AMC6821=y +CONFIG_SENSORS_INA209=y +CONFIG_SENSORS_INA2XX=y +CONFIG_SENSORS_INA3221=y +CONFIG_SENSORS_TC74=y +CONFIG_SENSORS_THMC50=y +CONFIG_SENSORS_TMP102=y +CONFIG_SENSORS_TMP103=y +CONFIG_SENSORS_TMP108=y +CONFIG_SENSORS_TMP401=y +CONFIG_SENSORS_TMP421=y +CONFIG_SENSORS_VIA_CPUTEMP=y +CONFIG_SENSORS_VIA686A=y +CONFIG_SENSORS_VT1211=y +CONFIG_SENSORS_VT8231=y +CONFIG_SENSORS_W83773G=y +CONFIG_SENSORS_W83781D=y +CONFIG_SENSORS_W83791D=y +CONFIG_SENSORS_W83792D=y +CONFIG_SENSORS_W83793=y +CONFIG_SENSORS_W83795=y +CONFIG_SENSORS_W83795_FANCTRL=y +CONFIG_SENSORS_W83L785TS=y +CONFIG_SENSORS_W83L786NG=y +CONFIG_SENSORS_W83627HF=y +CONFIG_SENSORS_W83627EHF=y +CONFIG_SENSORS_WM831X=y +CONFIG_SENSORS_WM8350=y +CONFIG_SENSORS_XGENE=y + +# +# ACPI drivers +# +CONFIG_SENSORS_ACPI_POWER=y +CONFIG_SENSORS_ATK0110=y +CONFIG_THERMAL=y +CONFIG_THERMAL_EMERGENCY_POWEROFF_DELAY_MS=0 +CONFIG_THERMAL_HWMON=y +CONFIG_THERMAL_OF=y +CONFIG_THERMAL_WRITABLE_TRIPS=y +CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE=y +# CONFIG_THERMAL_DEFAULT_GOV_FAIR_SHARE is not set +# CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE is not set +# CONFIG_THERMAL_DEFAULT_GOV_POWER_ALLOCATOR is not set +CONFIG_THERMAL_GOV_FAIR_SHARE=y +CONFIG_THERMAL_GOV_STEP_WISE=y +CONFIG_THERMAL_GOV_BANG_BANG=y +CONFIG_THERMAL_GOV_USER_SPACE=y +CONFIG_THERMAL_GOV_POWER_ALLOCATOR=y +CONFIG_CPU_THERMAL=y +CONFIG_CLOCK_THERMAL=y +CONFIG_DEVFREQ_THERMAL=y +CONFIG_THERMAL_EMULATION=y +CONFIG_HISI_THERMAL=y +CONFIG_IMX_THERMAL=y +CONFIG_MAX77620_THERMAL=y +CONFIG_QORIQ_THERMAL=y +CONFIG_SPEAR_THERMAL=y +CONFIG_ROCKCHIP_THERMAL=y +CONFIG_RCAR_THERMAL=y +CONFIG_RCAR_GEN3_THERMAL=y +CONFIG_KIRKWOOD_THERMAL=y +CONFIG_DOVE_THERMAL=y +CONFIG_ARMADA_THERMAL=y +CONFIG_DA9062_THERMAL=y +CONFIG_INTEL_POWERCLAMP=y +CONFIG_X86_PKG_TEMP_THERMAL=y +CONFIG_INTEL_SOC_DTS_IOSF_CORE=y +CONFIG_INTEL_SOC_DTS_THERMAL=y + +# +# ACPI INT340X thermal drivers +# +CONFIG_INT340X_THERMAL=y +CONFIG_ACPI_THERMAL_REL=y +CONFIG_INT3406_THERMAL=y +CONFIG_INTEL_BXT_PMIC_THERMAL=y +CONFIG_INTEL_PCH_THERMAL=y +CONFIG_MTK_THERMAL=y + +# +# Broadcom thermal drivers +# +CONFIG_BCM2835_THERMAL=y +CONFIG_BRCMSTB_THERMAL=y +CONFIG_BCM_NS_THERMAL=y + +# +# Texas Instruments thermal drivers +# +CONFIG_TI_SOC_THERMAL=y +CONFIG_TI_THERMAL=y +CONFIG_OMAP3_THERMAL=y +CONFIG_OMAP4_THERMAL=y +CONFIG_OMAP5_THERMAL=y +CONFIG_DRA752_THERMAL=y + +# +# Samsung thermal drivers +# +CONFIG_EXYNOS_THERMAL=y +CONFIG_TANGO_THERMAL=y +CONFIG_QCOM_SPMI_TEMP_ALARM=y +CONFIG_GENERIC_ADC_THERMAL=y + +# +# Qualcomm thermal drivers +# +CONFIG_QCOM_TSENS=y +CONFIG_ZX2967_THERMAL=y +CONFIG_UNIPHIER_THERMAL=y +CONFIG_WATCHDOG=y +CONFIG_WATCHDOG_CORE=y +CONFIG_WATCHDOG_NOWAYOUT=y +CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED=y +CONFIG_WATCHDOG_SYSFS=y + +# +# Watchdog Device Drivers +# +CONFIG_SOFT_WATCHDOG=y +CONFIG_SOFT_WATCHDOG_PRETIMEOUT=y +CONFIG_DA9052_WATCHDOG=y +CONFIG_DA9055_WATCHDOG=y +CONFIG_DA9063_WATCHDOG=y +CONFIG_DA9062_WATCHDOG=y +CONFIG_GPIO_WATCHDOG=y +CONFIG_GPIO_WATCHDOG_ARCH_INITCALL=y +CONFIG_MENF21BMC_WATCHDOG=y +CONFIG_TANGOX_WATCHDOG=y +CONFIG_WDAT_WDT=y +CONFIG_WM831X_WATCHDOG=y +CONFIG_WM8350_WATCHDOG=y +CONFIG_XILINX_WATCHDOG=y +CONFIG_ZIIRAVE_WATCHDOG=y +CONFIG_RAVE_SP_WATCHDOG=y +CONFIG_ASM9260_WATCHDOG=y +CONFIG_AT91RM9200_WATCHDOG=y +CONFIG_AT91SAM9X_WATCHDOG=y +CONFIG_SAMA5D4_WATCHDOG=y +CONFIG_CADENCE_WATCHDOG=y +CONFIG_FTWDT010_WATCHDOG=y +CONFIG_S3C2410_WATCHDOG=y +CONFIG_DW_WATCHDOG=y +CONFIG_EP93XX_WATCHDOG=y +CONFIG_OMAP_WATCHDOG=y +CONFIG_DAVINCI_WATCHDOG=y +CONFIG_RN5T618_WATCHDOG=y +CONFIG_SUNXI_WATCHDOG=y +CONFIG_TWL4030_WATCHDOG=y +CONFIG_STMP3XXX_RTC_WATCHDOG=y +CONFIG_NUC900_WATCHDOG=y +CONFIG_TS4800_WATCHDOG=y +CONFIG_TS72XX_WATCHDOG=y +CONFIG_MAX63XX_WATCHDOG=y +CONFIG_MAX77620_WATCHDOG=y +CONFIG_IMX2_WDT=y +CONFIG_RETU_WATCHDOG=y +CONFIG_MOXART_WDT=y +CONFIG_SIRFSOC_WATCHDOG=y +CONFIG_ST_LPC_WATCHDOG=y +CONFIG_TEGRA_WATCHDOG=y +CONFIG_QCOM_WDT=y +CONFIG_MESON_GXBB_WATCHDOG=y +CONFIG_MESON_WATCHDOG=y +CONFIG_MEDIATEK_WATCHDOG=y +CONFIG_DIGICOLOR_WATCHDOG=y +CONFIG_LPC18XX_WATCHDOG=y +CONFIG_ATLAS7_WATCHDOG=y +CONFIG_RENESAS_WDT=y +CONFIG_RENESAS_RZAWDT=y +CONFIG_ASPEED_WATCHDOG=y +CONFIG_UNIPHIER_WATCHDOG=y +CONFIG_RTD119X_WATCHDOG=y +CONFIG_SPRD_WATCHDOG=y +CONFIG_ACQUIRE_WDT=y +CONFIG_ADVANTECH_WDT=y +CONFIG_ALIM1535_WDT=y +CONFIG_ALIM7101_WDT=y +CONFIG_EBC_C384_WDT=y +CONFIG_F71808E_WDT=y +CONFIG_SP5100_TCO=y +CONFIG_GEODE_WDT=y +CONFIG_SC520_WDT=y +CONFIG_SBC_FITPC2_WATCHDOG=y +CONFIG_EUROTECH_WDT=y +CONFIG_IB700_WDT=y +CONFIG_IBMASR=y +CONFIG_WAFER_WDT=y +CONFIG_I6300ESB_WDT=y +CONFIG_IE6XX_WDT=y +CONFIG_INTEL_SCU_WATCHDOG=y +CONFIG_INTEL_MID_WATCHDOG=y +CONFIG_ITCO_WDT=y +CONFIG_ITCO_VENDOR_SUPPORT=y +CONFIG_IT8712F_WDT=y +CONFIG_IT87_WDT=y +CONFIG_HP_WATCHDOG=y +CONFIG_KEMPLD_WDT=y +CONFIG_HPWDT_NMI_DECODING=y +CONFIG_SC1200_WDT=y +CONFIG_PC87413_WDT=y +CONFIG_NV_TCO=y +CONFIG_RDC321X_WDT=y +CONFIG_60XX_WDT=y +CONFIG_CPU5_WDT=y +CONFIG_SMSC_SCH311X_WDT=y +CONFIG_SMSC37B787_WDT=y +CONFIG_VIA_WDT=y +CONFIG_W83627HF_WDT=y +CONFIG_W83877F_WDT=y +CONFIG_W83977F_WDT=y +CONFIG_MACHZ_WDT=y +CONFIG_SBC_EPX_C3_WATCHDOG=y +CONFIG_INTEL_MEI_WDT=y +CONFIG_NI903X_WDT=y +CONFIG_NIC7018_WDT=y +CONFIG_BCM47XX_WDT=y +CONFIG_BCM2835_WDT=y +CONFIG_BCM_KONA_WDT=y +CONFIG_BCM_KONA_WDT_DEBUG=y +CONFIG_BCM7038_WDT=y +CONFIG_IMGPDC_WDT=y +CONFIG_MPC5200_WDT=y +CONFIG_MV64X60_WDT=y +CONFIG_MEN_A21_WDT=y +CONFIG_XEN_WDT=y +CONFIG_UML_WATCHDOG=y + +# +# PCI-based Watchdog Cards +# +CONFIG_PCIPCWATCHDOG=y +CONFIG_WDTPCI=y + +# +# USB-based Watchdog Cards +# +CONFIG_USBPCWATCHDOG=y + +# +# Watchdog Pretimeout Governors +# +CONFIG_WATCHDOG_PRETIMEOUT_GOV=y +# CONFIG_WATCHDOG_PRETIMEOUT_DEFAULT_GOV_NOOP is not set +CONFIG_WATCHDOG_PRETIMEOUT_DEFAULT_GOV_PANIC=y +CONFIG_WATCHDOG_PRETIMEOUT_GOV_NOOP=y +CONFIG_WATCHDOG_PRETIMEOUT_GOV_PANIC=y +CONFIG_SSB_POSSIBLE=y +CONFIG_SSB=y +CONFIG_SSB_SPROM=y +CONFIG_SSB_BLOCKIO=y +CONFIG_SSB_PCIHOST_POSSIBLE=y +CONFIG_SSB_PCIHOST=y +CONFIG_SSB_B43_PCI_BRIDGE=y +CONFIG_SSB_PCMCIAHOST_POSSIBLE=y +CONFIG_SSB_PCMCIAHOST=y +CONFIG_SSB_SDIOHOST_POSSIBLE=y +CONFIG_SSB_SDIOHOST=y +CONFIG_SSB_SILENT=y +CONFIG_SSB_DRIVER_PCICORE_POSSIBLE=y +CONFIG_SSB_DRIVER_PCICORE=y +CONFIG_SSB_DRIVER_GPIO=y +CONFIG_BCMA_POSSIBLE=y +CONFIG_BCMA=y +CONFIG_BCMA_BLOCKIO=y +CONFIG_BCMA_HOST_PCI_POSSIBLE=y +CONFIG_BCMA_HOST_PCI=y +CONFIG_BCMA_HOST_SOC=y +CONFIG_BCMA_DRIVER_PCI=y +CONFIG_BCMA_SFLASH=y +CONFIG_BCMA_DRIVER_GMAC_CMN=y +CONFIG_BCMA_DRIVER_GPIO=y +CONFIG_BCMA_DEBUG=y + +# +# Multifunction device drivers +# +CONFIG_MFD_CORE=y +CONFIG_MFD_CS5535=y +CONFIG_MFD_ACT8945A=y +CONFIG_MFD_AS3711=y +CONFIG_MFD_AS3722=y +CONFIG_PMIC_ADP5520=y +CONFIG_MFD_AAT2870_CORE=y +CONFIG_MFD_ATMEL_FLEXCOM=y +CONFIG_MFD_ATMEL_HLCDC=y +CONFIG_MFD_BCM590XX=y +CONFIG_MFD_BD9571MWV=y +CONFIG_MFD_AXP20X=y +CONFIG_MFD_AXP20X_I2C=y +CONFIG_MFD_CROS_EC=y +CONFIG_MFD_CROS_EC_I2C=y +CONFIG_MFD_CROS_EC_SPI=y +CONFIG_MFD_CROS_EC_CHARDEV=y +CONFIG_PMIC_DA903X=y +CONFIG_PMIC_DA9052=y +CONFIG_MFD_DA9052_SPI=y +CONFIG_MFD_DA9052_I2C=y +CONFIG_MFD_DA9055=y +CONFIG_MFD_DA9062=y +CONFIG_MFD_DA9063=y +CONFIG_MFD_DA9150=y +CONFIG_MFD_DLN2=y +CONFIG_MFD_EXYNOS_LPASS=y +CONFIG_MFD_MC13XXX=y +CONFIG_MFD_MC13XXX_SPI=y +CONFIG_MFD_MC13XXX_I2C=y +CONFIG_MFD_MXS_LRADC=y +CONFIG_MFD_MX25_TSADC=y +CONFIG_MFD_HI6421_PMIC=y +CONFIG_MFD_HI655X_PMIC=y +CONFIG_HTC_PASIC3=y +CONFIG_HTC_I2CPLD=y +CONFIG_MFD_INTEL_QUARK_I2C_GPIO=y +CONFIG_LPC_ICH=y +CONFIG_LPC_SCH=y +CONFIG_INTEL_SOC_PMIC=y +CONFIG_INTEL_SOC_PMIC_BXTWC=y +CONFIG_INTEL_SOC_PMIC_CHTWC=y +CONFIG_INTEL_SOC_PMIC_CHTDC_TI=y +CONFIG_MFD_INTEL_LPSS=y +CONFIG_MFD_INTEL_LPSS_ACPI=y +CONFIG_MFD_INTEL_LPSS_PCI=y +CONFIG_MFD_INTEL_MSIC=y +CONFIG_MFD_JANZ_CMODIO=y +CONFIG_MFD_KEMPLD=y +CONFIG_MFD_88PM800=y +CONFIG_MFD_88PM805=y +CONFIG_MFD_88PM860X=y +CONFIG_MFD_MAX14577=y +CONFIG_MFD_MAX77620=y +CONFIG_MFD_MAX77686=y +CONFIG_MFD_MAX77693=y +CONFIG_MFD_MAX77843=y +CONFIG_MFD_MAX8907=y +CONFIG_MFD_MAX8925=y +CONFIG_MFD_MAX8997=y +CONFIG_MFD_MAX8998=y +CONFIG_MFD_MT6397=y +CONFIG_MFD_MENF21BMC=y +CONFIG_EZX_PCAP=y +CONFIG_MFD_CPCAP=y +CONFIG_MFD_VIPERBOARD=y +CONFIG_MFD_RETU=y +CONFIG_MFD_PCF50633=y +CONFIG_PCF50633_ADC=y +CONFIG_PCF50633_GPIO=y +CONFIG_UCB1400_CORE=y +CONFIG_MFD_PM8XXX=y +CONFIG_MFD_SPMI_PMIC=y +CONFIG_MFD_RDC321X=y +CONFIG_MFD_RT5033=y +CONFIG_MFD_RC5T583=y +CONFIG_MFD_RK808=y +CONFIG_MFD_RN5T618=y +CONFIG_MFD_SEC_CORE=y +CONFIG_MFD_SI476X_CORE=y +CONFIG_MFD_SM501=y +CONFIG_MFD_SM501_GPIO=y +CONFIG_MFD_SKY81452=y +CONFIG_MFD_SMSC=y +CONFIG_MFD_SC27XX_PMIC=y +CONFIG_ABX500_CORE=y +CONFIG_AB3100_CORE=y +CONFIG_AB3100_OTP=y +CONFIG_MFD_STMPE=y + +# +# STMicroelectronics STMPE Interface Drivers +# +CONFIG_STMPE_I2C=y +CONFIG_STMPE_SPI=y +CONFIG_MFD_SYSCON=y +CONFIG_MFD_TI_AM335X_TSCADC=y +CONFIG_MFD_LP3943=y +CONFIG_MFD_LP8788=y +CONFIG_MFD_TI_LMU=y +CONFIG_MFD_PALMAS=y +CONFIG_TPS6105X=y +CONFIG_TPS65010=y +CONFIG_TPS6507X=y +CONFIG_MFD_TPS65086=y +CONFIG_MFD_TPS65090=y +CONFIG_MFD_TPS65217=y +CONFIG_MFD_TPS68470=y +CONFIG_MFD_TI_LP873X=y +CONFIG_MFD_TI_LP87565=y +CONFIG_MFD_TPS65218=y +CONFIG_MFD_TPS6586X=y +CONFIG_MFD_TPS65910=y +CONFIG_MFD_TPS65912=y +CONFIG_MFD_TPS65912_I2C=y +CONFIG_MFD_TPS65912_SPI=y +CONFIG_MFD_TPS80031=y +CONFIG_TWL4030_CORE=y +CONFIG_MFD_TWL4030_AUDIO=y +CONFIG_TWL6040_CORE=y +CONFIG_MFD_WL1273_CORE=y +CONFIG_MFD_LM3533=y +CONFIG_MFD_TIMBERDALE=y +CONFIG_MFD_TC3589X=y +# CONFIG_MFD_TMIO is not set +CONFIG_MFD_VX855=y +CONFIG_MFD_ARIZONA=y +CONFIG_MFD_ARIZONA_I2C=y +CONFIG_MFD_ARIZONA_SPI=y +CONFIG_MFD_CS47L24=y +CONFIG_MFD_WM5102=y +CONFIG_MFD_WM5110=y +CONFIG_MFD_WM8997=y +CONFIG_MFD_WM8998=y +CONFIG_MFD_WM8400=y +CONFIG_MFD_WM831X=y +CONFIG_MFD_WM831X_I2C=y +CONFIG_MFD_WM831X_SPI=y +CONFIG_MFD_WM8350=y +CONFIG_MFD_WM8350_I2C=y +CONFIG_MFD_WM8994=y +CONFIG_MFD_STW481X=y +CONFIG_MFD_STM32_LPTIMER=y +CONFIG_MFD_STM32_TIMERS=y +CONFIG_RAVE_SP_CORE=y +CONFIG_REGULATOR=y +CONFIG_REGULATOR_DEBUG=y +CONFIG_REGULATOR_FIXED_VOLTAGE=y +CONFIG_REGULATOR_VIRTUAL_CONSUMER=y +CONFIG_REGULATOR_USERSPACE_CONSUMER=y +CONFIG_REGULATOR_88PM800=y +CONFIG_REGULATOR_88PM8607=y +CONFIG_REGULATOR_ACT8865=y +CONFIG_REGULATOR_ACT8945A=y +CONFIG_REGULATOR_AD5398=y +CONFIG_REGULATOR_ANATOP=y +CONFIG_REGULATOR_AAT2870=y +CONFIG_REGULATOR_AB3100=y +CONFIG_REGULATOR_ARIZONA_LDO1=y +CONFIG_REGULATOR_ARIZONA_MICSUPP=y +CONFIG_REGULATOR_AS3711=y +CONFIG_REGULATOR_AS3722=y +CONFIG_REGULATOR_AXP20X=y +CONFIG_REGULATOR_BCM590XX=y +CONFIG_REGULATOR_BD9571MWV=y +CONFIG_REGULATOR_CPCAP=y +CONFIG_REGULATOR_DA903X=y +CONFIG_REGULATOR_DA9052=y +CONFIG_REGULATOR_DA9055=y +CONFIG_REGULATOR_DA9062=y +CONFIG_REGULATOR_DA9063=y +CONFIG_REGULATOR_DA9210=y +CONFIG_REGULATOR_DA9211=y +CONFIG_REGULATOR_FAN53555=y +CONFIG_REGULATOR_GPIO=y +CONFIG_REGULATOR_HI6421=y +CONFIG_REGULATOR_HI6421V530=y +CONFIG_REGULATOR_HI655X=y +CONFIG_REGULATOR_ISL9305=y +CONFIG_REGULATOR_ISL6271A=y +CONFIG_REGULATOR_LM363X=y +CONFIG_REGULATOR_LP3971=y +CONFIG_REGULATOR_LP3972=y +CONFIG_REGULATOR_LP872X=y +CONFIG_REGULATOR_LP873X=y +CONFIG_REGULATOR_LP8755=y +CONFIG_REGULATOR_LP87565=y +CONFIG_REGULATOR_LP8788=y +CONFIG_REGULATOR_LTC3589=y +CONFIG_REGULATOR_LTC3676=y +CONFIG_REGULATOR_MAX14577=y +CONFIG_REGULATOR_MAX1586=y +CONFIG_REGULATOR_MAX77620=y +CONFIG_REGULATOR_MAX8649=y +CONFIG_REGULATOR_MAX8660=y +CONFIG_REGULATOR_MAX8907=y +CONFIG_REGULATOR_MAX8925=y +CONFIG_REGULATOR_MAX8952=y +CONFIG_REGULATOR_MAX8973=y +CONFIG_REGULATOR_MAX8997=y +CONFIG_REGULATOR_MAX8998=y +CONFIG_REGULATOR_MAX77686=y +CONFIG_REGULATOR_MAX77693=y +CONFIG_REGULATOR_MAX77802=y +CONFIG_REGULATOR_MC13XXX_CORE=y +CONFIG_REGULATOR_MC13783=y +CONFIG_REGULATOR_MC13892=y +CONFIG_REGULATOR_MT6311=y +CONFIG_REGULATOR_MT6323=y +CONFIG_REGULATOR_MT6380=y +CONFIG_REGULATOR_MT6397=y +CONFIG_REGULATOR_PALMAS=y +CONFIG_REGULATOR_PBIAS=y +CONFIG_REGULATOR_PCAP=y +CONFIG_REGULATOR_PCF50633=y +CONFIG_REGULATOR_PFUZE100=y +CONFIG_REGULATOR_PV88060=y +CONFIG_REGULATOR_PV88080=y +CONFIG_REGULATOR_PV88090=y +CONFIG_REGULATOR_PWM=y +CONFIG_REGULATOR_QCOM_SPMI=y +CONFIG_REGULATOR_RC5T583=y +CONFIG_REGULATOR_RK808=y +CONFIG_REGULATOR_RN5T618=y +CONFIG_REGULATOR_RT5033=y +CONFIG_REGULATOR_S2MPA01=y +CONFIG_REGULATOR_S2MPS11=y +CONFIG_REGULATOR_S5M8767=y +CONFIG_REGULATOR_SC2731=y +CONFIG_REGULATOR_SKY81452=y +CONFIG_REGULATOR_STM32_VREFBUF=y +CONFIG_REGULATOR_STW481X_VMMC=y +CONFIG_REGULATOR_TPS51632=y +CONFIG_REGULATOR_TPS6105X=y +CONFIG_REGULATOR_TPS62360=y +CONFIG_REGULATOR_TPS65023=y +CONFIG_REGULATOR_TPS6507X=y +CONFIG_REGULATOR_TPS65086=y +CONFIG_REGULATOR_TPS65090=y +CONFIG_REGULATOR_TPS65132=y +CONFIG_REGULATOR_TPS65217=y +CONFIG_REGULATOR_TPS65218=y +CONFIG_REGULATOR_TPS6524X=y +CONFIG_REGULATOR_TPS6586X=y +CONFIG_REGULATOR_TPS65910=y +CONFIG_REGULATOR_TPS65912=y +CONFIG_REGULATOR_TPS80031=y +CONFIG_REGULATOR_TWL4030=y +CONFIG_REGULATOR_VCTRL=y +CONFIG_REGULATOR_WM831X=y +CONFIG_REGULATOR_WM8350=y +CONFIG_REGULATOR_WM8400=y +CONFIG_REGULATOR_WM8994=y +CONFIG_CEC_CORE=y +CONFIG_CEC_NOTIFIER=y +CONFIG_RC_CORE=y +CONFIG_RC_MAP=y +CONFIG_LIRC=y +CONFIG_RC_DECODERS=y +CONFIG_IR_NEC_DECODER=y +CONFIG_IR_RC5_DECODER=y +CONFIG_IR_RC6_DECODER=y +CONFIG_IR_JVC_DECODER=y +CONFIG_IR_SONY_DECODER=y +CONFIG_IR_SANYO_DECODER=y +CONFIG_IR_SHARP_DECODER=y +CONFIG_IR_MCE_KBD_DECODER=y +CONFIG_IR_XMP_DECODER=y +CONFIG_RC_DEVICES=y +CONFIG_RC_ATI_REMOTE=y +CONFIG_IR_ENE=y +CONFIG_IR_HIX5HD2=y +CONFIG_IR_IMON=y +CONFIG_IR_MCEUSB=y +CONFIG_IR_ITE_CIR=y +CONFIG_IR_FINTEK=y +CONFIG_IR_MESON=y +CONFIG_IR_MTK=y +CONFIG_IR_NUVOTON=y +CONFIG_IR_REDRAT3=y +CONFIG_IR_SPI=y +CONFIG_IR_STREAMZAP=y +CONFIG_IR_WINBOND_CIR=y +CONFIG_IR_IGORPLUGUSB=y +CONFIG_IR_IGUANA=y +CONFIG_IR_TTUSBIR=y +CONFIG_IR_RX51=y +CONFIG_IR_IMG=y +CONFIG_IR_IMG_RAW=y +CONFIG_IR_IMG_HW=y +CONFIG_IR_IMG_NEC=y +CONFIG_IR_IMG_JVC=y +CONFIG_IR_IMG_SONY=y +CONFIG_IR_IMG_SHARP=y +CONFIG_IR_IMG_SANYO=y +CONFIG_IR_IMG_RC5=y +CONFIG_IR_IMG_RC6=y +CONFIG_RC_LOOPBACK=y +CONFIG_IR_GPIO_CIR=y +CONFIG_IR_GPIO_TX=y +CONFIG_IR_PWM_TX=y +CONFIG_RC_ST=y +CONFIG_IR_SUNXI=y +CONFIG_IR_SERIAL=y +CONFIG_IR_SERIAL_TRANSMITTER=y +CONFIG_IR_SIR=y +CONFIG_IR_TANGO=y +CONFIG_IR_ZX=y +CONFIG_MEDIA_SUPPORT=y + +# +# Multimedia core support +# +CONFIG_MEDIA_CAMERA_SUPPORT=y +CONFIG_MEDIA_ANALOG_TV_SUPPORT=y +CONFIG_MEDIA_DIGITAL_TV_SUPPORT=y +CONFIG_MEDIA_RADIO_SUPPORT=y +CONFIG_MEDIA_SDR_SUPPORT=y +CONFIG_MEDIA_CEC_SUPPORT=y +CONFIG_MEDIA_CEC_RC=y +CONFIG_MEDIA_CONTROLLER=y +CONFIG_MEDIA_CONTROLLER_DVB=y +CONFIG_VIDEO_DEV=y +CONFIG_VIDEO_V4L2_SUBDEV_API=y +CONFIG_VIDEO_V4L2=y +CONFIG_VIDEO_ADV_DEBUG=y +CONFIG_VIDEO_FIXED_MINOR_RANGES=y +CONFIG_VIDEO_PCI_SKELETON=y +CONFIG_VIDEO_TUNER=y +CONFIG_V4L2_MEM2MEM_DEV=y +CONFIG_V4L2_FLASH_LED_CLASS=y +CONFIG_V4L2_FWNODE=y +CONFIG_VIDEOBUF_GEN=y +CONFIG_VIDEOBUF_DMA_SG=y +CONFIG_VIDEOBUF_VMALLOC=y +CONFIG_VIDEOBUF_DMA_CONTIG=y +CONFIG_VIDEOBUF_DVB=y +CONFIG_DVB_CORE=y +CONFIG_DVB_MMAP=y +CONFIG_DVB_NET=y +CONFIG_TTPCI_EEPROM=y +CONFIG_DVB_MAX_ADAPTERS=16 +CONFIG_DVB_DYNAMIC_MINORS=y +CONFIG_DVB_DEMUX_SECTION_LOSS_LOG=y +CONFIG_DVB_ULE_DEBUG=y + +# +# Media drivers +# +CONFIG_MEDIA_USB_SUPPORT=y + +# +# Webcam devices +# +CONFIG_USB_VIDEO_CLASS=y +CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y +CONFIG_USB_GSPCA=y +CONFIG_USB_M5602=y +CONFIG_USB_STV06XX=y +CONFIG_USB_GL860=y +CONFIG_USB_GSPCA_BENQ=y +CONFIG_USB_GSPCA_CONEX=y +CONFIG_USB_GSPCA_CPIA1=y +CONFIG_USB_GSPCA_DTCS033=y +CONFIG_USB_GSPCA_ETOMS=y +CONFIG_USB_GSPCA_FINEPIX=y +CONFIG_USB_GSPCA_JEILINJ=y +CONFIG_USB_GSPCA_JL2005BCD=y +CONFIG_USB_GSPCA_KINECT=y +CONFIG_USB_GSPCA_KONICA=y +CONFIG_USB_GSPCA_MARS=y +CONFIG_USB_GSPCA_MR97310A=y +CONFIG_USB_GSPCA_NW80X=y +CONFIG_USB_GSPCA_OV519=y +CONFIG_USB_GSPCA_OV534=y +CONFIG_USB_GSPCA_OV534_9=y +CONFIG_USB_GSPCA_PAC207=y +CONFIG_USB_GSPCA_PAC7302=y +CONFIG_USB_GSPCA_PAC7311=y +CONFIG_USB_GSPCA_SE401=y +CONFIG_USB_GSPCA_SN9C2028=y +CONFIG_USB_GSPCA_SN9C20X=y +CONFIG_USB_GSPCA_SONIXB=y +CONFIG_USB_GSPCA_SONIXJ=y +CONFIG_USB_GSPCA_SPCA500=y +CONFIG_USB_GSPCA_SPCA501=y +CONFIG_USB_GSPCA_SPCA505=y +CONFIG_USB_GSPCA_SPCA506=y +CONFIG_USB_GSPCA_SPCA508=y +CONFIG_USB_GSPCA_SPCA561=y +CONFIG_USB_GSPCA_SPCA1528=y +CONFIG_USB_GSPCA_SQ905=y +CONFIG_USB_GSPCA_SQ905C=y +CONFIG_USB_GSPCA_SQ930X=y +CONFIG_USB_GSPCA_STK014=y +CONFIG_USB_GSPCA_STK1135=y +CONFIG_USB_GSPCA_STV0680=y +CONFIG_USB_GSPCA_SUNPLUS=y +CONFIG_USB_GSPCA_T613=y +CONFIG_USB_GSPCA_TOPRO=y +CONFIG_USB_GSPCA_TOUPTEK=y +CONFIG_USB_GSPCA_TV8532=y +CONFIG_USB_GSPCA_VC032X=y +CONFIG_USB_GSPCA_VICAM=y +CONFIG_USB_GSPCA_XIRLINK_CIT=y +CONFIG_USB_GSPCA_ZC3XX=y +CONFIG_USB_PWC=y +CONFIG_USB_PWC_DEBUG=y +CONFIG_USB_PWC_INPUT_EVDEV=y +CONFIG_VIDEO_CPIA2=y +CONFIG_USB_ZR364XX=y +CONFIG_USB_STKWEBCAM=y +CONFIG_USB_S2255=y +CONFIG_VIDEO_USBTV=y + +# +# Analog TV USB devices +# +CONFIG_VIDEO_PVRUSB2=y +CONFIG_VIDEO_PVRUSB2_SYSFS=y +CONFIG_VIDEO_PVRUSB2_DVB=y +CONFIG_VIDEO_PVRUSB2_DEBUGIFC=y +CONFIG_VIDEO_HDPVR=y +CONFIG_VIDEO_USBVISION=y +CONFIG_VIDEO_STK1160_COMMON=y +CONFIG_VIDEO_STK1160=y +CONFIG_VIDEO_GO7007=y +CONFIG_VIDEO_GO7007_USB=y +CONFIG_VIDEO_GO7007_LOADER=y +CONFIG_VIDEO_GO7007_USB_S2250_BOARD=y + +# +# Analog/digital TV USB devices +# +CONFIG_VIDEO_AU0828=y +CONFIG_VIDEO_AU0828_V4L2=y +CONFIG_VIDEO_AU0828_RC=y +CONFIG_VIDEO_CX231XX=y +CONFIG_VIDEO_CX231XX_RC=y +CONFIG_VIDEO_CX231XX_ALSA=y +CONFIG_VIDEO_CX231XX_DVB=y +CONFIG_VIDEO_TM6000=y +CONFIG_VIDEO_TM6000_ALSA=y +CONFIG_VIDEO_TM6000_DVB=y + +# +# Digital TV USB devices +# +CONFIG_DVB_USB=y +CONFIG_DVB_USB_DEBUG=y +CONFIG_DVB_USB_DIB3000MC=y +CONFIG_DVB_USB_A800=y +CONFIG_DVB_USB_DIBUSB_MB=y +CONFIG_DVB_USB_DIBUSB_MB_FAULTY=y +CONFIG_DVB_USB_DIBUSB_MC=y +CONFIG_DVB_USB_DIB0700=y +CONFIG_DVB_USB_UMT_010=y +CONFIG_DVB_USB_CXUSB=y +CONFIG_DVB_USB_M920X=y +CONFIG_DVB_USB_DIGITV=y +CONFIG_DVB_USB_VP7045=y +CONFIG_DVB_USB_VP702X=y +CONFIG_DVB_USB_GP8PSK=y +CONFIG_DVB_USB_NOVA_T_USB2=y +CONFIG_DVB_USB_TTUSB2=y +CONFIG_DVB_USB_DTT200U=y +CONFIG_DVB_USB_OPERA1=y +CONFIG_DVB_USB_AF9005=y +CONFIG_DVB_USB_AF9005_REMOTE=y +CONFIG_DVB_USB_PCTV452E=y +CONFIG_DVB_USB_DW2102=y +CONFIG_DVB_USB_CINERGY_T2=y +CONFIG_DVB_USB_DTV5100=y +CONFIG_DVB_USB_FRIIO=y +CONFIG_DVB_USB_AZ6027=y +CONFIG_DVB_USB_TECHNISAT_USB2=y +CONFIG_DVB_USB_V2=y +CONFIG_DVB_USB_AF9015=y +CONFIG_DVB_USB_AF9035=y +CONFIG_DVB_USB_ANYSEE=y +CONFIG_DVB_USB_AU6610=y +CONFIG_DVB_USB_AZ6007=y +CONFIG_DVB_USB_CE6230=y +CONFIG_DVB_USB_EC168=y +CONFIG_DVB_USB_GL861=y +CONFIG_DVB_USB_LME2510=y +CONFIG_DVB_USB_MXL111SF=y +CONFIG_DVB_USB_RTL28XXU=y +CONFIG_DVB_USB_DVBSKY=y +CONFIG_DVB_USB_ZD1301=y +CONFIG_DVB_TTUSB_BUDGET=y +CONFIG_DVB_TTUSB_DEC=y +CONFIG_SMS_USB_DRV=y +CONFIG_DVB_B2C2_FLEXCOP_USB=y +CONFIG_DVB_B2C2_FLEXCOP_USB_DEBUG=y +CONFIG_DVB_AS102=y + +# +# Webcam, TV (analog/digital) USB devices +# +CONFIG_VIDEO_EM28XX=y +CONFIG_VIDEO_EM28XX_V4L2=y +CONFIG_VIDEO_EM28XX_ALSA=y +CONFIG_VIDEO_EM28XX_DVB=y +CONFIG_VIDEO_EM28XX_RC=y + +# +# Software defined radio USB devices +# +CONFIG_USB_AIRSPY=y +CONFIG_USB_HACKRF=y +CONFIG_USB_MSI2500=y + +# +# USB HDMI CEC adapters +# +CONFIG_USB_PULSE8_CEC=y +CONFIG_USB_RAINSHADOW_CEC=y +CONFIG_MEDIA_PCI_SUPPORT=y + +# +# Media capture support +# +CONFIG_VIDEO_MEYE=y +CONFIG_VIDEO_SOLO6X10=y +CONFIG_VIDEO_TW5864=y +CONFIG_VIDEO_TW68=y +CONFIG_VIDEO_TW686X=y +CONFIG_VIDEO_ZORAN=y +CONFIG_VIDEO_ZORAN_DC30=y +CONFIG_VIDEO_ZORAN_ZR36060=y +CONFIG_VIDEO_ZORAN_BUZ=y +CONFIG_VIDEO_ZORAN_DC10=y +CONFIG_VIDEO_ZORAN_LML33=y +CONFIG_VIDEO_ZORAN_LML33R10=y +CONFIG_VIDEO_ZORAN_AVS6EYES=y + +# +# Media capture/analog TV support +# +CONFIG_VIDEO_IVTV=y +CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS=y +CONFIG_VIDEO_IVTV_ALSA=y +CONFIG_VIDEO_FB_IVTV=y +CONFIG_VIDEO_HEXIUM_GEMINI=y +CONFIG_VIDEO_HEXIUM_ORION=y +CONFIG_VIDEO_MXB=y +CONFIG_VIDEO_DT3155=y + +# +# Media capture/analog/hybrid TV support +# +CONFIG_VIDEO_CX18=y +CONFIG_VIDEO_CX18_ALSA=y +CONFIG_VIDEO_CX23885=y +CONFIG_MEDIA_ALTERA_CI=y +CONFIG_VIDEO_CX25821=y +CONFIG_VIDEO_CX25821_ALSA=y +CONFIG_VIDEO_CX88=y +CONFIG_VIDEO_CX88_ALSA=y +CONFIG_VIDEO_CX88_BLACKBIRD=y +CONFIG_VIDEO_CX88_DVB=y +CONFIG_VIDEO_CX88_ENABLE_VP3054=y +CONFIG_VIDEO_CX88_VP3054=y +CONFIG_VIDEO_CX88_MPEG=y +CONFIG_VIDEO_BT848=y +CONFIG_DVB_BT8XX=y +CONFIG_VIDEO_SAA7134=y +CONFIG_VIDEO_SAA7134_ALSA=y +CONFIG_VIDEO_SAA7134_RC=y +CONFIG_VIDEO_SAA7134_DVB=y +CONFIG_VIDEO_SAA7134_GO7007=y +CONFIG_VIDEO_SAA7164=y +CONFIG_VIDEO_COBALT=y + +# +# Media digital TV PCI Adapters +# +CONFIG_DVB_AV7110_IR=y +CONFIG_DVB_AV7110=y +CONFIG_DVB_AV7110_OSD=y +CONFIG_DVB_BUDGET_CORE=y +CONFIG_DVB_BUDGET=y +CONFIG_DVB_BUDGET_CI=y +CONFIG_DVB_BUDGET_AV=y +CONFIG_DVB_BUDGET_PATCH=y +CONFIG_DVB_B2C2_FLEXCOP_PCI=y +CONFIG_DVB_B2C2_FLEXCOP_PCI_DEBUG=y +CONFIG_DVB_PLUTO2=y +CONFIG_DVB_DM1105=y +CONFIG_DVB_PT1=y +CONFIG_DVB_PT3=y +CONFIG_MANTIS_CORE=y +CONFIG_DVB_MANTIS=y +CONFIG_DVB_HOPPER=y +CONFIG_DVB_NGENE=y +CONFIG_DVB_DDBRIDGE=y +CONFIG_DVB_DDBRIDGE_MSIENABLE=y +CONFIG_DVB_SMIPCIE=y +CONFIG_DVB_NETUP_UNIDVB=y +CONFIG_VIDEO_IPU3_CIO2=y +CONFIG_V4L_PLATFORM_DRIVERS=y +CONFIG_VIDEO_CAFE_CCIC=y +CONFIG_VIDEO_VIA_CAMERA=y +CONFIG_VIDEO_DAVINCI_VPIF_DISPLAY=y +CONFIG_VIDEO_DAVINCI_VPIF_CAPTURE=y +CONFIG_VIDEO_DM6446_CCDC=y +CONFIG_VIDEO_DM355_CCDC=y +CONFIG_VIDEO_SH_VOU=y +CONFIG_VIDEO_M32R_AR=y +CONFIG_VIDEO_MUX=y +CONFIG_VIDEO_PXA27x=y +CONFIG_VIDEO_QCOM_CAMSS=y +CONFIG_VIDEO_S3C_CAMIF=y +CONFIG_VIDEO_STM32_DCMI=y +CONFIG_SOC_CAMERA=y +CONFIG_SOC_CAMERA_SCALE_CROP=y +CONFIG_SOC_CAMERA_PLATFORM=y +CONFIG_VIDEO_SH_MOBILE_CEU=y +CONFIG_VIDEO_SAMSUNG_EXYNOS4_IS=y +CONFIG_VIDEO_EXYNOS4_IS_COMMON=y +CONFIG_VIDEO_S5P_FIMC=y +CONFIG_VIDEO_S5P_MIPI_CSIS=y +CONFIG_VIDEO_EXYNOS4_FIMC_IS=y +CONFIG_VIDEO_EXYNOS4_ISP_DMA_CAPTURE=y +CONFIG_VIDEO_AM437X_VPFE=y +CONFIG_VIDEO_XILINX=y +CONFIG_VIDEO_XILINX_TPG=y +CONFIG_VIDEO_XILINX_VTC=y +CONFIG_VIDEO_RCAR_VIN=y +CONFIG_VIDEO_ATMEL_ISC=y +CONFIG_VIDEO_ATMEL_ISI=y +CONFIG_VIDEO_TI_CAL=y +CONFIG_V4L_MEM2MEM_DRIVERS=y +CONFIG_VIDEO_CODA=y +CONFIG_VIDEO_IMX_VDOA=y +CONFIG_VIDEO_MEDIATEK_JPEG=y +CONFIG_VIDEO_MEDIATEK_VPU=y +CONFIG_VIDEO_MEDIATEK_MDP=y +CONFIG_VIDEO_MEDIATEK_VCODEC=y +CONFIG_VIDEO_MEM2MEM_DEINTERLACE=y +CONFIG_VIDEO_SAMSUNG_S5P_G2D=y +CONFIG_VIDEO_SAMSUNG_S5P_JPEG=y +CONFIG_VIDEO_SAMSUNG_S5P_MFC=y +CONFIG_VIDEO_MX2_EMMAPRP=y +CONFIG_VIDEO_SAMSUNG_EXYNOS_GSC=y +CONFIG_VIDEO_STI_BDISP=y +CONFIG_VIDEO_STI_HVA=y +CONFIG_VIDEO_STI_HVA_DEBUGFS=y +CONFIG_VIDEO_STI_DELTA=y +CONFIG_VIDEO_STI_DELTA_MJPEG=y +CONFIG_VIDEO_STI_DELTA_DRIVER=y +CONFIG_VIDEO_SH_VEU=y +CONFIG_VIDEO_RENESAS_FDP1=y +CONFIG_VIDEO_RENESAS_JPU=y +CONFIG_VIDEO_RENESAS_FCP=y +CONFIG_VIDEO_RENESAS_VSP1=y +CONFIG_VIDEO_ROCKCHIP_RGA=y +CONFIG_VIDEO_TI_VPE=y +CONFIG_VIDEO_TI_VPE_DEBUG=y +CONFIG_VIDEO_QCOM_VENUS=y +CONFIG_VIDEO_TI_VPDMA=y +CONFIG_VIDEO_TI_SC=y +CONFIG_VIDEO_TI_CSC=y +CONFIG_V4L_TEST_DRIVERS=y +CONFIG_VIDEO_VIMC=y +CONFIG_VIDEO_VIVID=y +CONFIG_VIDEO_VIVID_CEC=y +CONFIG_VIDEO_VIVID_MAX_DEVS=64 +CONFIG_VIDEO_VIM2M=y +CONFIG_DVB_PLATFORM_DRIVERS=y +CONFIG_DVB_C8SECTPFE=y +CONFIG_CEC_PLATFORM_DRIVERS=y +CONFIG_VIDEO_MESON_AO_CEC=y +CONFIG_VIDEO_SAMSUNG_S5P_CEC=y +CONFIG_VIDEO_STI_HDMI_CEC=y +CONFIG_VIDEO_STM32_HDMI_CEC=y +CONFIG_VIDEO_TEGRA_HDMI_CEC=y +CONFIG_SDR_PLATFORM_DRIVERS=y +CONFIG_VIDEO_RCAR_DRIF=y + +# +# Supported MMC/SDIO adapters +# +CONFIG_SMS_SDIO_DRV=y +CONFIG_RADIO_ADAPTERS=y +CONFIG_RADIO_TEA575X=y +CONFIG_RADIO_SI470X=y +CONFIG_USB_SI470X=y +CONFIG_RADIO_SI4713=y +CONFIG_USB_SI4713=y +CONFIG_PLATFORM_SI4713=y +CONFIG_I2C_SI4713=y +CONFIG_RADIO_SI476X=y +CONFIG_USB_MR800=y +CONFIG_USB_DSBR=y +CONFIG_RADIO_MAXIRADIO=y +CONFIG_RADIO_SHARK=y +CONFIG_RADIO_SHARK2=y +CONFIG_USB_KEENE=y +CONFIG_USB_RAREMONO=y +CONFIG_USB_MA901=y +CONFIG_RADIO_TEA5764=y +CONFIG_RADIO_TEA5764_XTAL=y +CONFIG_RADIO_SAA7706H=y +CONFIG_RADIO_TEF6862=y +CONFIG_RADIO_TIMBERDALE=y +CONFIG_RADIO_WL1273=y + +# +# Texas Instruments WL128x FM driver (ST based) +# +CONFIG_RADIO_WL128X=y + +# +# Supported FireWire (IEEE 1394) Adapters +# +CONFIG_DVB_FIREDTV=y +CONFIG_DVB_FIREDTV_INPUT=y +CONFIG_MEDIA_COMMON_OPTIONS=y + +# +# common driver options +# +CONFIG_VIDEO_CX2341X=y +CONFIG_VIDEO_TVEEPROM=y +CONFIG_CYPRESS_FIRMWARE=y +CONFIG_VIDEOBUF2_CORE=y +CONFIG_VIDEOBUF2_V4L2=y +CONFIG_VIDEOBUF2_MEMOPS=y +CONFIG_VIDEOBUF2_DMA_CONTIG=y +CONFIG_VIDEOBUF2_VMALLOC=y +CONFIG_VIDEOBUF2_DMA_SG=y +CONFIG_VIDEOBUF2_DVB=y +CONFIG_DVB_B2C2_FLEXCOP=y +CONFIG_DVB_B2C2_FLEXCOP_DEBUG=y +CONFIG_VIDEO_SAA7146=y +CONFIG_VIDEO_SAA7146_VV=y +CONFIG_SMS_SIANO_MDTV=y +CONFIG_SMS_SIANO_RC=y +CONFIG_SMS_SIANO_DEBUGFS=y +CONFIG_VIDEO_V4L2_TPG=y + +# +# Media ancillary drivers (tuners, sensors, i2c, spi, frontends) +# +CONFIG_MEDIA_SUBDRV_AUTOSELECT=y +CONFIG_MEDIA_ATTACH=y +CONFIG_VIDEO_IR_I2C=y + +# +# I2C Encoders, decoders, sensors and other helper chips +# + +# +# Audio decoders, processors and mixers +# +CONFIG_VIDEO_TVAUDIO=y +CONFIG_VIDEO_TDA7432=y +CONFIG_VIDEO_TDA9840=y +CONFIG_VIDEO_TEA6415C=y +CONFIG_VIDEO_TEA6420=y +CONFIG_VIDEO_MSP3400=y +CONFIG_VIDEO_CS3308=y +CONFIG_VIDEO_CS5345=y +CONFIG_VIDEO_CS53L32A=y +CONFIG_VIDEO_TLV320AIC23B=y +CONFIG_VIDEO_UDA1342=y +CONFIG_VIDEO_WM8775=y +CONFIG_VIDEO_WM8739=y +CONFIG_VIDEO_VP27SMPX=y +CONFIG_VIDEO_SONY_BTF_MPX=y + +# +# RDS decoders +# +CONFIG_VIDEO_SAA6588=y + +# +# Video decoders +# +CONFIG_VIDEO_ADV7180=y +CONFIG_VIDEO_ADV7183=y +CONFIG_VIDEO_ADV748X=y +CONFIG_VIDEO_ADV7604=y +CONFIG_VIDEO_ADV7604_CEC=y +CONFIG_VIDEO_ADV7842=y +CONFIG_VIDEO_ADV7842_CEC=y +CONFIG_VIDEO_BT819=y +CONFIG_VIDEO_BT856=y +CONFIG_VIDEO_BT866=y +CONFIG_VIDEO_KS0127=y +CONFIG_VIDEO_ML86V7667=y +CONFIG_VIDEO_AD5820=y +CONFIG_VIDEO_DW9714=y +CONFIG_VIDEO_SAA7110=y +CONFIG_VIDEO_SAA711X=y +CONFIG_VIDEO_TC358743=y +CONFIG_VIDEO_TC358743_CEC=y +CONFIG_VIDEO_TVP514X=y +CONFIG_VIDEO_TVP5150=y +CONFIG_VIDEO_TVP7002=y +CONFIG_VIDEO_TW2804=y +CONFIG_VIDEO_TW9903=y +CONFIG_VIDEO_TW9906=y +CONFIG_VIDEO_VPX3220=y + +# +# Video and audio decoders +# +CONFIG_VIDEO_SAA717X=y +CONFIG_VIDEO_CX25840=y + +# +# Video encoders +# +CONFIG_VIDEO_SAA7127=y +CONFIG_VIDEO_SAA7185=y +CONFIG_VIDEO_ADV7170=y +CONFIG_VIDEO_ADV7175=y +CONFIG_VIDEO_ADV7343=y +CONFIG_VIDEO_ADV7393=y +CONFIG_VIDEO_ADV7511=y +CONFIG_VIDEO_ADV7511_CEC=y +CONFIG_VIDEO_AD9389B=y +CONFIG_VIDEO_AK881X=y +CONFIG_VIDEO_THS8200=y + +# +# Camera sensor devices +# +CONFIG_VIDEO_APTINA_PLL=y +CONFIG_VIDEO_SMIAPP_PLL=y +CONFIG_VIDEO_IMX274=y +CONFIG_VIDEO_OV2640=y +CONFIG_VIDEO_OV2659=y +CONFIG_VIDEO_OV5640=y +CONFIG_VIDEO_OV5645=y +CONFIG_VIDEO_OV5647=y +CONFIG_VIDEO_OV6650=y +CONFIG_VIDEO_OV5670=y +CONFIG_VIDEO_OV7640=y +CONFIG_VIDEO_OV7670=y +CONFIG_VIDEO_OV7740=y +CONFIG_VIDEO_OV9650=y +CONFIG_VIDEO_OV13858=y +CONFIG_VIDEO_VS6624=y +CONFIG_VIDEO_MT9M032=y +CONFIG_VIDEO_MT9M111=y +CONFIG_VIDEO_MT9P031=y +CONFIG_VIDEO_MT9T001=y +CONFIG_VIDEO_MT9V011=y +CONFIG_VIDEO_MT9V032=y +CONFIG_VIDEO_SR030PC30=y +CONFIG_VIDEO_NOON010PC30=y +CONFIG_VIDEO_M5MOLS=y +CONFIG_VIDEO_S5K6AA=y +CONFIG_VIDEO_S5K6A3=y +CONFIG_VIDEO_S5K4ECGX=y +CONFIG_VIDEO_S5K5BAF=y +CONFIG_VIDEO_SMIAPP=y +CONFIG_VIDEO_ET8EK8=y +CONFIG_VIDEO_S5C73M3=y + +# +# Flash devices +# +CONFIG_VIDEO_ADP1653=y +CONFIG_VIDEO_LM3560=y +CONFIG_VIDEO_LM3646=y + +# +# Video improvement chips +# +CONFIG_VIDEO_UPD64031A=y +CONFIG_VIDEO_UPD64083=y + +# +# Audio/Video compression chips +# +CONFIG_VIDEO_SAA6752HS=y + +# +# SDR tuner chips +# +CONFIG_SDR_MAX2175=y + +# +# Miscellaneous helper chips +# +CONFIG_VIDEO_THS7303=y +CONFIG_VIDEO_M52790=y + +# +# Sensors used on soc_camera driver +# + +# +# soc_camera sensor drivers +# +CONFIG_SOC_CAMERA_IMX074=y +CONFIG_SOC_CAMERA_MT9M001=y +CONFIG_SOC_CAMERA_MT9M111=y +CONFIG_SOC_CAMERA_MT9T031=y +CONFIG_SOC_CAMERA_MT9T112=y +CONFIG_SOC_CAMERA_MT9V022=y +CONFIG_SOC_CAMERA_OV5642=y +CONFIG_SOC_CAMERA_OV772X=y +CONFIG_SOC_CAMERA_OV9640=y +CONFIG_SOC_CAMERA_OV9740=y +CONFIG_SOC_CAMERA_RJ54N1=y +CONFIG_SOC_CAMERA_TW9910=y + +# +# SPI helper chips +# +CONFIG_VIDEO_GS1662=y +CONFIG_MEDIA_TUNER=y + +# +# Customize TV tuners +# +CONFIG_MEDIA_TUNER_SIMPLE=y +CONFIG_MEDIA_TUNER_TDA18250=y +CONFIG_MEDIA_TUNER_TDA8290=y +CONFIG_MEDIA_TUNER_TDA827X=y +CONFIG_MEDIA_TUNER_TDA18271=y +CONFIG_MEDIA_TUNER_TDA9887=y +CONFIG_MEDIA_TUNER_TEA5761=y +CONFIG_MEDIA_TUNER_TEA5767=y +CONFIG_MEDIA_TUNER_MSI001=y +CONFIG_MEDIA_TUNER_MT20XX=y +CONFIG_MEDIA_TUNER_MT2060=y +CONFIG_MEDIA_TUNER_MT2063=y +CONFIG_MEDIA_TUNER_MT2266=y +CONFIG_MEDIA_TUNER_MT2131=y +CONFIG_MEDIA_TUNER_QT1010=y +CONFIG_MEDIA_TUNER_XC2028=y +CONFIG_MEDIA_TUNER_XC5000=y +CONFIG_MEDIA_TUNER_XC4000=y +CONFIG_MEDIA_TUNER_MXL5005S=y +CONFIG_MEDIA_TUNER_MXL5007T=y +CONFIG_MEDIA_TUNER_MC44S803=y +CONFIG_MEDIA_TUNER_MAX2165=y +CONFIG_MEDIA_TUNER_TDA18218=y +CONFIG_MEDIA_TUNER_FC0011=y +CONFIG_MEDIA_TUNER_FC0012=y +CONFIG_MEDIA_TUNER_FC0013=y +CONFIG_MEDIA_TUNER_TDA18212=y +CONFIG_MEDIA_TUNER_E4000=y +CONFIG_MEDIA_TUNER_FC2580=y +CONFIG_MEDIA_TUNER_M88RS6000T=y +CONFIG_MEDIA_TUNER_TUA9001=y +CONFIG_MEDIA_TUNER_SI2157=y +CONFIG_MEDIA_TUNER_IT913X=y +CONFIG_MEDIA_TUNER_R820T=y +CONFIG_MEDIA_TUNER_MXL301RF=y +CONFIG_MEDIA_TUNER_QM1D1C0042=y + +# +# Customise DVB Frontends +# + +# +# Multistandard (satellite) frontends +# +CONFIG_DVB_STB0899=y +CONFIG_DVB_STB6100=y +CONFIG_DVB_STV090x=y +CONFIG_DVB_STV0910=y +CONFIG_DVB_STV6110x=y +CONFIG_DVB_STV6111=y +CONFIG_DVB_MXL5XX=y +CONFIG_DVB_M88DS3103=y + +# +# Multistandard (cable + terrestrial) frontends +# +CONFIG_DVB_DRXK=y +CONFIG_DVB_TDA18271C2DD=y +CONFIG_DVB_SI2165=y +CONFIG_DVB_MN88472=y +CONFIG_DVB_MN88473=y + +# +# DVB-S (satellite) frontends +# +CONFIG_DVB_CX24110=y +CONFIG_DVB_CX24123=y +CONFIG_DVB_MT312=y +CONFIG_DVB_ZL10036=y +CONFIG_DVB_ZL10039=y +CONFIG_DVB_S5H1420=y +CONFIG_DVB_STV0288=y +CONFIG_DVB_STB6000=y +CONFIG_DVB_STV0299=y +CONFIG_DVB_STV6110=y +CONFIG_DVB_STV0900=y +CONFIG_DVB_TDA8083=y +CONFIG_DVB_TDA10086=y +CONFIG_DVB_TDA8261=y +CONFIG_DVB_VES1X93=y +CONFIG_DVB_TUNER_ITD1000=y +CONFIG_DVB_TUNER_CX24113=y +CONFIG_DVB_TDA826X=y +CONFIG_DVB_TUA6100=y +CONFIG_DVB_CX24116=y +CONFIG_DVB_CX24117=y +CONFIG_DVB_CX24120=y +CONFIG_DVB_SI21XX=y +CONFIG_DVB_TS2020=y +CONFIG_DVB_DS3000=y +CONFIG_DVB_MB86A16=y +CONFIG_DVB_TDA10071=y + +# +# DVB-T (terrestrial) frontends +# +CONFIG_DVB_SP8870=y +CONFIG_DVB_SP887X=y +CONFIG_DVB_CX22700=y +CONFIG_DVB_CX22702=y +CONFIG_DVB_S5H1432=y +CONFIG_DVB_DRXD=y +CONFIG_DVB_L64781=y +CONFIG_DVB_TDA1004X=y +CONFIG_DVB_NXT6000=y +CONFIG_DVB_MT352=y +CONFIG_DVB_ZL10353=y +CONFIG_DVB_DIB3000MB=y +CONFIG_DVB_DIB3000MC=y +CONFIG_DVB_DIB7000M=y +CONFIG_DVB_DIB7000P=y +CONFIG_DVB_DIB9000=y +CONFIG_DVB_TDA10048=y +CONFIG_DVB_AF9013=y +CONFIG_DVB_EC100=y +CONFIG_DVB_STV0367=y +CONFIG_DVB_CXD2820R=y +CONFIG_DVB_CXD2841ER=y +CONFIG_DVB_RTL2830=y +CONFIG_DVB_RTL2832=y +CONFIG_DVB_RTL2832_SDR=y +CONFIG_DVB_SI2168=y +CONFIG_DVB_AS102_FE=y +CONFIG_DVB_ZD1301_DEMOD=y +CONFIG_DVB_GP8PSK_FE=y + +# +# DVB-C (cable) frontends +# +CONFIG_DVB_VES1820=y +CONFIG_DVB_TDA10021=y +CONFIG_DVB_TDA10023=y +CONFIG_DVB_STV0297=y + +# +# ATSC (North American/Korean Terrestrial/Cable DTV) frontends +# +CONFIG_DVB_NXT200X=y +CONFIG_DVB_OR51211=y +CONFIG_DVB_OR51132=y +CONFIG_DVB_BCM3510=y +CONFIG_DVB_LGDT330X=y +CONFIG_DVB_LGDT3305=y +CONFIG_DVB_LGDT3306A=y +CONFIG_DVB_LG2160=y +CONFIG_DVB_S5H1409=y +CONFIG_DVB_AU8522=y +CONFIG_DVB_AU8522_DTV=y +CONFIG_DVB_AU8522_V4L=y +CONFIG_DVB_S5H1411=y + +# +# ISDB-T (terrestrial) frontends +# +CONFIG_DVB_S921=y +CONFIG_DVB_DIB8000=y +CONFIG_DVB_MB86A20S=y + +# +# ISDB-S (satellite) & ISDB-T (terrestrial) frontends +# +CONFIG_DVB_TC90522=y + +# +# Digital terrestrial only tuners/PLL +# +CONFIG_DVB_PLL=y +CONFIG_DVB_TUNER_DIB0070=y +CONFIG_DVB_TUNER_DIB0090=y + +# +# SEC control devices for DVB-S +# +CONFIG_DVB_DRX39XYJ=y +CONFIG_DVB_LNBH25=y +CONFIG_DVB_LNBP21=y +CONFIG_DVB_LNBP22=y +CONFIG_DVB_ISL6405=y +CONFIG_DVB_ISL6421=y +CONFIG_DVB_ISL6423=y +CONFIG_DVB_A8293=y +CONFIG_DVB_SP2=y +CONFIG_DVB_LGS8GL5=y +CONFIG_DVB_LGS8GXX=y +CONFIG_DVB_ATBM8830=y +CONFIG_DVB_TDA665x=y +CONFIG_DVB_IX2505V=y +CONFIG_DVB_M88RS2000=y +CONFIG_DVB_AF9033=y +CONFIG_DVB_HORUS3A=y +CONFIG_DVB_ASCOT2E=y +CONFIG_DVB_HELENE=y + +# +# Tools to develop new frontends +# +CONFIG_DVB_DUMMY_FE=y + +# +# Graphics support +# +CONFIG_AGP=y +CONFIG_AGP_AMD64=y +CONFIG_AGP_INTEL=y +CONFIG_AGP_SIS=y +CONFIG_AGP_VIA=y +CONFIG_INTEL_GTT=y +CONFIG_VGA_ARB=y +CONFIG_VGA_ARB_MAX_GPUS=16 +CONFIG_VGA_SWITCHEROO=y +CONFIG_IMX_IPUV3_CORE=y +CONFIG_DRM=y +CONFIG_DRM_MIPI_DSI=y +CONFIG_DRM_DP_AUX_CHARDEV=y +CONFIG_DRM_DEBUG_MM=y +CONFIG_DRM_DEBUG_MM_SELFTEST=y +CONFIG_DRM_KMS_HELPER=y +CONFIG_DRM_KMS_FB_HELPER=y +CONFIG_DRM_FBDEV_EMULATION=y +CONFIG_DRM_FBDEV_OVERALLOC=100 +CONFIG_DRM_LOAD_EDID_FIRMWARE=y +CONFIG_DRM_TTM=y +CONFIG_DRM_GEM_CMA_HELPER=y +CONFIG_DRM_KMS_CMA_HELPER=y +CONFIG_DRM_VM=y +CONFIG_DRM_SCHED=y + +# +# I2C encoder or helper chips +# +CONFIG_DRM_I2C_CH7006=y +CONFIG_DRM_I2C_SIL164=y +CONFIG_DRM_I2C_NXP_TDA998X=y +CONFIG_DRM_RADEON=y +CONFIG_DRM_RADEON_USERPTR=y +CONFIG_DRM_AMDGPU=y +CONFIG_DRM_AMDGPU_SI=y +CONFIG_DRM_AMDGPU_CIK=y +CONFIG_DRM_AMDGPU_USERPTR=y +CONFIG_DRM_AMDGPU_GART_DEBUGFS=y + +# +# ACP (Audio CoProcessor) Configuration +# +CONFIG_DRM_AMD_ACP=y + +# +# Display Engine Configuration +# +CONFIG_DRM_AMD_DC=y +CONFIG_DRM_AMD_DC_PRE_VEGA=y +CONFIG_DRM_AMD_DC_FBC=y +# CONFIG_DRM_AMD_DC_DCN1_0 is not set +CONFIG_DEBUG_KERNEL_DC=y + +# +# AMD Library routines +# +CONFIG_CHASH=y +CONFIG_CHASH_STATS=y +CONFIG_CHASH_SELFTEST=y +CONFIG_DRM_NOUVEAU=y +CONFIG_NOUVEAU_DEBUG=5 +CONFIG_NOUVEAU_DEBUG_DEFAULT=3 +CONFIG_NOUVEAU_DEBUG_MMU=y +CONFIG_DRM_NOUVEAU_BACKLIGHT=y +CONFIG_DRM_I915=y +CONFIG_DRM_I915_ALPHA_SUPPORT=y +CONFIG_DRM_I915_CAPTURE_ERROR=y +CONFIG_DRM_I915_COMPRESS_ERROR=y +CONFIG_DRM_I915_USERPTR=y +CONFIG_DRM_I915_GVT=y +CONFIG_DRM_I915_GVT_KVMGT=y + +# +# drm/i915 Debugging +# +CONFIG_DRM_I915_DEBUG=y +CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS=y +CONFIG_DRM_I915_SW_FENCE_CHECK_DAG=y +CONFIG_DRM_I915_SELFTEST=y +CONFIG_DRM_I915_LOW_LEVEL_TRACEPOINTS=y +CONFIG_DRM_I915_DEBUG_VBLANK_EVADE=y +CONFIG_DRM_VGEM=y +CONFIG_DRM_VMWGFX=y +CONFIG_DRM_VMWGFX_FBCON=y +CONFIG_DRM_GMA500=y +CONFIG_DRM_GMA600=y +CONFIG_DRM_GMA3600=y +CONFIG_DRM_MEDFIELD=y +CONFIG_DRM_UDL=y +CONFIG_DRM_AST=y +CONFIG_DRM_MGAG200=y +CONFIG_DRM_CIRRUS_QEMU=y +CONFIG_DRM_RCAR_DW_HDMI=y +CONFIG_DRM_QXL=y +CONFIG_DRM_BOCHS=y +CONFIG_DRM_VIRTIO_GPU=y +CONFIG_DRM_PANEL=y + +# +# Display Panels +# +CONFIG_DRM_PANEL_LVDS=y +CONFIG_DRM_PANEL_SIMPLE=y +CONFIG_DRM_PANEL_ILITEK_IL9322=y +CONFIG_DRM_PANEL_INNOLUX_P079ZCA=y +CONFIG_DRM_PANEL_JDI_LT070ME05000=y +CONFIG_DRM_PANEL_SAMSUNG_LD9040=y +CONFIG_DRM_PANEL_LG_LG4573=y +CONFIG_DRM_PANEL_ORISETECH_OTM8009A=y +CONFIG_DRM_PANEL_PANASONIC_VVX10F034N00=y +CONFIG_DRM_PANEL_RASPBERRYPI_TOUCHSCREEN=y +CONFIG_DRM_PANEL_SAMSUNG_S6E3HA2=y +CONFIG_DRM_PANEL_SAMSUNG_S6E63J0X03=y +CONFIG_DRM_PANEL_SAMSUNG_S6E8AA0=y +CONFIG_DRM_PANEL_SEIKO_43WVF1G=y +CONFIG_DRM_PANEL_SHARP_LQ101R1SX01=y +CONFIG_DRM_PANEL_SHARP_LS043T1LE01=y +CONFIG_DRM_PANEL_SITRONIX_ST7789V=y +CONFIG_DRM_BRIDGE=y +CONFIG_DRM_PANEL_BRIDGE=y + +# +# Display Interface Bridges +# +CONFIG_DRM_ANALOGIX_ANX78XX=y +CONFIG_DRM_DUMB_VGA_DAC=y +CONFIG_DRM_LVDS_ENCODER=y +CONFIG_DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW=y +CONFIG_DRM_NXP_PTN3460=y +CONFIG_DRM_PARADE_PS8622=y +CONFIG_DRM_SIL_SII8620=y +CONFIG_DRM_SII902X=y +CONFIG_DRM_SII9234=y +CONFIG_DRM_TOSHIBA_TC358767=y +CONFIG_DRM_TI_TFP410=y +CONFIG_DRM_I2C_ADV7511=y +CONFIG_DRM_I2C_ADV7511_AUDIO=y +CONFIG_DRM_I2C_ADV7533=y +CONFIG_DRM_I2C_ADV7511_CEC=y +CONFIG_DRM_DW_HDMI=y +CONFIG_DRM_DW_HDMI_AHB_AUDIO=y +CONFIG_DRM_DW_HDMI_I2S_AUDIO=y +CONFIG_DRM_DW_HDMI_CEC=y +CONFIG_HSA_AMD=y +CONFIG_DRM_VC4=y +CONFIG_DRM_VC4_HDMI_CEC=y +CONFIG_DRM_ARCPGU=y +CONFIG_DRM_HISI_HIBMC=y +CONFIG_DRM_MXS=y +CONFIG_DRM_MXSFB=y +CONFIG_DRM_TINYDRM=y +CONFIG_TINYDRM_MIPI_DBI=y +CONFIG_TINYDRM_ILI9225=y +CONFIG_TINYDRM_MI0283QT=y +CONFIG_TINYDRM_REPAPER=y +CONFIG_TINYDRM_ST7586=y +CONFIG_TINYDRM_ST7735R=y +CONFIG_DRM_PL111=y +CONFIG_DRM_TVE200=y +CONFIG_DRM_LEGACY=y +CONFIG_DRM_TDFX=y +CONFIG_DRM_R128=y +CONFIG_DRM_I810=y +CONFIG_DRM_MGA=y +CONFIG_DRM_SIS=y +CONFIG_DRM_VIA=y +CONFIG_DRM_SAVAGE=y +CONFIG_DRM_PANEL_ORIENTATION_QUIRKS=y +CONFIG_DRM_LIB_RANDOM=y + +# +# Frame buffer Devices +# +CONFIG_FB=y +CONFIG_FIRMWARE_EDID=y +CONFIG_FB_CMDLINE=y +CONFIG_FB_NOTIFY=y +CONFIG_FB_DDC=y +CONFIG_FB_BOOT_VESA_SUPPORT=y +CONFIG_FB_CFB_FILLRECT=y +CONFIG_FB_CFB_COPYAREA=y +CONFIG_FB_CFB_IMAGEBLIT=y +# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set +CONFIG_FB_SYS_FILLRECT=y +CONFIG_FB_SYS_COPYAREA=y +CONFIG_FB_SYS_IMAGEBLIT=y +# CONFIG_FB_PROVIDE_GET_FB_UNMAPPED_AREA is not set +CONFIG_FB_FOREIGN_ENDIAN=y +CONFIG_FB_BOTH_ENDIAN=y +# CONFIG_FB_BIG_ENDIAN is not set +# CONFIG_FB_LITTLE_ENDIAN is not set +CONFIG_FB_SYS_FOPS=y +CONFIG_FB_DEFERRED_IO=y +CONFIG_FB_HECUBA=y +CONFIG_FB_SVGALIB=y +# CONFIG_FB_MACMODES is not set +CONFIG_FB_BACKLIGHT=y +CONFIG_FB_MODE_HELPERS=y +CONFIG_FB_TILEBLITTING=y + +# +# Frame buffer hardware drivers +# +CONFIG_FB_CIRRUS=y +CONFIG_FB_PM2=y +CONFIG_FB_PM2_FIFO_DISCONNECT=y +CONFIG_FB_CLPS711X=y +CONFIG_FB_CYBER2000=y +CONFIG_FB_CYBER2000_DDC=y +CONFIG_FB_ARC=y +CONFIG_FB_ASILIANT=y +CONFIG_FB_IMSTT=y +CONFIG_FB_VGA16=y +CONFIG_FB_UVESA=y +CONFIG_FB_VESA=y +CONFIG_FB_EFI=y +CONFIG_FB_N411=y +CONFIG_FB_HGA=y +CONFIG_FB_OPENCORES=y +CONFIG_FB_S1D13XXX=y +CONFIG_FB_NVIDIA=y +CONFIG_FB_NVIDIA_I2C=y +CONFIG_FB_NVIDIA_DEBUG=y +CONFIG_FB_NVIDIA_BACKLIGHT=y +CONFIG_FB_RIVA=y +CONFIG_FB_RIVA_I2C=y +CONFIG_FB_RIVA_DEBUG=y +CONFIG_FB_RIVA_BACKLIGHT=y +CONFIG_FB_I740=y +CONFIG_FB_LE80578=y +CONFIG_FB_CARILLO_RANCH=y +CONFIG_FB_MATROX=y +CONFIG_FB_MATROX_MILLENIUM=y +CONFIG_FB_MATROX_MYSTIQUE=y +CONFIG_FB_MATROX_G=y +CONFIG_FB_MATROX_I2C=y +CONFIG_FB_MATROX_MAVEN=y +CONFIG_FB_RADEON=y +CONFIG_FB_RADEON_I2C=y +CONFIG_FB_RADEON_BACKLIGHT=y +CONFIG_FB_RADEON_DEBUG=y +CONFIG_FB_ATY128=y +CONFIG_FB_ATY128_BACKLIGHT=y +CONFIG_FB_ATY=y +CONFIG_FB_ATY_CT=y +CONFIG_FB_ATY_GENERIC_LCD=y +CONFIG_FB_ATY_GX=y +CONFIG_FB_ATY_BACKLIGHT=y +CONFIG_FB_S3=y +CONFIG_FB_S3_DDC=y +CONFIG_FB_SAVAGE=y +CONFIG_FB_SAVAGE_I2C=y +CONFIG_FB_SAVAGE_ACCEL=y +CONFIG_FB_SIS=y +CONFIG_FB_SIS_300=y +CONFIG_FB_SIS_315=y +CONFIG_FB_VIA=y +CONFIG_FB_VIA_DIRECT_PROCFS=y +CONFIG_FB_VIA_X_COMPATIBILITY=y +CONFIG_FB_NEOMAGIC=y +CONFIG_FB_KYRO=y +CONFIG_FB_3DFX=y +CONFIG_FB_3DFX_ACCEL=y +CONFIG_FB_3DFX_I2C=y +CONFIG_FB_VOODOO1=y +CONFIG_FB_VT8623=y +CONFIG_FB_TRIDENT=y +CONFIG_FB_ARK=y +CONFIG_FB_PM3=y +CONFIG_FB_CARMINE=y +CONFIG_FB_CARMINE_DRAM_EVAL=y +# CONFIG_CARMINE_DRAM_CUSTOM is not set +CONFIG_FB_GEODE=y +CONFIG_FB_GEODE_LX=y +CONFIG_FB_GEODE_GX=y +CONFIG_FB_GEODE_GX1=y +CONFIG_FB_TMIO=y +CONFIG_FB_TMIO_ACCELL=y +CONFIG_FB_SM501=y +CONFIG_FB_SMSCUFX=y +CONFIG_FB_UDL=y +CONFIG_FB_IBM_GXT4500=y +CONFIG_FB_GOLDFISH=y +CONFIG_FB_VIRTUAL=y +CONFIG_XEN_FBDEV_FRONTEND=y +CONFIG_FB_METRONOME=y +CONFIG_FB_MB862XX=y +CONFIG_FB_MB862XX_PCI_GDC=y +CONFIG_FB_MB862XX_I2C=y +CONFIG_FB_BROADSHEET=y +CONFIG_FB_AUO_K190X=y +CONFIG_FB_AUO_K1900=y +CONFIG_FB_AUO_K1901=y +CONFIG_FB_HYPERV=y +CONFIG_FB_SIMPLE=y +CONFIG_FB_SSD1307=y +CONFIG_FB_SM712=y +CONFIG_BACKLIGHT_LCD_SUPPORT=y +CONFIG_LCD_CLASS_DEVICE=y +CONFIG_LCD_L4F00242T03=y +CONFIG_LCD_LMS283GF05=y +CONFIG_LCD_LTV350QV=y +CONFIG_LCD_ILI922X=y +CONFIG_LCD_ILI9320=y +CONFIG_LCD_TDO24M=y +CONFIG_LCD_VGG2432A4=y +CONFIG_LCD_PLATFORM=y +CONFIG_LCD_S6E63M0=y +CONFIG_LCD_LD9040=y +CONFIG_LCD_AMS369FG06=y +CONFIG_LCD_LMS501KF03=y +CONFIG_LCD_HX8357=y +CONFIG_BACKLIGHT_CLASS_DEVICE=y +CONFIG_BACKLIGHT_GENERIC=y +CONFIG_BACKLIGHT_LM3533=y +CONFIG_BACKLIGHT_CARILLO_RANCH=y +CONFIG_BACKLIGHT_PWM=y +CONFIG_BACKLIGHT_DA903X=y +CONFIG_BACKLIGHT_DA9052=y +CONFIG_BACKLIGHT_MAX8925=y +CONFIG_BACKLIGHT_APPLE=y +CONFIG_BACKLIGHT_PM8941_WLED=y +CONFIG_BACKLIGHT_SAHARA=y +CONFIG_BACKLIGHT_WM831X=y +CONFIG_BACKLIGHT_ADP5520=y +CONFIG_BACKLIGHT_ADP8860=y +CONFIG_BACKLIGHT_ADP8870=y +CONFIG_BACKLIGHT_88PM860X=y +CONFIG_BACKLIGHT_PCF50633=y +CONFIG_BACKLIGHT_AAT2870=y +CONFIG_BACKLIGHT_LM3630A=y +CONFIG_BACKLIGHT_LM3639=y +CONFIG_BACKLIGHT_LP855X=y +CONFIG_BACKLIGHT_LP8788=y +CONFIG_BACKLIGHT_OT200=y +CONFIG_BACKLIGHT_PANDORA=y +CONFIG_BACKLIGHT_SKY81452=y +CONFIG_BACKLIGHT_TPS65217=y +CONFIG_BACKLIGHT_AS3711=y +CONFIG_BACKLIGHT_GPIO=y +CONFIG_BACKLIGHT_LV5207LP=y +CONFIG_BACKLIGHT_BD6107=y +CONFIG_BACKLIGHT_ARCXCNN=y +CONFIG_VGASTATE=y +CONFIG_VIDEOMODE_HELPERS=y +CONFIG_HDMI=y + +# +# Console display driver support +# +CONFIG_VGA_CONSOLE=y +CONFIG_VGACON_SOFT_SCROLLBACK=y +CONFIG_VGACON_SOFT_SCROLLBACK_SIZE=64 +CONFIG_VGACON_SOFT_SCROLLBACK_PERSISTENT_ENABLE_BY_DEFAULT=y +CONFIG_DUMMY_CONSOLE=y +CONFIG_DUMMY_CONSOLE_COLUMNS=80 +CONFIG_DUMMY_CONSOLE_ROWS=25 +CONFIG_FRAMEBUFFER_CONSOLE=y +CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y +CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y +CONFIG_LOGO=y +CONFIG_LOGO_LINUX_MONO=y +CONFIG_LOGO_LINUX_VGA16=y +CONFIG_LOGO_LINUX_CLUT224=y +CONFIG_SOUND=y +CONFIG_SOUND_OSS_CORE=y +CONFIG_SOUND_OSS_CORE_PRECLAIM=y +CONFIG_SND=y +CONFIG_SND_TIMER=y +CONFIG_SND_PCM=y +CONFIG_SND_PCM_ELD=y +CONFIG_SND_PCM_IEC958=y +CONFIG_SND_DMAENGINE_PCM=y +CONFIG_SND_HWDEP=y +CONFIG_SND_SEQ_DEVICE=y +CONFIG_SND_RAWMIDI=y +CONFIG_SND_COMPRESS_OFFLOAD=y +CONFIG_SND_JACK=y +CONFIG_SND_JACK_INPUT_DEV=y +CONFIG_SND_OSSEMUL=y +CONFIG_SND_MIXER_OSS=y +CONFIG_SND_PCM_OSS=y +CONFIG_SND_PCM_OSS_PLUGINS=y +CONFIG_SND_PCM_TIMER=y +CONFIG_SND_HRTIMER=y +CONFIG_SND_DYNAMIC_MINORS=y +CONFIG_SND_MAX_CARDS=32 +CONFIG_SND_SUPPORT_OLD_API=y +CONFIG_SND_PROC_FS=y +CONFIG_SND_VERBOSE_PROCFS=y +CONFIG_SND_VERBOSE_PRINTK=y +CONFIG_SND_DEBUG=y +CONFIG_SND_DEBUG_VERBOSE=y +CONFIG_SND_PCM_XRUN_DEBUG=y +CONFIG_SND_VMASTER=y +CONFIG_SND_DMA_SGBUF=y +CONFIG_SND_SEQUENCER=y +CONFIG_SND_SEQ_DUMMY=y +CONFIG_SND_SEQUENCER_OSS=y +CONFIG_SND_SEQ_HRTIMER_DEFAULT=y +CONFIG_SND_SEQ_MIDI_EVENT=y +CONFIG_SND_SEQ_MIDI=y +CONFIG_SND_SEQ_MIDI_EMUL=y +CONFIG_SND_SEQ_VIRMIDI=y +CONFIG_SND_MPU401_UART=y +CONFIG_SND_OPL3_LIB=y +CONFIG_SND_OPL3_LIB_SEQ=y +# CONFIG_SND_OPL4_LIB_SEQ is not set +CONFIG_SND_VX_LIB=y +CONFIG_SND_AC97_CODEC=y +CONFIG_SND_DRIVERS=y +CONFIG_SND_PCSP=y +CONFIG_SND_DUMMY=y +CONFIG_SND_ALOOP=y +CONFIG_SND_VIRMIDI=y +CONFIG_SND_MTPAV=y +CONFIG_SND_MTS64=y +CONFIG_SND_SERIAL_U16550=y +CONFIG_SND_MPU401=y +CONFIG_SND_PORTMAN2X4=y +CONFIG_SND_AC97_POWER_SAVE=y +CONFIG_SND_AC97_POWER_SAVE_DEFAULT=0 +CONFIG_SND_SB_COMMON=y +CONFIG_SND_SB16_DSP=y +CONFIG_SND_PCI=y +CONFIG_SND_AD1889=y +CONFIG_SND_ALS300=y +CONFIG_SND_ALS4000=y +CONFIG_SND_ALI5451=y +CONFIG_SND_ASIHPI=y +CONFIG_SND_ATIIXP=y +CONFIG_SND_ATIIXP_MODEM=y +CONFIG_SND_AU8810=y +CONFIG_SND_AU8820=y +CONFIG_SND_AU8830=y +CONFIG_SND_AW2=y +CONFIG_SND_AZT3328=y +CONFIG_SND_BT87X=y +CONFIG_SND_BT87X_OVERCLOCK=y +CONFIG_SND_CA0106=y +CONFIG_SND_CMIPCI=y +CONFIG_SND_OXYGEN_LIB=y +CONFIG_SND_OXYGEN=y +CONFIG_SND_CS4281=y +CONFIG_SND_CS46XX=y +CONFIG_SND_CS46XX_NEW_DSP=y +CONFIG_SND_CS5530=y +CONFIG_SND_CS5535AUDIO=y +CONFIG_SND_CTXFI=y +CONFIG_SND_DARLA20=y +CONFIG_SND_GINA20=y +CONFIG_SND_LAYLA20=y +CONFIG_SND_DARLA24=y +CONFIG_SND_GINA24=y +CONFIG_SND_LAYLA24=y +CONFIG_SND_MONA=y +CONFIG_SND_MIA=y +CONFIG_SND_ECHO3G=y +CONFIG_SND_INDIGO=y +CONFIG_SND_INDIGOIO=y +CONFIG_SND_INDIGODJ=y +CONFIG_SND_INDIGOIOX=y +CONFIG_SND_INDIGODJX=y +CONFIG_SND_EMU10K1=y +CONFIG_SND_EMU10K1_SEQ=y +CONFIG_SND_EMU10K1X=y +CONFIG_SND_ENS1370=y +CONFIG_SND_ENS1371=y +CONFIG_SND_ES1938=y +CONFIG_SND_ES1968=y +CONFIG_SND_ES1968_INPUT=y +CONFIG_SND_ES1968_RADIO=y +CONFIG_SND_FM801=y +CONFIG_SND_FM801_TEA575X_BOOL=y +CONFIG_SND_HDSP=y + +# +# Don't forget to add built-in firmwares for HDSP driver +# +CONFIG_SND_HDSPM=y +CONFIG_SND_ICE1712=y +CONFIG_SND_ICE1724=y +CONFIG_SND_INTEL8X0=y +CONFIG_SND_INTEL8X0M=y +CONFIG_SND_KORG1212=y +CONFIG_SND_LOLA=y +CONFIG_SND_LX6464ES=y +CONFIG_SND_MAESTRO3=y +CONFIG_SND_MAESTRO3_INPUT=y +CONFIG_SND_MIXART=y +CONFIG_SND_NM256=y +CONFIG_SND_PCXHR=y +CONFIG_SND_RIPTIDE=y +CONFIG_SND_RME32=y +CONFIG_SND_RME96=y +CONFIG_SND_RME9652=y +CONFIG_SND_SONICVIBES=y +CONFIG_SND_TRIDENT=y +CONFIG_SND_VIA82XX=y +CONFIG_SND_VIA82XX_MODEM=y +CONFIG_SND_VIRTUOSO=y +CONFIG_SND_VX222=y +CONFIG_SND_YMFPCI=y + +# +# HD-Audio +# +CONFIG_SND_HDA=y +CONFIG_SND_HDA_INTEL=y +CONFIG_SND_HDA_HWDEP=y +CONFIG_SND_HDA_RECONFIG=y +CONFIG_SND_HDA_INPUT_BEEP=y +CONFIG_SND_HDA_INPUT_BEEP_MODE=1 +CONFIG_SND_HDA_PATCH_LOADER=y +CONFIG_SND_HDA_CODEC_REALTEK=y +CONFIG_SND_HDA_CODEC_ANALOG=y +CONFIG_SND_HDA_CODEC_SIGMATEL=y +CONFIG_SND_HDA_CODEC_VIA=y +CONFIG_SND_HDA_CODEC_HDMI=y +CONFIG_SND_HDA_CODEC_CIRRUS=y +CONFIG_SND_HDA_CODEC_CONEXANT=y +CONFIG_SND_HDA_CODEC_CA0110=y +CONFIG_SND_HDA_CODEC_CA0132=y +CONFIG_SND_HDA_CODEC_CA0132_DSP=y +CONFIG_SND_HDA_CODEC_CMEDIA=y +CONFIG_SND_HDA_CODEC_SI3054=y +CONFIG_SND_HDA_GENERIC=y +CONFIG_SND_HDA_POWER_SAVE_DEFAULT=0 +CONFIG_SND_HDA_CORE=y +CONFIG_SND_HDA_DSP_LOADER=y +CONFIG_SND_HDA_I915=y +CONFIG_SND_HDA_EXT_CORE=y +CONFIG_SND_HDA_PREALLOC_SIZE=64 +CONFIG_SND_PXA2XX_LIB=y +CONFIG_SND_SPI=y +CONFIG_SND_AT73C213=y +CONFIG_SND_AT73C213_TARGET_BITRATE=48000 +CONFIG_SND_USB=y +CONFIG_SND_USB_AUDIO=y +CONFIG_SND_USB_UA101=y +CONFIG_SND_USB_USX2Y=y +CONFIG_SND_USB_CAIAQ=y +CONFIG_SND_USB_CAIAQ_INPUT=y +CONFIG_SND_USB_US122L=y +CONFIG_SND_USB_6FIRE=y +CONFIG_SND_USB_HIFACE=y +CONFIG_SND_BCD2000=y +CONFIG_SND_USB_LINE6=y +CONFIG_SND_USB_POD=y +CONFIG_SND_USB_PODHD=y +CONFIG_SND_USB_TONEPORT=y +CONFIG_SND_USB_VARIAX=y +CONFIG_SND_FIREWIRE=y +CONFIG_SND_FIREWIRE_LIB=y +CONFIG_SND_DICE=y +CONFIG_SND_OXFW=y +CONFIG_SND_ISIGHT=y +CONFIG_SND_FIREWORKS=y +CONFIG_SND_BEBOB=y +CONFIG_SND_FIREWIRE_DIGI00X=y +CONFIG_SND_FIREWIRE_TASCAM=y +CONFIG_SND_FIREWIRE_MOTU=y +CONFIG_SND_FIREFACE=y +CONFIG_SND_PCMCIA=y +CONFIG_SND_VXPOCKET=y +CONFIG_SND_PDAUDIOCF=y +CONFIG_SND_SOC=y +CONFIG_SND_SOC_AC97_BUS=y +CONFIG_SND_SOC_GENERIC_DMAENGINE_PCM=y +CONFIG_SND_SOC_COMPRESS=y +CONFIG_SND_SOC_TOPOLOGY=y +CONFIG_SND_SOC_ACPI=y +CONFIG_SND_SOC_ADI=y +CONFIG_SND_SOC_ADI_AXI_I2S=y +CONFIG_SND_SOC_ADI_AXI_SPDIF=y +CONFIG_SND_SOC_AMD_ACP=y +CONFIG_SND_SOC_AMD_CZ_RT5645_MACH=y +CONFIG_SND_ATMEL_SOC=y +CONFIG_SND_ATMEL_SOC_PDC=y +CONFIG_SND_ATMEL_SOC_SSC_PDC=y +CONFIG_SND_ATMEL_SOC_DMA=y +CONFIG_SND_ATMEL_SOC_SSC_DMA=y +CONFIG_SND_ATMEL_SOC_SSC=y +CONFIG_SND_AT91_SOC_SAM9G20_WM8731=y +CONFIG_SND_ATMEL_SOC_WM8904=y +CONFIG_SND_AT91_SOC_SAM9X5_WM8731=y +CONFIG_SND_ATMEL_SOC_CLASSD=y +CONFIG_SND_ATMEL_SOC_PDMIC=y +CONFIG_SND_BCM2835_SOC_I2S=y +CONFIG_SND_SOC_CYGNUS=y +CONFIG_SND_EP93XX_SOC=y +CONFIG_SND_EDMA_SOC=y +CONFIG_SND_DAVINCI_SOC_I2S=y +CONFIG_SND_DAVINCI_SOC_MCASP=y +CONFIG_SND_DESIGNWARE_I2S=y +CONFIG_SND_DESIGNWARE_PCM=y + +# +# SoC Audio for Freescale CPUs +# + +# +# Common SoC Audio options for Freescale CPUs: +# +CONFIG_SND_SOC_FSL_ASRC=y +CONFIG_SND_SOC_FSL_SAI=y +CONFIG_SND_SOC_FSL_SSI=y +CONFIG_SND_SOC_FSL_SPDIF=y +CONFIG_SND_SOC_FSL_ESAI=y +CONFIG_SND_SOC_IMX_PCM_DMA=y +CONFIG_SND_SOC_IMX_AUDMUX=y +CONFIG_SND_IMX_SOC=y + +# +# SoC Audio support for Freescale i.MX boards: +# +CONFIG_SND_SOC_IMX_WM8962=y +CONFIG_SND_SOC_IMX_ES8328=y +CONFIG_SND_SOC_IMX_SGTL5000=y +CONFIG_SND_SOC_IMX_SPDIF=y +CONFIG_SND_SOC_FSL_ASOC_CARD=y +CONFIG_SND_I2S_HI6210_I2S=y +CONFIG_SND_JZ4740_SOC=y +CONFIG_SND_JZ4740_SOC_I2S=y +CONFIG_SND_JZ4740_SOC_QI_LB60=y +CONFIG_SND_KIRKWOOD_SOC=y +CONFIG_SND_KIRKWOOD_SOC_ARMADA370_DB=y +CONFIG_SND_SOC_IMG=y +CONFIG_SND_SOC_IMG_I2S_IN=y +CONFIG_SND_SOC_IMG_I2S_OUT=y +CONFIG_SND_SOC_IMG_PARALLEL_OUT=y +CONFIG_SND_SOC_IMG_SPDIF_IN=y +CONFIG_SND_SOC_IMG_SPDIF_OUT=y +CONFIG_SND_SOC_IMG_PISTACHIO_INTERNAL_DAC=y +CONFIG_SND_SOC_INTEL_SST_TOPLEVEL=y +CONFIG_SND_SST_IPC=y +CONFIG_SND_SST_IPC_PCI=y +CONFIG_SND_SST_IPC_ACPI=y +CONFIG_SND_SOC_INTEL_SST_ACPI=y +CONFIG_SND_SOC_INTEL_SST=y +CONFIG_SND_SOC_INTEL_SST_FIRMWARE=y +CONFIG_SND_SOC_INTEL_HASWELL=y +CONFIG_SND_SOC_INTEL_BAYTRAIL=y +CONFIG_SND_SST_ATOM_HIFI2_PLATFORM_PCI=y +CONFIG_SND_SST_ATOM_HIFI2_PLATFORM=y +CONFIG_SND_SOC_INTEL_SKYLAKE_SSP_CLK=y +CONFIG_SND_SOC_INTEL_SKYLAKE=y +CONFIG_SND_SOC_ACPI_INTEL_MATCH=y +CONFIG_SND_SOC_INTEL_MACH=y +CONFIG_SND_SOC_INTEL_HASWELL_MACH=y +CONFIG_SND_SOC_INTEL_BDW_RT5677_MACH=y +CONFIG_SND_SOC_INTEL_BROADWELL_MACH=y +CONFIG_SND_SOC_INTEL_BYT_MAX98090_MACH=y +CONFIG_SND_SOC_INTEL_BYT_RT5640_MACH=y +CONFIG_SND_SOC_INTEL_BYTCR_RT5640_MACH=y +CONFIG_SND_SOC_INTEL_BYTCR_RT5651_MACH=y +CONFIG_SND_SOC_INTEL_CHT_BSW_RT5672_MACH=y +CONFIG_SND_SOC_INTEL_CHT_BSW_RT5645_MACH=y +CONFIG_SND_SOC_INTEL_CHT_BSW_MAX98090_TI_MACH=y +CONFIG_SND_SOC_INTEL_BYT_CHT_DA7213_MACH=y +CONFIG_SND_SOC_INTEL_BYT_CHT_ES8316_MACH=y +CONFIG_SND_SOC_INTEL_BYT_CHT_NOCODEC_MACH=y +CONFIG_SND_SOC_INTEL_SKL_RT286_MACH=y +CONFIG_SND_SOC_INTEL_SKL_NAU88L25_SSM4567_MACH=y +CONFIG_SND_SOC_INTEL_SKL_NAU88L25_MAX98357A_MACH=y +CONFIG_SND_SOC_INTEL_BXT_DA7219_MAX98357A_MACH=y +CONFIG_SND_SOC_INTEL_BXT_RT298_MACH=y +CONFIG_SND_SOC_INTEL_KBL_RT5663_MAX98927_MACH=y +CONFIG_SND_SOC_INTEL_KBL_RT5663_RT5514_MAX98927_MACH=y +CONFIG_SND_MXS_SOC=y +CONFIG_SND_SOC_MXS_SGTL5000=y +CONFIG_SND_PXA2XX_SOC=y +CONFIG_SND_SOC_QCOM=y +CONFIG_SND_SOC_LPASS_CPU=y +CONFIG_SND_SOC_LPASS_PLATFORM=y +CONFIG_SND_SOC_LPASS_IPQ806X=y +CONFIG_SND_SOC_LPASS_APQ8016=y +CONFIG_SND_SOC_STORM=y +CONFIG_SND_SOC_APQ8016_SBC=y +CONFIG_SND_SOC_ROCKCHIP=y +CONFIG_SND_SOC_ROCKCHIP_I2S=y +CONFIG_SND_SOC_ROCKCHIP_PDM=y +CONFIG_SND_SOC_ROCKCHIP_SPDIF=y +CONFIG_SND_SOC_ROCKCHIP_MAX98090=y +CONFIG_SND_SOC_ROCKCHIP_RT5645=y +CONFIG_SND_SOC_RK3288_HDMI_ANALOG=y +CONFIG_SND_SOC_RK3399_GRU_SOUND=y +CONFIG_SND_SOC_SAMSUNG=y +CONFIG_SND_SAMSUNG_PCM=y +CONFIG_SND_SAMSUNG_SPDIF=y +CONFIG_SND_SAMSUNG_I2S=y +CONFIG_SND_SOC_SAMSUNG_SMDK_WM8580=y +CONFIG_SND_SOC_SAMSUNG_SMDK_WM8994=y +CONFIG_SND_SOC_SMARTQ=y +CONFIG_SND_SOC_SAMSUNG_SMDK_SPDIF=y +CONFIG_SND_SOC_SMDK_WM8994_PCM=y +CONFIG_SND_SOC_SPEYSIDE=y +CONFIG_SND_SOC_TOBERMORY=y +CONFIG_SND_SOC_BELLS=y +CONFIG_SND_SOC_LOWLAND=y +CONFIG_SND_SOC_LITTLEMILL=y +CONFIG_SND_SOC_SNOW=y +CONFIG_SND_SOC_ODROID=y +CONFIG_SND_SOC_ARNDALE_RT5631_ALC5631=y +CONFIG_SND_SOC_SAMSUNG_TM2_WM5110=y + +# +# SoC Audio support for SuperH +# +CONFIG_SND_SOC_SH4_FSI=y +CONFIG_SND_SOC_RCAR=y +CONFIG_SND_SOC_SIRF=y +CONFIG_SND_SOC_SIRF_AUDIO=y +CONFIG_SND_SOC_SIRF_AUDIO_PORT=y +CONFIG_SND_SOC_SIRF_USP=y +CONFIG_SND_SOC_STI=y + +# +# STMicroelectronics STM32 SOC audio support +# +CONFIG_SND_SOC_STM32_SAI=y +CONFIG_SND_SOC_STM32_I2S=y +CONFIG_SND_SOC_STM32_SPDIFRX=y +CONFIG_SND_SOC_STM32_DFSDM=y + +# +# Allwinner SoC Audio support +# +CONFIG_SND_SUN4I_CODEC=y +CONFIG_SND_SUN8I_CODEC=y +CONFIG_SND_SUN8I_CODEC_ANALOG=y +CONFIG_SND_SUN4I_I2S=y +CONFIG_SND_SUN4I_SPDIF=y +CONFIG_SND_SOC_TEGRA=y +CONFIG_SND_SOC_TEGRA20_AC97=y +CONFIG_SND_SOC_TEGRA20_DAS=y +CONFIG_SND_SOC_TEGRA20_I2S=y +CONFIG_SND_SOC_TEGRA20_SPDIF=y +CONFIG_SND_SOC_TEGRA30_AHUB=y +CONFIG_SND_SOC_TEGRA30_I2S=y +CONFIG_SND_SOC_TEGRA_RT5640=y +CONFIG_SND_SOC_TEGRA_WM8753=y +CONFIG_SND_SOC_TEGRA_WM8903=y +CONFIG_SND_SOC_TEGRA_WM9712=y +CONFIG_SND_SOC_TEGRA_TRIMSLICE=y +CONFIG_SND_SOC_TEGRA_ALC5632=y +CONFIG_SND_SOC_TEGRA_MAX98090=y +CONFIG_SND_SOC_TEGRA_RT5677=y +CONFIG_SND_SOC_TEGRA_SGTL5000=y +CONFIG_SND_SOC_UNIPHIER=y +CONFIG_SND_SOC_UNIPHIER_EVEA_CODEC=y +CONFIG_SND_SOC_XTFPGA_I2S=y +CONFIG_ZX_SPDIF=y +CONFIG_ZX_I2S=y +CONFIG_ZX_TDM=y +CONFIG_SND_SOC_I2C_AND_SPI=y + +# +# CODEC drivers +# +CONFIG_SND_SOC_ALL_CODECS=y +CONFIG_SND_SOC_88PM860X=y +CONFIG_SND_SOC_ARIZONA=y +CONFIG_SND_SOC_WM_HUBS=y +CONFIG_SND_SOC_WM_ADSP=y +CONFIG_SND_SOC_AB8500_CODEC=y +CONFIG_SND_SOC_AC97_CODEC=y +CONFIG_SND_SOC_AD1836=y +CONFIG_SND_SOC_AD193X=y +CONFIG_SND_SOC_AD193X_SPI=y +CONFIG_SND_SOC_AD193X_I2C=y +CONFIG_SND_SOC_AD1980=y +CONFIG_SND_SOC_AD73311=y +CONFIG_SND_SOC_ADAU_UTILS=y +CONFIG_SND_SOC_ADAU1373=y +CONFIG_SND_SOC_ADAU1701=y +CONFIG_SND_SOC_ADAU17X1=y +CONFIG_SND_SOC_ADAU1761=y +CONFIG_SND_SOC_ADAU1761_I2C=y +CONFIG_SND_SOC_ADAU1761_SPI=y +CONFIG_SND_SOC_ADAU1781=y +CONFIG_SND_SOC_ADAU1781_I2C=y +CONFIG_SND_SOC_ADAU1781_SPI=y +CONFIG_SND_SOC_ADAU1977=y +CONFIG_SND_SOC_ADAU1977_SPI=y +CONFIG_SND_SOC_ADAU1977_I2C=y +CONFIG_SND_SOC_ADAU7002=y +CONFIG_SND_SOC_ADAV80X=y +CONFIG_SND_SOC_ADAV801=y +CONFIG_SND_SOC_ADAV803=y +CONFIG_SND_SOC_ADS117X=y +CONFIG_SND_SOC_AK4104=y +CONFIG_SND_SOC_AK4535=y +CONFIG_SND_SOC_AK4554=y +CONFIG_SND_SOC_AK4613=y +CONFIG_SND_SOC_AK4641=y +CONFIG_SND_SOC_AK4642=y +CONFIG_SND_SOC_AK4671=y +CONFIG_SND_SOC_AK5386=y +CONFIG_SND_SOC_ALC5623=y +CONFIG_SND_SOC_ALC5632=y +CONFIG_SND_SOC_BT_SCO=y +CONFIG_SND_SOC_CQ0093VC=y +CONFIG_SND_SOC_CS35L32=y +CONFIG_SND_SOC_CS35L33=y +CONFIG_SND_SOC_CS35L34=y +CONFIG_SND_SOC_CS35L35=y +CONFIG_SND_SOC_CS42L42=y +CONFIG_SND_SOC_CS42L51=y +CONFIG_SND_SOC_CS42L51_I2C=y +CONFIG_SND_SOC_CS42L52=y +CONFIG_SND_SOC_CS42L56=y +CONFIG_SND_SOC_CS42L73=y +CONFIG_SND_SOC_CS4265=y +CONFIG_SND_SOC_CS4270=y +CONFIG_SND_SOC_CS4271=y +CONFIG_SND_SOC_CS4271_I2C=y +CONFIG_SND_SOC_CS4271_SPI=y +CONFIG_SND_SOC_CS42XX8=y +CONFIG_SND_SOC_CS42XX8_I2C=y +CONFIG_SND_SOC_CS43130=y +CONFIG_SND_SOC_CS4349=y +CONFIG_SND_SOC_CS47L24=y +CONFIG_SND_SOC_CS53L30=y +CONFIG_SND_SOC_CX20442=y +CONFIG_SND_SOC_JZ4740_CODEC=y +CONFIG_SND_SOC_L3=y +CONFIG_SND_SOC_DA7210=y +CONFIG_SND_SOC_DA7213=y +CONFIG_SND_SOC_DA7218=y +CONFIG_SND_SOC_DA7219=y +CONFIG_SND_SOC_DA732X=y +CONFIG_SND_SOC_DA9055=y +CONFIG_SND_SOC_DIO2125=y +CONFIG_SND_SOC_DMIC=y +CONFIG_SND_SOC_HDMI_CODEC=y +CONFIG_SND_SOC_ES7134=y +CONFIG_SND_SOC_ES8316=y +CONFIG_SND_SOC_ES8328=y +CONFIG_SND_SOC_ES8328_I2C=y +CONFIG_SND_SOC_ES8328_SPI=y +CONFIG_SND_SOC_GTM601=y +CONFIG_SND_SOC_HDAC_HDMI=y +CONFIG_SND_SOC_ICS43432=y +CONFIG_SND_SOC_INNO_RK3036=y +CONFIG_SND_SOC_ISABELLE=y +CONFIG_SND_SOC_LM49453=y +CONFIG_SND_SOC_MAX98088=y +CONFIG_SND_SOC_MAX98090=y +CONFIG_SND_SOC_MAX98095=y +CONFIG_SND_SOC_MAX98357A=y +CONFIG_SND_SOC_MAX98371=y +CONFIG_SND_SOC_MAX98504=y +CONFIG_SND_SOC_MAX9867=y +CONFIG_SND_SOC_MAX98925=y +CONFIG_SND_SOC_MAX98926=y +CONFIG_SND_SOC_MAX98927=y +CONFIG_SND_SOC_MAX98373=y +CONFIG_SND_SOC_MAX9850=y +CONFIG_SND_SOC_MAX9860=y +CONFIG_SND_SOC_MSM8916_WCD_ANALOG=y +CONFIG_SND_SOC_MSM8916_WCD_DIGITAL=y +CONFIG_SND_SOC_PCM1681=y +CONFIG_SND_SOC_PCM179X=y +CONFIG_SND_SOC_PCM179X_I2C=y +CONFIG_SND_SOC_PCM179X_SPI=y +CONFIG_SND_SOC_PCM186X=y +CONFIG_SND_SOC_PCM186X_I2C=y +CONFIG_SND_SOC_PCM186X_SPI=y +CONFIG_SND_SOC_PCM3008=y +CONFIG_SND_SOC_PCM3168A=y +CONFIG_SND_SOC_PCM3168A_I2C=y +CONFIG_SND_SOC_PCM3168A_SPI=y +CONFIG_SND_SOC_PCM5102A=y +CONFIG_SND_SOC_PCM512x=y +CONFIG_SND_SOC_PCM512x_I2C=y +CONFIG_SND_SOC_PCM512x_SPI=y +CONFIG_SND_SOC_RL6231=y +CONFIG_SND_SOC_RL6347A=y +CONFIG_SND_SOC_RT274=y +CONFIG_SND_SOC_RT286=y +CONFIG_SND_SOC_RT298=y +CONFIG_SND_SOC_RT5514=y +CONFIG_SND_SOC_RT5514_SPI=y +# CONFIG_SND_SOC_RT5514_SPI_BUILTIN is not set +CONFIG_SND_SOC_RT5616=y +CONFIG_SND_SOC_RT5631=y +CONFIG_SND_SOC_RT5640=y +CONFIG_SND_SOC_RT5645=y +CONFIG_SND_SOC_RT5651=y +CONFIG_SND_SOC_RT5659=y +CONFIG_SND_SOC_RT5660=y +CONFIG_SND_SOC_RT5663=y +CONFIG_SND_SOC_RT5665=y +CONFIG_SND_SOC_RT5670=y +CONFIG_SND_SOC_RT5677=y +CONFIG_SND_SOC_RT5677_SPI=y +CONFIG_SND_SOC_SGTL5000=y +CONFIG_SND_SOC_SI476X=y +CONFIG_SND_SOC_SIGMADSP=y +CONFIG_SND_SOC_SIGMADSP_I2C=y +CONFIG_SND_SOC_SIGMADSP_REGMAP=y +CONFIG_SND_SOC_SIRF_AUDIO_CODEC=y +CONFIG_SND_SOC_SPDIF=y +CONFIG_SND_SOC_SSM2518=y +CONFIG_SND_SOC_SSM2602=y +CONFIG_SND_SOC_SSM2602_SPI=y +CONFIG_SND_SOC_SSM2602_I2C=y +CONFIG_SND_SOC_SSM4567=y +CONFIG_SND_SOC_STA32X=y +CONFIG_SND_SOC_STA350=y +CONFIG_SND_SOC_STA529=y +CONFIG_SND_SOC_STAC9766=y +CONFIG_SND_SOC_STI_SAS=y +CONFIG_SND_SOC_TAS2552=y +CONFIG_SND_SOC_TAS5086=y +CONFIG_SND_SOC_TAS571X=y +CONFIG_SND_SOC_TAS5720=y +CONFIG_SND_SOC_TAS6424=y +CONFIG_SND_SOC_TFA9879=y +CONFIG_SND_SOC_TLV320AIC23=y +CONFIG_SND_SOC_TLV320AIC23_I2C=y +CONFIG_SND_SOC_TLV320AIC23_SPI=y +CONFIG_SND_SOC_TLV320AIC26=y +CONFIG_SND_SOC_TLV320AIC31XX=y +CONFIG_SND_SOC_TLV320AIC32X4=y +CONFIG_SND_SOC_TLV320AIC32X4_I2C=y +CONFIG_SND_SOC_TLV320AIC32X4_SPI=y +CONFIG_SND_SOC_TLV320AIC3X=y +CONFIG_SND_SOC_TLV320DAC33=y +CONFIG_SND_SOC_TS3A227E=y +CONFIG_SND_SOC_TSCS42XX=y +CONFIG_SND_SOC_TWL4030=y +CONFIG_SND_SOC_TWL6040=y +CONFIG_SND_SOC_UDA134X=y +CONFIG_SND_SOC_UDA1380=y +CONFIG_SND_SOC_WL1273=y +CONFIG_SND_SOC_WM0010=y +CONFIG_SND_SOC_WM1250_EV1=y +CONFIG_SND_SOC_WM2000=y +CONFIG_SND_SOC_WM2200=y +CONFIG_SND_SOC_WM5100=y +CONFIG_SND_SOC_WM5102=y +CONFIG_SND_SOC_WM5110=y +CONFIG_SND_SOC_WM8350=y +CONFIG_SND_SOC_WM8400=y +CONFIG_SND_SOC_WM8510=y +CONFIG_SND_SOC_WM8523=y +CONFIG_SND_SOC_WM8524=y +CONFIG_SND_SOC_WM8580=y +CONFIG_SND_SOC_WM8711=y +CONFIG_SND_SOC_WM8727=y +CONFIG_SND_SOC_WM8728=y +CONFIG_SND_SOC_WM8731=y +CONFIG_SND_SOC_WM8737=y +CONFIG_SND_SOC_WM8741=y +CONFIG_SND_SOC_WM8750=y +CONFIG_SND_SOC_WM8753=y +CONFIG_SND_SOC_WM8770=y +CONFIG_SND_SOC_WM8776=y +CONFIG_SND_SOC_WM8782=y +CONFIG_SND_SOC_WM8804=y +CONFIG_SND_SOC_WM8804_I2C=y +CONFIG_SND_SOC_WM8804_SPI=y +CONFIG_SND_SOC_WM8900=y +CONFIG_SND_SOC_WM8903=y +CONFIG_SND_SOC_WM8904=y +CONFIG_SND_SOC_WM8940=y +CONFIG_SND_SOC_WM8955=y +CONFIG_SND_SOC_WM8960=y +CONFIG_SND_SOC_WM8961=y +CONFIG_SND_SOC_WM8962=y +CONFIG_SND_SOC_WM8971=y +CONFIG_SND_SOC_WM8974=y +CONFIG_SND_SOC_WM8978=y +CONFIG_SND_SOC_WM8983=y +CONFIG_SND_SOC_WM8985=y +CONFIG_SND_SOC_WM8988=y +CONFIG_SND_SOC_WM8990=y +CONFIG_SND_SOC_WM8991=y +CONFIG_SND_SOC_WM8993=y +CONFIG_SND_SOC_WM8994=y +CONFIG_SND_SOC_WM8995=y +CONFIG_SND_SOC_WM8996=y +CONFIG_SND_SOC_WM8997=y +CONFIG_SND_SOC_WM8998=y +CONFIG_SND_SOC_WM9081=y +CONFIG_SND_SOC_WM9090=y +CONFIG_SND_SOC_WM9705=y +CONFIG_SND_SOC_WM9712=y +CONFIG_SND_SOC_WM9713=y +CONFIG_SND_SOC_ZX_AUD96P22=y +CONFIG_SND_SOC_LM4857=y +CONFIG_SND_SOC_MAX9768=y +CONFIG_SND_SOC_MAX9877=y +CONFIG_SND_SOC_MC13783=y +CONFIG_SND_SOC_ML26124=y +CONFIG_SND_SOC_NAU8540=y +CONFIG_SND_SOC_NAU8810=y +CONFIG_SND_SOC_NAU8824=y +CONFIG_SND_SOC_NAU8825=y +CONFIG_SND_SOC_TPA6130A2=y +CONFIG_SND_SIMPLE_CARD_UTILS=y +CONFIG_SND_SIMPLE_CARD=y +CONFIG_SND_SIMPLE_SCU_CARD=y +CONFIG_SND_AUDIO_GRAPH_CARD=y +CONFIG_SND_AUDIO_GRAPH_SCU_CARD=y +CONFIG_SND_X86=y +CONFIG_HDMI_LPE_AUDIO=y +CONFIG_SND_SYNTH_EMUX=y +CONFIG_AC97_BUS=y + +# +# HID support +# +CONFIG_HID=y +CONFIG_HID_BATTERY_STRENGTH=y +CONFIG_HIDRAW=y +CONFIG_UHID=y +CONFIG_HID_GENERIC=y + +# +# Special HID drivers +# +CONFIG_HID_A4TECH=y +CONFIG_HID_ACCUTOUCH=y +CONFIG_HID_ACRUX=y +CONFIG_HID_ACRUX_FF=y +CONFIG_HID_APPLE=y +CONFIG_HID_APPLEIR=y +CONFIG_HID_ASUS=y +CONFIG_HID_AUREAL=y +CONFIG_HID_BELKIN=y +CONFIG_HID_BETOP_FF=y +CONFIG_HID_CHERRY=y +CONFIG_HID_CHICONY=y +CONFIG_HID_CORSAIR=y +CONFIG_HID_PRODIKEYS=y +CONFIG_HID_CMEDIA=y +CONFIG_HID_CP2112=y +CONFIG_HID_CYPRESS=y +CONFIG_HID_DRAGONRISE=y +CONFIG_DRAGONRISE_FF=y +CONFIG_HID_EMS_FF=y +CONFIG_HID_ELECOM=y +CONFIG_HID_ELO=y +CONFIG_HID_EZKEY=y +CONFIG_HID_GEMBIRD=y +CONFIG_HID_GFRM=y +CONFIG_HID_HOLTEK=y +CONFIG_HOLTEK_FF=y +CONFIG_HID_GT683R=y +CONFIG_HID_KEYTOUCH=y +CONFIG_HID_KYE=y +CONFIG_HID_UCLOGIC=y +CONFIG_HID_WALTOP=y +CONFIG_HID_GYRATION=y +CONFIG_HID_ICADE=y +CONFIG_HID_ITE=y +CONFIG_HID_JABRA=y +CONFIG_HID_TWINHAN=y +CONFIG_HID_KENSINGTON=y +CONFIG_HID_LCPOWER=y +CONFIG_HID_LED=y +CONFIG_HID_LENOVO=y +CONFIG_HID_LOGITECH=y +CONFIG_HID_LOGITECH_DJ=y +CONFIG_HID_LOGITECH_HIDPP=y +CONFIG_LOGITECH_FF=y +CONFIG_LOGIRUMBLEPAD2_FF=y +CONFIG_LOGIG940_FF=y +CONFIG_LOGIWHEELS_FF=y +CONFIG_HID_MAGICMOUSE=y +CONFIG_HID_MAYFLASH=y +CONFIG_HID_MICROSOFT=y +CONFIG_HID_MONTEREY=y +CONFIG_HID_MULTITOUCH=y +CONFIG_HID_NTI=y +CONFIG_HID_NTRIG=y +CONFIG_HID_ORTEK=y +CONFIG_HID_PANTHERLORD=y +CONFIG_PANTHERLORD_FF=y +CONFIG_HID_PENMOUNT=y +CONFIG_HID_PETALYNX=y +CONFIG_HID_PICOLCD=y +CONFIG_HID_PICOLCD_FB=y +CONFIG_HID_PICOLCD_BACKLIGHT=y +CONFIG_HID_PICOLCD_LCD=y +CONFIG_HID_PICOLCD_LEDS=y +CONFIG_HID_PICOLCD_CIR=y +CONFIG_HID_PLANTRONICS=y +CONFIG_HID_PRIMAX=y +CONFIG_HID_RETRODE=y +CONFIG_HID_ROCCAT=y +CONFIG_HID_SAITEK=y +CONFIG_HID_SAMSUNG=y +CONFIG_HID_SONY=y +CONFIG_SONY_FF=y +CONFIG_HID_SPEEDLINK=y +CONFIG_HID_STEELSERIES=y +CONFIG_HID_SUNPLUS=y +CONFIG_HID_RMI=y +CONFIG_HID_GREENASIA=y +CONFIG_GREENASIA_FF=y +CONFIG_HID_HYPERV_MOUSE=y +CONFIG_HID_SMARTJOYPLUS=y +CONFIG_SMARTJOYPLUS_FF=y +CONFIG_HID_TIVO=y +CONFIG_HID_TOPSEED=y +CONFIG_HID_THINGM=y +CONFIG_HID_THRUSTMASTER=y +CONFIG_THRUSTMASTER_FF=y +CONFIG_HID_UDRAW_PS3=y +CONFIG_HID_WACOM=y +CONFIG_HID_WIIMOTE=y +CONFIG_HID_XINMO=y +CONFIG_HID_ZEROPLUS=y +CONFIG_ZEROPLUS_FF=y +CONFIG_HID_ZYDACRON=y +CONFIG_HID_SENSOR_HUB=y +CONFIG_HID_SENSOR_CUSTOM_SENSOR=y +CONFIG_HID_ALPS=y + +# +# USB HID support +# +CONFIG_USB_HID=y +CONFIG_HID_PID=y +CONFIG_USB_HIDDEV=y + +# +# I2C HID support +# +CONFIG_I2C_HID=y + +# +# Intel ISH HID support +# +CONFIG_INTEL_ISH_HID=y +CONFIG_USB_OHCI_LITTLE_ENDIAN=y +CONFIG_USB_SUPPORT=y +CONFIG_USB_COMMON=y +CONFIG_USB_ARCH_HAS_HCD=y +CONFIG_USB=y +CONFIG_USB_PCI=y +CONFIG_USB_ANNOUNCE_NEW_DEVICES=y + +# +# Miscellaneous USB options +# +CONFIG_USB_DEFAULT_PERSIST=y +CONFIG_USB_DYNAMIC_MINORS=y +CONFIG_USB_OTG=y +CONFIG_USB_OTG_WHITELIST=y +CONFIG_USB_OTG_BLACKLIST_HUB=y +CONFIG_USB_OTG_FSM=y +CONFIG_USB_LEDS_TRIGGER_USBPORT=y +CONFIG_USB_MON=y +CONFIG_USB_WUSB=y +CONFIG_USB_WUSB_CBAF=y +CONFIG_USB_WUSB_CBAF_DEBUG=y + +# +# USB Host Controller Drivers +# +CONFIG_USB_C67X00_HCD=y +CONFIG_USB_XHCI_HCD=y +CONFIG_USB_XHCI_DBGCAP=y +CONFIG_USB_XHCI_PCI=y +CONFIG_USB_XHCI_PLATFORM=y +CONFIG_USB_XHCI_MTK=y +CONFIG_USB_XHCI_MVEBU=y +CONFIG_USB_XHCI_RCAR=y +CONFIG_USB_EHCI_HCD=y +CONFIG_USB_EHCI_ROOT_HUB_TT=y +CONFIG_USB_EHCI_TT_NEWSCHED=y +CONFIG_USB_EHCI_PCI=y +CONFIG_USB_EHCI_HCD_PLATFORM=y +CONFIG_USB_OXU210HP_HCD=y +CONFIG_USB_ISP116X_HCD=y +CONFIG_USB_ISP1362_HCD=y +CONFIG_USB_FOTG210_HCD=y +CONFIG_USB_MAX3421_HCD=y +CONFIG_USB_OHCI_HCD=y +CONFIG_USB_OHCI_HCD_PCI=y +CONFIG_USB_OHCI_HCD_SSB=y +CONFIG_USB_OHCI_HCD_PLATFORM=y +CONFIG_USB_UHCI_HCD=y +CONFIG_USB_U132_HCD=y +CONFIG_USB_SL811_HCD=y +CONFIG_USB_SL811_HCD_ISO=y +CONFIG_USB_SL811_CS=y +CONFIG_USB_R8A66597_HCD=y +CONFIG_USB_RENESAS_USBHS_HCD=y +CONFIG_USB_WHCI_HCD=y +CONFIG_USB_HWA_HCD=y +CONFIG_USB_HCD_BCMA=y +CONFIG_USB_HCD_SSB=y +CONFIG_USB_HCD_TEST_MODE=y +CONFIG_USB_RENESAS_USBHS=y + +# +# USB Device Class drivers +# +CONFIG_USB_ACM=y +CONFIG_USB_PRINTER=y +CONFIG_USB_WDM=y +CONFIG_USB_TMC=y + +# +# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may +# + +# +# also be needed; see USB_STORAGE Help for more info +# +CONFIG_USB_STORAGE=y +CONFIG_USB_STORAGE_DEBUG=y +CONFIG_USB_STORAGE_REALTEK=y +CONFIG_REALTEK_AUTOPM=y +CONFIG_USB_STORAGE_DATAFAB=y +CONFIG_USB_STORAGE_FREECOM=y +CONFIG_USB_STORAGE_ISD200=y +CONFIG_USB_STORAGE_USBAT=y +CONFIG_USB_STORAGE_SDDR09=y +CONFIG_USB_STORAGE_SDDR55=y +CONFIG_USB_STORAGE_JUMPSHOT=y +CONFIG_USB_STORAGE_ALAUDA=y +CONFIG_USB_STORAGE_ONETOUCH=y +CONFIG_USB_STORAGE_KARMA=y +CONFIG_USB_STORAGE_CYPRESS_ATACB=y +CONFIG_USB_STORAGE_ENE_UB6250=y +CONFIG_USB_UAS=y + +# +# USB Imaging devices +# +CONFIG_USB_MDC800=y +CONFIG_USB_MICROTEK=y +CONFIG_USBIP_CORE=y +CONFIG_USBIP_VHCI_HCD=y +CONFIG_USBIP_VHCI_HC_PORTS=8 +CONFIG_USBIP_VHCI_NR_HCS=1 +CONFIG_USBIP_HOST=y +CONFIG_USBIP_VUDC=y +CONFIG_USBIP_DEBUG=y +CONFIG_USB_MTU3=y +# CONFIG_USB_MTU3_HOST is not set +# CONFIG_USB_MTU3_GADGET is not set +CONFIG_USB_MTU3_DUAL_ROLE=y +CONFIG_USB_MTU3_DEBUG=y +CONFIG_USB_MUSB_HDRC=y +# CONFIG_USB_MUSB_HOST is not set +# CONFIG_USB_MUSB_GADGET is not set +CONFIG_USB_MUSB_DUAL_ROLE=y + +# +# Platform Glue Layer +# +CONFIG_USB_MUSB_TUSB6010=y +CONFIG_USB_MUSB_DSPS=y +CONFIG_USB_MUSB_UX500=y +CONFIG_USB_MUSB_AM335X_CHILD=y + +# +# MUSB DMA mode +# +CONFIG_MUSB_PIO_ONLY=y +CONFIG_USB_DWC3=y +CONFIG_USB_DWC3_ULPI=y +# CONFIG_USB_DWC3_HOST is not set +# CONFIG_USB_DWC3_GADGET is not set +CONFIG_USB_DWC3_DUAL_ROLE=y + +# +# Platform Glue Driver Support +# +CONFIG_USB_DWC3_OMAP=y +CONFIG_USB_DWC3_EXYNOS=y +CONFIG_USB_DWC3_PCI=y +CONFIG_USB_DWC3_KEYSTONE=y +CONFIG_USB_DWC3_OF_SIMPLE=y +CONFIG_USB_DWC3_ST=y +CONFIG_USB_DWC2=y +# CONFIG_USB_DWC2_HOST is not set + +# +# Gadget/Dual-role mode requires USB Gadget support to be enabled +# +# CONFIG_USB_DWC2_PERIPHERAL is not set +CONFIG_USB_DWC2_DUAL_ROLE=y +CONFIG_USB_DWC2_PCI=y +CONFIG_USB_DWC2_DEBUG=y +CONFIG_USB_DWC2_VERBOSE=y +CONFIG_USB_DWC2_TRACK_MISSED_SOFS=y +CONFIG_USB_DWC2_DEBUG_PERIODIC=y +CONFIG_USB_CHIPIDEA=y +CONFIG_USB_CHIPIDEA_OF=y +CONFIG_USB_CHIPIDEA_PCI=y +CONFIG_USB_CHIPIDEA_UDC=y +CONFIG_USB_CHIPIDEA_HOST=y +CONFIG_USB_CHIPIDEA_ULPI=y +CONFIG_USB_ISP1760=y +CONFIG_USB_ISP1760_HCD=y +CONFIG_USB_ISP1761_UDC=y +# CONFIG_USB_ISP1760_HOST_ROLE is not set +# CONFIG_USB_ISP1760_GADGET_ROLE is not set +CONFIG_USB_ISP1760_DUAL_ROLE=y + +# +# USB port drivers +# +CONFIG_USB_USS720=y +CONFIG_USB_SERIAL=y +CONFIG_USB_SERIAL_CONSOLE=y +CONFIG_USB_SERIAL_GENERIC=y +CONFIG_USB_SERIAL_SIMPLE=y +CONFIG_USB_SERIAL_AIRCABLE=y +CONFIG_USB_SERIAL_ARK3116=y +CONFIG_USB_SERIAL_BELKIN=y +CONFIG_USB_SERIAL_CH341=y +CONFIG_USB_SERIAL_WHITEHEAT=y +CONFIG_USB_SERIAL_DIGI_ACCELEPORT=y +CONFIG_USB_SERIAL_CP210X=y +CONFIG_USB_SERIAL_CYPRESS_M8=y +CONFIG_USB_SERIAL_EMPEG=y +CONFIG_USB_SERIAL_FTDI_SIO=y +CONFIG_USB_SERIAL_VISOR=y +CONFIG_USB_SERIAL_IPAQ=y +CONFIG_USB_SERIAL_IR=y +CONFIG_USB_SERIAL_EDGEPORT=y +CONFIG_USB_SERIAL_EDGEPORT_TI=y +CONFIG_USB_SERIAL_F81232=y +CONFIG_USB_SERIAL_F8153X=y +CONFIG_USB_SERIAL_GARMIN=y +CONFIG_USB_SERIAL_IPW=y +CONFIG_USB_SERIAL_IUU=y +CONFIG_USB_SERIAL_KEYSPAN_PDA=y +CONFIG_USB_SERIAL_KEYSPAN=y +CONFIG_USB_SERIAL_KLSI=y +CONFIG_USB_SERIAL_KOBIL_SCT=y +CONFIG_USB_SERIAL_MCT_U232=y +CONFIG_USB_SERIAL_METRO=y +CONFIG_USB_SERIAL_MOS7720=y +CONFIG_USB_SERIAL_MOS7715_PARPORT=y +CONFIG_USB_SERIAL_MOS7840=y +CONFIG_USB_SERIAL_MXUPORT=y +CONFIG_USB_SERIAL_NAVMAN=y +CONFIG_USB_SERIAL_PL2303=y +CONFIG_USB_SERIAL_OTI6858=y +CONFIG_USB_SERIAL_QCAUX=y +CONFIG_USB_SERIAL_QUALCOMM=y +CONFIG_USB_SERIAL_SPCP8X5=y +CONFIG_USB_SERIAL_SAFE=y +CONFIG_USB_SERIAL_SAFE_PADDED=y +CONFIG_USB_SERIAL_SIERRAWIRELESS=y +CONFIG_USB_SERIAL_SYMBOL=y +CONFIG_USB_SERIAL_TI=y +CONFIG_USB_SERIAL_CYBERJACK=y +CONFIG_USB_SERIAL_XIRCOM=y +CONFIG_USB_SERIAL_WWAN=y +CONFIG_USB_SERIAL_OPTION=y +CONFIG_USB_SERIAL_OMNINET=y +CONFIG_USB_SERIAL_OPTICON=y +CONFIG_USB_SERIAL_XSENS_MT=y +CONFIG_USB_SERIAL_WISHBONE=y +CONFIG_USB_SERIAL_SSU100=y +CONFIG_USB_SERIAL_QT2=y +CONFIG_USB_SERIAL_UPD78F0730=y +CONFIG_USB_SERIAL_DEBUG=y + +# +# USB Miscellaneous drivers +# +CONFIG_USB_EMI62=y +CONFIG_USB_EMI26=y +CONFIG_USB_ADUTUX=y +CONFIG_USB_SEVSEG=y +CONFIG_USB_RIO500=y +CONFIG_USB_LEGOTOWER=y +CONFIG_USB_LCD=y +CONFIG_USB_CYPRESS_CY7C63=y +CONFIG_USB_CYTHERM=y +CONFIG_USB_IDMOUSE=y +CONFIG_USB_FTDI_ELAN=y +CONFIG_USB_APPLEDISPLAY=y +CONFIG_USB_SISUSBVGA=y +CONFIG_USB_SISUSBVGA_CON=y +CONFIG_USB_LD=y +CONFIG_USB_TRANCEVIBRATOR=y +CONFIG_USB_IOWARRIOR=y +CONFIG_USB_TEST=y +CONFIG_USB_EHSET_TEST_FIXTURE=y +CONFIG_USB_ISIGHTFW=y +CONFIG_USB_YUREX=y +CONFIG_USB_EZUSB_FX2=y +CONFIG_USB_HUB_USB251XB=y +CONFIG_USB_HSIC_USB3503=y +CONFIG_USB_HSIC_USB4604=y +CONFIG_USB_LINK_LAYER_TEST=y +CONFIG_USB_CHAOSKEY=y +CONFIG_USB_ATM=y +CONFIG_USB_SPEEDTOUCH=y +CONFIG_USB_CXACRU=y +CONFIG_USB_UEAGLEATM=y +CONFIG_USB_XUSBATM=y + +# +# USB Physical Layer drivers +# +CONFIG_USB_PHY=y +CONFIG_KEYSTONE_USB_PHY=y +CONFIG_NOP_USB_XCEIV=y +CONFIG_AM335X_CONTROL_USB=y +CONFIG_AM335X_PHY_USB=y +CONFIG_USB_GPIO_VBUS=y +CONFIG_TAHVO_USB=y +CONFIG_TAHVO_USB_HOST_BY_DEFAULT=y +CONFIG_USB_ISP1301=y +CONFIG_USB_GADGET=y +CONFIG_USB_GADGET_DEBUG=y +CONFIG_USB_GADGET_VERBOSE=y +CONFIG_USB_GADGET_DEBUG_FILES=y +CONFIG_USB_GADGET_DEBUG_FS=y +CONFIG_USB_GADGET_VBUS_DRAW=2 +CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS=2 +CONFIG_U_SERIAL_CONSOLE=y + +# +# USB Peripheral Controller +# +CONFIG_USB_FOTG210_UDC=y +CONFIG_USB_GR_UDC=y +CONFIG_USB_R8A66597=y +CONFIG_USB_RENESAS_USBHS_UDC=y +CONFIG_USB_RENESAS_USB3=y +CONFIG_USB_PXA27X=y +CONFIG_USB_MV_UDC=y +CONFIG_USB_MV_U3D=y +CONFIG_USB_SNP_CORE=y +CONFIG_USB_SNP_UDC_PLAT=y +CONFIG_USB_M66592=y +CONFIG_USB_BDC_UDC=y + +# +# Platform Support +# +CONFIG_USB_BDC_PCI=y +CONFIG_USB_AMD5536UDC=y +CONFIG_USB_NET2272=y +CONFIG_USB_NET2272_DMA=y +CONFIG_USB_NET2280=y +CONFIG_USB_GOKU=y +CONFIG_USB_EG20T=y +CONFIG_USB_GADGET_XILINX=y +CONFIG_USB_DUMMY_HCD=y +CONFIG_USB_LIBCOMPOSITE=y +CONFIG_USB_F_ACM=y +CONFIG_USB_F_SS_LB=y +CONFIG_USB_U_SERIAL=y +CONFIG_USB_U_ETHER=y +CONFIG_USB_U_AUDIO=y +CONFIG_USB_F_SERIAL=y +CONFIG_USB_F_OBEX=y +CONFIG_USB_F_NCM=y +CONFIG_USB_F_ECM=y +CONFIG_USB_F_PHONET=y +CONFIG_USB_F_EEM=y +CONFIG_USB_F_SUBSET=y +CONFIG_USB_F_RNDIS=y +CONFIG_USB_F_MASS_STORAGE=y +CONFIG_USB_F_FS=y +CONFIG_USB_F_UAC1=y +CONFIG_USB_F_UAC1_LEGACY=y +CONFIG_USB_F_UAC2=y +CONFIG_USB_F_UVC=y +CONFIG_USB_F_MIDI=y +CONFIG_USB_F_HID=y +CONFIG_USB_F_PRINTER=y +CONFIG_USB_F_TCM=y +CONFIG_USB_CONFIGFS=y +CONFIG_USB_CONFIGFS_SERIAL=y +CONFIG_USB_CONFIGFS_ACM=y +CONFIG_USB_CONFIGFS_OBEX=y +CONFIG_USB_CONFIGFS_NCM=y +CONFIG_USB_CONFIGFS_ECM=y +CONFIG_USB_CONFIGFS_ECM_SUBSET=y +CONFIG_USB_CONFIGFS_RNDIS=y +CONFIG_USB_CONFIGFS_EEM=y +CONFIG_USB_CONFIGFS_PHONET=y +CONFIG_USB_CONFIGFS_MASS_STORAGE=y +CONFIG_USB_CONFIGFS_F_LB_SS=y +CONFIG_USB_CONFIGFS_F_FS=y +CONFIG_USB_CONFIGFS_F_UAC1=y +CONFIG_USB_CONFIGFS_F_UAC1_LEGACY=y +CONFIG_USB_CONFIGFS_F_UAC2=y +CONFIG_USB_CONFIGFS_F_MIDI=y +CONFIG_USB_CONFIGFS_F_HID=y +CONFIG_USB_CONFIGFS_F_UVC=y +CONFIG_USB_CONFIGFS_F_PRINTER=y +CONFIG_USB_CONFIGFS_F_TCM=y +# CONFIG_USB_ZERO is not set +# CONFIG_USB_AUDIO is not set +CONFIG_USB_ETH=y +CONFIG_USB_ETH_RNDIS=y +CONFIG_USB_ETH_EEM=y +# CONFIG_USB_G_NCM is not set +# CONFIG_USB_GADGETFS is not set +# CONFIG_USB_FUNCTIONFS is not set +# CONFIG_USB_MASS_STORAGE is not set +# CONFIG_USB_GADGET_TARGET is not set +# CONFIG_USB_G_SERIAL is not set +# CONFIG_USB_MIDI_GADGET is not set +# CONFIG_USB_G_PRINTER is not set +# CONFIG_USB_CDC_COMPOSITE is not set +# CONFIG_USB_G_NOKIA is not set +# CONFIG_USB_G_ACM_MS is not set +# CONFIG_USB_G_MULTI is not set +# CONFIG_USB_G_HID is not set +# CONFIG_USB_G_DBGP is not set +# CONFIG_USB_G_WEBCAM is not set +CONFIG_TYPEC=y +CONFIG_TYPEC_TCPM=y +CONFIG_TYPEC_FUSB302=y +CONFIG_TYPEC_WCOVE=y +CONFIG_TYPEC_UCSI=y +CONFIG_UCSI_ACPI=y +CONFIG_TYPEC_TPS6598X=y +CONFIG_USB_LED_TRIG=y +CONFIG_USB_ULPI_BUS=y +CONFIG_UWB=y +CONFIG_UWB_HWA=y +CONFIG_UWB_WHCI=y +CONFIG_UWB_I1480U=y +CONFIG_MMC=y +CONFIG_PWRSEQ_EMMC=y +CONFIG_PWRSEQ_SD8787=y +CONFIG_PWRSEQ_SIMPLE=y +CONFIG_MMC_BLOCK=y +CONFIG_MMC_BLOCK_MINORS=8 +CONFIG_SDIO_UART=y +CONFIG_MMC_TEST=y + +# +# MMC/SD/SDIO Host Controller Drivers +# +CONFIG_MMC_DEBUG=y +CONFIG_MMC_SDHCI=y +CONFIG_MMC_SDHCI_IO_ACCESSORS=y +CONFIG_MMC_SDHCI_PCI=y +CONFIG_MMC_RICOH_MMC=y +CONFIG_MMC_SDHCI_ACPI=y +CONFIG_MMC_SDHCI_PLTFM=y +CONFIG_MMC_SDHCI_OF_ARASAN=y +CONFIG_MMC_SDHCI_OF_AT91=y +CONFIG_MMC_SDHCI_CADENCE=y +CONFIG_MMC_SDHCI_PXAV3=y +CONFIG_MMC_SDHCI_PXAV2=y +CONFIG_MMC_SDHCI_F_SDH30=y +CONFIG_MMC_SDHCI_IPROC=y +CONFIG_MMC_MESON_MX_SDIO=y +CONFIG_MMC_OMAP_HS=y +CONFIG_MMC_WBSD=y +CONFIG_MMC_TIFM_SD=y +CONFIG_MMC_GOLDFISH=y +CONFIG_MMC_SPI=y +CONFIG_MMC_SDRICOH_CS=y +CONFIG_MMC_TMIO_CORE=y +CONFIG_MMC_SDHI=y +CONFIG_MMC_SDHI_SYS_DMAC=y +CONFIG_MMC_SDHI_INTERNAL_DMAC=y +CONFIG_MMC_CB710=y +CONFIG_MMC_VIA_SDMMC=y +CONFIG_MMC_CAVIUM_THUNDERX=y +CONFIG_MMC_DW=y +CONFIG_MMC_DW_PLTFM=y +CONFIG_MMC_DW_EXYNOS=y +CONFIG_MMC_DW_K3=y +CONFIG_MMC_DW_PCI=y +CONFIG_MMC_SH_MMCIF=y +CONFIG_MMC_VUB300=y +CONFIG_MMC_USHC=y +CONFIG_MMC_USDHI6ROL0=y +CONFIG_MMC_REALTEK_PCI=y +CONFIG_MMC_REALTEK_USB=y +CONFIG_MMC_CQHCI=y +CONFIG_MMC_TOSHIBA_PCI=y +CONFIG_MMC_BCM2835=y +CONFIG_MMC_MTK=y +CONFIG_MMC_SDHCI_XENON=y +CONFIG_MMC_SDHCI_OMAP=y +CONFIG_MEMSTICK=y +CONFIG_MEMSTICK_DEBUG=y + +# +# MemoryStick drivers +# +CONFIG_MEMSTICK_UNSAFE_RESUME=y +CONFIG_MSPRO_BLOCK=y +CONFIG_MS_BLOCK=y + +# +# MemoryStick Host Controller Drivers +# +CONFIG_MEMSTICK_TIFM_MS=y +CONFIG_MEMSTICK_JMICRON_38X=y +CONFIG_MEMSTICK_R592=y +CONFIG_MEMSTICK_REALTEK_PCI=y +CONFIG_MEMSTICK_REALTEK_USB=y +CONFIG_NEW_LEDS=y +CONFIG_LEDS_CLASS=y +CONFIG_LEDS_CLASS_FLASH=y +CONFIG_LEDS_BRIGHTNESS_HW_CHANGED=y + +# +# LED drivers +# +CONFIG_LEDS_88PM860X=y +CONFIG_LEDS_AAT1290=y +CONFIG_LEDS_APU=y +CONFIG_LEDS_AS3645A=y +CONFIG_LEDS_BCM6328=y +CONFIG_LEDS_BCM6358=y +CONFIG_LEDS_CPCAP=y +CONFIG_LEDS_LM3530=y +CONFIG_LEDS_LM3533=y +CONFIG_LEDS_LM3642=y +CONFIG_LEDS_LM3692X=y +CONFIG_LEDS_MT6323=y +CONFIG_LEDS_PCA9532=y +CONFIG_LEDS_PCA9532_GPIO=y +CONFIG_LEDS_GPIO=y +CONFIG_LEDS_LP3944=y +CONFIG_LEDS_LP3952=y +CONFIG_LEDS_LP55XX_COMMON=y +CONFIG_LEDS_LP5521=y +CONFIG_LEDS_LP5523=y +CONFIG_LEDS_LP5562=y +CONFIG_LEDS_LP8501=y +CONFIG_LEDS_LP8788=y +CONFIG_LEDS_LP8860=y +CONFIG_LEDS_CLEVO_MAIL=y +CONFIG_LEDS_PCA955X=y +CONFIG_LEDS_PCA955X_GPIO=y +CONFIG_LEDS_PCA963X=y +CONFIG_LEDS_WM831X_STATUS=y +CONFIG_LEDS_WM8350=y +CONFIG_LEDS_DA903X=y +CONFIG_LEDS_DA9052=y +CONFIG_LEDS_DAC124S085=y +CONFIG_LEDS_PWM=y +CONFIG_LEDS_REGULATOR=y +CONFIG_LEDS_BD2802=y +CONFIG_LEDS_INTEL_SS4200=y +CONFIG_LEDS_LT3593=y +CONFIG_LEDS_ADP5520=y +CONFIG_LEDS_MC13783=y +CONFIG_LEDS_TCA6507=y +CONFIG_LEDS_TLC591XX=y +CONFIG_LEDS_MAX77693=y +CONFIG_LEDS_MAX8997=y +CONFIG_LEDS_LM355x=y +CONFIG_LEDS_OT200=y +CONFIG_LEDS_MENF21BMC=y +CONFIG_LEDS_KTD2692=y +CONFIG_LEDS_IS31FL319X=y +CONFIG_LEDS_IS31FL32XX=y + +# +# LED driver for blink(1) USB RGB LED is under Special HID drivers (HID_THINGM) +# +CONFIG_LEDS_BLINKM=y +CONFIG_LEDS_SYSCON=y +CONFIG_LEDS_PM8058=y +CONFIG_LEDS_MLXCPLD=y +CONFIG_LEDS_USER=y +CONFIG_LEDS_NIC78BX=y + +# +# LED Triggers +# +CONFIG_LEDS_TRIGGERS=y +CONFIG_LEDS_TRIGGER_TIMER=y +CONFIG_LEDS_TRIGGER_ONESHOT=y +CONFIG_LEDS_TRIGGER_DISK=y +CONFIG_LEDS_TRIGGER_MTD=y +CONFIG_LEDS_TRIGGER_HEARTBEAT=y +CONFIG_LEDS_TRIGGER_BACKLIGHT=y +CONFIG_LEDS_TRIGGER_CPU=y +CONFIG_LEDS_TRIGGER_ACTIVITY=y +CONFIG_LEDS_TRIGGER_GPIO=y +CONFIG_LEDS_TRIGGER_DEFAULT_ON=y + +# +# iptables trigger is under Netfilter config (LED target) +# +CONFIG_LEDS_TRIGGER_TRANSIENT=y +CONFIG_LEDS_TRIGGER_CAMERA=y +CONFIG_LEDS_TRIGGER_PANIC=y +CONFIG_LEDS_TRIGGER_NETDEV=y +CONFIG_ACCESSIBILITY=y +CONFIG_A11Y_BRAILLE_CONSOLE=y +CONFIG_INFINIBAND=y +CONFIG_INFINIBAND_USER_MAD=y +CONFIG_INFINIBAND_USER_ACCESS=y +CONFIG_INFINIBAND_EXP_USER_ACCESS=y +CONFIG_INFINIBAND_USER_MEM=y +CONFIG_INFINIBAND_ON_DEMAND_PAGING=y +CONFIG_INFINIBAND_ADDR_TRANS=y +CONFIG_INFINIBAND_ADDR_TRANS_CONFIGFS=y +CONFIG_INFINIBAND_MTHCA=y +CONFIG_INFINIBAND_MTHCA_DEBUG=y +CONFIG_INFINIBAND_QIB=y +CONFIG_INFINIBAND_QIB_DCA=y +CONFIG_INFINIBAND_CXGB3=y +CONFIG_INFINIBAND_CXGB3_DEBUG=y +CONFIG_INFINIBAND_CXGB4=y +CONFIG_INFINIBAND_I40IW=y +CONFIG_MLX4_INFINIBAND=y +CONFIG_MLX5_INFINIBAND=y +CONFIG_INFINIBAND_NES=y +CONFIG_INFINIBAND_NES_DEBUG=y +CONFIG_INFINIBAND_OCRDMA=y +CONFIG_INFINIBAND_VMWARE_PVRDMA=y +CONFIG_INFINIBAND_USNIC=y +CONFIG_INFINIBAND_HNS=y +CONFIG_INFINIBAND_HNS_HIP06=y +CONFIG_INFINIBAND_HNS_HIP08=y +CONFIG_INFINIBAND_IPOIB=y +CONFIG_INFINIBAND_IPOIB_CM=y +CONFIG_INFINIBAND_IPOIB_DEBUG=y +CONFIG_INFINIBAND_IPOIB_DEBUG_DATA=y +CONFIG_INFINIBAND_SRP=y +CONFIG_INFINIBAND_SRPT=y +CONFIG_INFINIBAND_ISER=y +CONFIG_INFINIBAND_ISERT=y +CONFIG_INFINIBAND_OPA_VNIC=y +CONFIG_INFINIBAND_RDMAVT=y +CONFIG_RDMA_RXE=y +CONFIG_INFINIBAND_HFI1=y +CONFIG_HFI1_DEBUG_SDMA_ORDER=y +CONFIG_SDMA_VERBOSITY=y +CONFIG_INFINIBAND_QEDR=y +CONFIG_INFINIBAND_BNXT_RE=y +CONFIG_EDAC_ATOMIC_SCRUB=y +CONFIG_EDAC_SUPPORT=y +CONFIG_EDAC=y +CONFIG_EDAC_LEGACY_SYSFS=y +CONFIG_EDAC_DEBUG=y +CONFIG_EDAC_DECODE_MCE=y +CONFIG_EDAC_GHES=y +CONFIG_EDAC_AMD64=y +CONFIG_EDAC_AMD64_ERROR_INJECTION=y +CONFIG_EDAC_E752X=y +CONFIG_EDAC_I82975X=y +CONFIG_EDAC_I3000=y +CONFIG_EDAC_I3200=y +CONFIG_EDAC_IE31200=y +CONFIG_EDAC_X38=y +CONFIG_EDAC_I5400=y +CONFIG_EDAC_I7CORE=y +CONFIG_EDAC_I5000=y +CONFIG_EDAC_I5100=y +CONFIG_EDAC_I7300=y +CONFIG_EDAC_SBRIDGE=y +CONFIG_EDAC_SKX=y +CONFIG_EDAC_PND2=y +CONFIG_EDAC_XGENE=y +CONFIG_RTC_LIB=y +CONFIG_RTC_MC146818_LIB=y +CONFIG_RTC_CLASS=y +CONFIG_RTC_HCTOSYS=y +CONFIG_RTC_HCTOSYS_DEVICE="rtc0" +CONFIG_RTC_SYSTOHC=y +CONFIG_RTC_SYSTOHC_DEVICE="rtc0" +CONFIG_RTC_DEBUG=y +CONFIG_RTC_NVMEM=y + +# +# RTC interfaces +# +CONFIG_RTC_INTF_SYSFS=y +CONFIG_RTC_INTF_PROC=y +CONFIG_RTC_INTF_DEV=y +CONFIG_RTC_INTF_DEV_UIE_EMUL=y +CONFIG_RTC_DRV_TEST=y + +# +# I2C RTC drivers +# +CONFIG_RTC_DRV_88PM860X=y +CONFIG_RTC_DRV_88PM80X=y +CONFIG_RTC_DRV_ABB5ZES3=y +CONFIG_RTC_DRV_ABX80X=y +CONFIG_RTC_DRV_BRCMSTB=y +CONFIG_RTC_DRV_AS3722=y +CONFIG_RTC_DRV_DS1307=y +CONFIG_RTC_DRV_DS1307_HWMON=y +CONFIG_RTC_DRV_DS1307_CENTURY=y +CONFIG_RTC_DRV_DS1374=y +CONFIG_RTC_DRV_DS1374_WDT=y +CONFIG_RTC_DRV_DS1672=y +CONFIG_RTC_DRV_HYM8563=y +CONFIG_RTC_DRV_LP8788=y +CONFIG_RTC_DRV_MAX6900=y +CONFIG_RTC_DRV_MAX8907=y +CONFIG_RTC_DRV_MAX8925=y +CONFIG_RTC_DRV_MAX8998=y +CONFIG_RTC_DRV_MAX8997=y +CONFIG_RTC_DRV_MAX77686=y +CONFIG_RTC_DRV_RK808=y +CONFIG_RTC_DRV_RS5C372=y +CONFIG_RTC_DRV_ISL1208=y +CONFIG_RTC_DRV_ISL12022=y +CONFIG_RTC_DRV_X1205=y +CONFIG_RTC_DRV_PCF8523=y +CONFIG_RTC_DRV_PCF85063=y +CONFIG_RTC_DRV_PCF85363=y +CONFIG_RTC_DRV_PCF8563=y +CONFIG_RTC_DRV_PCF8583=y +CONFIG_RTC_DRV_M41T80=y +CONFIG_RTC_DRV_M41T80_WDT=y +CONFIG_RTC_DRV_BQ32K=y +CONFIG_RTC_DRV_TWL4030=y +CONFIG_RTC_DRV_PALMAS=y +CONFIG_RTC_DRV_TPS6586X=y +CONFIG_RTC_DRV_TPS65910=y +CONFIG_RTC_DRV_TPS80031=y +CONFIG_RTC_DRV_RC5T583=y +CONFIG_RTC_DRV_S35390A=y +CONFIG_RTC_DRV_FM3130=y +CONFIG_RTC_DRV_RX8010=y +CONFIG_RTC_DRV_RX8581=y +CONFIG_RTC_DRV_RX8025=y +CONFIG_RTC_DRV_EM3027=y +CONFIG_RTC_DRV_RV8803=y +CONFIG_RTC_DRV_S5M=y + +# +# SPI RTC drivers +# +CONFIG_RTC_DRV_M41T93=y +CONFIG_RTC_DRV_M41T94=y +CONFIG_RTC_DRV_DS1302=y +CONFIG_RTC_DRV_DS1305=y +CONFIG_RTC_DRV_DS1343=y +CONFIG_RTC_DRV_DS1347=y +CONFIG_RTC_DRV_DS1390=y +CONFIG_RTC_DRV_MAX6916=y +CONFIG_RTC_DRV_R9701=y +CONFIG_RTC_DRV_RX4581=y +CONFIG_RTC_DRV_RX6110=y +CONFIG_RTC_DRV_RS5C348=y +CONFIG_RTC_DRV_MAX6902=y +CONFIG_RTC_DRV_PCF2123=y +CONFIG_RTC_DRV_MCP795=y +CONFIG_RTC_I2C_AND_SPI=y + +# +# SPI and I2C RTC drivers +# +CONFIG_RTC_DRV_DS3232=y +CONFIG_RTC_DRV_DS3232_HWMON=y +CONFIG_RTC_DRV_PCF2127=y +CONFIG_RTC_DRV_RV3029C2=y +CONFIG_RTC_DRV_RV3029_HWMON=y + +# +# Platform RTC drivers +# +CONFIG_RTC_DRV_CMOS=y +CONFIG_RTC_DRV_VRTC=y +CONFIG_RTC_DRV_DS1286=y +CONFIG_RTC_DRV_DS1511=y +CONFIG_RTC_DRV_DS1553=y +CONFIG_RTC_DRV_DS1685_FAMILY=y +CONFIG_RTC_DRV_DS1685=y +# CONFIG_RTC_DRV_DS1689 is not set +# CONFIG_RTC_DRV_DS17285 is not set +# CONFIG_RTC_DRV_DS17485 is not set +# CONFIG_RTC_DRV_DS17885 is not set +CONFIG_RTC_DS1685_PROC_REGS=y +CONFIG_RTC_DS1685_SYSFS_REGS=y +CONFIG_RTC_DRV_DS1742=y +CONFIG_RTC_DRV_DS2404=y +CONFIG_RTC_DRV_DA9052=y +CONFIG_RTC_DRV_DA9055=y +CONFIG_RTC_DRV_DA9063=y +CONFIG_RTC_DRV_STK17TA8=y +CONFIG_RTC_DRV_M48T86=y +CONFIG_RTC_DRV_M48T35=y +CONFIG_RTC_DRV_M48T59=y +CONFIG_RTC_DRV_MSM6242=y +CONFIG_RTC_DRV_BQ4802=y +CONFIG_RTC_DRV_RP5C01=y +CONFIG_RTC_DRV_V3020=y +CONFIG_RTC_DRV_WM831X=y +CONFIG_RTC_DRV_WM8350=y +CONFIG_RTC_DRV_SC27XX=y +CONFIG_RTC_DRV_SPEAR=y +CONFIG_RTC_DRV_PCF50633=y +CONFIG_RTC_DRV_AB3100=y +CONFIG_RTC_DRV_NUC900=y +CONFIG_RTC_DRV_ZYNQMP=y +CONFIG_RTC_DRV_CROS_EC=y + +# +# on-CPU RTC drivers +# +CONFIG_RTC_DRV_ASM9260=y +CONFIG_RTC_DRV_DAVINCI=y +CONFIG_RTC_DRV_DIGICOLOR=y +CONFIG_RTC_DRV_OMAP=y +CONFIG_RTC_DRV_S3C=y +CONFIG_RTC_DRV_EP93XX=y +CONFIG_RTC_DRV_VR41XX=y +CONFIG_RTC_DRV_AT91RM9200=y +CONFIG_RTC_DRV_AT91SAM9=y +CONFIG_RTC_DRV_GENERIC=y +CONFIG_RTC_DRV_VT8500=y +CONFIG_RTC_DRV_SUN6I=y +CONFIG_RTC_DRV_SUNXI=y +CONFIG_RTC_DRV_MV=y +CONFIG_RTC_DRV_ARMADA38X=y +CONFIG_RTC_DRV_FTRTC010=y +CONFIG_RTC_DRV_COH901331=y +CONFIG_RTC_DRV_STMP=y +CONFIG_RTC_DRV_PCAP=y +CONFIG_RTC_DRV_MC13XXX=y +CONFIG_RTC_DRV_JZ4740=y +CONFIG_RTC_DRV_LPC24XX=y +CONFIG_RTC_DRV_LPC32XX=y +CONFIG_RTC_DRV_PM8XXX=y +CONFIG_RTC_DRV_TEGRA=y +CONFIG_RTC_DRV_SNVS=y +CONFIG_RTC_DRV_MOXART=y +CONFIG_RTC_DRV_MT6397=y +CONFIG_RTC_DRV_MT7622=y +CONFIG_RTC_DRV_XGENE=y +CONFIG_RTC_DRV_R7301=y +CONFIG_RTC_DRV_STM32=y +CONFIG_RTC_DRV_CPCAP=y +CONFIG_RTC_DRV_RTD119X=y + +# +# HID Sensor RTC drivers +# +CONFIG_RTC_DRV_HID_SENSOR_TIME=y +CONFIG_DMADEVICES=y +CONFIG_DMADEVICES_DEBUG=y +CONFIG_DMADEVICES_VDEBUG=y + +# +# DMA Devices +# +CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH=y +CONFIG_DMA_ENGINE=y +CONFIG_DMA_VIRTUAL_CHANNELS=y +CONFIG_DMA_ACPI=y +CONFIG_DMA_OF=y +CONFIG_ALTERA_MSGDMA=y +CONFIG_AXI_DMAC=y +CONFIG_BCM_SBA_RAID=y +CONFIG_COH901318=y +CONFIG_DMA_JZ4740=y +CONFIG_DMA_JZ4780=y +CONFIG_DMA_OMAP=y +CONFIG_DMA_SA11X0=y +CONFIG_DMA_SUN6I=y +CONFIG_EP93XX_DMA=y +CONFIG_FSL_EDMA=y +CONFIG_IMG_MDC_DMA=y +CONFIG_INTEL_IDMA64=y +CONFIG_INTEL_IOATDMA=y +CONFIG_INTEL_MIC_X100_DMA=y +CONFIG_K3_DMA=y +CONFIG_MMP_PDMA=y +CONFIG_MMP_TDMA=y +CONFIG_MV_XOR=y +CONFIG_MXS_DMA=y +CONFIG_NBPFAXI_DMA=y +CONFIG_PCH_DMA=y +CONFIG_STM32_DMA=y +CONFIG_STM32_DMAMUX=y +CONFIG_STM32_MDMA=y +CONFIG_SPRD_DMA=y +CONFIG_S3C24XX_DMAC=y +CONFIG_TEGRA210_ADMA=y +CONFIG_TIMB_DMA=y +CONFIG_TI_DMA_CROSSBAR=y +CONFIG_TI_EDMA=y +CONFIG_XGENE_DMA=y +CONFIG_ZX_DMA=y +CONFIG_QCOM_HIDMA_MGMT=y +CONFIG_QCOM_HIDMA=y +CONFIG_DW_DMAC_CORE=y +CONFIG_DW_DMAC=y +CONFIG_DW_DMAC_PCI=y +CONFIG_HSU_DMA=y +CONFIG_HSU_DMA_PCI=y +CONFIG_RENESAS_DMA=y +CONFIG_SH_DMAE_BASE=y +CONFIG_SH_DMAE=y +CONFIG_RCAR_DMAC=y +CONFIG_RENESAS_USB_DMAC=y +CONFIG_SUDMAC=y + +# +# DMA Clients +# +CONFIG_ASYNC_TX_DMA=y +CONFIG_DMATEST=y +CONFIG_DMA_ENGINE_RAID=y + +# +# DMABUF options +# +CONFIG_SYNC_FILE=y +CONFIG_SW_SYNC=y +CONFIG_DCA=y +CONFIG_AUXDISPLAY=y +CONFIG_CHARLCD=y +CONFIG_HD44780=y +CONFIG_KS0108=y +CONFIG_KS0108_PORT=0x378 +CONFIG_KS0108_DELAY=2 +CONFIG_CFAG12864B=y +CONFIG_CFAG12864B_RATE=20 +CONFIG_IMG_ASCII_LCD=y +CONFIG_HT16K33=y +CONFIG_PANEL=y +CONFIG_PANEL_PARPORT=0 +CONFIG_PANEL_PROFILE=5 +CONFIG_PANEL_CHANGE_MESSAGE=y +CONFIG_PANEL_BOOT_MESSAGE="" +CONFIG_UIO=y +CONFIG_UIO_CIF=y +CONFIG_UIO_PDRV_GENIRQ=y +CONFIG_UIO_DMEM_GENIRQ=y +CONFIG_UIO_AEC=y +CONFIG_UIO_SERCOS3=y +CONFIG_UIO_PCI_GENERIC=y +CONFIG_UIO_NETX=y +CONFIG_UIO_PRUSS=y +CONFIG_UIO_MF624=y +CONFIG_UIO_HV_GENERIC=y +CONFIG_VFIO_IOMMU_TYPE1=y +CONFIG_VFIO_VIRQFD=y +CONFIG_VFIO=y +CONFIG_VFIO_NOIOMMU=y +CONFIG_VFIO_PCI=y +CONFIG_VFIO_PCI_VGA=y +CONFIG_VFIO_PCI_MMAP=y +CONFIG_VFIO_PCI_INTX=y +CONFIG_VFIO_PCI_IGD=y +CONFIG_VFIO_MDEV=y +CONFIG_VFIO_MDEV_DEVICE=y +CONFIG_IRQ_BYPASS_MANAGER=y +CONFIG_VIRT_DRIVERS=y +CONFIG_VBOXGUEST=y +CONFIG_VIRTIO=y +CONFIG_VIRTIO_MENU=y +CONFIG_VIRTIO_PCI=y +CONFIG_VIRTIO_PCI_LEGACY=y +CONFIG_VIRTIO_BALLOON=y +CONFIG_VIRTIO_INPUT=y +CONFIG_VIRTIO_MMIO=y +CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES=y + +# +# Microsoft Hyper-V guest support +# +CONFIG_HYPERV=y +CONFIG_HYPERV_TSCPAGE=y +CONFIG_HYPERV_UTILS=y +CONFIG_HYPERV_BALLOON=y + +# +# Xen driver support +# +CONFIG_XEN_BALLOON=y +CONFIG_XEN_SELFBALLOONING=y +CONFIG_XEN_BALLOON_MEMORY_HOTPLUG=y +CONFIG_XEN_SCRUB_PAGES=y +CONFIG_XEN_DEV_EVTCHN=y +CONFIG_XENFS=y +CONFIG_XEN_COMPAT_XENFS=y +CONFIG_XEN_SYS_HYPERVISOR=y +CONFIG_XEN_XENBUS_FRONTEND=y +CONFIG_XEN_GNTDEV=y +CONFIG_XEN_GRANT_DEV_ALLOC=y +CONFIG_SWIOTLB_XEN=y +CONFIG_XEN_TMEM=m +CONFIG_XEN_PVCALLS_FRONTEND=y +CONFIG_XEN_PRIVCMD=y +CONFIG_XEN_EFI=y +CONFIG_XEN_AUTO_XLATE=y +CONFIG_XEN_ACPI=y +CONFIG_STAGING=y +CONFIG_IRDA=y + +# +# IrDA protocols +# +CONFIG_IRLAN=y +CONFIG_IRNET=y +CONFIG_IRCOMM=y +CONFIG_IRDA_ULTRA=y + +# +# IrDA options +# +CONFIG_IRDA_CACHE_LAST_LSAP=y +CONFIG_IRDA_FAST_RR=y +CONFIG_IRDA_DEBUG=y + +# +# Infrared-port device drivers +# + +# +# SIR device drivers +# +CONFIG_IRTTY_SIR=y + +# +# Dongle support +# +CONFIG_DONGLE=y +CONFIG_ESI_DONGLE=y +CONFIG_ACTISYS_DONGLE=y +CONFIG_TEKRAM_DONGLE=y +CONFIG_TOIM3232_DONGLE=y +CONFIG_LITELINK_DONGLE=y +CONFIG_MA600_DONGLE=y +CONFIG_GIRBIL_DONGLE=y +CONFIG_MCP2120_DONGLE=y +CONFIG_OLD_BELKIN_DONGLE=y +CONFIG_ACT200L_DONGLE=y +CONFIG_KINGSUN_DONGLE=y +CONFIG_KSDAZZLE_DONGLE=y +CONFIG_KS959_DONGLE=y + +# +# FIR device drivers +# +CONFIG_USB_IRDA=y +CONFIG_SIGMATEL_FIR=y +CONFIG_NSC_FIR=y +CONFIG_WINBOND_FIR=y +CONFIG_SMC_IRCC_FIR=y +CONFIG_ALI_FIR=y +CONFIG_VLSI_FIR=y +CONFIG_VIA_FIR=y +CONFIG_MCS_FIR=y +CONFIG_IPX=y +CONFIG_IPX_INTERN=y +CONFIG_NCP_FS=y +CONFIG_NCPFS_PACKET_SIGNING=y +CONFIG_NCPFS_IOCTL_LOCKING=y +CONFIG_NCPFS_STRONG=y +CONFIG_NCPFS_NFS_NS=y +CONFIG_NCPFS_OS2_NS=y +CONFIG_NCPFS_SMALLDOS=y +CONFIG_NCPFS_NLS=y +CONFIG_NCPFS_EXTRAS=y +CONFIG_PRISM2_USB=y +CONFIG_COMEDI=y +CONFIG_COMEDI_DEBUG=y +CONFIG_COMEDI_DEFAULT_BUF_SIZE_KB=2048 +CONFIG_COMEDI_DEFAULT_BUF_MAXSIZE_KB=20480 +CONFIG_COMEDI_MISC_DRIVERS=y +CONFIG_COMEDI_BOND=y +CONFIG_COMEDI_TEST=y +CONFIG_COMEDI_PARPORT=y +CONFIG_COMEDI_SERIAL2002=y +CONFIG_COMEDI_SSV_DNP=y +CONFIG_COMEDI_ISA_DRIVERS=y +CONFIG_COMEDI_PCL711=y +CONFIG_COMEDI_PCL724=y +CONFIG_COMEDI_PCL726=y +CONFIG_COMEDI_PCL730=y +CONFIG_COMEDI_PCL812=y +CONFIG_COMEDI_PCL816=y +CONFIG_COMEDI_PCL818=y +CONFIG_COMEDI_PCM3724=y +CONFIG_COMEDI_AMPLC_DIO200_ISA=y +CONFIG_COMEDI_AMPLC_PC236_ISA=y +CONFIG_COMEDI_AMPLC_PC263_ISA=y +CONFIG_COMEDI_RTI800=y +CONFIG_COMEDI_RTI802=y +CONFIG_COMEDI_DAC02=y +CONFIG_COMEDI_DAS16M1=y +CONFIG_COMEDI_DAS08_ISA=y +CONFIG_COMEDI_DAS16=y +CONFIG_COMEDI_DAS800=y +CONFIG_COMEDI_DAS1800=y +CONFIG_COMEDI_DAS6402=y +CONFIG_COMEDI_DT2801=y +CONFIG_COMEDI_DT2811=y +CONFIG_COMEDI_DT2814=y +CONFIG_COMEDI_DT2815=y +CONFIG_COMEDI_DT2817=y +CONFIG_COMEDI_DT282X=y +CONFIG_COMEDI_DMM32AT=y +CONFIG_COMEDI_FL512=y +CONFIG_COMEDI_AIO_AIO12_8=y +CONFIG_COMEDI_AIO_IIRO_16=y +CONFIG_COMEDI_II_PCI20KC=y +CONFIG_COMEDI_C6XDIGIO=y +CONFIG_COMEDI_MPC624=y +CONFIG_COMEDI_ADQ12B=y +CONFIG_COMEDI_NI_AT_A2150=y +CONFIG_COMEDI_NI_AT_AO=y +CONFIG_COMEDI_NI_ATMIO=y +CONFIG_COMEDI_NI_ATMIO16D=y +CONFIG_COMEDI_NI_LABPC_ISA=y +CONFIG_COMEDI_PCMAD=y +CONFIG_COMEDI_PCMDA12=y +CONFIG_COMEDI_PCMMIO=y +CONFIG_COMEDI_PCMUIO=y +CONFIG_COMEDI_MULTIQ3=y +CONFIG_COMEDI_S526=y +CONFIG_COMEDI_PCI_DRIVERS=y +CONFIG_COMEDI_8255_PCI=y +CONFIG_COMEDI_ADDI_WATCHDOG=y +CONFIG_COMEDI_ADDI_APCI_1032=y +CONFIG_COMEDI_ADDI_APCI_1500=y +CONFIG_COMEDI_ADDI_APCI_1516=y +CONFIG_COMEDI_ADDI_APCI_1564=y +CONFIG_COMEDI_ADDI_APCI_16XX=y +CONFIG_COMEDI_ADDI_APCI_2032=y +CONFIG_COMEDI_ADDI_APCI_2200=y +CONFIG_COMEDI_ADDI_APCI_3120=y +CONFIG_COMEDI_ADDI_APCI_3501=y +CONFIG_COMEDI_ADDI_APCI_3XXX=y +CONFIG_COMEDI_ADL_PCI6208=y +CONFIG_COMEDI_ADL_PCI7X3X=y +CONFIG_COMEDI_ADL_PCI8164=y +CONFIG_COMEDI_ADL_PCI9111=y +CONFIG_COMEDI_ADL_PCI9118=y +CONFIG_COMEDI_ADV_PCI1710=y +CONFIG_COMEDI_ADV_PCI1720=y +CONFIG_COMEDI_ADV_PCI1723=y +CONFIG_COMEDI_ADV_PCI1724=y +CONFIG_COMEDI_ADV_PCI1760=y +CONFIG_COMEDI_ADV_PCI_DIO=y +CONFIG_COMEDI_AMPLC_DIO200_PCI=y +CONFIG_COMEDI_AMPLC_PC236_PCI=y +CONFIG_COMEDI_AMPLC_PC263_PCI=y +CONFIG_COMEDI_AMPLC_PCI224=y +CONFIG_COMEDI_AMPLC_PCI230=y +CONFIG_COMEDI_CONTEC_PCI_DIO=y +CONFIG_COMEDI_DAS08_PCI=y +CONFIG_COMEDI_DT3000=y +CONFIG_COMEDI_DYNA_PCI10XX=y +CONFIG_COMEDI_GSC_HPDI=y +CONFIG_COMEDI_MF6X4=y +CONFIG_COMEDI_ICP_MULTI=y +CONFIG_COMEDI_DAQBOARD2000=y +CONFIG_COMEDI_JR3_PCI=y +CONFIG_COMEDI_KE_COUNTER=y +CONFIG_COMEDI_CB_PCIDAS64=y +CONFIG_COMEDI_CB_PCIDAS=y +CONFIG_COMEDI_CB_PCIDDA=y +CONFIG_COMEDI_CB_PCIMDAS=y +CONFIG_COMEDI_CB_PCIMDDA=y +CONFIG_COMEDI_ME4000=y +CONFIG_COMEDI_ME_DAQ=y +CONFIG_COMEDI_NI_6527=y +CONFIG_COMEDI_NI_65XX=y +CONFIG_COMEDI_NI_660X=y +CONFIG_COMEDI_NI_670X=y +CONFIG_COMEDI_NI_LABPC_PCI=y +CONFIG_COMEDI_NI_PCIDIO=y +CONFIG_COMEDI_NI_PCIMIO=y +CONFIG_COMEDI_RTD520=y +CONFIG_COMEDI_S626=y +CONFIG_COMEDI_MITE=y +CONFIG_COMEDI_NI_TIOCMD=y +CONFIG_COMEDI_PCMCIA_DRIVERS=y +CONFIG_COMEDI_CB_DAS16_CS=y +CONFIG_COMEDI_DAS08_CS=y +CONFIG_COMEDI_NI_DAQ_700_CS=y +CONFIG_COMEDI_NI_DAQ_DIO24_CS=y +CONFIG_COMEDI_NI_LABPC_CS=y +CONFIG_COMEDI_NI_MIO_CS=y +CONFIG_COMEDI_QUATECH_DAQP_CS=y +CONFIG_COMEDI_USB_DRIVERS=y +CONFIG_COMEDI_DT9812=y +CONFIG_COMEDI_NI_USB6501=y +CONFIG_COMEDI_USBDUX=y +CONFIG_COMEDI_USBDUXFAST=y +CONFIG_COMEDI_USBDUXSIGMA=y +CONFIG_COMEDI_VMK80XX=y +CONFIG_COMEDI_8254=y +CONFIG_COMEDI_8255=y +CONFIG_COMEDI_8255_SA=y +CONFIG_COMEDI_KCOMEDILIB=y +CONFIG_COMEDI_AMPLC_DIO200=y +CONFIG_COMEDI_AMPLC_PC236=y +CONFIG_COMEDI_DAS08=y +CONFIG_COMEDI_ISADMA=y +CONFIG_COMEDI_NI_LABPC=y +CONFIG_COMEDI_NI_LABPC_ISADMA=y +CONFIG_COMEDI_NI_TIO=y +CONFIG_RTL8192U=m +CONFIG_RTLLIB=m +CONFIG_RTLLIB_CRYPTO_CCMP=m +CONFIG_RTLLIB_CRYPTO_TKIP=m +CONFIG_RTLLIB_CRYPTO_WEP=m +CONFIG_RTL8192E=m +CONFIG_RTL8723BS=m +CONFIG_R8712U=y +CONFIG_R8188EU=m +CONFIG_88EU_AP_MODE=y +CONFIG_R8822BE=m +CONFIG_RTLWIFI_DEBUG_ST=y +CONFIG_RTS5208=y +CONFIG_VT6655=m +CONFIG_VT6656=m + +# +# IIO staging drivers +# + +# +# Accelerometers +# +CONFIG_ADIS16201=y +CONFIG_ADIS16203=y +CONFIG_ADIS16209=y +CONFIG_ADIS16240=y + +# +# Analog to digital converters +# +CONFIG_AD7606=y +CONFIG_AD7606_IFACE_PARALLEL=y +CONFIG_AD7606_IFACE_SPI=y +CONFIG_AD7780=y +CONFIG_AD7816=y +CONFIG_AD7192=y +CONFIG_AD7280=y + +# +# Analog digital bi-direction converters +# +CONFIG_ADT7316=y +CONFIG_ADT7316_SPI=y +CONFIG_ADT7316_I2C=y + +# +# Capacitance to digital converters +# +CONFIG_AD7150=y +CONFIG_AD7152=y +CONFIG_AD7746=y + +# +# Direct Digital Synthesis +# +CONFIG_AD9832=y +CONFIG_AD9834=y + +# +# Digital gyroscope sensors +# +CONFIG_ADIS16060=y + +# +# Network Analyzer, Impedance Converters +# +CONFIG_AD5933=y + +# +# Light sensors +# +CONFIG_TSL2x7x=y + +# +# Active energy metering IC +# +CONFIG_ADE7753=y +CONFIG_ADE7754=y +CONFIG_ADE7758=y +CONFIG_ADE7759=y +CONFIG_ADE7854=y +CONFIG_ADE7854_I2C=y +CONFIG_ADE7854_SPI=y + +# +# Resolver to digital converters +# +CONFIG_AD2S90=y +CONFIG_AD2S1200=y +CONFIG_AD2S1210=y + +# +# Triggers - standalone +# +CONFIG_FB_SM750=y +CONFIG_FB_XGI=y + +# +# Speakup console speech +# +CONFIG_SPEAKUP=y +CONFIG_SPEAKUP_SYNTH_ACNTSA=y +CONFIG_SPEAKUP_SYNTH_ACNTPC=y +CONFIG_SPEAKUP_SYNTH_APOLLO=y +CONFIG_SPEAKUP_SYNTH_AUDPTR=y +CONFIG_SPEAKUP_SYNTH_BNS=y +CONFIG_SPEAKUP_SYNTH_DECTLK=y +CONFIG_SPEAKUP_SYNTH_DECEXT=y +CONFIG_SPEAKUP_SYNTH_DECPC=m +CONFIG_SPEAKUP_SYNTH_DTLK=y +CONFIG_SPEAKUP_SYNTH_KEYPC=y +CONFIG_SPEAKUP_SYNTH_LTLK=y +CONFIG_SPEAKUP_SYNTH_SOFT=y +CONFIG_SPEAKUP_SYNTH_SPKOUT=y +CONFIG_SPEAKUP_SYNTH_TXPRT=y +CONFIG_SPEAKUP_SYNTH_DUMMY=y +CONFIG_STAGING_MEDIA=y +CONFIG_INTEL_ATOMISP=y +CONFIG_VIDEO_ATOMISP=y +CONFIG_VIDEO_ATOMISP_OV5693=y +CONFIG_VIDEO_ATOMISP_OV2722=y +CONFIG_VIDEO_ATOMISP_GC2235=y +CONFIG_VIDEO_ATOMISP_OV8858=y +CONFIG_VIDEO_ATOMISP_MSRLIST_HELPER=y +CONFIG_VIDEO_ATOMISP_MT9M114=y +CONFIG_VIDEO_ATOMISP_GC0310=y +CONFIG_VIDEO_ATOMISP_OV2680=y +CONFIG_VIDEO_ATOMISP_LM3554=y +CONFIG_I2C_BCM2048=y +CONFIG_DVB_CXD2099=y +CONFIG_TEGRA_VDE=y + +# +# Android +# +CONFIG_ASHMEM=y +CONFIG_ION=y +CONFIG_ION_SYSTEM_HEAP=y +CONFIG_ION_CARVEOUT_HEAP=y +CONFIG_ION_CHUNK_HEAP=y +CONFIG_ION_CMA_HEAP=y +CONFIG_STAGING_BOARD=y +CONFIG_LTE_GDM724X=m +CONFIG_FIREWIRE_SERIAL=y +CONFIG_FWTTY_MAX_TOTAL_PORTS=64 +CONFIG_FWTTY_MAX_CARD_PORTS=32 +CONFIG_GOLDFISH_AUDIO=y +CONFIG_MTD_GOLDFISH_NAND=y +CONFIG_MTD_SPINAND_MT29F=y +CONFIG_MTD_SPINAND_ONDIEECC=y +CONFIG_LNET=m +CONFIG_LNET_MAX_PAYLOAD=1048576 +CONFIG_LNET_SELFTEST=m +CONFIG_LNET_XPRT_IB=m +CONFIG_LUSTRE_FS=m +CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK=y +CONFIG_DGNC=y +CONFIG_GS_FPGABOOT=y +CONFIG_CRYPTO_SKEIN=y +CONFIG_UNISYSSPAR=y +CONFIG_UNISYS_VISORNIC=y +CONFIG_UNISYS_VISORINPUT=y +CONFIG_UNISYS_VISORHBA=y +CONFIG_COMMON_CLK_XLNX_CLKWZRD=y +CONFIG_FB_TFT=y +CONFIG_FB_TFT_AGM1264K_FL=y +CONFIG_FB_TFT_BD663474=y +CONFIG_FB_TFT_HX8340BN=y +CONFIG_FB_TFT_HX8347D=y +CONFIG_FB_TFT_HX8353D=y +CONFIG_FB_TFT_HX8357D=y +CONFIG_FB_TFT_ILI9163=y +CONFIG_FB_TFT_ILI9320=y +CONFIG_FB_TFT_ILI9325=y +CONFIG_FB_TFT_ILI9340=y +CONFIG_FB_TFT_ILI9341=y +CONFIG_FB_TFT_ILI9481=y +CONFIG_FB_TFT_ILI9486=y +CONFIG_FB_TFT_PCD8544=y +CONFIG_FB_TFT_RA8875=y +CONFIG_FB_TFT_S6D02A1=y +CONFIG_FB_TFT_S6D1121=y +CONFIG_FB_TFT_SH1106=y +CONFIG_FB_TFT_SSD1289=y +CONFIG_FB_TFT_SSD1305=y +CONFIG_FB_TFT_SSD1306=y +CONFIG_FB_TFT_SSD1331=y +CONFIG_FB_TFT_SSD1351=y +CONFIG_FB_TFT_ST7735R=y +CONFIG_FB_TFT_ST7789V=y +CONFIG_FB_TFT_TINYLCD=y +CONFIG_FB_TFT_TLS8204=y +CONFIG_FB_TFT_UC1611=y +CONFIG_FB_TFT_UC1701=y +CONFIG_FB_TFT_UPD161704=y +CONFIG_FB_TFT_WATTEROTT=y +CONFIG_FB_FLEX=y +CONFIG_FB_TFT_FBTFT_DEVICE=y +CONFIG_FSL_MC_BUS=y +CONFIG_WILC1000=y +CONFIG_WILC1000_SDIO=y +CONFIG_WILC1000_SPI=y +CONFIG_WILC1000_HW_OOB_INTR=y +CONFIG_MOST=y +CONFIG_MOST_CDEV=y +CONFIG_MOST_NET=y +CONFIG_MOST_SOUND=y +CONFIG_MOST_VIDEO=y +CONFIG_MOST_DIM2=y +CONFIG_MOST_I2C=y +CONFIG_MOST_USB=y +CONFIG_KS7010=y +CONFIG_GREYBUS=y +CONFIG_GREYBUS_ES2=y +CONFIG_GREYBUS_AUDIO=y +CONFIG_GREYBUS_BOOTROM=y +CONFIG_GREYBUS_FIRMWARE=y +CONFIG_GREYBUS_HID=y +CONFIG_GREYBUS_LIGHT=y +CONFIG_GREYBUS_LOG=y +CONFIG_GREYBUS_LOOPBACK=y +CONFIG_GREYBUS_POWER=y +CONFIG_GREYBUS_RAW=y +CONFIG_GREYBUS_VIBRATOR=y +CONFIG_GREYBUS_BRIDGED_PHY=y +CONFIG_GREYBUS_GPIO=y +CONFIG_GREYBUS_I2C=y +CONFIG_GREYBUS_PWM=y +CONFIG_GREYBUS_SDIO=y +CONFIG_GREYBUS_SPI=y +CONFIG_GREYBUS_UART=y +CONFIG_GREYBUS_USB=y +CONFIG_GREYBUS_ARCHE=y +CONFIG_BCM_VIDEOCORE=y +CONFIG_BCM2835_VCHIQ=y +CONFIG_VIDEO_BCM2835=y +CONFIG_CRYPTO_DEV_CCREE=y + +# +# USB Power Delivery and Type-C drivers +# +CONFIG_TYPEC_TCPCI=y +CONFIG_DRM_VBOXVIDEO=y +CONFIG_PI433=y +CONFIG_X86_PLATFORM_DEVICES=y +CONFIG_ACER_WMI=y +CONFIG_ACER_WIRELESS=y +CONFIG_ACERHDF=y +CONFIG_ALIENWARE_WMI=y +CONFIG_ASUS_LAPTOP=y +CONFIG_DELL_SMBIOS=y +CONFIG_DELL_SMBIOS_WMI=y +CONFIG_DELL_SMBIOS_SMM=y +CONFIG_DELL_LAPTOP=y +CONFIG_DELL_WMI=y +CONFIG_DELL_WMI_DESCRIPTOR=y +CONFIG_DELL_WMI_AIO=y +CONFIG_DELL_WMI_LED=y +CONFIG_DELL_SMO8800=y +CONFIG_DELL_RBTN=y +CONFIG_FUJITSU_LAPTOP=y +CONFIG_FUJITSU_TABLET=y +CONFIG_AMILO_RFKILL=y +CONFIG_GPD_POCKET_FAN=y +CONFIG_HP_ACCEL=y +CONFIG_HP_WIRELESS=y +CONFIG_HP_WMI=y +CONFIG_MSI_LAPTOP=y +CONFIG_PANASONIC_LAPTOP=y +CONFIG_COMPAL_LAPTOP=y +CONFIG_SONY_LAPTOP=y +CONFIG_SONYPI_COMPAT=y +CONFIG_IDEAPAD_LAPTOP=y +CONFIG_SURFACE3_WMI=y +CONFIG_THINKPAD_ACPI=y +CONFIG_THINKPAD_ACPI_ALSA_SUPPORT=y +CONFIG_THINKPAD_ACPI_DEBUGFACILITIES=y +CONFIG_THINKPAD_ACPI_DEBUG=y +CONFIG_THINKPAD_ACPI_UNSAFE_LEDS=y +CONFIG_THINKPAD_ACPI_VIDEO=y +CONFIG_THINKPAD_ACPI_HOTKEY_POLL=y +CONFIG_SENSORS_HDAPS=y +CONFIG_INTEL_MENLOW=y +CONFIG_EEEPC_LAPTOP=y +CONFIG_ASUS_WMI=y +CONFIG_ASUS_NB_WMI=y +CONFIG_EEEPC_WMI=y +CONFIG_ASUS_WIRELESS=y +CONFIG_ACPI_WMI=y +CONFIG_WMI_BMOF=y +CONFIG_INTEL_WMI_THUNDERBOLT=y +CONFIG_MSI_WMI=y +CONFIG_PEAQ_WMI=y +CONFIG_TOPSTAR_LAPTOP=y +CONFIG_ACPI_TOSHIBA=y +CONFIG_TOSHIBA_BT_RFKILL=y +CONFIG_TOSHIBA_HAPS=y +CONFIG_TOSHIBA_WMI=y +CONFIG_ACPI_CMPC=y +CONFIG_INTEL_CHT_INT33FE=y +CONFIG_INTEL_INT0002_VGPIO=y +CONFIG_INTEL_HID_EVENT=y +CONFIG_INTEL_VBTN=y +CONFIG_INTEL_SCU_IPC=y +CONFIG_INTEL_SCU_IPC_UTIL=y +CONFIG_INTEL_MID_POWER_BUTTON=y +CONFIG_INTEL_MFLD_THERMAL=y +CONFIG_INTEL_IPS=y +CONFIG_INTEL_PMC_CORE=y +CONFIG_IBM_RTL=y +CONFIG_XO1_RFKILL=y +CONFIG_XO15_EBOOK=y +CONFIG_SAMSUNG_LAPTOP=y +CONFIG_MXM_WMI=y +CONFIG_INTEL_OAKTRAIL=y +CONFIG_SAMSUNG_Q10=y +CONFIG_APPLE_GMUX=y +CONFIG_INTEL_RST=y +CONFIG_INTEL_SMARTCONNECT=y +CONFIG_PVPANIC=y +CONFIG_INTEL_PMC_IPC=y +CONFIG_INTEL_BXTWC_PMIC_TMU=y +CONFIG_SURFACE_PRO3_BUTTON=y +CONFIG_SURFACE_3_BUTTON=y +CONFIG_INTEL_PUNIT_IPC=y +CONFIG_INTEL_TELEMETRY=y +CONFIG_MLX_PLATFORM=y +CONFIG_INTEL_TURBO_MAX_3=y +CONFIG_SILEAD_DMI=y +CONFIG_INTEL_CHTDC_TI_PWRBTN=y +CONFIG_PMC_ATOM=y +CONFIG_GOLDFISH_BUS=y +CONFIG_GOLDFISH_PIPE=y +CONFIG_CHROME_PLATFORMS=y +CONFIG_CHROMEOS_LAPTOP=y +CONFIG_CHROMEOS_PSTORE=y +CONFIG_CROS_EC_CTL=y +CONFIG_CROS_EC_LPC=y +CONFIG_CROS_EC_LPC_MEC=y +CONFIG_CROS_EC_PROTO=y +CONFIG_CROS_KBD_LED_BACKLIGHT=y +CONFIG_MELLANOX_PLATFORM=y +CONFIG_MLXREG_HOTPLUG=y +CONFIG_CLKDEV_LOOKUP=y +CONFIG_HAVE_CLK_PREPARE=y +CONFIG_COMMON_CLK=y + +# +# Common Clock Framework +# +CONFIG_COMMON_CLK_WM831X=y +CONFIG_COMMON_CLK_VERSATILE=y +CONFIG_CLK_SP810=y +CONFIG_CLK_HSDK=y +CONFIG_COMMON_CLK_MAX77686=y +CONFIG_COMMON_CLK_RK808=y +CONFIG_COMMON_CLK_HI655X=y +CONFIG_COMMON_CLK_SCPI=y +CONFIG_COMMON_CLK_SI5351=y +CONFIG_COMMON_CLK_SI514=y +CONFIG_COMMON_CLK_SI570=y +CONFIG_COMMON_CLK_CDCE706=y +CONFIG_COMMON_CLK_CDCE925=y +CONFIG_COMMON_CLK_CS2000_CP=y +CONFIG_COMMON_CLK_GEMINI=y +CONFIG_COMMON_CLK_ASPEED=y +CONFIG_COMMON_CLK_S2MPS11=y +CONFIG_CLK_TWL6040=y +CONFIG_COMMON_CLK_AXI_CLKGEN=y +CONFIG_CLK_QORIQ=y +CONFIG_COMMON_CLK_XGENE=y +# CONFIG_COMMON_CLK_NXP is not set +CONFIG_COMMON_CLK_PALMAS=y +CONFIG_COMMON_CLK_PWM=y +# CONFIG_COMMON_CLK_PXA is not set +# CONFIG_COMMON_CLK_PIC32 is not set +CONFIG_COMMON_CLK_OXNAS=y +CONFIG_COMMON_CLK_VC5=y +CONFIG_CLK_BCM_63XX=y +CONFIG_CLK_BCM_KONA=y +CONFIG_COMMON_CLK_IPROC=y +CONFIG_CLK_BCM_CYGNUS=y +CONFIG_CLK_BCM_HR2=y +CONFIG_CLK_BCM_NSP=y +CONFIG_CLK_BCM_NS2=y +CONFIG_CLK_BCM_SR=y +CONFIG_COMMON_CLK_HI3516CV300=y +CONFIG_COMMON_CLK_HI3519=y +CONFIG_COMMON_CLK_HI3660=y +CONFIG_COMMON_CLK_HI3798CV200=y +CONFIG_COMMON_CLK_HI6220=y +CONFIG_RESET_HISI=y +CONFIG_STUB_CLK_HI6220=y +CONFIG_STUB_CLK_HI3660=y +CONFIG_COMMON_CLK_BOSTON=y +CONFIG_COMMON_CLK_KEYSTONE=y + +# +# Clock driver for MediaTek SoC +# +CONFIG_COMMON_CLK_MEDIATEK=y +CONFIG_COMMON_CLK_MT2701=y +CONFIG_COMMON_CLK_MT2701_MMSYS=y +CONFIG_COMMON_CLK_MT2701_IMGSYS=y +CONFIG_COMMON_CLK_MT2701_VDECSYS=y +CONFIG_COMMON_CLK_MT2701_HIFSYS=y +CONFIG_COMMON_CLK_MT2701_ETHSYS=y +CONFIG_COMMON_CLK_MT2701_BDPSYS=y +CONFIG_COMMON_CLK_MT2712=y +CONFIG_COMMON_CLK_MT2712_BDPSYS=y +CONFIG_COMMON_CLK_MT2712_IMGSYS=y +CONFIG_COMMON_CLK_MT2712_JPGDECSYS=y +CONFIG_COMMON_CLK_MT2712_MFGCFG=y +CONFIG_COMMON_CLK_MT2712_MMSYS=y +CONFIG_COMMON_CLK_MT2712_VDECSYS=y +CONFIG_COMMON_CLK_MT2712_VENCSYS=y +CONFIG_COMMON_CLK_MT6797=y +CONFIG_COMMON_CLK_MT6797_MMSYS=y +CONFIG_COMMON_CLK_MT6797_IMGSYS=y +CONFIG_COMMON_CLK_MT6797_VDECSYS=y +CONFIG_COMMON_CLK_MT6797_VENCSYS=y +CONFIG_COMMON_CLK_MT7622=y +CONFIG_COMMON_CLK_MT7622_ETHSYS=y +CONFIG_COMMON_CLK_MT7622_HIFSYS=y +CONFIG_COMMON_CLK_MT7622_AUDSYS=y +CONFIG_COMMON_CLK_MT8135=y +CONFIG_COMMON_CLK_MT8173=y +CONFIG_QCOM_GDSC=y +CONFIG_COMMON_CLK_QCOM=y +CONFIG_QCOM_A53PLL=y +CONFIG_QCOM_CLK_APCS_MSM8916=y +CONFIG_APQ_GCC_8084=y +CONFIG_APQ_MMCC_8084=y +CONFIG_IPQ_GCC_4019=y +CONFIG_IPQ_GCC_806X=y +CONFIG_IPQ_LCC_806X=y +CONFIG_IPQ_GCC_8074=y +CONFIG_MSM_GCC_8660=y +CONFIG_MSM_GCC_8916=y +CONFIG_MSM_GCC_8960=y +CONFIG_MSM_LCC_8960=y +CONFIG_MDM_GCC_9615=y +CONFIG_MDM_LCC_9615=y +CONFIG_MSM_MMCC_8960=y +CONFIG_MSM_GCC_8974=y +CONFIG_MSM_MMCC_8974=y +CONFIG_MSM_GCC_8994=y +CONFIG_MSM_GCC_8996=y +CONFIG_MSM_MMCC_8996=y +CONFIG_SPMI_PMIC_CLKDIV=y +CONFIG_CLK_RENESAS=y +CONFIG_CLK_RENESAS_LEGACY=y +CONFIG_CLK_EMEV2=y +CONFIG_CLK_RZA1=y +CONFIG_CLK_R8A73A4=y +CONFIG_CLK_R8A7740=y +CONFIG_CLK_R8A7743=y +CONFIG_CLK_R8A7745=y +CONFIG_CLK_R8A7778=y +CONFIG_CLK_R8A7779=y +CONFIG_CLK_R8A7790=y +CONFIG_CLK_R8A7791=y +CONFIG_CLK_R8A7792=y +CONFIG_CLK_R8A7794=y +CONFIG_CLK_R8A7795=y +CONFIG_CLK_R8A7796=y +CONFIG_CLK_R8A77970=y +CONFIG_CLK_R8A77995=y +CONFIG_CLK_SH73A0=y +CONFIG_CLK_RCAR_GEN2=y +CONFIG_CLK_RCAR_GEN2_CPG=y +CONFIG_CLK_RCAR_GEN3_CPG=y +CONFIG_CLK_RCAR_USB2_CLOCK_SEL=y +CONFIG_CLK_RENESAS_CPG_MSSR=y +CONFIG_CLK_RENESAS_CPG_MSTP=y +CONFIG_CLK_RENESAS_DIV6=y +CONFIG_COMMON_CLK_SAMSUNG=y +CONFIG_EXYNOS_ARM64_COMMON_CLK=y +CONFIG_EXYNOS_AUDSS_CLK_CON=y +CONFIG_S3C2410_COMMON_CLK=y +CONFIG_S3C2412_COMMON_CLK=y +CONFIG_S3C2443_COMMON_CLK=y +CONFIG_SPRD_COMMON_CLK=y +CONFIG_SPRD_SC9860_CLK=y +CONFIG_SUNXI_CCU=y +CONFIG_SUN50I_A64_CCU=y +CONFIG_SUN4I_A10_CCU=y +CONFIG_SUN5I_CCU=y +CONFIG_SUN6I_A31_CCU=y +CONFIG_SUN8I_A23_CCU=y +CONFIG_SUN8I_A33_CCU=y +CONFIG_SUN8I_A83T_CCU=y +CONFIG_SUN8I_H3_CCU=y +CONFIG_SUN8I_V3S_CCU=y +CONFIG_SUN8I_DE2_CCU=y +CONFIG_SUN8I_R40_CCU=y +CONFIG_SUN9I_A80_CCU=y +CONFIG_SUN8I_R_CCU=y +CONFIG_COMMON_CLK_TI_ADPLL=y +CONFIG_CLK_UNIPHIER=y +CONFIG_HWSPINLOCK=y + +# +# Clock Source drivers +# +CONFIG_TIMER_OF=y +CONFIG_TIMER_PROBE=y +CONFIG_CLKEVT_I8253=y +CONFIG_I8253_LOCK=y +CONFIG_CLKBLD_I8253=y +CONFIG_CLKSRC_MMIO=y +CONFIG_BCM2835_TIMER=y +CONFIG_BCM_KONA_TIMER=y +CONFIG_DIGICOLOR_TIMER=y +CONFIG_DW_APB_TIMER=y +CONFIG_FTTMR010_TIMER=y +CONFIG_MESON6_TIMER=y +CONFIG_OWL_TIMER=y +CONFIG_SUN4I_TIMER=y +CONFIG_SUN5I_HSTIMER=y +CONFIG_VT8500_TIMER=y +CONFIG_CADENCE_TTC_TIMER=y +CONFIG_ASM9260_TIMER=y +CONFIG_CLKSRC_DBX500_PRCMU=y +CONFIG_CLPS711X_TIMER=y +CONFIG_ATLAS7_TIMER=y +CONFIG_MXS_TIMER=y +CONFIG_PRIMA2_TIMER=y +CONFIG_NSPIRE_TIMER=y +CONFIG_INTEGRATOR_AP_TIMER=y +CONFIG_CLKSRC_DBX500_PRCMU_SCHED_CLOCK=y +CONFIG_CLKSRC_PISTACHIO=y +CONFIG_ARC_TIMERS=y +CONFIG_ARC_TIMERS_64BIT=y +CONFIG_ARMV7M_SYSTICK=y +# CONFIG_ATMEL_PIT is not set +CONFIG_ATMEL_ST=y +CONFIG_CLKSRC_SAMSUNG_PWM=y +CONFIG_FSL_FTM_TIMER=y +CONFIG_OXNAS_RPS_TIMER=y +CONFIG_MTK_TIMER=y +CONFIG_SPRD_TIMER=y +CONFIG_CLKSRC_JCORE_PIT=y +CONFIG_SH_TIMER_CMT=y +CONFIG_SH_TIMER_MTU2=y +CONFIG_RENESAS_OSTM=y +CONFIG_SH_TIMER_TMU=y +CONFIG_EM_TIMER_STI=y +CONFIG_CLKSRC_PXA=y +CONFIG_H8300_TMR8=y +CONFIG_H8300_TMR16=y +CONFIG_H8300_TPU=y +CONFIG_CLKSRC_ST_LPC=y +CONFIG_MAILBOX=y +CONFIG_PLATFORM_MHU=y +CONFIG_ROCKCHIP_MBOX=y +CONFIG_PCC=y +CONFIG_ALTERA_MBOX=y +CONFIG_MAILBOX_TEST=y +CONFIG_QCOM_APCS_IPC=y +CONFIG_BCM_PDC_MBOX=y +CONFIG_IOMMU_API=y +CONFIG_IOMMU_SUPPORT=y + +# +# Generic IOMMU Pagetable Support +# +CONFIG_IOMMU_IO_PGTABLE=y +CONFIG_IOMMU_IO_PGTABLE_LPAE=y +CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST=y +CONFIG_IOMMU_IO_PGTABLE_ARMV7S=y +CONFIG_IOMMU_IO_PGTABLE_ARMV7S_SELFTEST=y +CONFIG_IOMMU_IOVA=y +CONFIG_OF_IOMMU=y +CONFIG_AMD_IOMMU=y +CONFIG_AMD_IOMMU_V2=y +CONFIG_DMAR_TABLE=y +CONFIG_INTEL_IOMMU=y +CONFIG_INTEL_IOMMU_SVM=y +CONFIG_INTEL_IOMMU_DEFAULT_ON=y +CONFIG_INTEL_IOMMU_FLOPPY_WA=y +CONFIG_IRQ_REMAP=y +CONFIG_QCOM_IOMMU=y + +# +# Remoteproc drivers +# +CONFIG_REMOTEPROC=y + +# +# Rpmsg drivers +# +CONFIG_RPMSG=y +CONFIG_RPMSG_CHAR=y +CONFIG_RPMSG_QCOM_GLINK_NATIVE=y +CONFIG_RPMSG_QCOM_GLINK_RPM=y +CONFIG_RPMSG_VIRTIO=y +CONFIG_SOUNDWIRE=y + +# +# SoundWire Devices +# +CONFIG_SOUNDWIRE_BUS=y +CONFIG_SOUNDWIRE_CADENCE=y +CONFIG_SOUNDWIRE_INTEL=y + +# +# SOC (System On Chip) specific Drivers +# +CONFIG_OWL_PM_DOMAINS_HELPER=y +CONFIG_OWL_PM_DOMAINS=y + +# +# Amlogic SoC drivers +# +CONFIG_MESON_GX_SOCINFO=y +CONFIG_MESON_GX_PM_DOMAINS=y +CONFIG_MESON_MX_SOCINFO=y +CONFIG_AT91_SOC_ID=y + +# +# Broadcom SoC drivers +# +CONFIG_SOC_BRCMSTB=y + +# +# i.MX SoC drivers +# +CONFIG_IMX7_PM_DOMAINS=y + +# +# MediaTek SoC drivers +# +CONFIG_MTK_INFRACFG=y +CONFIG_MTK_PMIC_WRAP=y +CONFIG_MTK_SCPSYS=y + +# +# Qualcomm SoC drivers +# +CONFIG_SOC_RENESAS=y +CONFIG_SYSC_R8A7743=y +CONFIG_SYSC_R8A7745=y +CONFIG_SYSC_R8A7779=y +CONFIG_SYSC_R8A7790=y +CONFIG_SYSC_R8A7791=y +CONFIG_SYSC_R8A7792=y +CONFIG_SYSC_R8A7794=y +CONFIG_SYSC_R8A7795=y +CONFIG_SYSC_R8A7796=y +CONFIG_SYSC_R8A77970=y +CONFIG_SYSC_R8A77995=y +CONFIG_RST_RCAR=y +CONFIG_SYSC_RCAR=y +CONFIG_ROCKCHIP_GRF=y +CONFIG_ROCKCHIP_PM_DOMAINS=y +CONFIG_SOC_SAMSUNG=y +CONFIG_EXYNOS_PM_DOMAINS=y +# CONFIG_SUNXI_SRAM is not set +CONFIG_SOC_TI=y +CONFIG_UX500_SOC_ID=y + +# +# Xilinx SoC drivers +# +CONFIG_XILINX_VCU=y +CONFIG_SOC_ZTE=y +CONFIG_ZX2967_PM_DOMAINS=y +CONFIG_PM_DEVFREQ=y + +# +# DEVFREQ Governors +# +CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND=y +CONFIG_DEVFREQ_GOV_PERFORMANCE=y +CONFIG_DEVFREQ_GOV_POWERSAVE=y +CONFIG_DEVFREQ_GOV_USERSPACE=y +CONFIG_DEVFREQ_GOV_PASSIVE=y + +# +# DEVFREQ Drivers +# +CONFIG_ARM_EXYNOS_BUS_DEVFREQ=y +CONFIG_PM_DEVFREQ_EVENT=y +CONFIG_DEVFREQ_EVENT_EXYNOS_NOCP=y +CONFIG_DEVFREQ_EVENT_EXYNOS_PPMU=y +CONFIG_EXTCON=y + +# +# Extcon Device Drivers +# +CONFIG_EXTCON_ADC_JACK=y +CONFIG_EXTCON_ARIZONA=y +CONFIG_EXTCON_AXP288=y +CONFIG_EXTCON_GPIO=y +CONFIG_EXTCON_INTEL_INT3496=y +CONFIG_EXTCON_INTEL_CHT_WC=y +CONFIG_EXTCON_MAX14577=y +CONFIG_EXTCON_MAX3355=y +CONFIG_EXTCON_MAX77693=y +CONFIG_EXTCON_MAX77843=y +CONFIG_EXTCON_MAX8997=y +CONFIG_EXTCON_PALMAS=y +CONFIG_EXTCON_QCOM_SPMI_MISC=y +CONFIG_EXTCON_RT8973A=y +CONFIG_EXTCON_SM5502=y +CONFIG_EXTCON_USB_GPIO=y +CONFIG_EXTCON_USBC_CROS_EC=y +CONFIG_MEMORY=y +CONFIG_SAMSUNG_MC=y +CONFIG_EXYNOS_SROM=y +CONFIG_IIO=y +CONFIG_IIO_BUFFER=y +CONFIG_IIO_BUFFER_CB=y +CONFIG_IIO_BUFFER_HW_CONSUMER=y +CONFIG_IIO_KFIFO_BUF=y +CONFIG_IIO_TRIGGERED_BUFFER=y +CONFIG_IIO_CONFIGFS=y +CONFIG_IIO_TRIGGER=y +CONFIG_IIO_CONSUMERS_PER_TRIGGER=2 +CONFIG_IIO_SW_DEVICE=y +CONFIG_IIO_SW_TRIGGER=y +CONFIG_IIO_TRIGGERED_EVENT=y + +# +# Accelerometers +# +CONFIG_BMA180=y +CONFIG_BMA220=y +CONFIG_BMC150_ACCEL=y +CONFIG_BMC150_ACCEL_I2C=y +CONFIG_BMC150_ACCEL_SPI=y +CONFIG_DA280=y +CONFIG_DA311=y +CONFIG_DMARD06=y +CONFIG_DMARD09=y +CONFIG_DMARD10=y +CONFIG_HID_SENSOR_ACCEL_3D=y +CONFIG_IIO_CROS_EC_ACCEL_LEGACY=y +CONFIG_KXSD9=y +CONFIG_KXSD9_SPI=y +CONFIG_KXSD9_I2C=y +CONFIG_KXCJK1013=y +CONFIG_MC3230=y +CONFIG_MMA7455=y +CONFIG_MMA7455_I2C=y +CONFIG_MMA7455_SPI=y +CONFIG_MMA7660=y +CONFIG_MMA8452=y +CONFIG_MMA9551_CORE=y +CONFIG_MMA9551=y +CONFIG_MMA9553=y +CONFIG_MXC4005=y +CONFIG_MXC6255=y +CONFIG_SCA3000=y +CONFIG_STK8312=y +CONFIG_STK8BA50=y + +# +# Analog to digital converters +# +CONFIG_AD_SIGMA_DELTA=y +CONFIG_AD7266=y +CONFIG_AD7291=y +CONFIG_AD7298=y +CONFIG_AD7476=y +CONFIG_AD7766=y +CONFIG_AD7791=y +CONFIG_AD7793=y +CONFIG_AD7887=y +CONFIG_AD7923=y +CONFIG_AD799X=y +CONFIG_ASPEED_ADC=y +CONFIG_AT91_SAMA5D2_ADC=y +CONFIG_AXP20X_ADC=y +CONFIG_AXP288_ADC=y +CONFIG_BCM_IPROC_ADC=y +CONFIG_CC10001_ADC=y +CONFIG_CPCAP_ADC=y +CONFIG_DA9150_GPADC=y +CONFIG_DLN2_ADC=y +CONFIG_ENVELOPE_DETECTOR=y +CONFIG_EXYNOS_ADC=y +CONFIG_MXS_LRADC_ADC=y +CONFIG_FSL_MX25_ADC=y +CONFIG_HI8435=y +CONFIG_HX711=y +CONFIG_IMX7D_ADC=y +CONFIG_LP8788_ADC=y +CONFIG_LPC18XX_ADC=y +CONFIG_LPC32XX_ADC=y +CONFIG_LTC2471=y +CONFIG_LTC2485=y +CONFIG_LTC2497=y +CONFIG_MAX1027=y +CONFIG_MAX11100=y +CONFIG_MAX1118=y +CONFIG_MAX1363=y +CONFIG_MAX9611=y +CONFIG_MCP320X=y +CONFIG_MCP3422=y +CONFIG_MEDIATEK_MT6577_AUXADC=y +CONFIG_MEN_Z188_ADC=y +CONFIG_MESON_SARADC=y +CONFIG_NAU7802=y +CONFIG_PALMAS_GPADC=y +CONFIG_QCOM_VADC_COMMON=y +CONFIG_QCOM_PM8XXX_XOADC=y +CONFIG_QCOM_SPMI_IADC=y +CONFIG_QCOM_SPMI_VADC=y +CONFIG_RCAR_GYRO_ADC=y +CONFIG_SPEAR_ADC=y +CONFIG_SD_ADC_MODULATOR=y +CONFIG_STM32_ADC_CORE=y +CONFIG_STM32_ADC=y +CONFIG_STM32_DFSDM_CORE=y +CONFIG_STM32_DFSDM_ADC=y +CONFIG_STX104=y +CONFIG_TI_ADC081C=y +CONFIG_TI_ADC0832=y +CONFIG_TI_ADC084S021=y +CONFIG_TI_ADC12138=y +CONFIG_TI_ADC108S102=y +CONFIG_TI_ADC128S052=y +CONFIG_TI_ADC161S626=y +CONFIG_TI_ADS7950=y +CONFIG_TI_ADS8688=y +CONFIG_TI_AM335X_ADC=y +CONFIG_TI_TLC4541=y +CONFIG_TWL4030_MADC=y +CONFIG_TWL6030_GPADC=y +CONFIG_VF610_ADC=y +CONFIG_VIPERBOARD_ADC=y +CONFIG_XILINX_XADC=y + +# +# Amplifiers +# +CONFIG_AD8366=y + +# +# Chemical Sensors +# +CONFIG_ATLAS_PH_SENSOR=y +CONFIG_CCS811=y +CONFIG_IAQCORE=y +CONFIG_VZ89X=y +CONFIG_IIO_CROS_EC_SENSORS_CORE=y +CONFIG_IIO_CROS_EC_SENSORS=y + +# +# Hid Sensor IIO Common +# +CONFIG_HID_SENSOR_IIO_COMMON=y +CONFIG_HID_SENSOR_IIO_TRIGGER=y +CONFIG_IIO_MS_SENSORS_I2C=y + +# +# SSP Sensor Common +# +CONFIG_IIO_SSP_SENSORS_COMMONS=y +CONFIG_IIO_SSP_SENSORHUB=y +CONFIG_IIO_ST_SENSORS_I2C=y +CONFIG_IIO_ST_SENSORS_SPI=y +CONFIG_IIO_ST_SENSORS_CORE=y + +# +# Counters +# +CONFIG_104_QUAD_8=y +CONFIG_STM32_LPTIMER_CNT=y + +# +# Digital to analog converters +# +CONFIG_AD5064=y +CONFIG_AD5360=y +CONFIG_AD5380=y +CONFIG_AD5421=y +CONFIG_AD5446=y +CONFIG_AD5449=y +CONFIG_AD5592R_BASE=y +CONFIG_AD5592R=y +CONFIG_AD5593R=y +CONFIG_AD5504=y +CONFIG_AD5624R_SPI=y +CONFIG_LTC2632=y +CONFIG_AD5686=y +CONFIG_AD5755=y +CONFIG_AD5761=y +CONFIG_AD5764=y +CONFIG_AD5791=y +CONFIG_AD7303=y +CONFIG_CIO_DAC=y +CONFIG_AD8801=y +CONFIG_DPOT_DAC=y +CONFIG_DS4424=y +CONFIG_LPC18XX_DAC=y +CONFIG_M62332=y +CONFIG_MAX517=y +CONFIG_MAX5821=y +CONFIG_MCP4725=y +CONFIG_MCP4922=y +CONFIG_STM32_DAC=y +CONFIG_STM32_DAC_CORE=y +CONFIG_TI_DAC082S085=y +CONFIG_VF610_DAC=y + +# +# IIO dummy driver +# +CONFIG_IIO_DUMMY_EVGEN=y +CONFIG_IIO_SIMPLE_DUMMY=y +CONFIG_IIO_SIMPLE_DUMMY_EVENTS=y +CONFIG_IIO_SIMPLE_DUMMY_BUFFER=y + +# +# Frequency Synthesizers DDS/PLL +# + +# +# Clock Generator/Distribution +# +CONFIG_AD9523=y + +# +# Phase-Locked Loop (PLL) frequency synthesizers +# +CONFIG_ADF4350=y + +# +# Digital gyroscope sensors +# +CONFIG_ADIS16080=y +CONFIG_ADIS16130=y +CONFIG_ADIS16136=y +CONFIG_ADIS16260=y +CONFIG_ADXRS450=y +CONFIG_BMG160=y +CONFIG_BMG160_I2C=y +CONFIG_BMG160_SPI=y +CONFIG_HID_SENSOR_GYRO_3D=y +CONFIG_MPU3050=y +CONFIG_MPU3050_I2C=y +CONFIG_IIO_ST_GYRO_3AXIS=y +CONFIG_IIO_ST_GYRO_I2C_3AXIS=y +CONFIG_IIO_ST_GYRO_SPI_3AXIS=y +CONFIG_ITG3200=y + +# +# Health Sensors +# + +# +# Heart Rate Monitors +# +CONFIG_AFE4403=y +CONFIG_AFE4404=y +CONFIG_MAX30100=y +CONFIG_MAX30102=y + +# +# Humidity sensors +# +CONFIG_AM2315=y +CONFIG_DHT11=y +CONFIG_HDC100X=y +CONFIG_HID_SENSOR_HUMIDITY=y +CONFIG_HTS221=y +CONFIG_HTS221_I2C=y +CONFIG_HTS221_SPI=y +CONFIG_HTU21=y +CONFIG_SI7005=y +CONFIG_SI7020=y + +# +# Inertial measurement units +# +CONFIG_ADIS16400=y +CONFIG_ADIS16480=y +CONFIG_BMI160=y +CONFIG_BMI160_I2C=y +CONFIG_BMI160_SPI=y +CONFIG_KMX61=y +CONFIG_INV_MPU6050_IIO=y +CONFIG_INV_MPU6050_I2C=y +CONFIG_INV_MPU6050_SPI=y +CONFIG_IIO_ST_LSM6DSX=y +CONFIG_IIO_ST_LSM6DSX_I2C=y +CONFIG_IIO_ST_LSM6DSX_SPI=y +CONFIG_IIO_ADIS_LIB=y +CONFIG_IIO_ADIS_LIB_BUFFER=y + +# +# Light sensors +# +CONFIG_ACPI_ALS=y +CONFIG_ADJD_S311=y +CONFIG_AL3320A=y +CONFIG_APDS9300=y +CONFIG_APDS9960=y +CONFIG_BH1750=y +CONFIG_BH1780=y +CONFIG_CM32181=y +CONFIG_CM3232=y +CONFIG_CM3323=y +CONFIG_CM3605=y +CONFIG_CM36651=y +CONFIG_IIO_CROS_EC_LIGHT_PROX=y +CONFIG_GP2AP020A00F=y +CONFIG_SENSORS_ISL29018=y +CONFIG_SENSORS_ISL29028=y +CONFIG_ISL29125=y +CONFIG_HID_SENSOR_ALS=y +CONFIG_HID_SENSOR_PROX=y +CONFIG_JSA1212=y +CONFIG_RPR0521=y +CONFIG_SENSORS_LM3533=y +CONFIG_LTR501=y +CONFIG_MAX44000=y +CONFIG_OPT3001=y +CONFIG_PA12203001=y +CONFIG_SI1145=y +CONFIG_STK3310=y +CONFIG_ST_UVIS25=y +CONFIG_ST_UVIS25_I2C=y +CONFIG_ST_UVIS25_SPI=y +CONFIG_TCS3414=y +CONFIG_TCS3472=y +CONFIG_SENSORS_TSL2563=y +CONFIG_TSL2583=y +CONFIG_TSL4531=y +CONFIG_US5182D=y +CONFIG_VCNL4000=y +CONFIG_VEML6070=y +CONFIG_VL6180=y +CONFIG_ZOPT2201=y + +# +# Magnetometer sensors +# +CONFIG_AK8974=y +CONFIG_AK8975=y +CONFIG_AK09911=y +CONFIG_BMC150_MAGN=y +CONFIG_BMC150_MAGN_I2C=y +CONFIG_BMC150_MAGN_SPI=y +CONFIG_MAG3110=y +CONFIG_HID_SENSOR_MAGNETOMETER_3D=y +CONFIG_MMC35240=y +CONFIG_IIO_ST_MAGN_3AXIS=y +CONFIG_IIO_ST_MAGN_I2C_3AXIS=y +CONFIG_IIO_ST_MAGN_SPI_3AXIS=y +CONFIG_SENSORS_HMC5843=y +CONFIG_SENSORS_HMC5843_I2C=y +CONFIG_SENSORS_HMC5843_SPI=y + +# +# Multiplexers +# +CONFIG_IIO_MUX=y + +# +# Inclinometer sensors +# +CONFIG_HID_SENSOR_INCLINOMETER_3D=y +CONFIG_HID_SENSOR_DEVICE_ROTATION=y + +# +# Triggers - standalone +# +CONFIG_IIO_HRTIMER_TRIGGER=y +CONFIG_IIO_INTERRUPT_TRIGGER=y +CONFIG_IIO_STM32_LPTIMER_TRIGGER=y +CONFIG_IIO_STM32_TIMER_TRIGGER=y +CONFIG_IIO_TIGHTLOOP_TRIGGER=y +CONFIG_IIO_SYSFS_TRIGGER=y + +# +# Digital potentiometers +# +CONFIG_DS1803=y +CONFIG_MAX5481=y +CONFIG_MAX5487=y +CONFIG_MCP4131=y +CONFIG_MCP4531=y +CONFIG_TPL0102=y + +# +# Digital potentiostats +# +CONFIG_LMP91000=y + +# +# Pressure sensors +# +CONFIG_ABP060MG=y +CONFIG_BMP280=y +CONFIG_BMP280_I2C=y +CONFIG_BMP280_SPI=y +CONFIG_IIO_CROS_EC_BARO=y +CONFIG_HID_SENSOR_PRESS=y +CONFIG_HP03=y +CONFIG_MPL115=y +CONFIG_MPL115_I2C=y +CONFIG_MPL115_SPI=y +CONFIG_MPL3115=y +CONFIG_MS5611=y +CONFIG_MS5611_I2C=y +CONFIG_MS5611_SPI=y +CONFIG_MS5637=y +CONFIG_IIO_ST_PRESS=y +CONFIG_IIO_ST_PRESS_I2C=y +CONFIG_IIO_ST_PRESS_SPI=y +CONFIG_T5403=y +CONFIG_HP206C=y +CONFIG_ZPA2326=y +CONFIG_ZPA2326_I2C=y +CONFIG_ZPA2326_SPI=y + +# +# Lightning sensors +# +CONFIG_AS3935=y + +# +# Proximity and distance sensors +# +CONFIG_LIDAR_LITE_V2=y +CONFIG_RFD77402=y +CONFIG_SRF04=y +CONFIG_SX9500=y +CONFIG_SRF08=y + +# +# Temperature sensors +# +CONFIG_MAXIM_THERMOCOUPLE=y +CONFIG_HID_SENSOR_TEMP=y +CONFIG_MLX90614=y +CONFIG_TMP006=y +CONFIG_TMP007=y +CONFIG_TSYS01=y +CONFIG_TSYS02D=y +CONFIG_NTB=y +CONFIG_NTB_AMD=y +CONFIG_NTB_IDT=y +CONFIG_NTB_INTEL=y +CONFIG_NTB_SWITCHTEC=y +CONFIG_NTB_PINGPONG=y +CONFIG_NTB_TOOL=y +CONFIG_NTB_PERF=y +CONFIG_NTB_TRANSPORT=y +CONFIG_VME_BUS=y + +# +# VME Bridge Drivers +# +CONFIG_VME_CA91CX42=y +CONFIG_VME_TSI148=y +CONFIG_VME_FAKE=y + +# +# VME Board Drivers +# +CONFIG_VMIVME_7805=y + +# +# VME Device Drivers +# +CONFIG_VME_USER=y +CONFIG_PWM=y +CONFIG_PWM_SYSFS=y +CONFIG_PWM_ATMEL_HLCDC_PWM=y +CONFIG_PWM_BCM_IPROC=y +CONFIG_PWM_CLPS711X=y +CONFIG_PWM_CRC=y +CONFIG_PWM_CROS_EC=y +CONFIG_PWM_FSL_FTM=y +CONFIG_PWM_HIBVT=y +CONFIG_PWM_IMG=y +CONFIG_PWM_LP3943=y +CONFIG_PWM_LPSS=y +CONFIG_PWM_LPSS_PCI=y +CONFIG_PWM_LPSS_PLATFORM=y +CONFIG_PWM_MTK_DISP=y +CONFIG_PWM_MEDIATEK=y +CONFIG_PWM_PCA9685=y +CONFIG_PWM_RCAR=y +CONFIG_PWM_RENESAS_TPU=y +CONFIG_PWM_STM32=y +CONFIG_PWM_STM32_LP=y +CONFIG_PWM_STMPE=y +CONFIG_PWM_SUN4I=y +CONFIG_PWM_TWL=y +CONFIG_PWM_TWL_LED=y + +# +# IRQ chip support +# +CONFIG_IRQCHIP=y +CONFIG_ARM_GIC_MAX_NR=1 +# CONFIG_ARM_GIC_V3_ITS is not set +CONFIG_JCORE_AIC=y +CONFIG_TS4800_IRQ=y +CONFIG_IRQ_UNIPHIER_AIDET=y +CONFIG_IPACK_BUS=y +CONFIG_BOARD_TPCI200=y +CONFIG_SERIAL_IPOCTAL=y +CONFIG_RESET_CONTROLLER=y +CONFIG_RESET_ATH79=y +CONFIG_RESET_AXS10X=y +CONFIG_RESET_BERLIN=y +CONFIG_RESET_HSDK=y +CONFIG_RESET_IMX7=y +CONFIG_RESET_LANTIQ=y +CONFIG_RESET_LPC18XX=y +CONFIG_RESET_MESON=y +CONFIG_RESET_PISTACHIO=y +CONFIG_RESET_SIMPLE=y +CONFIG_RESET_SUNXI=y +CONFIG_RESET_TI_SYSCON=y +CONFIG_RESET_UNIPHIER=y +CONFIG_RESET_ZYNQ=y +CONFIG_COMMON_RESET_HI3660=y +CONFIG_COMMON_RESET_HI6220=y +# CONFIG_RESET_TEGRA_BPMP is not set +CONFIG_FMC=y +CONFIG_FMC_FAKEDEV=y +CONFIG_FMC_TRIVIAL=y +CONFIG_FMC_WRITE_EEPROM=y +CONFIG_FMC_CHARDEV=y + +# +# PHY Subsystem +# +CONFIG_GENERIC_PHY=y +CONFIG_PHY_LPC18XX_USB_OTG=y +CONFIG_PHY_XGENE=y +CONFIG_PHY_MESON8B_USB2=y +CONFIG_PHY_MESON_GXL_USB2=y +CONFIG_PHY_CYGNUS_PCIE=y +CONFIG_BCM_KONA_USB2_PHY=y +CONFIG_PHY_BCM_NS_USB2=y +CONFIG_PHY_BCM_NS_USB3=y +CONFIG_PHY_NS2_PCIE=y +CONFIG_PHY_NS2_USB_DRD=y +CONFIG_PHY_BRCM_SATA=y +CONFIG_PHY_HI6220_USB=y +CONFIG_PHY_LANTIQ_RCU_USB2=y +CONFIG_ARMADA375_USBCLUSTER_PHY=y +CONFIG_PHY_MVEBU_CP110_COMPHY=y +CONFIG_PHY_PXA_28NM_HSIC=y +CONFIG_PHY_PXA_28NM_USB2=y +CONFIG_PHY_CPCAP_USB=y +CONFIG_PHY_QCOM_QMP=y +CONFIG_PHY_QCOM_QUSB2=y +CONFIG_PHY_QCOM_USB_HS=y +CONFIG_PHY_QCOM_USB_HSIC=y +CONFIG_PHY_RALINK_USB=y +CONFIG_PHY_RCAR_GEN3_USB3=y +CONFIG_PHY_ROCKCHIP_INNO_USB2=y +CONFIG_PHY_ROCKCHIP_PCIE=y +CONFIG_PHY_ROCKCHIP_TYPEC=y +CONFIG_PHY_EXYNOS_DP_VIDEO=y +CONFIG_PHY_EXYNOS_MIPI_VIDEO=y +CONFIG_PHY_EXYNOS_PCIE=y +CONFIG_PHY_SAMSUNG_USB2=y +# CONFIG_PHY_EXYNOS4210_USB2 is not set +# CONFIG_PHY_EXYNOS4X12_USB2 is not set +# CONFIG_PHY_EXYNOS5250_USB2 is not set +CONFIG_PHY_ST_SPEAR1310_MIPHY=y +CONFIG_PHY_ST_SPEAR1340_MIPHY=y +CONFIG_PHY_STIH407_USB=y +CONFIG_OMAP_CONTROL_PHY=y +CONFIG_PHY_TUSB1210=y +CONFIG_POWERCAP=y +CONFIG_INTEL_RAPL=y +CONFIG_MCB=y +CONFIG_MCB_PCI=y +CONFIG_MCB_LPC=y + +# +# Performance monitor support +# +CONFIG_RAS=y +CONFIG_RAS_CEC=y +CONFIG_THUNDERBOLT=y + +# +# Android +# +CONFIG_ANDROID=y +CONFIG_ANDROID_BINDER_IPC=y +CONFIG_ANDROID_BINDER_DEVICES="binder,hwbinder,vndbinder" +CONFIG_ANDROID_BINDER_IPC_SELFTEST=y +CONFIG_LIBNVDIMM=y +CONFIG_BLK_DEV_PMEM=y +CONFIG_ND_BLK=y +CONFIG_ND_CLAIM=y +CONFIG_ND_BTT=y +CONFIG_BTT=y +CONFIG_ND_PFN=y +CONFIG_NVDIMM_PFN=y +CONFIG_NVDIMM_DAX=y +CONFIG_DAX=y +CONFIG_DEV_DAX=y +CONFIG_DEV_DAX_PMEM=y +CONFIG_NVMEM=y +CONFIG_NVMEM_IMX_IIM=y +CONFIG_NVMEM_IMX_OCOTP=y +CONFIG_NVMEM_LPC18XX_EEPROM=y +CONFIG_NVMEM_LPC18XX_OTP=y +CONFIG_NVMEM_MXS_OCOTP=y +CONFIG_MTK_EFUSE=y +CONFIG_QCOM_QFPROM=y +CONFIG_ROCKCHIP_EFUSE=y +CONFIG_NVMEM_BCM_OCOTP=y +CONFIG_UNIPHIER_EFUSE=y +CONFIG_NVMEM_VF610_OCOTP=y +CONFIG_MESON_MX_EFUSE=y +CONFIG_NVMEM_SNVS_LPGPR=y +CONFIG_STM=y +CONFIG_STM_DUMMY=y +CONFIG_STM_SOURCE_CONSOLE=y +CONFIG_STM_SOURCE_HEARTBEAT=y +CONFIG_STM_SOURCE_FTRACE=y +CONFIG_INTEL_TH=y +CONFIG_INTEL_TH_PCI=y +CONFIG_INTEL_TH_GTH=y +CONFIG_INTEL_TH_STH=y +CONFIG_INTEL_TH_MSU=y +CONFIG_INTEL_TH_PTI=y +CONFIG_INTEL_TH_DEBUG=y +CONFIG_FPGA=y +CONFIG_FPGA_MGR_SOCFPGA=y +CONFIG_FPGA_MGR_SOCFPGA_A10=y +CONFIG_ALTERA_PR_IP_CORE=y +CONFIG_ALTERA_PR_IP_CORE_PLAT=y +CONFIG_FPGA_MGR_ALTERA_PS_SPI=y +CONFIG_FPGA_MGR_ALTERA_CVP=y +CONFIG_FPGA_MGR_ZYNQ_FPGA=y +CONFIG_FPGA_MGR_XILINX_SPI=y +CONFIG_FPGA_MGR_ICE40_SPI=y +CONFIG_FPGA_BRIDGE=y +CONFIG_XILINX_PR_DECOUPLER=y +CONFIG_FPGA_REGION=y +CONFIG_OF_FPGA_REGION=y +CONFIG_FSI=y +CONFIG_FSI_MASTER_GPIO=y +CONFIG_FSI_MASTER_HUB=y +CONFIG_FSI_SCOM=y +CONFIG_TEE=y + +# +# TEE drivers +# +CONFIG_MULTIPLEXER=y + +# +# Multiplexer drivers +# +CONFIG_MUX_ADG792A=y +CONFIG_MUX_GPIO=y +CONFIG_MUX_MMIO=y +CONFIG_PM_OPP=y +CONFIG_UNISYS_VISORBUS=y +CONFIG_SIOX=y +CONFIG_SIOX_BUS_GPIO=y +CONFIG_SLIMBUS=y +CONFIG_SLIM_QCOM_CTRL=y + +# +# Firmware Drivers +# +CONFIG_ARM_SCPI_PROTOCOL=y +CONFIG_ARM_SCPI_POWER_DOMAIN=y +CONFIG_EDD=y +CONFIG_EDD_OFF=y +CONFIG_FIRMWARE_MEMMAP=y +CONFIG_DELL_RBU=y +CONFIG_DCDBAS=y +CONFIG_DMIID=y +CONFIG_DMI_SYSFS=y +CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK=y +CONFIG_ISCSI_IBFT_FIND=y +CONFIG_ISCSI_IBFT=y +CONFIG_FW_CFG_SYSFS=y +CONFIG_FW_CFG_SYSFS_CMDLINE=y +CONFIG_GOOGLE_FIRMWARE=y +CONFIG_GOOGLE_SMI=y +CONFIG_GOOGLE_COREBOOT_TABLE=y +CONFIG_GOOGLE_COREBOOT_TABLE_ACPI=y +CONFIG_GOOGLE_COREBOOT_TABLE_OF=y +CONFIG_GOOGLE_MEMCONSOLE=y +CONFIG_GOOGLE_MEMCONSOLE_X86_LEGACY=y +CONFIG_GOOGLE_MEMCONSOLE_COREBOOT=y +CONFIG_GOOGLE_VPD=y + +# +# EFI (Extensible Firmware Interface) Support +# +CONFIG_EFI_VARS=y +CONFIG_EFI_ESRT=y +CONFIG_EFI_VARS_PSTORE=y +CONFIG_EFI_VARS_PSTORE_DEFAULT_DISABLE=y +CONFIG_EFI_RUNTIME_MAP=y +CONFIG_EFI_FAKE_MEMMAP=y +CONFIG_EFI_MAX_FAKE_MEM=8 +CONFIG_EFI_RUNTIME_WRAPPERS=y +CONFIG_EFI_BOOTLOADER_CONTROL=y +CONFIG_EFI_CAPSULE_LOADER=y +CONFIG_EFI_TEST=y +CONFIG_APPLE_PROPERTIES=y +CONFIG_RESET_ATTACK_MITIGATION=y +CONFIG_UEFI_CPER=y +CONFIG_EFI_DEV_PATH_PARSER=y + +# +# Tegra firmware driver +# + +# +# File systems +# +CONFIG_DCACHE_WORD_ACCESS=y +CONFIG_FS_IOMAP=y +CONFIG_EXT2_FS=y +CONFIG_EXT2_FS_XATTR=y +CONFIG_EXT2_FS_POSIX_ACL=y +CONFIG_EXT2_FS_SECURITY=y +CONFIG_EXT3_FS=y +CONFIG_EXT3_FS_POSIX_ACL=y +CONFIG_EXT3_FS_SECURITY=y +CONFIG_EXT4_FS=y +CONFIG_EXT4_FS_POSIX_ACL=y +CONFIG_EXT4_FS_SECURITY=y +CONFIG_EXT4_ENCRYPTION=y +CONFIG_EXT4_FS_ENCRYPTION=y +CONFIG_EXT4_DEBUG=y +CONFIG_JBD2=y +CONFIG_JBD2_DEBUG=y +CONFIG_FS_MBCACHE=y +CONFIG_REISERFS_FS=y +CONFIG_REISERFS_CHECK=y +CONFIG_REISERFS_PROC_INFO=y +CONFIG_REISERFS_FS_XATTR=y +CONFIG_REISERFS_FS_POSIX_ACL=y +CONFIG_REISERFS_FS_SECURITY=y +CONFIG_JFS_FS=y +CONFIG_JFS_POSIX_ACL=y +CONFIG_JFS_SECURITY=y +CONFIG_JFS_DEBUG=y +CONFIG_JFS_STATISTICS=y +CONFIG_XFS_FS=y +CONFIG_XFS_QUOTA=y +CONFIG_XFS_POSIX_ACL=y +CONFIG_XFS_RT=y +CONFIG_XFS_ONLINE_SCRUB=y +CONFIG_XFS_DEBUG=y +CONFIG_XFS_ASSERT_FATAL=y +CONFIG_GFS2_FS=y +CONFIG_GFS2_FS_LOCKING_DLM=y +CONFIG_OCFS2_FS=y +CONFIG_OCFS2_FS_O2CB=y +CONFIG_OCFS2_FS_USERSPACE_CLUSTER=y +CONFIG_OCFS2_FS_STATS=y +CONFIG_OCFS2_DEBUG_MASKLOG=y +CONFIG_OCFS2_DEBUG_FS=y +CONFIG_BTRFS_FS=y +CONFIG_BTRFS_FS_POSIX_ACL=y +CONFIG_BTRFS_FS_CHECK_INTEGRITY=y +CONFIG_BTRFS_FS_RUN_SANITY_TESTS=y +CONFIG_BTRFS_DEBUG=y +CONFIG_BTRFS_ASSERT=y +CONFIG_BTRFS_FS_REF_VERIFY=y +CONFIG_NILFS2_FS=y +CONFIG_F2FS_FS=y +CONFIG_F2FS_STAT_FS=y +CONFIG_F2FS_FS_XATTR=y +CONFIG_F2FS_FS_POSIX_ACL=y +CONFIG_F2FS_FS_SECURITY=y +CONFIG_F2FS_CHECK_FS=y +CONFIG_F2FS_FS_ENCRYPTION=y +CONFIG_F2FS_IO_TRACE=y +CONFIG_F2FS_FAULT_INJECTION=y +CONFIG_FS_DAX=y +CONFIG_FS_DAX_PMD=y +CONFIG_FS_POSIX_ACL=y +CONFIG_EXPORTFS=y +CONFIG_EXPORTFS_BLOCK_OPS=y +CONFIG_FILE_LOCKING=y +CONFIG_MANDATORY_FILE_LOCKING=y +CONFIG_FS_ENCRYPTION=y +CONFIG_FSNOTIFY=y +CONFIG_DNOTIFY=y +CONFIG_INOTIFY_USER=y +CONFIG_FANOTIFY=y +CONFIG_FANOTIFY_ACCESS_PERMISSIONS=y +CONFIG_QUOTA=y +CONFIG_QUOTA_NETLINK_INTERFACE=y +CONFIG_PRINT_QUOTA_WARNING=y +CONFIG_QUOTA_DEBUG=y +CONFIG_QUOTA_TREE=y +CONFIG_QFMT_V1=y +CONFIG_QFMT_V2=y +CONFIG_QUOTACTL=y +CONFIG_QUOTACTL_COMPAT=y +CONFIG_AUTOFS4_FS=y +CONFIG_FUSE_FS=y +CONFIG_CUSE=y +CONFIG_OVERLAY_FS=y +CONFIG_OVERLAY_FS_REDIRECT_DIR=y +CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW=y +CONFIG_OVERLAY_FS_INDEX=y +CONFIG_OVERLAY_FS_NFS_EXPORT=y + +# +# Caches +# +CONFIG_FSCACHE=y +CONFIG_FSCACHE_STATS=y +CONFIG_FSCACHE_HISTOGRAM=y +CONFIG_FSCACHE_DEBUG=y +CONFIG_FSCACHE_OBJECT_LIST=y +CONFIG_CACHEFILES=y +CONFIG_CACHEFILES_DEBUG=y +CONFIG_CACHEFILES_HISTOGRAM=y + +# +# CD-ROM/DVD Filesystems +# +CONFIG_ISO9660_FS=y +CONFIG_JOLIET=y +CONFIG_ZISOFS=y +CONFIG_UDF_FS=y +CONFIG_UDF_NLS=y + +# +# DOS/FAT/NT Filesystems +# +CONFIG_FAT_FS=y +CONFIG_MSDOS_FS=y +CONFIG_VFAT_FS=y +CONFIG_FAT_DEFAULT_CODEPAGE=437 +CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" +CONFIG_FAT_DEFAULT_UTF8=y +CONFIG_NTFS_FS=y +CONFIG_NTFS_DEBUG=y +CONFIG_NTFS_RW=y + +# +# Pseudo filesystems +# +CONFIG_PROC_FS=y +CONFIG_PROC_KCORE=y +CONFIG_PROC_VMCORE=y +CONFIG_PROC_SYSCTL=y +CONFIG_PROC_PAGE_MONITOR=y +CONFIG_PROC_CHILDREN=y +CONFIG_KERNFS=y +CONFIG_SYSFS=y +CONFIG_TMPFS=y +CONFIG_TMPFS_POSIX_ACL=y +CONFIG_TMPFS_XATTR=y +CONFIG_HUGETLBFS=y +CONFIG_HUGETLB_PAGE=y +CONFIG_ARCH_HAS_GIGANTIC_PAGE=y +CONFIG_CONFIGFS_FS=y +CONFIG_EFIVAR_FS=y +CONFIG_MISC_FILESYSTEMS=y +CONFIG_ORANGEFS_FS=y +CONFIG_ADFS_FS=y +CONFIG_ADFS_FS_RW=y +CONFIG_AFFS_FS=y +CONFIG_ECRYPT_FS=y +CONFIG_ECRYPT_FS_MESSAGING=y +CONFIG_HFS_FS=y +CONFIG_HFSPLUS_FS=y +CONFIG_HFSPLUS_FS_POSIX_ACL=y +CONFIG_BEFS_FS=y +CONFIG_BEFS_DEBUG=y +CONFIG_BFS_FS=y +CONFIG_EFS_FS=y +CONFIG_JFFS2_FS=y +CONFIG_JFFS2_FS_DEBUG=0 +CONFIG_JFFS2_FS_WRITEBUFFER=y +CONFIG_JFFS2_FS_WBUF_VERIFY=y +CONFIG_JFFS2_SUMMARY=y +CONFIG_JFFS2_FS_XATTR=y +CONFIG_JFFS2_FS_POSIX_ACL=y +CONFIG_JFFS2_FS_SECURITY=y +CONFIG_JFFS2_COMPRESSION_OPTIONS=y +CONFIG_JFFS2_ZLIB=y +CONFIG_JFFS2_LZO=y +CONFIG_JFFS2_RTIME=y +CONFIG_JFFS2_RUBIN=y +# CONFIG_JFFS2_CMODE_NONE is not set +CONFIG_JFFS2_CMODE_PRIORITY=y +# CONFIG_JFFS2_CMODE_SIZE is not set +# CONFIG_JFFS2_CMODE_FAVOURLZO is not set +CONFIG_UBIFS_FS=y +CONFIG_UBIFS_FS_ADVANCED_COMPR=y +CONFIG_UBIFS_FS_LZO=y +CONFIG_UBIFS_FS_ZLIB=y +CONFIG_UBIFS_ATIME_SUPPORT=y +CONFIG_UBIFS_FS_ENCRYPTION=y +CONFIG_UBIFS_FS_SECURITY=y +CONFIG_CRAMFS=y +CONFIG_CRAMFS_BLOCKDEV=y +CONFIG_CRAMFS_MTD=y +CONFIG_SQUASHFS=y +CONFIG_SQUASHFS_FILE_CACHE=y +# CONFIG_SQUASHFS_FILE_DIRECT is not set +CONFIG_SQUASHFS_DECOMP_SINGLE=y +# CONFIG_SQUASHFS_DECOMP_MULTI is not set +# CONFIG_SQUASHFS_DECOMP_MULTI_PERCPU is not set +CONFIG_SQUASHFS_XATTR=y +CONFIG_SQUASHFS_ZLIB=y +CONFIG_SQUASHFS_LZ4=y +CONFIG_SQUASHFS_LZO=y +CONFIG_SQUASHFS_XZ=y +CONFIG_SQUASHFS_ZSTD=y +CONFIG_SQUASHFS_4K_DEVBLK_SIZE=y +CONFIG_SQUASHFS_EMBEDDED=y +CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3 +CONFIG_VXFS_FS=y +CONFIG_MINIX_FS=y +CONFIG_OMFS_FS=y +CONFIG_HPFS_FS=y +CONFIG_QNX4FS_FS=y +CONFIG_QNX6FS_FS=y +CONFIG_QNX6FS_DEBUG=y +CONFIG_ROMFS_FS=y +CONFIG_ROMFS_BACKED_BY_BLOCK=y +# CONFIG_ROMFS_BACKED_BY_MTD is not set +# CONFIG_ROMFS_BACKED_BY_BOTH is not set +CONFIG_ROMFS_ON_BLOCK=y +CONFIG_PSTORE=y +CONFIG_PSTORE_ZLIB_COMPRESS=y +# CONFIG_PSTORE_LZO_COMPRESS is not set +# CONFIG_PSTORE_LZ4_COMPRESS is not set +CONFIG_PSTORE_CONSOLE=y +CONFIG_PSTORE_PMSG=y +CONFIG_PSTORE_FTRACE=y +CONFIG_PSTORE_RAM=y +CONFIG_SYSV_FS=y +CONFIG_UFS_FS=y +CONFIG_UFS_FS_WRITE=y +CONFIG_UFS_DEBUG=y +CONFIG_EXOFS_FS=y +CONFIG_EXOFS_DEBUG=y +CONFIG_ORE=y +CONFIG_NETWORK_FILESYSTEMS=y +CONFIG_NFS_FS=y +CONFIG_NFS_V2=y +CONFIG_NFS_V3=y +CONFIG_NFS_V3_ACL=y +CONFIG_NFS_V4=y +CONFIG_NFS_SWAP=y +CONFIG_NFS_V4_1=y +CONFIG_NFS_V4_2=y +CONFIG_PNFS_FILE_LAYOUT=y +CONFIG_PNFS_BLOCK=y +CONFIG_PNFS_FLEXFILE_LAYOUT=m +CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN="kernel.org" +CONFIG_NFS_V4_1_MIGRATION=y +CONFIG_NFS_V4_SECURITY_LABEL=y +CONFIG_ROOT_NFS=y +CONFIG_NFS_FSCACHE=y +CONFIG_NFS_USE_LEGACY_DNS=y +CONFIG_NFS_DEBUG=y +CONFIG_NFSD=y +CONFIG_NFSD_V2_ACL=y +CONFIG_NFSD_V3=y +CONFIG_NFSD_V3_ACL=y +CONFIG_NFSD_V4=y +CONFIG_NFSD_PNFS=y +CONFIG_NFSD_BLOCKLAYOUT=y +CONFIG_NFSD_SCSILAYOUT=y +CONFIG_NFSD_FLEXFILELAYOUT=y +CONFIG_NFSD_V4_SECURITY_LABEL=y +CONFIG_NFSD_FAULT_INJECTION=y +CONFIG_GRACE_PERIOD=y +CONFIG_LOCKD=y +CONFIG_LOCKD_V4=y +CONFIG_NFS_ACL_SUPPORT=y +CONFIG_NFS_COMMON=y +CONFIG_SUNRPC=y +CONFIG_SUNRPC_GSS=y +CONFIG_SUNRPC_BACKCHANNEL=y +CONFIG_SUNRPC_SWAP=y +CONFIG_RPCSEC_GSS_KRB5=y +CONFIG_SUNRPC_DEBUG=y +CONFIG_SUNRPC_XPRT_RDMA=y +CONFIG_CEPH_FS=y +CONFIG_CEPH_FSCACHE=y +CONFIG_CEPH_FS_POSIX_ACL=y +CONFIG_CIFS=y +CONFIG_CIFS_STATS=y +CONFIG_CIFS_STATS2=y +CONFIG_CIFS_WEAK_PW_HASH=y +CONFIG_CIFS_UPCALL=y +CONFIG_CIFS_XATTR=y +CONFIG_CIFS_POSIX=y +CONFIG_CIFS_ACL=y +CONFIG_CIFS_DEBUG=y +CONFIG_CIFS_DEBUG2=y +CONFIG_CIFS_DEBUG_DUMP_KEYS=y +CONFIG_CIFS_DFS_UPCALL=y +CONFIG_CIFS_SMB311=y +CONFIG_CIFS_SMB_DIRECT=y +CONFIG_CIFS_FSCACHE=y +CONFIG_CODA_FS=y +CONFIG_AFS_FS=y +CONFIG_AFS_DEBUG=y +CONFIG_AFS_FSCACHE=y +CONFIG_9P_FS=y +CONFIG_9P_FSCACHE=y +CONFIG_9P_FS_POSIX_ACL=y +CONFIG_9P_FS_SECURITY=y +CONFIG_NLS=y +CONFIG_NLS_DEFAULT="iso8859-1" +CONFIG_NLS_CODEPAGE_437=y +CONFIG_NLS_CODEPAGE_737=y +CONFIG_NLS_CODEPAGE_775=y +CONFIG_NLS_CODEPAGE_850=y +CONFIG_NLS_CODEPAGE_852=y +CONFIG_NLS_CODEPAGE_855=y +CONFIG_NLS_CODEPAGE_857=y +CONFIG_NLS_CODEPAGE_860=y +CONFIG_NLS_CODEPAGE_861=y +CONFIG_NLS_CODEPAGE_862=y +CONFIG_NLS_CODEPAGE_863=y +CONFIG_NLS_CODEPAGE_864=y +CONFIG_NLS_CODEPAGE_865=y +CONFIG_NLS_CODEPAGE_866=y +CONFIG_NLS_CODEPAGE_869=y +CONFIG_NLS_CODEPAGE_936=y +CONFIG_NLS_CODEPAGE_950=y +CONFIG_NLS_CODEPAGE_932=y +CONFIG_NLS_CODEPAGE_949=y +CONFIG_NLS_CODEPAGE_874=y +CONFIG_NLS_ISO8859_8=y +CONFIG_NLS_CODEPAGE_1250=y +CONFIG_NLS_CODEPAGE_1251=y +CONFIG_NLS_ASCII=y +CONFIG_NLS_ISO8859_1=y +CONFIG_NLS_ISO8859_2=y +CONFIG_NLS_ISO8859_3=y +CONFIG_NLS_ISO8859_4=y +CONFIG_NLS_ISO8859_5=y +CONFIG_NLS_ISO8859_6=y +CONFIG_NLS_ISO8859_7=y +CONFIG_NLS_ISO8859_9=y +CONFIG_NLS_ISO8859_13=y +CONFIG_NLS_ISO8859_14=y +CONFIG_NLS_ISO8859_15=y +CONFIG_NLS_KOI8_R=y +CONFIG_NLS_KOI8_U=y +CONFIG_NLS_MAC_ROMAN=y +CONFIG_NLS_MAC_CELTIC=y +CONFIG_NLS_MAC_CENTEURO=y +CONFIG_NLS_MAC_CROATIAN=y +CONFIG_NLS_MAC_CYRILLIC=y +CONFIG_NLS_MAC_GAELIC=y +CONFIG_NLS_MAC_GREEK=y +CONFIG_NLS_MAC_ICELAND=y +CONFIG_NLS_MAC_INUIT=y +CONFIG_NLS_MAC_ROMANIAN=y +CONFIG_NLS_MAC_TURKISH=y +CONFIG_NLS_UTF8=y +CONFIG_DLM=y +CONFIG_DLM_DEBUG=y + +# +# Kernel hacking +# +CONFIG_TRACE_IRQFLAGS_SUPPORT=y + +# +# printk and dmesg options +# +CONFIG_PRINTK_TIME=y +CONFIG_CONSOLE_LOGLEVEL_DEFAULT=7 +CONFIG_MESSAGE_LOGLEVEL_DEFAULT=4 +CONFIG_BOOT_PRINTK_DELAY=y +CONFIG_DYNAMIC_DEBUG=y + +# +# Compile-time checks and compiler options +# +CONFIG_ENABLE_WARN_DEPRECATED=y +CONFIG_ENABLE_MUST_CHECK=y +CONFIG_FRAME_WARN=2048 +CONFIG_STRIP_ASM_SYMS=y +CONFIG_READABLE_ASM=y +CONFIG_UNUSED_SYMBOLS=y +CONFIG_PAGE_OWNER=y +CONFIG_DEBUG_FS=y +CONFIG_HEADERS_CHECK=y +CONFIG_DEBUG_SECTION_MISMATCH=y +CONFIG_SECTION_MISMATCH_WARN_ONLY=y +CONFIG_STACK_VALIDATION=y +CONFIG_DEBUG_FORCE_WEAK_PER_CPU=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x1 +CONFIG_MAGIC_SYSRQ_SERIAL=y +CONFIG_DEBUG_KERNEL=y + +# +# Memory Debugging +# +CONFIG_PAGE_EXTENSION=y +CONFIG_DEBUG_PAGEALLOC=y +CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT=y +CONFIG_PAGE_POISONING=y +CONFIG_PAGE_POISONING_NO_SANITY=y +CONFIG_PAGE_POISONING_ZERO=y +CONFIG_DEBUG_PAGE_REF=y +CONFIG_DEBUG_RODATA_TEST=y +CONFIG_DEBUG_OBJECTS=y +CONFIG_DEBUG_OBJECTS_SELFTEST=y +CONFIG_DEBUG_OBJECTS_FREE=y +CONFIG_DEBUG_OBJECTS_TIMERS=y +CONFIG_DEBUG_OBJECTS_WORK=y +CONFIG_DEBUG_OBJECTS_RCU_HEAD=y +CONFIG_DEBUG_OBJECTS_PERCPU_COUNTER=y +CONFIG_DEBUG_OBJECTS_ENABLE_DEFAULT=1 +CONFIG_SLUB_DEBUG_ON=y +CONFIG_SLUB_STATS=y +CONFIG_HAVE_DEBUG_KMEMLEAK=y +CONFIG_DEBUG_KMEMLEAK=y +CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE=400 +CONFIG_DEBUG_KMEMLEAK_TEST=m +CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF=y +CONFIG_DEBUG_STACK_USAGE=y +CONFIG_DEBUG_VM=y +CONFIG_DEBUG_VM_VMACACHE=y +CONFIG_DEBUG_VM_RB=y +CONFIG_DEBUG_VM_PGFLAGS=y +CONFIG_ARCH_HAS_DEBUG_VIRTUAL=y +CONFIG_DEBUG_VIRTUAL=y +CONFIG_DEBUG_MEMORY_INIT=y +CONFIG_MEMORY_NOTIFIER_ERROR_INJECT=y +CONFIG_DEBUG_PER_CPU_MAPS=y +CONFIG_HAVE_DEBUG_STACKOVERFLOW=y +CONFIG_DEBUG_STACKOVERFLOW=y +CONFIG_HAVE_ARCH_KASAN=y +CONFIG_KASAN=y +CONFIG_KASAN_OUTLINE=y +# CONFIG_KASAN_INLINE is not set +CONFIG_TEST_KASAN=m +CONFIG_ARCH_HAS_KCOV=y +CONFIG_KCOV=y +CONFIG_KCOV_ENABLE_COMPARISONS=y +CONFIG_KCOV_INSTRUMENT_ALL=y +CONFIG_DEBUG_SHIRQ=y + +# +# Debug Lockups and Hangs +# +CONFIG_LOCKUP_DETECTOR=y +CONFIG_SOFTLOCKUP_DETECTOR=y +CONFIG_HARDLOCKUP_DETECTOR_PERF=y +CONFIG_HARDLOCKUP_CHECK_TIMESTAMP=y +CONFIG_HARDLOCKUP_DETECTOR=y +CONFIG_BOOTPARAM_HARDLOCKUP_PANIC=y +CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE=1 +CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y +CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=1 +CONFIG_DETECT_HUNG_TASK=y +CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=120 +CONFIG_BOOTPARAM_HUNG_TASK_PANIC=y +CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=1 +CONFIG_WQ_WATCHDOG=y +CONFIG_PANIC_ON_OOPS=y +CONFIG_PANIC_ON_OOPS_VALUE=1 +CONFIG_PANIC_TIMEOUT=0 +CONFIG_SCHED_DEBUG=y +CONFIG_SCHED_INFO=y +CONFIG_SCHEDSTATS=y +CONFIG_SCHED_STACK_END_CHECK=y +CONFIG_DEBUG_TIMEKEEPING=y + +# +# Lock Debugging (spinlocks, mutexes, etc...) +# +CONFIG_DEBUG_RT_MUTEXES=y +CONFIG_DEBUG_SPINLOCK=y +CONFIG_DEBUG_MUTEXES=y +CONFIG_DEBUG_WW_MUTEX_SLOWPATH=y +CONFIG_DEBUG_LOCK_ALLOC=y +CONFIG_PROVE_LOCKING=y +CONFIG_LOCKDEP=y +CONFIG_LOCK_STAT=y +CONFIG_DEBUG_LOCKDEP=y +CONFIG_DEBUG_ATOMIC_SLEEP=y +CONFIG_DEBUG_LOCKING_API_SELFTESTS=y +CONFIG_LOCK_TORTURE_TEST=y +CONFIG_WW_MUTEX_SELFTEST=y +CONFIG_TRACE_IRQFLAGS=y +CONFIG_STACKTRACE=y +CONFIG_WARN_ALL_UNSEEDED_RANDOM=y +CONFIG_DEBUG_KOBJECT=y +CONFIG_DEBUG_KOBJECT_RELEASE=y +CONFIG_DEBUG_BUGVERBOSE=y +CONFIG_DEBUG_LIST=y +CONFIG_DEBUG_PI_LIST=y +CONFIG_DEBUG_SG=y +CONFIG_DEBUG_NOTIFIERS=y +CONFIG_DEBUG_CREDENTIALS=y + +# +# RCU Debugging +# +CONFIG_PROVE_RCU=y +CONFIG_TORTURE_TEST=y +CONFIG_RCU_PERF_TEST=y +CONFIG_RCU_TORTURE_TEST=y +CONFIG_RCU_CPU_STALL_TIMEOUT=21 +CONFIG_RCU_TRACE=y +CONFIG_RCU_EQS_DEBUG=y +CONFIG_DEBUG_WQ_FORCE_RR_CPU=y +CONFIG_DEBUG_BLOCK_EXT_DEVT=y +CONFIG_CPU_HOTPLUG_STATE_CONTROL=y +CONFIG_NOTIFIER_ERROR_INJECTION=y +CONFIG_PM_NOTIFIER_ERROR_INJECT=y +CONFIG_OF_RECONFIG_NOTIFIER_ERROR_INJECT=y +CONFIG_NETDEV_NOTIFIER_ERROR_INJECT=y +CONFIG_FAULT_INJECTION=y +CONFIG_FUNCTION_ERROR_INJECTION=y +CONFIG_FAILSLAB=y +CONFIG_FAIL_PAGE_ALLOC=y +CONFIG_FAIL_MAKE_REQUEST=y +CONFIG_FAIL_IO_TIMEOUT=y +CONFIG_FAIL_MMC_REQUEST=y +CONFIG_FAIL_FUTEX=y +CONFIG_FAIL_FUNCTION=y +CONFIG_FAULT_INJECTION_DEBUG_FS=y +CONFIG_LATENCYTOP=y +CONFIG_USER_STACKTRACE_SUPPORT=y +CONFIG_NOP_TRACER=y +CONFIG_HAVE_FUNCTION_TRACER=y +CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y +CONFIG_HAVE_DYNAMIC_FTRACE=y +CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS=y +CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y +CONFIG_HAVE_SYSCALL_TRACEPOINTS=y +CONFIG_HAVE_FENTRY=y +CONFIG_HAVE_C_RECORDMCOUNT=y +CONFIG_TRACER_MAX_TRACE=y +CONFIG_TRACE_CLOCK=y +CONFIG_RING_BUFFER=y +CONFIG_EVENT_TRACING=y +CONFIG_CONTEXT_SWITCH_TRACER=y +CONFIG_RING_BUFFER_ALLOW_SWAP=y +CONFIG_TRACING=y +CONFIG_GENERIC_TRACER=y +CONFIG_TRACING_SUPPORT=y +CONFIG_FTRACE=y +CONFIG_FUNCTION_TRACER=y +CONFIG_FUNCTION_GRAPH_TRACER=y +CONFIG_IRQSOFF_TRACER=y +CONFIG_SCHED_TRACER=y +CONFIG_HWLAT_TRACER=y +CONFIG_FTRACE_SYSCALLS=y +CONFIG_TRACER_SNAPSHOT=y +CONFIG_TRACER_SNAPSHOT_PER_CPU_SWAP=y +CONFIG_BRANCH_PROFILE_NONE=y +# CONFIG_PROFILE_ANNOTATED_BRANCHES is not set +CONFIG_STACK_TRACER=y +CONFIG_BLK_DEV_IO_TRACE=y +CONFIG_KPROBE_EVENTS=y +CONFIG_UPROBE_EVENTS=y +CONFIG_BPF_EVENTS=y +CONFIG_PROBE_EVENTS=y +CONFIG_DYNAMIC_FTRACE=y +CONFIG_DYNAMIC_FTRACE_WITH_REGS=y +CONFIG_FUNCTION_PROFILER=y +CONFIG_BPF_KPROBE_OVERRIDE=y +CONFIG_FTRACE_MCOUNT_RECORD=y +CONFIG_FTRACE_SELFTEST=y +CONFIG_FTRACE_STARTUP_TEST=y +CONFIG_EVENT_TRACE_TEST_SYSCALLS=y +CONFIG_MMIOTRACE=y +CONFIG_TRACING_MAP=y +CONFIG_HIST_TRIGGERS=y +CONFIG_MMIOTRACE_TEST=m +CONFIG_TRACEPOINT_BENCHMARK=y +CONFIG_RING_BUFFER_BENCHMARK=y +CONFIG_RING_BUFFER_STARTUP_TEST=y +CONFIG_TRACE_EVAL_MAP_FILE=y +CONFIG_TRACING_EVENTS_GPIO=y +CONFIG_PROVIDE_OHCI1394_DMA_INIT=y +CONFIG_DMA_API_DEBUG=y +CONFIG_RUNTIME_TESTING_MENU=y +CONFIG_LKDTM=y +CONFIG_TEST_LIST_SORT=y +CONFIG_TEST_SORT=y +CONFIG_KPROBES_SANITY_TEST=y +CONFIG_BACKTRACE_SELF_TEST=y +CONFIG_RBTREE_TEST=y +CONFIG_INTERVAL_TREE_TEST=y +CONFIG_PERCPU_TEST=m +CONFIG_ATOMIC64_SELFTEST=y +CONFIG_ASYNC_RAID6_TEST=y +CONFIG_TEST_HEXDUMP=y +CONFIG_TEST_STRING_HELPERS=y +CONFIG_TEST_KSTRTOX=y +CONFIG_TEST_PRINTF=y +CONFIG_TEST_BITMAP=y +CONFIG_TEST_UUID=y +CONFIG_TEST_RHASHTABLE=y +CONFIG_TEST_HASH=y +CONFIG_TEST_PARMAN=y +CONFIG_TEST_LKM=m +CONFIG_TEST_USER_COPY=m +CONFIG_TEST_BPF=m +CONFIG_FIND_BIT_BENCHMARK=y +CONFIG_TEST_FIRMWARE=y +CONFIG_TEST_SYSCTL=y +CONFIG_TEST_UDELAY=y +CONFIG_TEST_STATIC_KEYS=m +CONFIG_TEST_KMOD=m +CONFIG_TEST_DEBUG_VIRTUAL=y +CONFIG_MEMTEST=y +CONFIG_BUG_ON_DATA_CORRUPTION=y +CONFIG_SAMPLES=y +CONFIG_SAMPLE_TRACE_EVENTS=m +CONFIG_SAMPLE_TRACE_PRINTK=m +CONFIG_SAMPLE_KOBJECT=m +CONFIG_SAMPLE_KPROBES=m +CONFIG_SAMPLE_KRETPROBES=m +CONFIG_SAMPLE_HW_BREAKPOINT=m +CONFIG_SAMPLE_KFIFO=m +CONFIG_SAMPLE_KDB=m +CONFIG_SAMPLE_RPMSG_CLIENT=m +CONFIG_SAMPLE_LIVEPATCH=m +CONFIG_SAMPLE_CONFIGFS=m +CONFIG_SAMPLE_CONNECTOR=m +CONFIG_SAMPLE_SECCOMP=m +CONFIG_SAMPLE_VFIO_MDEV_MTTY=m +CONFIG_HAVE_ARCH_KGDB=y +CONFIG_KGDB=y +CONFIG_KGDB_SERIAL_CONSOLE=y +CONFIG_KGDB_TESTS=y +CONFIG_KGDB_TESTS_ON_BOOT=y +CONFIG_KGDB_TESTS_BOOT_STRING="V1F100" +CONFIG_KGDB_LOW_LEVEL_TRAP=y +CONFIG_KGDB_KDB=y +CONFIG_KDB_DEFAULT_ENABLE=0x1 +CONFIG_KDB_KEYBOARD=y +CONFIG_KDB_CONTINUE_CATASTROPHIC=0 +CONFIG_ARCH_HAS_UBSAN_SANITIZE_ALL=y +# CONFIG_ARCH_WANTS_UBSAN_NO_NULL is not set +CONFIG_UBSAN=y +CONFIG_UBSAN_ALIGNMENT=y +CONFIG_UBSAN_NULL=y +CONFIG_ARCH_HAS_DEVMEM_IS_ALLOWED=y +CONFIG_STRICT_DEVMEM=y +CONFIG_IO_STRICT_DEVMEM=y +CONFIG_EARLY_PRINTK_USB=y +CONFIG_X86_VERBOSE_BOOTUP=y +CONFIG_EARLY_PRINTK=y +CONFIG_EARLY_PRINTK_DBGP=y +CONFIG_EARLY_PRINTK_EFI=y +CONFIG_EARLY_PRINTK_USB_XDBC=y +CONFIG_X86_PTDUMP_CORE=y +CONFIG_X86_PTDUMP=y +CONFIG_EFI_PGT_DUMP=y +CONFIG_DEBUG_WX=y +CONFIG_DOUBLEFAULT=y +CONFIG_DEBUG_TLBFLUSH=y +CONFIG_IOMMU_DEBUG=y +CONFIG_IOMMU_LEAK=y +CONFIG_HAVE_MMIOTRACE_SUPPORT=y +CONFIG_IO_DELAY_TYPE_0X80=0 +CONFIG_IO_DELAY_TYPE_0XED=1 +CONFIG_IO_DELAY_TYPE_UDELAY=2 +CONFIG_IO_DELAY_TYPE_NONE=3 +CONFIG_IO_DELAY_0X80=y +# CONFIG_IO_DELAY_0XED is not set +# CONFIG_IO_DELAY_UDELAY is not set +# CONFIG_IO_DELAY_NONE is not set +CONFIG_DEFAULT_IO_DELAY_TYPE=0 +CONFIG_DEBUG_BOOT_PARAMS=y +CONFIG_CPA_DEBUG=y +CONFIG_OPTIMIZE_INLINING=y +CONFIG_DEBUG_ENTRY=y +CONFIG_DEBUG_NMI_SELFTEST=y +CONFIG_X86_DEBUG_FPU=y +CONFIG_PUNIT_ATOM_DEBUG=y +CONFIG_UNWINDER_ORC=y +# CONFIG_UNWINDER_FRAME_POINTER is not set + +# +# Security options +# +CONFIG_KEYS=y +CONFIG_KEYS_COMPAT=y +CONFIG_PERSISTENT_KEYRINGS=y +CONFIG_BIG_KEYS=y +CONFIG_TRUSTED_KEYS=y +CONFIG_ENCRYPTED_KEYS=y +CONFIG_KEY_DH_OPERATIONS=y +CONFIG_SECURITY_DMESG_RESTRICT=y +CONFIG_SECURITY=y +CONFIG_SECURITY_WRITABLE_HOOKS=y +CONFIG_SECURITYFS=y +CONFIG_SECURITY_NETWORK=y +CONFIG_PAGE_TABLE_ISOLATION=y +CONFIG_SECURITY_INFINIBAND=y +CONFIG_SECURITY_NETWORK_XFRM=y +CONFIG_SECURITY_PATH=y +CONFIG_INTEL_TXT=y +CONFIG_LSM_MMAP_MIN_ADDR=65536 +CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR=y +CONFIG_HARDENED_USERCOPY=y +CONFIG_HARDENED_USERCOPY_FALLBACK=y +CONFIG_HARDENED_USERCOPY_PAGESPAN=y +CONFIG_FORTIFY_SOURCE=y +CONFIG_STATIC_USERMODEHELPER=y +CONFIG_STATIC_USERMODEHELPER_PATH="/sbin/usermode-helper" +CONFIG_SECURITY_SELINUX=y +CONFIG_SECURITY_SELINUX_BOOTPARAM=y +CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE=1 +CONFIG_SECURITY_SELINUX_DISABLE=y +CONFIG_SECURITY_SELINUX_DEVELOP=y +CONFIG_SECURITY_SELINUX_AVC_STATS=y +CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE=0 +CONFIG_SECURITY_SMACK=y +CONFIG_SECURITY_SMACK_BRINGUP=y +CONFIG_SECURITY_SMACK_NETFILTER=y +CONFIG_SECURITY_SMACK_APPEND_SIGNALS=y +CONFIG_SECURITY_TOMOYO=y +CONFIG_SECURITY_TOMOYO_MAX_ACCEPT_ENTRY=2048 +CONFIG_SECURITY_TOMOYO_MAX_AUDIT_LOG=1024 +CONFIG_SECURITY_TOMOYO_OMIT_USERSPACE_LOADER=y +CONFIG_SECURITY_APPARMOR=y +CONFIG_SECURITY_APPARMOR_BOOTPARAM_VALUE=1 +CONFIG_SECURITY_APPARMOR_HASH=y +CONFIG_SECURITY_APPARMOR_HASH_DEFAULT=y +CONFIG_SECURITY_APPARMOR_DEBUG=y +CONFIG_SECURITY_APPARMOR_DEBUG_ASSERTS=y +CONFIG_SECURITY_APPARMOR_DEBUG_MESSAGES=y +CONFIG_SECURITY_LOADPIN=y +CONFIG_SECURITY_LOADPIN_ENABLED=y +CONFIG_SECURITY_YAMA=y +CONFIG_INTEGRITY=y +CONFIG_INTEGRITY_SIGNATURE=y +CONFIG_INTEGRITY_ASYMMETRIC_KEYS=y +CONFIG_INTEGRITY_TRUSTED_KEYRING=y +CONFIG_INTEGRITY_AUDIT=y +CONFIG_IMA=y +CONFIG_IMA_MEASURE_PCR_IDX=10 +CONFIG_IMA_LSM_RULES=y +# CONFIG_IMA_TEMPLATE is not set +CONFIG_IMA_NG_TEMPLATE=y +# CONFIG_IMA_SIG_TEMPLATE is not set +CONFIG_IMA_DEFAULT_TEMPLATE="ima-ng" +CONFIG_IMA_DEFAULT_HASH_SHA1=y +# CONFIG_IMA_DEFAULT_HASH_SHA256 is not set +# CONFIG_IMA_DEFAULT_HASH_SHA512 is not set +# CONFIG_IMA_DEFAULT_HASH_WP512 is not set +CONFIG_IMA_DEFAULT_HASH="sha1" +CONFIG_IMA_WRITE_POLICY=y +CONFIG_IMA_READ_POLICY=y +CONFIG_IMA_APPRAISE=y +CONFIG_IMA_APPRAISE_BOOTPARAM=y +CONFIG_IMA_TRUSTED_KEYRING=y +CONFIG_IMA_KEYRINGS_PERMIT_SIGNED_BY_BUILTIN_OR_SECONDARY=y +CONFIG_IMA_BLACKLIST_KEYRING=y +CONFIG_IMA_LOAD_X509=y +CONFIG_IMA_X509_PATH="/etc/keys/x509_ima.der" +CONFIG_IMA_APPRAISE_SIGNED_INIT=y +CONFIG_EVM=y +CONFIG_EVM_ATTR_FSUUID=y +CONFIG_EVM_EXTRA_SMACK_XATTRS=y +CONFIG_EVM_LOAD_X509=y +CONFIG_EVM_X509_PATH="/etc/keys/x509_evm.der" +CONFIG_DEFAULT_SECURITY_SELINUX=y +# CONFIG_DEFAULT_SECURITY_SMACK is not set +# CONFIG_DEFAULT_SECURITY_TOMOYO is not set +# CONFIG_DEFAULT_SECURITY_APPARMOR is not set +# CONFIG_DEFAULT_SECURITY_DAC is not set +CONFIG_DEFAULT_SECURITY="selinux" +CONFIG_XOR_BLOCKS=y +CONFIG_ASYNC_CORE=y +CONFIG_ASYNC_MEMCPY=y +CONFIG_ASYNC_XOR=y +CONFIG_ASYNC_PQ=y +CONFIG_ASYNC_RAID6_RECOV=y +CONFIG_ASYNC_TX_DISABLE_PQ_VAL_DMA=y +CONFIG_ASYNC_TX_DISABLE_XOR_VAL_DMA=y +CONFIG_CRYPTO=y + +# +# Crypto core or helper +# +CONFIG_CRYPTO_ALGAPI=y +CONFIG_CRYPTO_ALGAPI2=y +CONFIG_CRYPTO_AEAD=y +CONFIG_CRYPTO_AEAD2=y +CONFIG_CRYPTO_BLKCIPHER=y +CONFIG_CRYPTO_BLKCIPHER2=y +CONFIG_CRYPTO_HASH=y +CONFIG_CRYPTO_HASH2=y +CONFIG_CRYPTO_RNG=y +CONFIG_CRYPTO_RNG2=y +CONFIG_CRYPTO_RNG_DEFAULT=y +CONFIG_CRYPTO_AKCIPHER2=y +CONFIG_CRYPTO_AKCIPHER=y +CONFIG_CRYPTO_KPP2=y +CONFIG_CRYPTO_KPP=y +CONFIG_CRYPTO_ACOMP2=y +CONFIG_CRYPTO_RSA=y +CONFIG_CRYPTO_DH=y +CONFIG_CRYPTO_ECDH=y +CONFIG_CRYPTO_MANAGER=y +CONFIG_CRYPTO_MANAGER2=y +CONFIG_CRYPTO_USER=y +CONFIG_CRYPTO_MANAGER_DISABLE_TESTS=y +CONFIG_CRYPTO_GF128MUL=y +CONFIG_CRYPTO_NULL=y +CONFIG_CRYPTO_NULL2=y +CONFIG_CRYPTO_PCRYPT=y +CONFIG_CRYPTO_WORKQUEUE=y +CONFIG_CRYPTO_CRYPTD=y +CONFIG_CRYPTO_MCRYPTD=y +CONFIG_CRYPTO_AUTHENC=y +CONFIG_CRYPTO_TEST=m +CONFIG_CRYPTO_ABLK_HELPER=y +CONFIG_CRYPTO_SIMD=y +CONFIG_CRYPTO_GLUE_HELPER_X86=y +CONFIG_CRYPTO_ENGINE=y + +# +# Authenticated Encryption with Associated Data +# +CONFIG_CRYPTO_CCM=y +CONFIG_CRYPTO_GCM=y +CONFIG_CRYPTO_CHACHA20POLY1305=y +CONFIG_CRYPTO_SEQIV=y +CONFIG_CRYPTO_ECHAINIV=y + +# +# Block modes +# +CONFIG_CRYPTO_CBC=y +CONFIG_CRYPTO_CTR=y +CONFIG_CRYPTO_CTS=y +CONFIG_CRYPTO_ECB=y +CONFIG_CRYPTO_LRW=y +CONFIG_CRYPTO_PCBC=y +CONFIG_CRYPTO_XTS=y +CONFIG_CRYPTO_KEYWRAP=y + +# +# Hash modes +# +CONFIG_CRYPTO_CMAC=y +CONFIG_CRYPTO_HMAC=y +CONFIG_CRYPTO_XCBC=y +CONFIG_CRYPTO_VMAC=y + +# +# Digest +# +CONFIG_CRYPTO_CRC32C=y +CONFIG_CRYPTO_CRC32C_INTEL=y +CONFIG_CRYPTO_CRC32=y +CONFIG_CRYPTO_CRC32_PCLMUL=y +CONFIG_CRYPTO_CRCT10DIF=y +CONFIG_CRYPTO_CRCT10DIF_PCLMUL=y +CONFIG_CRYPTO_GHASH=y +CONFIG_CRYPTO_POLY1305=y +CONFIG_CRYPTO_POLY1305_X86_64=y +CONFIG_CRYPTO_MD4=y +CONFIG_CRYPTO_MD5=y +CONFIG_CRYPTO_MICHAEL_MIC=y +CONFIG_CRYPTO_RMD128=y +CONFIG_CRYPTO_RMD160=y +CONFIG_CRYPTO_RMD256=y +CONFIG_CRYPTO_RMD320=y +CONFIG_CRYPTO_SHA1=y +CONFIG_CRYPTO_SHA1_SSSE3=y +CONFIG_CRYPTO_SHA256_SSSE3=y +CONFIG_CRYPTO_SHA512_SSSE3=y +CONFIG_CRYPTO_SHA1_MB=y +CONFIG_CRYPTO_SHA256_MB=y +CONFIG_CRYPTO_SHA512_MB=y +CONFIG_CRYPTO_SHA256=y +CONFIG_CRYPTO_SHA512=y +CONFIG_CRYPTO_SHA3=y +CONFIG_CRYPTO_SM3=y +CONFIG_CRYPTO_TGR192=y +CONFIG_CRYPTO_WP512=y +CONFIG_CRYPTO_GHASH_CLMUL_NI_INTEL=y + +# +# Ciphers +# +CONFIG_CRYPTO_AES=y +CONFIG_CRYPTO_AES_TI=y +CONFIG_CRYPTO_AES_X86_64=y +CONFIG_CRYPTO_AES_NI_INTEL=y +CONFIG_CRYPTO_ANUBIS=y +CONFIG_CRYPTO_ARC4=y +CONFIG_CRYPTO_BLOWFISH=y +CONFIG_CRYPTO_BLOWFISH_COMMON=y +CONFIG_CRYPTO_BLOWFISH_X86_64=y +CONFIG_CRYPTO_CAMELLIA=y +CONFIG_CRYPTO_CAMELLIA_X86_64=y +CONFIG_CRYPTO_CAMELLIA_AESNI_AVX_X86_64=y +CONFIG_CRYPTO_CAMELLIA_AESNI_AVX2_X86_64=y +CONFIG_CRYPTO_CAST_COMMON=y +CONFIG_CRYPTO_CAST5=y +CONFIG_CRYPTO_CAST5_AVX_X86_64=y +CONFIG_CRYPTO_CAST6=y +CONFIG_CRYPTO_CAST6_AVX_X86_64=y +CONFIG_CRYPTO_DES=y +CONFIG_CRYPTO_DES3_EDE_X86_64=y +CONFIG_CRYPTO_FCRYPT=y +CONFIG_CRYPTO_KHAZAD=y +CONFIG_CRYPTO_SALSA20=y +CONFIG_CRYPTO_SALSA20_X86_64=y +CONFIG_CRYPTO_CHACHA20=y +CONFIG_CRYPTO_CHACHA20_X86_64=y +CONFIG_CRYPTO_SEED=y +CONFIG_CRYPTO_SERPENT=y +CONFIG_CRYPTO_SERPENT_SSE2_X86_64=y +CONFIG_CRYPTO_SERPENT_AVX_X86_64=y +CONFIG_CRYPTO_SERPENT_AVX2_X86_64=y +CONFIG_CRYPTO_TEA=y +CONFIG_CRYPTO_TWOFISH=y +CONFIG_CRYPTO_TWOFISH_COMMON=y +CONFIG_CRYPTO_TWOFISH_X86_64=y +CONFIG_CRYPTO_TWOFISH_X86_64_3WAY=y +CONFIG_CRYPTO_TWOFISH_AVX_X86_64=y + +# +# Compression +# +CONFIG_CRYPTO_DEFLATE=y +CONFIG_CRYPTO_LZO=y +CONFIG_CRYPTO_842=y +CONFIG_CRYPTO_LZ4=y +CONFIG_CRYPTO_LZ4HC=y + +# +# Random Number Generation +# +CONFIG_CRYPTO_ANSI_CPRNG=y +CONFIG_CRYPTO_DRBG_MENU=y +CONFIG_CRYPTO_DRBG_HMAC=y +CONFIG_CRYPTO_DRBG_HASH=y +CONFIG_CRYPTO_DRBG_CTR=y +CONFIG_CRYPTO_DRBG=y +CONFIG_CRYPTO_JITTERENTROPY=y +CONFIG_CRYPTO_USER_API=y +CONFIG_CRYPTO_USER_API_HASH=y +CONFIG_CRYPTO_USER_API_SKCIPHER=y +CONFIG_CRYPTO_USER_API_RNG=y +CONFIG_CRYPTO_USER_API_AEAD=y +CONFIG_CRYPTO_HASH_INFO=y +CONFIG_CRYPTO_HW=y +CONFIG_CRYPTO_DEV_PADLOCK=y +CONFIG_CRYPTO_DEV_PADLOCK_AES=y +CONFIG_CRYPTO_DEV_PADLOCK_SHA=y +# CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_DESC is not set +CONFIG_CRYPTO_DEV_PICOXCELL=y +CONFIG_CRYPTO_DEV_EXYNOS_RNG=y +CONFIG_CRYPTO_DEV_S5P=y +CONFIG_CRYPTO_DEV_ATMEL_AUTHENC=y +CONFIG_CRYPTO_DEV_ATMEL_AES=y +CONFIG_CRYPTO_DEV_ATMEL_TDES=y +CONFIG_CRYPTO_DEV_ATMEL_SHA=y +CONFIG_CRYPTO_DEV_ATMEL_ECC=y +CONFIG_CRYPTO_DEV_CCP=y +CONFIG_CRYPTO_DEV_CCP_DD=y +CONFIG_CRYPTO_DEV_SP_CCP=y +CONFIG_CRYPTO_DEV_CCP_CRYPTO=y +CONFIG_CRYPTO_DEV_SP_PSP=y +CONFIG_CRYPTO_DEV_QAT=y +CONFIG_CRYPTO_DEV_QAT_DH895xCC=y +CONFIG_CRYPTO_DEV_QAT_C3XXX=y +CONFIG_CRYPTO_DEV_QAT_C62X=y +CONFIG_CRYPTO_DEV_QAT_DH895xCCVF=y +CONFIG_CRYPTO_DEV_QAT_C3XXXVF=y +CONFIG_CRYPTO_DEV_QAT_C62XVF=y +CONFIG_CRYPTO_DEV_CPT=y +CONFIG_CAVIUM_CPT=y +CONFIG_CRYPTO_DEV_NITROX=y +CONFIG_CRYPTO_DEV_NITROX_CNN55XX=y +CONFIG_CRYPTO_DEV_CAVIUM_ZIP=y +CONFIG_CRYPTO_DEV_QCE=y +CONFIG_CRYPTO_DEV_IMGTEC_HASH=y +CONFIG_CRYPTO_DEV_MEDIATEK=y +CONFIG_CRYPTO_DEV_CHELSIO=y +CONFIG_CHELSIO_IPSEC_INLINE=y +CONFIG_CRYPTO_DEV_VIRTIO=y +CONFIG_CRYPTO_DEV_SAFEXCEL=y +CONFIG_ASYMMETRIC_KEY_TYPE=y +CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y +CONFIG_X509_CERTIFICATE_PARSER=y +CONFIG_PKCS7_MESSAGE_PARSER=y +CONFIG_PKCS7_TEST_KEY=y +CONFIG_SIGNED_PE_FILE_VERIFICATION=y + +# +# Certificates for signature checking +# +CONFIG_MODULE_SIG_KEY="certs/signing_key.pem" +CONFIG_SYSTEM_TRUSTED_KEYRING=y +CONFIG_SYSTEM_TRUSTED_KEYS="" +CONFIG_SYSTEM_EXTRA_CERTIFICATE=y +CONFIG_SYSTEM_EXTRA_CERTIFICATE_SIZE=4096 +CONFIG_SECONDARY_TRUSTED_KEYRING=y +CONFIG_SYSTEM_BLACKLIST_KEYRING=y +CONFIG_SYSTEM_BLACKLIST_HASH_LIST="" +CONFIG_HAVE_KVM=y +CONFIG_HAVE_KVM_IRQCHIP=y +CONFIG_HAVE_KVM_IRQFD=y +CONFIG_HAVE_KVM_IRQ_ROUTING=y +CONFIG_HAVE_KVM_EVENTFD=y +CONFIG_KVM_MMIO=y +CONFIG_KVM_ASYNC_PF=y +CONFIG_HAVE_KVM_MSI=y +CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT=y +CONFIG_KVM_VFIO=y +CONFIG_KVM_GENERIC_DIRTYLOG_READ_PROTECT=y +CONFIG_KVM_COMPAT=y +CONFIG_HAVE_KVM_IRQ_BYPASS=y +CONFIG_VIRTUALIZATION=y +CONFIG_KVM=y +CONFIG_KVM_INTEL=y +CONFIG_KVM_AMD=y +CONFIG_KVM_AMD_SEV=y +CONFIG_KVM_MMU_AUDIT=y +CONFIG_VHOST_NET=y +CONFIG_VHOST_SCSI=m +CONFIG_VHOST_VSOCK=y +CONFIG_VHOST=y +CONFIG_VHOST_CROSS_ENDIAN_LEGACY=y +CONFIG_BINARY_PRINTF=y + +# +# Library routines +# +CONFIG_RAID6_PQ=y +CONFIG_BITREVERSE=y +# CONFIG_HAVE_ARCH_BITREVERSE is not set +CONFIG_RATIONAL=y +CONFIG_GENERIC_STRNCPY_FROM_USER=y +CONFIG_GENERIC_STRNLEN_USER=y +CONFIG_GENERIC_NET_UTILS=y +CONFIG_GENERIC_FIND_FIRST_BIT=y +CONFIG_GENERIC_PCI_IOMAP=y +CONFIG_GENERIC_IOMAP=y +CONFIG_STMP_DEVICE=y +CONFIG_ARCH_USE_CMPXCHG_LOCKREF=y +CONFIG_ARCH_HAS_FAST_MULTIPLIER=y +CONFIG_CRC_CCITT=y +CONFIG_CRC16=y +CONFIG_CRC_T10DIF=y +CONFIG_CRC_ITU_T=y +CONFIG_CRC32=y +CONFIG_CRC32_SELFTEST=y +CONFIG_CRC32_SLICEBY8=y +# CONFIG_CRC32_SLICEBY4 is not set +# CONFIG_CRC32_SARWATE is not set +# CONFIG_CRC32_BIT is not set +CONFIG_CRC4=y +CONFIG_CRC7=y +CONFIG_LIBCRC32C=y +CONFIG_CRC8=y +CONFIG_XXHASH=y +# CONFIG_AUDIT_ARCH_COMPAT_GENERIC is not set +CONFIG_RANDOM32_SELFTEST=y +CONFIG_842_COMPRESS=y +CONFIG_842_DECOMPRESS=y +CONFIG_ZLIB_INFLATE=y +CONFIG_ZLIB_DEFLATE=y +CONFIG_LZO_COMPRESS=y +CONFIG_LZO_DECOMPRESS=y +CONFIG_LZ4_COMPRESS=y +CONFIG_LZ4HC_COMPRESS=y +CONFIG_LZ4_DECOMPRESS=y +CONFIG_ZSTD_COMPRESS=y +CONFIG_ZSTD_DECOMPRESS=y +CONFIG_XZ_DEC=y +CONFIG_XZ_DEC_X86=y +CONFIG_XZ_DEC_POWERPC=y +CONFIG_XZ_DEC_IA64=y +CONFIG_XZ_DEC_ARM=y +CONFIG_XZ_DEC_ARMTHUMB=y +CONFIG_XZ_DEC_SPARC=y +CONFIG_XZ_DEC_BCJ=y +CONFIG_XZ_DEC_TEST=y +CONFIG_DECOMPRESS_GZIP=y +CONFIG_DECOMPRESS_BZIP2=y +CONFIG_DECOMPRESS_LZMA=y +CONFIG_DECOMPRESS_XZ=y +CONFIG_DECOMPRESS_LZO=y +CONFIG_DECOMPRESS_LZ4=y +CONFIG_GENERIC_ALLOCATOR=y +CONFIG_REED_SOLOMON=y +CONFIG_REED_SOLOMON_ENC8=y +CONFIG_REED_SOLOMON_DEC8=y +CONFIG_REED_SOLOMON_DEC16=y +CONFIG_BCH=y +CONFIG_BCH_CONST_PARAMS=y +CONFIG_TEXTSEARCH=y +CONFIG_TEXTSEARCH_KMP=y +CONFIG_TEXTSEARCH_BM=y +CONFIG_TEXTSEARCH_FSM=y +CONFIG_BTREE=y +CONFIG_INTERVAL_TREE=y +CONFIG_RADIX_TREE_MULTIORDER=y +CONFIG_ASSOCIATIVE_ARRAY=y +CONFIG_HAS_IOMEM=y +CONFIG_HAS_IOPORT_MAP=y +CONFIG_HAS_DMA=y +CONFIG_SGL_ALLOC=y +# CONFIG_DMA_DIRECT_OPS is not set +CONFIG_DMA_VIRT_OPS=y +CONFIG_CHECK_SIGNATURE=y +CONFIG_CPUMASK_OFFSTACK=y +CONFIG_CPU_RMAP=y +CONFIG_DQL=y +CONFIG_GLOB=y +CONFIG_GLOB_SELFTEST=y +CONFIG_NLATTR=y +CONFIG_LRU_CACHE=y +CONFIG_CLZ_TAB=y +CONFIG_CORDIC=y +CONFIG_DDR=y +CONFIG_IRQ_POLL=y +CONFIG_MPILIB=y +CONFIG_SIGNATURE=y +CONFIG_LIBFDT=y +CONFIG_OID_REGISTRY=y +CONFIG_UCS2_STRING=y +CONFIG_FONT_SUPPORT=y +CONFIG_FONTS=y +CONFIG_FONT_8x8=y +CONFIG_FONT_8x16=y +CONFIG_FONT_6x11=y +CONFIG_FONT_7x14=y +CONFIG_FONT_PEARL_8x8=y +CONFIG_FONT_ACORN_8x8=y +CONFIG_FONT_MINI_4x6=y +CONFIG_FONT_6x10=y +CONFIG_FONT_10x18=y +CONFIG_FONT_SUN8x16=y +CONFIG_FONT_SUN12x22=y +CONFIG_SG_SPLIT=y +CONFIG_SG_POOL=y +CONFIG_ARCH_HAS_SG_CHAIN=y +CONFIG_ARCH_HAS_PMEM_API=y +CONFIG_ARCH_HAS_UACCESS_FLUSHCACHE=y +CONFIG_STACKDEPOT=y +CONFIG_SBITMAP=y +CONFIG_PARMAN=y +CONFIG_PRIME_NUMBERS=y +CONFIG_STRING_SELFTEST=y From 8cb4a46092b424fc84a5c3ae455008d115df17c7 Mon Sep 17 00:00:00 2001 From: Ozan Alpay Date: Wed, 4 Jul 2018 11:29:48 +0200 Subject: [PATCH 3/4] Infer Results added for various kernel configurations and versions and grouped according to infer versions. Since Infer-Analyze is failed for infer-v4.16 maximalyesconfig with infer0150, Failure reports added for these runs. --- .../v415/infer0131/defconfig/analysisconfig | 5 + .../results/v415/infer0131/defconfig/bugs.txt | 17688 ++++++ .../v415/infer0131/defconfig/inferconfig | 1 + .../results/v415/infer0150/defconfig/bugs.txt | 45840 +++++++++++++++ infer/results/v416/infer0131/analysisconfig | 6 + infer/results/v416/infer0131/bugs.txt | 18144 ++++++ infer/results/v416/infer0131/inferconfig | 1 + .../results/v416/infer0140/defconfig/bugs.txt | 31217 +++++++++++ .../v416/infer0140/defconfig/inferdefconfig | 13 + .../results/v416/infer0150/defconfig/bugs.txt | 46368 ++++++++++++++++ .../InferOutOfMemoryFailure.md | 16 + .../maxyesconfig-fail/InferSigKillFailure.md | 24 + .../before_first_driver_attribute.txt | 7 + .../OutOfMemoryFiles/error_message.txt | 64 + .../first_struct_driver_attribute_line.txt | 10 + .../OutOfMemoryFiles/tail_logs.txt | 1000 + .../SigKillFailureFiles/infer_failure_log.txt | 18 + .../SigKillFailureFiles/infermaximalyesconfig | 13 + ...logs_starting_from_first_mod_tree_root.txt | 31 + .../logs_starting_from_first_pv_irq_ops.txt | 1401 + .../SigKillFailureFiles/maximalyesconfig | 11502 ++++ .../SigKillFailureFiles/tail_logs.txt | 1000 + 22 files changed, 174369 insertions(+) create mode 100644 infer/results/v415/infer0131/defconfig/analysisconfig create mode 100644 infer/results/v415/infer0131/defconfig/bugs.txt create mode 100644 infer/results/v415/infer0131/defconfig/inferconfig create mode 100644 infer/results/v415/infer0150/defconfig/bugs.txt create mode 100644 infer/results/v416/infer0131/analysisconfig create mode 100644 infer/results/v416/infer0131/bugs.txt create mode 100644 infer/results/v416/infer0131/inferconfig create mode 100644 infer/results/v416/infer0140/defconfig/bugs.txt create mode 100644 infer/results/v416/infer0140/defconfig/inferdefconfig create mode 100644 infer/results/v416/infer0150/defconfig/bugs.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/InferOutOfMemoryFailure.md create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/InferSigKillFailure.md create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/before_first_driver_attribute.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/error_message.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/first_struct_driver_attribute_line.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/tail_logs.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infer_failure_log.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infermaximalyesconfig create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_mod_tree_root.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_pv_irq_ops.txt create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/maximalyesconfig create mode 100644 infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/tail_logs.txt diff --git a/infer/results/v415/infer0131/defconfig/analysisconfig b/infer/results/v415/infer0131/defconfig/analysisconfig new file mode 100644 index 0000000..d3a71f0 --- /dev/null +++ b/infer/results/v415/infer0131/defconfig/analysisconfig @@ -0,0 +1,5 @@ +KERNEL_HEAD_SHA="d8a5b80568a9" +KERNEL_CONFIG="defconfig" +INFERCONFIG_LOCATION="../infer/results/v415/inferconfig" +KERNEL_REPOSITORY="stable" +RUN_ANALYZE=0 diff --git a/infer/results/v415/infer0131/defconfig/bugs.txt b/infer/results/v415/infer0131/defconfig/bugs.txt new file mode 100644 index 0000000..e6afc3a --- /dev/null +++ b/infer/results/v415/infer0131/defconfig/bugs.txt @@ -0,0 +1,17688 @@ +Found 2210 issues + +arch/x86/lib/msr.c:11: error: DEAD_STORE + The value written to &msrs is never used. + 9. struct msr *msrs_alloc(void) + 10. { + 11. > struct msr *msrs = NULL; + 12. + 13. msrs = alloc_percpu(struct msr); + +arch/x86/pci/init.c:12: error: DEAD_STORE + The value written to &type is never used. + 10. { + 11. #ifdef CONFIG_PCI_DIRECT + 12. > int type = 0; + 13. + 14. type = pci_direct_probe(); + +tools/include/asm-generic/bitops/fls.h:36: error: DEAD_STORE + The value written to &x is never used. + 34. } + 35. if (!(x & 0x80000000u)) { + 36. > x <<= 1; + 37. r -= 1; + 38. } + +block/blk-merge.c:50: error: DEAD_STORE + The value written to &tmp is never used. + 48. + 49. tmp = bio->bi_iter.bi_sector + split_sectors - alignment; + 50. > tmp = sector_div(tmp, granularity); + 51. + 52. if (split_sectors > tmp) + +tools/lib/subcmd/help.c:20: error: NULL_DEREFERENCE + pointer `ent` last assigned on line 18 could be null and is dereferenced at line 20, column 2. + 18. struct cmdname *ent = malloc(sizeof(*ent) + len + 1); + 19. + 20. > ent->len = len; + 21. memcpy(ent->name, name, len); + 22. ent->name[len] = 0; + +drivers/clk/clk-fractional-divider.c:23: error: DEAD_STORE + The value written to &flags is never used. + 21. { + 22. struct clk_fractional_divider *fd = to_clk_fd(hw); + 23. > unsigned long flags = 0; + 24. unsigned long m, n; + 25. u32 val; + +sound/hda/trace.h:19: error: DEAD_STORE + The value written to &p is never used. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +tools/lib/subcmd/sigchain.c:30: error: MEMORY_LEAK + memory dynamically allocated by call to `xrealloc()` at line 26, column 2 is not reachable after line 30, column 2. + 28. if (s->old[s->n] == SIG_ERR) + 29. return -1; + 30. > s->n++; + 31. return 0; + 32. } + +tools/lib/subcmd/sigchain.c:29: error: MEMORY_LEAK + memory dynamically allocated to `return` by call to `xrealloc()` at line 26, column 2 is not reachable after line 29, column 3. + 27. s->old[s->n] = signal(sig, f); + 28. if (s->old[s->n] == SIG_ERR) + 29. > return -1; + 30. s->n++; + 31. return 0; + +lib/assoc_array.c:109: error: DEAD_STORE + The value written to &cursor is never used. + 107. shortcut = assoc_array_ptr_to_shortcut(parent); + 108. smp_read_barrier_depends(); + 109. > cursor = parent; + 110. parent = READ_ONCE(shortcut->back_pointer); + 111. slot = shortcut->parent_slot; + +net/ipv6/ip6_offload.c:25: error: DEAD_STORE + The value written to &ops is never used. + 23. static int ipv6_gso_pull_exthdrs(struct sk_buff *skb, int proto) + 24. { + 25. > const struct net_offload *ops = NULL; + 26. + 27. for (;;) { + +tools/include/tools/be_byteshift.h:26: error: DEAD_STORE + The value written to &p is never used. + 24. { + 25. *p++ = val >> 8; + 26. > *p++ = val; + 27. } + 28. + +tools/include/tools/le_byteshift.h:26: error: DEAD_STORE + The value written to &p is never used. + 24. { + 25. *p++ = val; + 26. > *p++ = val >> 8; + 27. } + 28. + +drivers/dma-buf/seqno-fence.c:28: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 26 could be null and is dereferenced at line 28, column 9. + 26. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 27. + 28. > return seqno_fence->ops->get_driver_name(fence); + 29. } + 30. + +drivers/pci/proc.c:100: error: DEAD_STORE + The value written to &buf is never used. + 98. pci_user_read_config_byte(dev, pos, &val); + 99. __put_user(val, buf); + 100. > buf++; + 101. pos++; + 102. cnt--; + +drivers/pci/proc.c:102: error: DEAD_STORE + The value written to &cnt is never used. + 100. buf++; + 101. pos++; + 102. > cnt--; + 103. } + 104. + +lib/ratelimit.c:42: error: DEAD_STORE + The value written to &flags is never used. + 40. * the entity that is holding the lock already: + 41. */ + 42. > if (!raw_spin_trylock_irqsave(&rs->lock, flags)) + 43. return 0; + 44. + +block/partitions/amiga.c:36: error: DEAD_STORE + The value written to &blksize is never used. + 34. struct PartitionBlock *pb; + 35. int start_sect, nr_sects, blk, part, res = 0; + 36. > int blksize = 1; /* Multiplier for disk block size */ + 37. int slot = 1; + 38. char b[BDEVNAME_SIZE]; + +drivers/ras/ras.c:31: error: DEAD_STORE + The value written to &rc is never used. + 29. static int __init ras_init(void) + 30. { + 31. > int rc = 0; + 32. + 33. ras_debugfs_init(); + +drivers/scsi/scsi_trace.c:33: error: DEAD_STORE + The value written to &txlen is never used. + 31. { + 32. const char *ret = trace_seq_buffer_ptr(p); + 33. > sector_t lba = 0, txlen = 0; + 34. + 35. lba |= ((cdb[1] & 0x1F) << 16); + +tools/objtool/warn.h:48: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 48, column 3. + 46. + 47. if (func) + 48. > sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. sprintf(str, "%s+0x%lx", name, name_off); + +tools/objtool/warn.h:50: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 50, column 3. + 48. sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. > sprintf(str, "%s+0x%lx", name, name_off); + 51. + 52. return str; + +drivers/dma-buf/seqno-fence.c:35: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 33 could be null and is dereferenced at line 35, column 9. + 33. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 34. + 35. > return seqno_fence->ops->get_timeline_name(fence); + 36. } + 37. + +drivers/edac/edac_pci.c:40: error: DEAD_STORE + The value written to &pci is never used. + 38. edac_dbg(1, "\n"); + 39. + 40. > pci = edac_align_ptr(&p, sizeof(*pci), 1); + 41. pvt = edac_align_ptr(&p, 1, sz_pvt); + 42. size = ((unsigned long)pvt) + sz_pvt; + +kernel/power/process.c:44: error: DEAD_STORE + The value written to &end_time is never used. + 42. start = ktime_get_boottime(); + 43. + 44. > end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs); + 45. + 46. if (!user_only) + +kernel/power/process.c:40: error: DEAD_STORE + The value written to &sleep_usecs is never used. + 38. unsigned int elapsed_msecs; + 39. bool wakeup = false; + 40. > int sleep_usecs = USEC_PER_MSEC; + 41. + 42. start = ktime_get_boottime(); + +kernel/power/process.c:81: error: DEAD_STORE + The value written to &sleep_usecs is never used. + 79. usleep_range(sleep_usecs / 2, sleep_usecs); + 80. if (sleep_usecs < 8 * USEC_PER_MSEC) + 81. > sleep_usecs *= 2; + 82. } + 83. + +sound/hda/trace.h:31: error: DEAD_STORE + The value written to &p is never used. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +drivers/scsi/scsi_logging.c:36: error: DEAD_STORE + The value written to &idx is never used. + 34. struct scsi_log_buf *buf; + 35. unsigned long map_bits = sizeof(buf->buffer) / SCSI_LOG_BUFSIZE; + 36. > unsigned long idx = 0; + 37. + 38. preempt_disable(); + +net/ipv4/tcp_ulp.c:34: error: DEAD_STORE + The value written to &ulp is never used. + 32. static const struct tcp_ulp_ops *__tcp_ulp_find_autoload(const char *name) + 33. { + 34. > const struct tcp_ulp_ops *ulp = NULL; + 35. + 36. rcu_read_lock(); + +lib/decompress_unlz4.c:41: error: DEAD_STORE + The value written to &chunksize is never used. + 39. { + 40. int ret = -1; + 41. > size_t chunksize = 0; + 42. size_t uncomp_chunksize = LZ4_DEFAULT_UNCOMPRESSED_CHUNK_SIZE; + 43. u8 *inp; + +drivers/base/module.c:64: error: DEAD_STORE + The value written to &no_warn is never used. + 62. + 63. /* Don't check return codes; these calls are idempotent */ + 64. > no_warn = sysfs_create_link(&drv->p->kobj, &mk->kobj, "module"); + 65. driver_name = make_driver_name(drv); + 66. if (driver_name) { + +drivers/base/module.c:68: error: DEAD_STORE + The value written to &no_warn is never used. + 66. if (driver_name) { + 67. module_create_drivers_dir(mk); + 68. > no_warn = sysfs_create_link(mk->drivers_dir, &drv->p->kobj, + 69. driver_name); + 70. kfree(driver_name); + +lib/mpi/mpicoder.c:41: error: DEAD_STORE + The value written to &val is never used. + 39. unsigned nbits, nlimbs; + 40. mpi_limb_t a; + 41. > MPI val = NULL; + 42. + 43. while (nbytes > 0 && buffer[0] == 0) { + +lib/mpi/mpi-pow.c:56: error: DEAD_STORE + The value written to &esign is never used. + 54. msize = mod->nlimbs; + 55. size = 2 * msize; + 56. > esign = exp->sign; + 57. msign = mod->sign; + 58. + +drivers/dma-buf/seqno-fence.c:42: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 40 could be null and is dereferenced at line 42, column 9. + 40. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 41. + 42. > return seqno_fence->ops->enable_signaling(fence); + 43. } + 44. + +net/ipv6/netfilter/nf_log_ipv6.c:49: error: DEAD_STORE + The value written to &hdrlen is never used. + 47. const struct ipv6hdr *ih; + 48. unsigned int ptr; + 49. > unsigned int hdrlen = 0; + 50. unsigned int logflags; + 51. + +drivers/video/backlight/backlight.c:46: error: DEAD_STORE + The value written to &fb_blank is never used. + 44. struct fb_event *evdata = data; + 45. int node = evdata->info->node; + 46. > int fb_blank = 0; + 47. + 48. /* If we aren't interested in this event, skip it immediately ... */ + +drivers/clocksource/acpi_pm.c:43: error: DEAD_STORE + The value written to &v1 is never used. + 41. u32 acpi_pm_read_verified(void) + 42. { + 43. > u32 v1 = 0, v2 = 0, v3 = 0; + 44. + 45. /* + +drivers/clocksource/acpi_pm.c:43: error: DEAD_STORE + The value written to &v2 is never used. + 41. u32 acpi_pm_read_verified(void) + 42. { + 43. > u32 v1 = 0, v2 = 0, v3 = 0; + 44. + 45. /* + +drivers/clocksource/acpi_pm.c:43: error: DEAD_STORE + The value written to &v3 is never used. + 41. u32 acpi_pm_read_verified(void) + 42. { + 43. > u32 v1 = 0, v2 = 0, v3 = 0; + 44. + 45. /* + +drivers/clk/clk-gate.c:46: error: DEAD_STORE + The value written to &flags is never used. + 44. struct clk_gate *gate = to_clk_gate(hw); + 45. int set = gate->flags & CLK_GATE_SET_TO_DISABLE ? 1 : 0; + 46. > unsigned long uninitialized_var(flags); + 47. u32 reg; + 48. + +drivers/usb/core/driver.c:52: error: DEAD_STORE + The value written to &fields is never used. + 50. unsigned int bInterfaceClass = 0; + 51. u32 refVendor, refProduct; + 52. > int fields = 0; + 53. int retval = 0; + 54. + +drivers/usb/core/driver.c:53: error: DEAD_STORE + The value written to &retval is never used. + 51. u32 refVendor, refProduct; + 52. int fields = 0; + 53. > int retval = 0; + 54. + 55. fields = sscanf(buf, "%x %x %x %x %x", &idVendor, &idProduct, + +tools/objtool/builtin-orc.c:51: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 63, column 22) -> ShellExec(execvp at line 180, column 2). + 49. + 50. if (!strncmp(argv[0], "gen", 3)) { + 51. > argc = parse_options(argc, argv, check_options, orc_usage, 0); + 52. if (argc != 1) + 53. usage_with_options(orc_usage, check_options); + +tools/objtool/builtin-orc.c:53: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 63, column 22) -> ShellExec(execvp at line 180, column 2). + 51. argc = parse_options(argc, argv, check_options, orc_usage, 0); + 52. if (argc != 1) + 53. > usage_with_options(orc_usage, check_options); + 54. + 55. objname = argv[0]; + +tools/objtool/builtin-orc.c:62: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 63, column 22) -> ShellExec(execvp at line 180, column 2). + 60. if (!strcmp(argv[0], "dump")) { + 61. if (argc != 2) + 62. > usage_with_options(orc_usage, check_options); + 63. + 64. objname = argv[1]; + +tools/objtool/builtin-orc.c:69: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 63, column 22) -> ShellExec(execvp at line 180, column 2). + 67. } + 68. + 69. > usage_with_options(orc_usage, check_options); + 70. + 71. return 0; + +sound/hda/trace.h:43: error: DEAD_STORE + The value written to &p is never used. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +security/keys/process_keys.c:67: error: DEAD_STORE + The value written to &ret is never used. + 65. + 66. mutex_lock(&key_user_keyring_mutex); + 67. > ret = 0; + 68. + 69. if (!user->uid_keyring) { + +drivers/dma-buf/seqno-fence.c:49: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 47 could be null and is dereferenced at line 49, column 9. + 47. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 48. + 49. > return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence); + 50. } + 51. + +drivers/usb/core/otg_whitelist.h:47: error: DEAD_STORE + The value written to &id is never used. + 45. static int is_targeted(struct usb_device *dev) + 46. { + 47. > struct usb_device_id *id = whitelist_table; + 48. + 49. /* HNP test device is _never_ targeted (see OTG spec 6.6.6) */ + +tools/objtool/builtin-check.c:52: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 63, column 22) -> ShellExec(execvp at line 180, column 2). + 50. + 51. if (argc != 1) + 52. > usage_with_options(check_usage, check_options); + 53. + 54. objname = argv[0]; + +drivers/dma-buf/dma-fence-array.c:52: error: NULL_DEREFERENCE + pointer `array` last assigned on line 48 could be null and is dereferenced at line 52, column 18. + 50. unsigned i; + 51. + 52. > for (i = 0; i < array->num_fences; ++i) { + 53. cb[i].array = array; + 54. /* + +drivers/thermal/thermal_helpers.c:50: error: DEAD_STORE + The value written to &pos is never used. + 48. struct thermal_cooling_device *cdev, int trip) + 49. { + 50. > struct thermal_instance *pos = NULL; + 51. struct thermal_instance *target_instance = NULL; + 52. + +kernel/power/user.c:79: error: DEAD_STORE + The value written to &nr_calls is never used. + 77. error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls); + 78. if (error) + 79. > __pm_notifier_call_chain(PM_POST_HIBERNATION, --nr_calls, NULL); + 80. } else { + 81. /* + +security/selinux/ss/status.c:50: error: DEAD_STORE + The value written to &result is never used. + 48. { + 49. struct selinux_kernel_status *status; + 50. > struct page *result = NULL; + 51. + 52. mutex_lock(&selinux_status_lock); + +drivers/base/syscore.c:51: error: DEAD_STORE + The value written to &ret is never used. + 49. { + 50. struct syscore_ops *ops; + 51. > int ret = 0; + 52. + 53. trace_suspend_resume(TPS("syscore_suspend"), 0, true); + +drivers/edac/edac_device.c:78: error: DEAD_STORE + The value written to &dev_ctl is never used. + 76. */ + 77. p = NULL; + 78. > dev_ctl = edac_align_ptr(&p, sizeof(*dev_ctl), 1); + 79. + 80. /* Calc the 'end' offset past end of ONE ctl_info structure + +kernel/futex_compat.c:103: error: DEAD_STORE + The value written to &uentry is never used. + 101. if (rc) + 102. return; + 103. > uentry = next_uentry; + 104. entry = next_entry; + 105. pi = next_pi; + +drivers/dma-buf/seqno-fence.c:56: error: NULL_DEREFERENCE + pointer `f` last assigned on line 54 could be null and is dereferenced at line 56, column 14. + 54. struct seqno_fence *f = to_seqno_fence(fence); + 55. + 56. > dma_buf_put(f->sync_buf); + 57. if (f->ops->release) + 58. f->ops->release(fence); + +drivers/gpu/drm/drm_encoder_slave.c:60: error: DEAD_STORE + The value written to &err is never used. + 58. struct i2c_client *client; + 59. struct drm_i2c_encoder_driver *encoder_drv; + 60. > int err = 0; + 61. + 62. request_module("%s%s", I2C_MODULE_PREFIX, info->type); + +drivers/video/fbdev/core/sysimgblt.c:57: error: DEAD_STORE + The value written to &color is never used. + 55. /* Draw the penguin */ + 56. u32 *dst, *dst2; + 57. > u32 color = 0, val, shift; + 58. int i, n, bpp = p->var.bits_per_pixel; + 59. u32 null_bits = 32 - bpp; + +net/ipv6/anycast.c:56: error: DEAD_STORE + The value written to &dev is never used. + 54. { + 55. struct ipv6_pinfo *np = inet6_sk(sk); + 56. > struct net_device *dev = NULL; + 57. struct inet6_dev *idev; + 58. struct ipv6_ac_socklist *pac; + +net/ipv6/inet6_hashtables.c:63: error: DEAD_STORE + The value written to &ports is never used. + 61. struct sock *sk; + 62. const struct hlist_nulls_node *node; + 63. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 64. /* Optimize here for direct hit, only listening connections can + 65. * have wildcards anyways. + +crypto/cmac.c:63: error: DEAD_STORE + The value written to &err is never used. + 61. (alignmask | (__alignof__(__be64) - 1)) + 1); + 62. u64 _const[2]; + 63. > int i, err = 0; + 64. u8 msb_mask, gfmask; + 65. + +sound/hda/trace.h:55: error: DEAD_STORE + The value written to &p is never used. + 53. ); + 54. + 55. > DECLARE_EVENT_CLASS(hdac_stream, + 56. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 57. + +lib/decompress_unlzo.c:60: error: DEAD_STORE + The value written to &level is never used. + 58. u8 *parse = input; + 59. u8 *end = input + in_len; + 60. > u8 level = 0; + 61. u16 version; + 62. + +lib/decompress_unlzo.c:82: error: DEAD_STORE + The value written to &level is never used. + 80. parse += 7; + 81. if (version >= 0x0940) + 82. > level = *parse++; + 83. if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) + 84. parse += 8; /* flags + filter info */ + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:61: error: DEAD_STORE + The value written to &level is never used. + 59. struct intel_dp *intel_dp = enc_to_intel_dp(&connector->encoder->base); + 60. uint8_t read_val[2] = { 0x0 }; + 61. > uint16_t level = 0; + 62. + 63. if (drm_dp_dpcd_read(&intel_dp->aux, DP_EDP_BACKLIGHT_BRIGHTNESS_MSB, + +kernel/time/tick-sched.c:88: error: DEAD_STORE + The value written to &ticks is never used. + 86. incr * ticks); + 87. } + 88. > do_timer(++ticks); + 89. + 90. /* Keep the tick_next_period variable up to date */ + +net/sunrpc/cache.c:60: error: DEAD_STORE + The value written to &new is never used. + 58. struct cache_head *key, int hash) + 59. { + 60. > struct cache_head *new = NULL, *freeme = NULL, *tmp = NULL; + 61. struct hlist_head *head; + 62. + +net/sunrpc/cache.c:60: error: DEAD_STORE + The value written to &tmp is never used. + 58. struct cache_head *key, int hash) + 59. { + 60. > struct cache_head *new = NULL, *freeme = NULL, *tmp = NULL; + 61. struct hlist_head *head; + 62. + +arch/x86/pci/amd_bus.c:128: error: DEAD_STORE + The value written to &info is never used. + 126. link = (reg >> 8) & 0x03; + 127. + 128. > info = alloc_pci_root_info(min_bus, max_bus, node, link); + 129. } + 130. + +net/dns_resolver/dns_key.c:66: error: DEAD_STORE + The value written to &result_len is never used. + 64. unsigned long derrno; + 65. int ret; + 66. > int datalen = prep->datalen, result_len = 0; + 67. const char *data = prep->data, *end, *opt; + 68. + +block/badblocks.c:76: error: DEAD_STORE + The value written to §ors is never used. + 74. target += (1<shift) - 1; + 75. target >>= bb->shift; + 76. > sectors = target - s; + 77. } + 78. /* 'target' is now the first block after the bad range */ + +sound/core/vmaster.c:70: error: DEAD_STORE + The value written to &err is never used. + 68. return -ENOMEM; + 69. uctl->id = slave->slave.id; + 70. > err = slave->slave.get(&slave->slave, uctl); + 71. for (ch = 0; ch < slave->info.count; ch++) + 72. slave->vals[ch] = uctl->value.integer.value[ch]; + +tools/lib/subcmd/pager.c:89: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 63, column 22) -> ShellExec(execvp at line 180, column 2). + 87. pager_process.preexec_cb = pager_preexec; + 88. + 89. > if (start_command(&pager_process)) + 90. return; + 91. + +tools/lib/subcmd/pager.c:89: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 71, column 11) -> ShellExec(execvp at line 180, column 2). + 87. pager_process.preexec_cb = pager_preexec; + 88. + 89. > if (start_command(&pager_process)) + 90. return; + 91. + +drivers/dma-buf/seqno-fence.c:68: error: NULL_DEREFERENCE + pointer `f` last assigned on line 66 could be null and is dereferenced at line 68, column 9. + 66. struct seqno_fence *f = to_seqno_fence(fence); + 67. + 68. > return f->ops->wait(fence, intr, timeout); + 69. } + 70. + +drivers/char/agp/isoch.c:140: error: DEAD_STORE + The value written to &mcapndx is never used. + 138. dev = cur->dev; + 139. + 140. > mcapndx = cur->capndx; + 141. + 142. pci_read_config_dword(dev, cur->capndx+AGPNISTAT, &mnistat); + +drivers/char/agp/isoch.c:253: error: DEAD_STORE + The value written to &mcapndx is never used. + 251. dev = cur->dev; + 252. + 253. > mcapndx = cur->capndx; + 254. + 255. master[cdev].rq += (cdev == ndevs - 1) + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &timeout__ is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +drivers/clk/clk-mux.c:70: error: DEAD_STORE + The value written to &flags is never used. + 68. struct clk_mux *mux = to_clk_mux(hw); + 69. u32 val; + 70. > unsigned long flags = 0; + 71. + 72. if (mux->table) { + +lib/bug.c:69: error: DEAD_STORE + The value written to &bug is never used. + 67. { + 68. struct module *mod; + 69. > struct bug_entry *bug = NULL; + 70. + 71. rcu_read_lock_sched(); + +kernel/sched/cpupri.c:71: error: DEAD_STORE + The value written to &idx is never used. + 69. struct cpumask *lowest_mask) + 70. { + 71. > int idx = 0; + 72. int task_pri = convert_prio(p->prio); + 73. + +net/ipv6/xfrm6_mode_transport.c:77: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 74 could be null and is dereferenced at line 77, column 8. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +net/ipv4/syncookies.c:73: error: DEAD_STORE + The value written to &options is never used. + 71. struct inet_request_sock *ireq; + 72. u32 ts, ts_now = tcp_time_stamp_raw(); + 73. > u32 options = 0; + 74. + 75. ireq = inet_rsk(req); + +drivers/scsi/scsi_pm.c:74: error: DEAD_STORE + The value written to &err is never used. + 72. { + 73. const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; + 74. > int err = 0; + 75. + 76. err = cb(dev, pm); + +kernel/irq/chip.c:74: error: DEAD_STORE + The value written to &ret is never used. + 72. unsigned long flags; + 73. struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL); + 74. > int ret = 0; + 75. + 76. if (!desc) + +arch/x86/ia32/sys_ia32.c:74: error: DEAD_STORE + The value written to &gid is never used. + 72. { + 73. typeof(ubuf->st_uid) uid = 0; + 74. > typeof(ubuf->st_gid) gid = 0; + 75. SET_UID(uid, from_kuid_munged(current_user_ns(), stat->uid)); + 76. SET_GID(gid, from_kgid_munged(current_user_ns(), stat->gid)); + +arch/x86/ia32/sys_ia32.c:73: error: DEAD_STORE + The value written to &uid is never used. + 71. static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat) + 72. { + 73. > typeof(ubuf->st_uid) uid = 0; + 74. typeof(ubuf->st_gid) gid = 0; + 75. SET_UID(uid, from_kuid_munged(current_user_ns(), stat->uid)); + +crypto/sha256_generic.c:230: error: DEAD_STORE + The value written to &a is never used. + 228. + 229. /* clear any sensitive info... */ + 230. > a = b = c = d = e = f = g = h = t1 = t2 = 0; + 231. memzero_explicit(W, 64 * sizeof(u32)); + 232. } + +arch/x86/platform/efi/efi_64.c:105: error: DEAD_STORE + The value written to &vaddr is never used. + 103. for (pgd = 0; pgd < n_pgds; pgd++) { + 104. addr_pgd = (unsigned long)(pgd * PGDIR_SIZE); + 105. > vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 106. pgd_efi = pgd_offset_k(addr_pgd); + 107. save_pgd[pgd] = *pgd_efi; + +arch/x86/platform/efi/efi_64.c:107: error: NULL_DEREFERENCE + pointer `save_pgd` last assigned on line 93 could be null and is dereferenced at line 107, column 3. + 105. vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 106. pgd_efi = pgd_offset_k(addr_pgd); + 107. > save_pgd[pgd] = *pgd_efi; + 108. + 109. p4d = p4d_alloc(&init_mm, pgd_efi, addr_pgd); + +tools/objtool/orc_dump.c:102: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 102, column 3. + 100. elf = elf_begin(fd, ELF_C_READ_MMAP, NULL); + 101. if (!elf) { + 102. > WARN_ELF("elf_begin"); + 103. return -1; + 104. } + +tools/objtool/orc_dump.c:107: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 107, column 3. + 105. + 106. if (elf_getshdrnum(elf, &nr_sections)) { + 107. > WARN_ELF("elf_getshdrnum"); + 108. return -1; + 109. } + +tools/objtool/orc_dump.c:112: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 112, column 3. + 110. + 111. if (elf_getshdrstrndx(elf, &shstrtab_idx)) { + 112. > WARN_ELF("elf_getshdrstrndx"); + 113. return -1; + 114. } + +tools/objtool/orc_dump.c:119: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 119, column 4. + 117. scn = elf_getscn(elf, i); + 118. if (!scn) { + 119. > WARN_ELF("elf_getscn"); + 120. return -1; + 121. } + +tools/objtool/orc_dump.c:124: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 124, column 4. + 122. + 123. if (!gelf_getshdr(scn, &sh)) { + 124. > WARN_ELF("gelf_getshdr"); + 125. return -1; + 126. } + +tools/objtool/orc_dump.c:130: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 130, column 4. + 128. name = elf_strptr(elf, shstrtab_idx, sh.sh_name); + 129. if (!name) { + 130. > WARN_ELF("elf_strptr"); + 131. return -1; + 132. } + +tools/objtool/orc_dump.c:136: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 136, column 4. + 134. data = elf_getdata(scn, NULL); + 135. if (!data) { + 136. > WARN_ELF("elf_getdata"); + 137. return -1; + 138. } + +drivers/gpu/drm/drm_property.c:78: error: DEAD_STORE + The value written to &property is never used. + 76. const char *name, int num_values) + 77. { + 78. > struct drm_property *property = NULL; + 79. int ret; + 80. + +drivers/video/fbdev/core/cfbimgblt.c:82: error: DEAD_STORE + The value written to &color is never used. + 80. /* Draw the penguin */ + 81. u32 __iomem *dst, *dst2; + 82. > u32 color = 0, val, shift; + 83. int i, n, bpp = p->var.bits_per_pixel; + 84. u32 null_bits = 32 - bpp; + +drivers/power/supply/power_supply_sysfs.c:79: error: DEAD_STORE + The value written to &ret is never used. + 77. struct device_attribute *attr, + 78. char *buf) { + 79. > ssize_t ret = 0; + 80. struct power_supply *psy = dev_get_drvdata(dev); + 81. const ptrdiff_t off = attr - power_supply_attrs; + +kernel/cgroup/stat.c:96: error: NULL_DEREFERENCE + pointer `pos` last assigned on line 92 could be null and is dereferenced by call to `cgroup_cpu_stat()` at line 96, column 11. + 94. /* walk down to the first leaf */ + 95. while (true) { + 96. > cstat = cgroup_cpu_stat(pos, cpu); + 97. if (cstat->updated_children == pos) + 98. break; + +drivers/net/ethernet/intel/e1000e/phy.c:80: error: DEAD_STORE + The value written to &ret_val is never used. + 78. { + 79. struct e1000_phy_info *phy = &hw->phy; + 80. > s32 ret_val = 0; + 81. u16 phy_id; + 82. u16 retry_count = 0; + +drivers/gpu/drm/drm_global.c:80: error: DEAD_STORE + The value written to &ret is never used. + 78. int drm_global_item_ref(struct drm_global_reference *ref) + 79. { + 80. > int ret = 0; + 81. struct drm_global_item *item = &glob[ref->global_type]; + 82. + +drivers/pps/kapi.c:88: error: DEAD_STORE + The value written to &err is never used. + 86. pr_err("%s: unsupported default parameters\n", + 87. info->name); + 88. > err = -EINVAL; + 89. goto pps_register_source_exit; + 90. } + +drivers/pps/kapi.c:94: error: DEAD_STORE + The value written to &err is never used. + 92. pr_err("%s: unspecified time format\n", + 93. info->name); + 94. > err = -EINVAL; + 95. goto pps_register_source_exit; + 96. } + +drivers/pps/kapi.c:101: error: DEAD_STORE + The value written to &err is never used. + 99. pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL); + 100. if (pps == NULL) { + 101. > err = -ENOMEM; + 102. goto pps_register_source_exit; + 103. } + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:90: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 84 could be null and is dereferenced at line 90, column 6. + 88. + 89. /* Write the MSB and/or LSB */ + 90. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) { + 91. vals[0] = (level & 0xFF00) >> 8; + 92. vals[1] = (level & 0xFF); + +drivers/pnp/driver.c:85: error: DEAD_STORE + The value written to &dev_id is never used. + 83. struct pnp_driver *pnp_drv; + 84. struct pnp_dev *pnp_dev; + 85. > const struct pnp_device_id *dev_id = NULL; + 86. pnp_dev = to_pnp_dev(dev); + 87. pnp_drv = to_pnp_driver(dev->driver); + +net/core/net-sysfs.c:87: error: DEAD_STORE + The value written to &ret is never used. + 85. struct net *net = dev_net(netdev); + 86. unsigned long new; + 87. > int ret = -EINVAL; + 88. + 89. if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) + +drivers/dma-buf/dma-fence-array.c:86: error: NULL_DEREFERENCE + pointer `array` last assigned on line 83 could be null and is dereferenced at line 86, column 18. + 84. unsigned i; + 85. + 86. > for (i = 0; i < array->num_fences; ++i) + 87. dma_fence_put(array->fences[i]); + 88. + +net/ipv4/ping.c:87: error: DEAD_STORE + The value written to &sk2 is never used. + 85. struct hlist_nulls_head *hlist; + 86. struct inet_sock *isk, *isk2; + 87. > struct sock *sk2 = NULL; + 88. + 89. isk = inet_sk(sk); + +net/ipv6/xfrm6_input.c:88: error: DEAD_STORE + The value written to &i is never used. + 86. struct net *net = dev_net(skb->dev); + 87. struct xfrm_state *x = NULL; + 88. > int i = 0; + 89. + 90. if (secpath_set(skb)) { + +drivers/i2c/algos/i2c-algo-bit.c:94: error: DEAD_STORE + The value written to &start is never used. + 92. goto done; + 93. + 94. > start = jiffies; + 95. while (!getscl(adap)) { + 96. /* This hw knows how to read the clock line, so we wait + +drivers/usb/core/usb-acpi.c:100: error: DEAD_STORE + The value written to &status is never used. + 98. * no connectable, the port would be not used. + 99. */ + 100. > status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer); + 101. upc = buffer.pointer; + 102. if (!upc || (upc->type != ACPI_TYPE_PACKAGE) + +net/netlabel/netlabel_calipso.c:88: error: DEAD_STORE + The value written to &doi_def is never used. + 86. { + 87. int ret_val; + 88. > struct calipso_doi *doi_def = NULL; + 89. + 90. doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL); + +sound/hda/hdac_controller.c:88: error: DEAD_STORE + The value written to &timeout is never used. + 86. unsigned long timeout; + 87. + 88. > timeout = jiffies + msecs_to_jiffies(100); + 89. while ((snd_hdac_chip_readb(bus, RIRBCTL) & AZX_RBCTL_DMA_EN) + 90. && time_before(jiffies, timeout)) + +sound/hda/hdac_controller.c:93: error: DEAD_STORE + The value written to &timeout is never used. + 91. udelay(10); + 92. + 93. > timeout = jiffies + msecs_to_jiffies(100); + 94. while ((snd_hdac_chip_readb(bus, CORBCTL) & AZX_CORBCTL_RUN) + 95. && time_before(jiffies, timeout)) + +crypto/rsa.c:91: error: DEAD_STORE + The value written to &ret is never used. + 89. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 90. MPI m, c = mpi_alloc(0); + 91. > int ret = 0; + 92. int sign; + 93. + +drivers/gpu/drm/drm_probe_helper.c:92: error: DEAD_STORE + The value written to &ret is never used. + 90. struct drm_device *dev = connector->dev; + 91. uint32_t *ids = connector->encoder_ids; + 92. > enum drm_mode_status ret = MODE_OK; + 93. unsigned int i; + 94. + +lib/zlib_inflate/inffast.c:257: error: DEAD_STORE + The value written to &from is never used. + 255. PUP(out) = PUP(from); + 256. if (len > 1) + 257. > PUP(out) = PUP(from); + 258. } + 259. } + +lib/zlib_inflate/inffast.c:304: error: DEAD_STORE + The value written to &from is never used. + 302. } + 303. if (len & 1) + 304. > PUP(out) = PUP(from); + 305. } + 306. } + +crypto/ccm.c:96: error: DEAD_STORE + The value written to &err is never used. + 94. struct crypto_skcipher *ctr = ctx->ctr; + 95. struct crypto_ahash *mac = ctx->mac; + 96. > int err = 0; + 97. + 98. crypto_skcipher_clear_flags(ctr, CRYPTO_TFM_REQ_MASK); + +drivers/edac/edac_mc.c:92: error: DEAD_STORE + The value written to &ret is never used. + 90. static int edac_report_get(char *buffer, const struct kernel_param *kp) + 91. { + 92. > int ret = 0; + 93. + 94. switch (edac_report) { + +net/netfilter/nf_nat_sip.c:112: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 99 could be null and is dereferenced at line 112, column 13. + 110. ct->tuplehash[dir].tuple.dst.u.udp.port == port) { + 111. newaddr = ct->tuplehash[!dir].tuple.src.u3; + 112. > newport = ct_sip_info->forced_dport ? : + 113. ct->tuplehash[!dir].tuple.src.u.udp.port; + 114. } else + +drivers/clk/clk.c:95: error: DEAD_STORE + The value written to &ret is never used. + 93. static int clk_pm_runtime_get(struct clk_core *core) + 94. { + 95. > int ret = 0; + 96. + 97. if (!core->dev) + +drivers/gpu/drm/i915/intel_dp_mst.c:103: error: NULL_DEREFERENCE + pointer `old_conn_state` last assigned on line 102 could be null and is dereferenced at line 103, column 13. + 101. + 102. old_conn_state = drm_atomic_get_old_connector_state(state, connector); + 103. > old_crtc = old_conn_state->crtc; + 104. if (!old_crtc) + 105. return ret; + +drivers/clk/clk-fractional-divider.c:98: error: DEAD_STORE + The value written to &flags is never used. + 96. { + 97. struct clk_fractional_divider *fd = to_clk_fd(hw); + 98. > unsigned long flags = 0; + 99. unsigned long m, n; + 100. u32 val; + +drivers/video/fbdev/core/fbmem.c:97: error: DEAD_STORE + The value written to &depth is never used. + 95. struct fb_fix_screeninfo *fix) + 96. { + 97. > int depth = 0; + 98. + 99. if (fix->visual == FB_VISUAL_MONO01 || + +security/keys/request_key.c:99: error: DEAD_STORE + The value written to &cred is never used. + 97. { + 98. static char const request_key[] = "/sbin/request-key"; + 99. > const struct cred *cred = current_cred(); + 100. key_serial_t prkey, sskey; + 101. struct key *key = cons->key, *authkey = cons->authkey, *keyring, + +drivers/firmware/efi/vars.c:101: error: DEAD_STORE + The value written to &desclength is never used. + 99. { + 100. u16 filepathlength; + 101. > int i, desclength = 0, namelen; + 102. + 103. namelen = ucs2_strnlen(var_name, EFI_VAR_NAME_LEN); + +drivers/scsi/scsi_logging.c:115: error: DEAD_STORE + The value written to &off is never used. + 113. if (!WARN_ON(off >= logbuf_len)) { + 114. va_start(args, fmt); + 115. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 116. va_end(args); + 117. } + +net/sched/ematch.c:98: error: DEAD_STORE + The value written to &e is never used. + 96. static struct tcf_ematch_ops *tcf_em_lookup(u16 kind) + 97. { + 98. > struct tcf_ematch_ops *e = NULL; + 99. + 100. read_lock(&ematch_mod_lock); + +drivers/pcmcia/ds.c:105: error: DEAD_STORE + The value written to &fields is never used. + 103. __u8 func_id, function, device_no; + 104. __u32 prod_id_hash[4] = {0, 0, 0, 0}; + 105. > int fields = 0; + 106. int retval = 0; + 107. + +drivers/pcmcia/ds.c:106: error: DEAD_STORE + The value written to &retval is never used. + 104. __u32 prod_id_hash[4] = {0, 0, 0, 0}; + 105. int fields = 0; + 106. > int retval = 0; + 107. + 108. fields = sscanf(buf, "%hx %hx %hx %hhx %hhx %hhx %x %x %x %x", + +crypto/jitterentropy-kcapi.c:100: error: DEAD_STORE + The value written to &tmp is never used. + 98. void jent_get_nstime(__u64 *out) + 99. { + 100. > __u64 tmp = 0; + 101. + 102. tmp = random_get_entropy(); + +drivers/char/agp/frontend.c:112: error: DEAD_STORE + The value written to &num_segments is never used. + 110. pg_count = size / 4096; + 111. seg = *(client->segments); + 112. > num_segments = client->num_segments; + 113. + 114. for (i = 0; i < client->num_segments; i++) { + +drivers/gpu/drm/drm_rect.c:101: error: DEAD_STORE + The value written to &scale is never used. + 99. static int drm_calc_scale(int src, int dst) + 100. { + 101. > int scale = 0; + 102. + 103. if (WARN_ON(src < 0 || dst < 0)) + +drivers/pci/pci-driver.c:107: error: DEAD_STORE + The value written to &fields is never used. + 105. subdevice = PCI_ANY_ID, class = 0, class_mask = 0; + 106. unsigned long driver_data = 0; + 107. > int fields = 0; + 108. int retval = 0; + 109. + +kernel/sched/cpuacct.c:104: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 102 could be null and is dereferenced at line 104, column 14. + 102. struct cpuacct *ca = css_ca(css); + 103. + 104. > free_percpu(ca->cpustat); + 105. free_percpu(ca->cpuusage); + 106. kfree(ca); + +drivers/video/fbdev/core/fbcvt.c:103: error: DEAD_STORE + The value written to &hblank is never used. + 101. static u32 fb_cvt_hblank(struct fb_cvt_data *cvt) + 102. { + 103. > u32 hblank = 0; + 104. + 105. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) + +drivers/edac/edac_module.c:104: error: DEAD_STORE + The value written to &err is never used. + 102. static int __init edac_init(void) + 103. { + 104. > int err = 0; + 105. + 106. edac_printk(KERN_INFO, EDAC_MC, EDAC_VERSION "\n"); + +drivers/tty/serial/8250/8250_pci.c:106: error: DEAD_STORE + The value written to &bar is never used. + 104. struct uart_8250_port *port, int idx) + 105. { + 106. > unsigned int bar = 0, offset = board->first_offset; + 107. bar = FL_GET_BASE(board->flags); + 108. + +net/ipv4/netfilter/nf_reject_ipv4.c:128: error: DEAD_STORE + The value written to &niph is never used. + 126. + 127. skb_reserve(nskb, LL_MAX_HEADER); + 128. > niph = nf_reject_iphdr_put(nskb, oldskb, IPPROTO_TCP, + 129. ip4_dst_hoplimit(skb_dst(nskb))); + 130. nf_reject_ip_tcphdr_put(nskb, oldskb, oth); + +net/ipv4/netfilter/nf_reject_ipv4.c:135: error: DEAD_STORE + The value written to &niph is never used. + 133. goto free_nskb; + 134. + 135. > niph = ip_hdr(nskb); + 136. + 137. /* "Never happens" */ + +drivers/input/ff-core.c:109: error: DEAD_STORE + The value written to &ret is never used. + 107. struct ff_device *ff = dev->ff; + 108. struct ff_effect *old; + 109. > int ret = 0; + 110. int id; + 111. + +security/keys/proc.c:122: error: DEAD_STORE + The value written to &key is never used. + 120. break; + 121. } + 122. > key = NULL; + 123. } + 124. + +drivers/leds/led-core.c:109: error: DEAD_STORE + The value written to &ret is never used. + 107. struct led_classdev *led_cdev = + 108. container_of(ws, struct led_classdev, set_brightness_work); + 109. > int ret = 0; + 110. + 111. if (test_and_clear_bit(LED_BLINK_DISABLE, &led_cdev->work_flags)) { + +drivers/pnp/support.c:126: error: DEAD_STORE + The value written to &len is never used. + 124. case IORESOURCE_IO: + 125. port = &option->u.port; + 126. > len += scnprintf(buf + len, sizeof(buf) - len, "io min %#llx " + 127. "max %#llx align %lld size %lld flags %#x", + 128. (unsigned long long) port->min, + +drivers/pnp/support.c:135: error: DEAD_STORE + The value written to &len is never used. + 133. case IORESOURCE_MEM: + 134. mem = &option->u.mem; + 135. > len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx " + 136. "max %#llx align %lld size %lld flags %#x", + 137. (unsigned long long) mem->min, + +drivers/pnp/support.c:158: error: DEAD_STORE + The value written to &len is never used. + 156. irq->flags); + 157. if (irq->flags & IORESOURCE_IRQ_OPTIONAL) + 158. > len += scnprintf(buf + len, sizeof(buf) - len, + 159. " (optional)"); + 160. break; + +drivers/pnp/support.c:174: error: DEAD_STORE + The value written to &len is never used. + 172. " %d", i); + 173. } + 174. > len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) " + 175. "flags %#x", dma->map, dma->flags); + 176. break; + +kernel/cgroup/freezer.c:108: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 107 could be null and is dereferenced by call to `parent_freezer()` at line 108, column 27. + 106. { + 107. struct freezer *freezer = css_freezer(css); + 108. > struct freezer *parent = parent_freezer(freezer); + 109. + 110. mutex_lock(&freezer_mutex); + +net/ipv6/netfilter/nf_defrag_ipv6_hooks.c:107: error: DEAD_STORE + The value written to &ret is never used. + 105. static int __init nf_defrag_init(void) + 106. { + 107. > int ret = 0; + 108. + 109. ret = nf_ct_frag6_init(); + +crypto/asymmetric_keys/x509_public_key.c:108: error: DEAD_STORE + The value written to &ret is never used. + 106. int x509_check_for_self_signed(struct x509_certificate *cert) + 107. { + 108. > int ret = 0; + 109. + 110. pr_devel("==>%s()\n", __func__); + +drivers/leds/led-triggers.c:109: error: DEAD_STORE + The value written to &event is never used. + 107. { + 108. unsigned long flags; + 109. > char *event = NULL; + 110. char *envp[2]; + 111. const char *name; + +kernel/sched/cpuacct.c:129: error: DEAD_STORE + The value written to &i is never used. + 127. + 128. if (index == CPUACCT_STAT_NSTATS) { + 129. > int i = 0; + 130. + 131. data = 0; + +lib/oid_registry.c:129: error: DEAD_STORE + The value written to &num is never used. + 127. + 128. while (v < end) { + 129. > num = 0; + 130. n = *v++; + 131. if (!(n & 0x80)) { + +drivers/clk/clk-multiplier.c:116: error: DEAD_STORE + The value written to &flags is never used. + 114. struct clk_multiplier *mult = to_clk_multiplier(hw); + 115. unsigned long factor = __get_mult(mult, rate, parent_rate); + 116. > unsigned long flags = 0; + 117. unsigned long val; + 118. + +drivers/pci/proc.c:173: error: DEAD_STORE + The value written to &buf is never used. + 171. __get_user(val, buf); + 172. pci_user_write_config_byte(dev, pos, val); + 173. > buf++; + 174. pos++; + 175. cnt--; + +drivers/pci/proc.c:175: error: DEAD_STORE + The value written to &cnt is never used. + 173. buf++; + 174. pos++; + 175. > cnt--; + 176. } + 177. + +drivers/video/fbdev/core/sysimgblt.c:115: error: DEAD_STORE + The value written to &color is never used. + 113. u32 start_index, u32 pitch_index) + 114. { + 115. > u32 shift, color = 0, bpp = p->var.bits_per_pixel; + 116. u32 *dst, *dst2; + 117. u32 val, pitch = p->fix.line_length; + +lib/kobject_uevent.c:114: error: DEAD_STORE + The value written to &env is never used. + 112. struct kobj_uevent_env **ret_env) + 113. { + 114. > struct kobj_uevent_env *env = NULL; + 115. const char *next, *buf_end, *key; + 116. int key_len; + +security/lsm_audit.c:114: error: DEAD_STORE + The value written to &ret is never used. + 112. struct common_audit_data *ad, u8 *proto) + 113. { + 114. > int offset, ret = 0; + 115. struct ipv6hdr *ip6; + 116. u8 nexthdr; + +net/ipv6/xfrm6_mode_tunnel.c:116: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 114 could be null and is dereferenced at line 116, column 6. + 114. struct xfrm_offload *xo = xfrm_offload(skb); + 115. + 116. > if (xo->flags & XFRM_GSO_SEGMENT) { + 117. skb->network_header = skb->network_header - x->props.header_len; + 118. skb->transport_header = skb->network_header + sizeof(struct ipv6hdr); + +net/sched/act_api.c:115: error: DEAD_STORE + The value written to &err is never used. + 113. struct netlink_callback *cb) + 114. { + 115. > int err = 0, index = -1, s_i = 0, n_i = 0; + 116. u32 act_flags = cb->args[2]; + 117. unsigned long jiffy_since = cb->args[3]; + +net/sched/act_api.c:121: error: DEAD_STORE + The value written to &id is never used. + 119. struct idr *idr = &idrinfo->action_idr; + 120. struct tc_action *p; + 121. > unsigned long id = 1; + 122. + 123. spin_lock_bh(&idrinfo->lock); + +net/sched/act_api.c:115: error: DEAD_STORE + The value written to &s_i is never used. + 113. struct netlink_callback *cb) + 114. { + 115. > int err = 0, index = -1, s_i = 0, n_i = 0; + 116. u32 act_flags = cb->args[2]; + 117. unsigned long jiffy_since = cb->args[3]; + +lib/decompress_unlzo.c:118: error: DEAD_STORE + The value written to &r is never used. + 116. void (*error) (char *x)) + 117. { + 118. > u8 r = 0; + 119. long skip = 0; + 120. u32 src_len, dst_len; + +arch/x86/include/asm/syscall.h:138: error: DEAD_STORE + The value written to &args is never used. + 136. case 5: + 137. if (!n--) break; + 138. > *args++ = regs->bp; + 139. case 6: + 140. if (!n--) break; + +arch/x86/include/asm/syscall.h:165: error: DEAD_STORE + The value written to &args is never used. + 163. case 5: + 164. if (!n--) break; + 165. > *args++ = regs->r9; + 166. case 6: + 167. if (!n--) break; + +arch/x86/include/asm/syscall.h:140: error: DEAD_STORE + The value written to &n is never used. + 138. *args++ = regs->bp; + 139. case 6: + 140. > if (!n--) break; + 141. default: + 142. BUG(); + +arch/x86/include/asm/syscall.h:167: error: DEAD_STORE + The value written to &n is never used. + 165. *args++ = regs->r9; + 166. case 6: + 167. > if (!n--) break; + 168. default: + 169. BUG(); + +drivers/hid/hidraw.c:118: error: DEAD_STORE + The value written to &ret is never used. + 116. struct hid_device *dev; + 117. __u8 *buf; + 118. > int ret = 0; + 119. + 120. if (!hidraw_table[minor] || !hidraw_table[minor]->exist) { + +net/ipv4/tcp_ulp.c:118: error: DEAD_STORE + The value written to &err is never used. + 116. struct inet_connection_sock *icsk = inet_csk(sk); + 117. const struct tcp_ulp_ops *ulp_ops; + 118. > int err = 0; + 119. + 120. if (icsk->icsk_ulp_ops) + +drivers/clk/clk-mux.c:125: error: DEAD_STORE + The value written to &width is never used. + 123. struct clk_hw *hw; + 124. struct clk_init_data init; + 125. > u8 width = 0; + 126. int ret; + 127. + +init/do_mounts.c:120: error: DEAD_STORE + The value written to &dev is never used. + 118. dev_t res = 0; + 119. struct uuidcmp cmp; + 120. > struct device *dev = NULL; + 121. struct gendisk *disk; + 122. struct hd_struct *part; + +security/selinux/selinuxfs.c:120: error: DEAD_STORE + The value written to &page is never used. + 118. + 119. { + 120. > char *page = NULL; + 121. ssize_t length; + 122. int new_value; + +crypto/echainiv.c:131: error: DEAD_STORE + The value written to &alg is never used. + 129. + 130. spawn = aead_instance_ctx(inst); + 131. > alg = crypto_spawn_aead_alg(spawn); + 132. + 133. err = -EINVAL; + +net/ipv6/ah6.c:122: error: DEAD_STORE + The value written to &optlen is never used. + 120. int len = ipv6_optlen(opthdr); + 121. int off = 0; + 122. > int optlen = 0; + 123. + 124. off += 2; + +drivers/gpu/drm/i915/intel_dsi.c:136: error: DEAD_STORE + The value written to &data is never used. + 134. + 135. header = packet.header; + 136. > data = packet.payload; + 137. + 138. if (msg->flags & MIPI_DSI_MSG_USE_LPM) { + +drivers/md/dm-raid1.c:122: error: DEAD_STORE + The value written to &should_wake is never used. + 120. { + 121. unsigned long flags; + 122. > int should_wake = 0; + 123. struct bio_list *bl; + 124. + +net/ipv6/xfrm6_policy.c:162: error: DEAD_STORE + The value written to &exthdr is never used. + 160. offset += ipv6_optlen(exthdr); + 161. nexthdr = exthdr->nexthdr; + 162. > exthdr = (struct ipv6_opt_hdr *)(nh + offset); + 163. break; + 164. + +sound/core/info.c:130: error: DEAD_STORE + The value written to &offset is never used. + 128. mutex_lock(&entry->access); + 129. if (entry->c.ops->llseek) { + 130. > offset = entry->c.ops->llseek(entry, + 131. data->file_private_data, + 132. file, offset, orig); + +drivers/scsi/scsi_logging.c:128: error: DEAD_STORE + The value written to &off is never used. + 126. va_list args; + 127. char *logbuf; + 128. > size_t off = 0, logbuf_len; + 129. + 130. if (!scmd || !scmd->cmnd) + +drivers/scsi/scsi_logging.c:140: error: DEAD_STORE + The value written to &off is never used. + 138. if (off < logbuf_len) { + 139. va_start(args, fmt); + 140. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 141. va_end(args); + 142. } + +kernel/taskstats.c:134: error: DEAD_STORE + The value written to &rc is never used. + 132. genlmsg_end(skb, reply); + 133. + 134. > rc = 0; + 135. down_read(&listeners->sem); + 136. list_for_each_entry(s, &listeners->list, list) { + +net/sched/cls_api.c:134: error: DEAD_STORE + The value written to &err is never used. + 132. return ERR_PTR(-ENOBUFS); + 133. + 134. > err = -ENOENT; + 135. tp->ops = tcf_proto_lookup_ops(kind); + 136. if (!tp->ops) { + +security/selinux/ss/services.c:128: error: DEAD_STORE + The value written to &out_map is never used. + 126. u16 *out_map_size) + 127. { + 128. > struct selinux_mapping *out_map = NULL; + 129. size_t size = sizeof(struct selinux_mapping); + 130. u16 i, j; + +drivers/input/ff-memless.c:127: error: DEAD_STORE + The value written to &now is never used. + 125. { + 126. struct ml_effect_state *state; + 127. > unsigned long now = jiffies; + 128. unsigned long earliest = 0; + 129. unsigned long next_at; + +crypto/rsa.c:130: error: DEAD_STORE + The value written to &ret is never used. + 128. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 129. MPI c, m = mpi_alloc(0); + 130. > int ret = 0; + 131. int sign; + 132. + +drivers/gpu/drm/drm_mode_object.c:130: error: DEAD_STORE + The value written to &obj is never used. + 128. uint32_t id, uint32_t type) + 129. { + 130. > struct drm_mode_object *obj = NULL; + 131. + 132. mutex_lock(&dev->mode_config.idr_mutex); + +drivers/usb/storage/sierra_ms.c:135: error: DEAD_STORE + The value written to &result is never used. + 133. + 134. retries = 3; + 135. > result = 0; + 136. udev = us->pusb_dev; + 137. + +drivers/usb/storage/sierra_ms.c:197: error: DEAD_STORE + The value written to &result is never used. + 195. } + 196. complete: + 197. > result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); + 198. + 199. return 0; + +drivers/usb/storage/sierra_ms.c:134: error: DEAD_STORE + The value written to &retries is never used. + 132. struct Scsi_Host *sh; + 133. + 134. > retries = 3; + 135. result = 0; + 136. udev = us->pusb_dev; + +drivers/char/hw_random/via-rng.c:177: error: DEAD_STORE + The value written to &hi is never used. + 175. /* perhaps-unnecessary sanity check; remove after testing if + 176. unneeded */ + 177. > rdmsr(MSR_VIA_RNG, lo, hi); + 178. if ((lo & VIA_RNG_ENABLE) == 0) { + 179. pr_err(PFX "cannot enable VIA C3 RNG, aborting\n"); + +drivers/gpu/drm/i915/intel_guc_fw.c:136: error: DEAD_STORE + The value written to &ret is never used. + 134. struct sg_table *sg = vma->pages; + 135. u32 status, rsa[UOS_RSA_SCRATCH_MAX_COUNT]; + 136. > int i, ret = 0; + 137. + 138. /* where RSA signature starts */ + +drivers/gpu/drm/i915/intel_guc_fw.c:173: error: DEAD_STORE + The value written to &timeout__ is never used. + 171. * execlist mode if this happens.) + 172. */ + 173. > ret = wait_for(guc_ucode_response(dev_priv, &status), 100); + 174. + 175. DRM_DEBUG_DRIVER("DMA status 0x%x, GuC status 0x%x\n", + +kernel/cgroup/freezer.c:136: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 132 could be null and is dereferenced at line 136, column 6. + 134. mutex_lock(&freezer_mutex); + 135. + 136. > if (freezer->state & CGROUP_FREEZING) + 137. atomic_dec(&system_freezing_cnt); + 138. + +drivers/usb/host/pci-quirks.c:133: error: DEAD_STORE + The value written to &rev is never used. + 131. static int amd_chipset_sb_type_init(struct amd_chipset_info *pinfo) + 132. { + 133. > u8 rev = 0; + 134. pinfo->sb_type.gen = AMD_CHIPSET_UNKNOWN; + 135. + +init/initramfs.c:137: error: NULL_DEREFERENCE + pointer `de` last assigned on line 133 could be null and is dereferenced at line 137, column 2. + 135. panic("can't allocate dir_entry buffer"); + 136. INIT_LIST_HEAD(&de->list); + 137. > de->name = kstrdup(name, GFP_KERNEL); + 138. de->mtime = mtime; + 139. list_add(&de->list, &dir_list); + +net/ipv6/reassembly.c:134: error: DEAD_STORE + The value written to &dev is never used. + 132. struct inet_frags *frags) + 133. { + 134. > struct net_device *dev = NULL; + 135. + 136. spin_lock(&fq->q.lock); + +net/ipv6/netfilter/nf_reject_ipv6.c:140: error: DEAD_STORE + The value written to &dst is never used. + 138. const struct ipv6hdr *oip6h = ipv6_hdr(oldskb); + 139. struct ipv6hdr *ip6h; + 140. > struct dst_entry *dst = NULL; + 141. struct flowi6 fl6; + 142. + +net/ipv6/netfilter/nf_reject_ipv6.c:187: error: DEAD_STORE + The value written to &ip6h is never used. + 185. + 186. skb_reserve(nskb, hh_len + dst->header_len); + 187. > ip6h = nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP, + 188. ip6_dst_hoplimit(dst)); + 189. nf_reject_ip6_tcphdr_put(nskb, oldskb, otcph, otcplen); + +crypto/jitterentropy.c:138: error: DEAD_STORE + The value written to &i is never used. + 136. __u64 time = 0; + 137. __u64 shuffle = 0; + 138. > unsigned int i = 0; + 139. unsigned int mask = (1< struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + 140. struct nlattr *nla_b; + +net/netlabel/netlabel_cipso_v4.c:137: error: DEAD_STORE + The value written to &ret_val is never used. + 135. struct netlbl_audit *audit_info) + 136. { + 137. > int ret_val = -EINVAL; + 138. struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + +drivers/tty/sysrq.c:147: error: NULL_DEREFERENCE + pointer `killer` last assigned on line 137 could be null and is dereferenced at line 147, column 2. + 145. panic_on_oops = 1; /* force panic */ + 146. wmb(); + 147. > *killer = 1; + 148. } + 149. static struct sysrq_key_op sysrq_crash_op = { + +sound/core/timer.c:137: error: DEAD_STORE + The value written to &timer is never used. + 135. static struct snd_timer *snd_timer_find(struct snd_timer_id *tid) + 136. { + 137. > struct snd_timer *timer = NULL; + 138. + 139. list_for_each_entry(timer, &snd_timer_list, device_list) { + +drivers/net/ethernet/intel/e1000e/phy.c:139: error: DEAD_STORE + The value written to &mdic is never used. + 137. { + 138. struct e1000_phy_info *phy = &hw->phy; + 139. > u32 i, mdic = 0; + 140. + 141. if (offset > MAX_PHY_REG_ADDRESS) { + +drivers/video/fbdev/core/cfbimgblt.c:143: error: DEAD_STORE + The value written to &color is never used. + 141. u32 pitch_index) + 142. { + 143. > u32 shift, color = 0, bpp = p->var.bits_per_pixel; + 144. u32 __iomem *dst, *dst2; + 145. u32 val, pitch = p->fix.line_length; + +drivers/pci/pcie/aer/aerdrv_errprint.c:143: error: DEAD_STORE + The value written to &errmsg is never used. + 141. { + 142. int i, status; + 143. > const char *errmsg = NULL; + 144. status = (info->status & ~info->mask); + 145. + +net/ipv6/mcast_snoop.c:143: error: DEAD_STORE + The value written to &skb_chk is never used. + 141. + 142. { + 143. > struct sk_buff *skb_chk = NULL; + 144. unsigned int transport_len; + 145. unsigned int len = skb_transport_offset(skb) + sizeof(struct mld_msg); + +drivers/net/ethernet/intel/e1000e/nvm.c:143: error: DEAD_STORE + The value written to ® is never used. + 141. { + 142. u32 attempts = 100000; + 143. > u32 i, reg = 0; + 144. + 145. for (i = 0; i < attempts; i++) { + +security/selinux/ibpkey.c:144: error: DEAD_STORE + The value written to &new is never used. + 142. int ret; + 143. struct sel_ib_pkey *pkey; + 144. > struct sel_ib_pkey *new = NULL; + 145. unsigned long flags; + 146. + +net/ipv6/ipv6_sockglue.c:569: error: DEAD_STORE + The value written to &dev is never used. + 567. case IPV6_UNICAST_IF: + 568. { + 569. > struct net_device *dev = NULL; + 570. int ifindex; + 571. + +net/ipv6/ipv6_sockglue.c:821: error: DEAD_STORE + The value written to &retv is never used. + 819. goto e_inval; + 820. + 821. > retv = -EINVAL; + 822. + 823. /* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */ + +drivers/char/hpet.c:167: error: DEAD_STORE + The value written to &m is never used. + 165. + 166. t = devp->hd_ireqfreq; + 167. > m = read_counter(&devp->hd_timer->hpet_compare); + 168. mc = read_counter(&hpet->hpet_mc); + 169. /* The time for the next interrupt would logically be t + m, + +drivers/gpu/drm/drm_modes.c:252: error: DEAD_STORE + The value written to &vback_porch is never used. + 250. vsyncandback_porch = tmp1; + 251. /* 10. Find number of lines in back porch */ + 252. > vback_porch = vsyncandback_porch - vsync; + 253. drm_mode->vtotal = vdisplay_rnd + 2 * vmargin + + 254. vsyncandback_porch + CVT_MIN_V_PORCH; + +security/selinux/ss/ebitmap.c:148: error: DEAD_STORE + The value written to &e_prev is never used. + 146. int rc; + 147. struct ebitmap_node *e_iter = NULL; + 148. > struct ebitmap_node *e_prev = NULL; + 149. u32 offset = 0, idx; + 150. unsigned long bitmap; + +arch/x86/pci/mmconfig-shared.c:146: error: DEAD_STORE + The value written to &len is never used. + 144. static const char *__init pci_mmcfg_intel_945(void) + 145. { + 146. > u32 pciexbar, mask = 0, len = 0; + 147. + 148. raw_pci_ops->read(0, 0, PCI_DEVFN(0, 0), 0x48, 4, &pciexbar); + +arch/x86/pci/mmconfig-shared.c:146: error: DEAD_STORE + The value written to &mask is never used. + 144. static const char *__init pci_mmcfg_intel_945(void) + 145. { + 146. > u32 pciexbar, mask = 0, len = 0; + 147. + 148. raw_pci_ops->read(0, 0, PCI_DEVFN(0, 0), 0x48, 4, &pciexbar); + +crypto/seqiv.c:157: error: DEAD_STORE + The value written to &alg is never used. + 155. + 156. spawn = aead_instance_ctx(inst); + 157. > alg = crypto_spawn_aead_alg(spawn); + 158. + 159. err = -EINVAL; + +drivers/connector/cn_queue.c:160: error: DEAD_STORE + The value written to &dev is never used. + 158. + 159. kfree(dev); + 160. > dev = NULL; + 161. } + +drivers/hid/hid-ntrig.c:162: error: DEAD_STORE + The value written to &ret is never used. + 160. + 161. if (ret == 8) { + 162. > ret = ntrig_version_string(&data[2], buf); + 163. + 164. hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n", + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &timeout__ is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +drivers/usb/host/ohci-hcd.c:156: error: DEAD_STORE + The value written to &retval is never used. + 154. int i, size = 0; + 155. unsigned long flags; + 156. > int retval = 0; + 157. + 158. /* every endpoint has a ed, locate and maybe (re)initialize it */ + +arch/x86/platform/efi/efi_64.c:184: error: DEAD_STORE + The value written to &p4d is never used. + 182. } + 183. + 184. > p4d = (p4d_t *)pgd_page_vaddr(*pgd); + 185. p4d_free(&init_mm, p4d); + 186. } + +net/core/dst.c:151: error: DEAD_STORE + The value written to &dst is never used. + 149. struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head); + 150. + 151. > dst = dst_destroy(dst); + 152. } + 153. + +crypto/jitterentropy-kcapi.c:153: error: DEAD_STORE + The value written to &ret is never used. + 151. { + 152. struct jitterentropy *rng = crypto_rng_ctx(tfm); + 153. > int ret = 0; + 154. + 155. spin_lock(&rng->jent_lock); + +drivers/gpu/drm/drm_framebuffer.c:177: error: NULL_DEREFERENCE + pointer `info` last assigned on line 165 could be null and is dereferenced at line 177, column 18. + 175. } + 176. + 177. > for (i = 0; i < info->num_planes; i++) { + 178. unsigned int width = fb_plane_width(r->width, info, i); + 179. unsigned int height = fb_plane_height(r->height, info, i); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:158: error: DEAD_STORE + The value written to &p is never used. + 156. if (unlikely(p == NULL)) + 157. return -ENOSPC; + 158. > count = be32_to_cpup(p++); + 159. memset(&dummy, 0, sizeof(dummy)); + 160. for (i = 0; i < count; i++) { + +security/selinux/netport.c:152: error: DEAD_STORE + The value written to &new is never used. + 150. int ret = -ENOMEM; + 151. struct sel_netport *port; + 152. > struct sel_netport *new = NULL; + 153. + 154. spin_lock_bh(&sel_netport_lock); + +net/core/netpoll.c:151: error: DEAD_STORE + The value written to &work is never used. + 149. static void poll_one_napi(struct napi_struct *napi) + 150. { + 151. > int work = 0; + 152. + 153. /* net_rx_action's ->poll() invocations and our's are + +drivers/i2c/i2c-core-base.c:154: error: DEAD_STORE + The value written to &ret is never used. + 152. struct i2c_bus_recovery_info *bri = adap->bus_recovery_info; + 153. struct device *dev = &adap->dev; + 154. > int ret = 0; + 155. + 156. ret = gpio_request_one(bri->scl_gpio, GPIOF_OPEN_DRAIN | + +kernel/capability.c:152: error: DEAD_STORE + The value written to &ret is never used. + 150. SYSCALL_DEFINE2(capget, cap_user_header_t, header, cap_user_data_t, dataptr) + 151. { + 152. > int ret = 0; + 153. pid_t pid; + 154. unsigned tocopy; + +sound/core/sound.c:153: error: DEAD_STORE + The value written to &mptr is never used. + 151. { + 152. unsigned int minor = iminor(inode); + 153. > struct snd_minor *mptr = NULL; + 154. const struct file_operations *new_fops; + 155. int err = 0; + +security/keys/request_key_auth.c:156: error: DEAD_STORE + The value written to &authkey is never used. + 154. struct request_key_auth *rka, *irka; + 155. const struct cred *cred = current->cred; + 156. > struct key *authkey = NULL; + 157. char desc[20]; + 158. int ret = -ENOMEM; + +net/sched/sch_mq.c:157: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 155 could be null and is dereferenced at line 157, column 9. + 155. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 156. + 157. > return dev_queue->qdisc_sleeping; + 158. } + 159. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:166: error: DEAD_STORE + The value written to &ret_val is never used. + 164. * at the end of this routine. + 165. */ + 166. > ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data); + 167. + 168. /* Disabled the PHY transmitter */ + +lib/ioremap.c:168: error: DEAD_STORE + The value written to &start is never used. + 166. BUG_ON(addr >= end); + 167. + 168. > start = addr; + 169. phys_addr -= addr; + 170. pgd = pgd_offset_k(addr); + +kernel/trace/blktrace.c:184: error: DEAD_STORE + The value written to &blkcg is never used. + 182. + 183. if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CGROUP)) + 184. > blkcg = NULL; + 185. #ifdef CONFIG_BLK_CGROUP + 186. trace_note(bt, 0, BLK_TN_MESSAGE, buf, n, + +crypto/ccm.c:161: error: DEAD_STORE + The value written to &len is never used. + 159. static int format_adata(u8 *adata, unsigned int a) + 160. { + 161. > int len = 0; + 162. + 163. /* add control info for associated data + +drivers/pcmcia/pcmcia_resource.c:168: error: DEAD_STORE + The value written to &ret is never used. + 166. config_t *c; + 167. int addr; + 168. > int ret = 0; + 169. + 170. s = p_dev->socket; + +drivers/firmware/efi/runtime-map.c:162: error: DEAD_STORE + The value written to &ret is never used. + 160. int __init efi_runtime_map_init(struct kobject *efi_kobj) + 161. { + 162. > int i, j, ret = 0; + 163. struct efi_runtime_map_entry *entry; + 164. efi_memory_desc_t *md; + +net/netfilter/core.c:165: error: DEAD_STORE + The value written to &i is never used. + 163. struct nf_hook_ops **orig_ops; + 164. int prio = INT_MIN; + 165. > size_t i = 0; + 166. + 167. orig_ops = nf_hook_entries_get_hook_ops(hooks); + +net/wireless/reg.c:162: error: DEAD_STORE + The value written to ®d is never used. + 160. enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy) + 161. { + 162. > const struct ieee80211_regdomain *regd = NULL; + 163. const struct ieee80211_regdomain *wiphy_regd = NULL; + 164. + +net/wireless/reg.c:163: error: DEAD_STORE + The value written to &wiphy_regd is never used. + 161. { + 162. const struct ieee80211_regdomain *regd = NULL; + 163. > const struct ieee80211_regdomain *wiphy_regd = NULL; + 164. + 165. regd = get_cfg80211_regdom(); + +crypto/asymmetric_keys/x509_public_key.c:167: error: DEAD_STORE + The value written to &desc is never used. + 165. const char *q; + 166. size_t srlen, sulen; + 167. > char *desc = NULL, *p; + 168. int ret; + 169. + +crypto/rsa.c:168: error: DEAD_STORE + The value written to &ret is never used. + 166. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 167. MPI m, s = mpi_alloc(0); + 168. > int ret = 0; + 169. int sign; + 170. + +drivers/gpu/drm/drm_mode_object.c:167: error: DEAD_STORE + The value written to &obj is never used. + 165. uint32_t id, uint32_t type) + 166. { + 167. > struct drm_mode_object *obj = NULL; + 168. + 169. obj = __drm_mode_object_find(dev, file_priv, id, type); + +drivers/net/ethernet/intel/e1000e/netdev.c:165: error: DEAD_STORE + The value written to &n is never used. + 163. static void e1000_regdump(struct e1000_hw *hw, struct e1000_reg_info *reginfo) + 164. { + 165. > int n = 0; + 166. char rname[16]; + 167. u32 regs[8]; + +arch/x86/lib/delay.c:175: error: DEAD_STORE + The value written to &xloops is never used. + 173. :"1" (xloops), "0" (lpj * (HZ / 4))); + 174. + 175. > __delay(++xloops); + 176. } + 177. EXPORT_SYMBOL(__const_udelay); + +drivers/firmware/efi/esrt.c:177: error: DEAD_STORE + The value written to &rc is never used. + 175. + 176. if (esrt->fw_resource_version == 1) { + 177. > int rc = 0; + 178. + 179. entry->esre.esre1 = esre; + +kernel/audit_fsnotify.c:175: error: DEAD_STORE + The value written to &inode is never used. + 173. { + 174. struct audit_fsnotify_mark *audit_mark; + 175. > const struct inode *inode = NULL; + 176. + 177. audit_mark = container_of(inode_mark, struct audit_fsnotify_mark, mark); + +kernel/sched/cpuacct.c:174: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 169 could be null and is dereferenced by call to `cpuacct_cpuusage_read()` at line 174, column 20. + 172. + 173. for_each_possible_cpu(i) + 174. > totalcpuusage += cpuacct_cpuusage_read(ca, i, index); + 175. + 176. return totalcpuusage; + +drivers/pci/pci-driver.c:174: error: DEAD_STORE + The value written to &fields is never used. + 172. __u32 vendor, device, subvendor = PCI_ANY_ID, + 173. subdevice = PCI_ANY_ID, class = 0, class_mask = 0; + 174. > int fields = 0; + 175. size_t retval = -ENODEV; + 176. + +net/sunrpc/auth_gss/gss_mech_switch.c:169: error: DEAD_STORE + The value written to &gm is never used. + 167. struct gss_api_mech * gss_mech_get_by_name(const char *name) + 168. { + 169. > struct gss_api_mech *gm = NULL; + 170. + 171. gm = _gss_mech_get_by_name(name); + +net/sched/act_api.c:176: error: DEAD_STORE + The value written to &id is never used. + 174. struct idr *idr = &idrinfo->action_idr; + 175. struct tc_action *p; + 176. > unsigned long id = 1; + 177. + 178. nest = nla_nest_start(skb, 0); + +net/sched/sch_mq.c:176: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 172 could be null and is dereferenced at line 176, column 18. + 174. tcm->tcm_parent = TC_H_ROOT; + 175. tcm->tcm_handle |= TC_H_MIN(cl); + 176. > tcm->tcm_info = dev_queue->qdisc_sleeping->handle; + 177. return 0; + 178. } + +kernel/time/time.c:174: error: DEAD_STORE + The value written to &error is never used. + 172. { + 173. static int firsttime = 1; + 174. > int error = 0; + 175. + 176. if (tv && !timespec64_valid(tv)) + +drivers/ata/libata-scsi.c:197: error: DEAD_STORE + The value written to &now is never used. + 195. + 196. link = dev->link; + 197. > now = jiffies; + 198. if (ap->pflags & ATA_PFLAG_EH_IN_PROGRESS && + 199. link->eh_context.unloaded_mask & (1 << dev->devno) && + +drivers/pcmcia/yenta_socket.c:176: error: DEAD_STORE + The value written to &offset is never used. + 174. struct pci_dev *dev = to_pci_dev(yentadev); + 175. struct yenta_socket *socket = pci_get_drvdata(dev); + 176. > int offset = 0, i; + 177. + 178. offset = snprintf(buf, PAGE_SIZE, "CB registers:"); + +net/ipv4/inet_connection_sock.c:176: error: DEAD_STORE + The value written to &port is never used. + 174. { + 175. struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo; + 176. > int port = 0; + 177. struct inet_bind_hashbucket *head; + 178. struct net *net = sock_net(sk); + +net/ipv4/ping.c:177: error: DEAD_STORE + The value written to &sk is never used. + 175. { + 176. struct hlist_nulls_head *hslot = ping_hashslot(&ping_table, net, ident); + 177. > struct sock *sk = NULL; + 178. struct inet_sock *isk; + 179. struct hlist_nulls_node *hnode; + +drivers/clocksource/acpi_pm.c:179: error: DEAD_STORE + The value written to &j is never used. + 177. { + 178. u64 value1, value2; + 179. > unsigned int i, j = 0; + 180. + 181. if (!pmtmr_ioport) + +arch/x86/events/intel/pt.c:229: error: DEAD_STORE + The value written to &attrs is never used. + 227. } + 228. + 229. > attrs = NULL; + 230. + 231. for (i = 0; i < PT_CPUID_LEAVES; i++) { + +drivers/firmware/dmi-id.c:206: error: DEAD_STORE + The value written to &i is never used. + 204. ADD_DMI_ATTR(chassis_serial, DMI_CHASSIS_SERIAL); + 205. ADD_DMI_ATTR(chassis_asset_tag, DMI_CHASSIS_ASSET_TAG); + 206. > sys_dmi_attributes[i++] = &sys_dmi_modalias_attr.attr; + 207. } + 208. + +drivers/gpu/drm/i915/intel_hdmi.c:189: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 183 could be null and is dereferenced at line 189, column 37. + 187. return false; + 188. + 189. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->port)) + 190. return false; + 191. + +net/sunrpc/auth_gss/auth_gss.c:183: error: DEAD_STORE + The value written to &ctx is never used. + 181. { + 182. struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base); + 183. > struct gss_cl_ctx *ctx = NULL; + 184. + 185. rcu_read_lock(); + +drivers/gpu/drm/i915/intel_cdclk.c:221: error: DEAD_STORE + The value written to &tmp is never used. + 219. const unsigned int *vco_table; + 220. unsigned int vco; + 221. > uint8_t tmp = 0; + 222. + 223. /* FIXME other chipsets? */ + +drivers/tty/serial/serial_core.c:185: error: DEAD_STORE + The value written to &retval is never used. + 183. struct uart_port *uport = uart_port_check(state); + 184. unsigned long page; + 185. > int retval = 0; + 186. + 187. if (uport->type == PORT_UNKNOWN) + +net/sched/sch_mq.c:185: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 183 could be null and is dereferenced at line 185, column 8. + 183. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 184. + 185. > sch = dev_queue->qdisc_sleeping; + 186. if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || + 187. gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) + +drivers/gpu/drm/i915/intel_dp_mst.c:223: error: DEAD_STORE + The value written to &ret is never used. + 221. I915_WRITE(DP_TP_STATUS(port), temp); + 222. + 223. > ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); + 224. } + 225. + +drivers/gpu/drm/i915/intel_breadcrumbs.c:199: error: DEAD_STORE + The value written to &first is never used. + 197. + 198. spin_lock(&b->irq_lock); + 199. > first = fetch_and_zero(&b->irq_wait); + 200. __intel_engine_disarm_breadcrumbs(engine); + 201. spin_unlock(&b->irq_lock); + +crypto/jitterentropy-kcapi.c:186: error: DEAD_STORE + The value written to &ret is never used. + 184. static int __init jent_mod_init(void) + 185. { + 186. > int ret = 0; + 187. + 188. ret = jent_entropy_init(); + +net/ipv6/inet6_hashtables.c:196: error: DEAD_STORE + The value written to &ports is never used. + 194. struct net *net = sock_net(sk); + 195. const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 196. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 197. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + 198. inet->inet_dport); + +net/ipv6/inet6_hashtables.c:195: error: DEAD_STORE + The value written to &sdif is never used. + 193. const int dif = sk->sk_bound_dev_if; + 194. struct net *net = sock_net(sk); + 195. > const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 196. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 197. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + +drivers/video/fbdev/core/sysimgblt.c:194: error: DEAD_STORE + The value written to &tab is never used. + 192. const char *s = image->data, *src; + 193. u32 *dst; + 194. > const u32 *tab = NULL; + 195. int i, j, k; + 196. + +net/sunrpc/svcsock.c:197: error: DEAD_STORE + The value written to &len is never used. + 195. unsigned int flags = MSG_MORE | MSG_SENDPAGE_NOTLAST; + 196. int slen; + 197. > int len = 0; + 198. + 199. slen = xdr->len; + +drivers/hid/hidraw.c:192: error: DEAD_STORE + The value written to &ret is never used. + 190. struct hid_device *dev; + 191. __u8 *buf; + 192. > int ret = 0, len; + 193. unsigned char report_number; + 194. + +scripts/mod/file2alias.c:196: error: DEAD_STORE + The value written to &bcdDevice_lo is never used. + 194. DEF_FIELD(symval, usb_device_id, idVendor); + 195. DEF_FIELD(symval, usb_device_id, idProduct); + 196. > DEF_FIELD(symval, usb_device_id, bcdDevice_lo); + 197. DEF_FIELD(symval, usb_device_id, bDeviceClass); + 198. DEF_FIELD(symval, usb_device_id, bDeviceSubClass); + +arch/x86/events/amd/iommu.c:193: error: DEAD_STORE + The value written to &shift is never used. + 191. unsigned long flags; + 192. int max_banks, max_cntrs; + 193. > int shift = 0; + 194. + 195. max_banks = perf_iommu->max_banks; + +block/partitions/efi.c:190: error: DEAD_STORE + The value written to &sz is never used. + 188. static int is_pmbr_valid(legacy_mbr *mbr, sector_t total_sectors) + 189. { + 190. > uint32_t sz = 0; + 191. int i, part = 0, ret = 0; /* invalid by default */ + 192. + +drivers/video/fbdev/core/fbcvt.c:192: error: DEAD_STORE + The value written to &aspect is never used. + 190. u32 xres = cvt->xres; + 191. u32 yres = cvt->yres; + 192. > u32 aspect = -1; + 193. + 194. if (xres == (yres * 4)/3 && !((yres * 4) % 3)) + +security/selinux/hooks.c:199: error: NULL_DEREFERENCE + pointer `tsec` last assigned on line 195 could be null and is dereferenced at line 199, column 15. + 197. panic("SELinux: Failed to initialize initial task.\n"); + 198. + 199. > tsec->osid = tsec->sid = SECINITSID_KERNEL; + 200. cred->security = tsec; + 201. } + +arch/x86/events/core.c:195: error: DEAD_STORE + The value written to &ret is never used. + 193. { + 194. u64 val, val_fail = -1, val_new= ~0; + 195. > int i, reg, reg_fail = -1, ret = 0; + 196. int bios_fail = 0; + 197. int reg_safe = -1; + +crypto/crypto_null.c:194: error: DEAD_STORE + The value written to &ret is never used. + 192. static int __init crypto_null_mod_init(void) + 193. { + 194. > int ret = 0; + 195. + 196. ret = crypto_register_algs(null_algs, ARRAY_SIZE(null_algs)); + +drivers/clk/clk.c:194: error: DEAD_STORE + The value written to &ret is never used. + 192. static bool clk_core_is_enabled(struct clk_core *core) + 193. { + 194. > bool ret = false; + 195. + 196. /* + +drivers/gpu/vga/vgaarb.c:199: error: DEAD_STORE + The value written to &flags is never used. + 197. struct vga_device *conflict; + 198. unsigned int pci_bits; + 199. > u32 flags = 0; + 200. + 201. /* Account for "normal" resources to lock. If we decode the legacy, + +tools/lib/subcmd/help.c:210: error: NULL_DEREFERENCE + pointer `path` last assigned on line 208 could be null and is dereferenced by call to `strchr()` at line 210, column 17. + 208. path = paths = strdup(env_path); + 209. while (1) { + 210. > if ((colon = strchr(path, ':'))) + 211. *colon = 0; + 212. if (!exec_path || strcmp(path, exec_path)) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:200: error: DEAD_STORE + The value written to &mac_reg is never used. + 198. s32 ret_val = 0; + 199. u16 retry_count; + 200. > u32 mac_reg = 0; + 201. + 202. for (retry_count = 0; retry_count < 2; retry_count++) { + +drivers/tty/vt/vc_screen.c:206: error: DEAD_STORE + The value written to &org is never used. + 204. long attr, read; + 205. int col, maxcol, viewed; + 206. > unsigned short *org = NULL; + 207. ssize_t ret; + 208. char *con_buf; + +kernel/sched/cpuacct.c:209: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 199 could be null and is dereferenced by call to `cpuacct_cpuusage_write()` at line 209, column 3. + 207. + 208. for_each_possible_cpu(cpu) + 209. > cpuacct_cpuusage_write(ca, cpu, 0); + 210. + 211. return 0; + +kernel/irq/irqdesc.c:201: error: DEAD_STORE + The value written to &ret is never used. + 199. { + 200. struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj); + 201. > ssize_t ret = 0; + 202. + 203. raw_spin_lock_irq(&desc->lock); + +kernel/kthread.c:219: error: NULL_DEREFERENCE + pointer `done` last assigned on line 211 could be null and is dereferenced by call to `complete()` at line 219, column 3. + 217. if (!self) { + 218. create->result = ERR_PTR(-ENOMEM); + 219. > complete(done); + 220. do_exit(-ENOMEM); + 221. } + +drivers/gpu/drm/drm_drv.c:205: error: NULL_DEREFERENCE + pointer `slot` last assigned on line 204 could be null and is dereferenced at line 205, column 10. + 203. + 204. slot = drm_minor_get_slot(dev, type); + 205. > minor = *slot; + 206. if (!minor) + 207. return; + +drivers/net/ethernet/intel/e1000e/phy.c:202: error: DEAD_STORE + The value written to &mdic is never used. + 200. { + 201. struct e1000_phy_info *phy = &hw->phy; + 202. > u32 i, mdic = 0; + 203. + 204. if (offset > MAX_PHY_REG_ADDRESS) { + +lib/kobject.c:202: error: DEAD_STORE + The value written to &error is never used. + 200. static int kobject_add_internal(struct kobject *kobj) + 201. { + 202. > int error = 0; + 203. struct kobject *parent; + 204. + +security/selinux/netnode.c:204: error: DEAD_STORE + The value written to &new is never used. + 202. int ret = -ENOMEM; + 203. struct sel_netnode *node; + 204. > struct sel_netnode *new = NULL; + 205. + 206. spin_lock_bh(&sel_netnode_lock); + +crypto/jitterentropy.c:206: error: DEAD_STORE + The value written to &j is never used. + 204. { + 205. unsigned int i; + 206. > __u64 j = 0; + 207. __u64 new = 0; + 208. #define MAX_FOLD_LOOP_BIT 4 + +crypto/rsa.c:207: error: DEAD_STORE + The value written to &ret is never used. + 205. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 206. MPI s, m = mpi_alloc(0); + 207. > int ret = 0; + 208. int sign; + 209. + +crypto/rsa.c:218: error: DEAD_STORE + The value written to &ret is never used. + 216. } + 217. + 218. > ret = -ENOMEM; + 219. s = mpi_read_raw_from_sgl(req->src, req->src_len); + 220. if (!s) { + +drivers/ptp/ptp_clock.c:207: error: DEAD_STORE + The value written to &err is never used. + 205. { + 206. struct ptp_clock *ptp; + 207. > int err = 0, index, major = MAJOR(ptp_devt); + 208. + 209. if (info->n_alarm > PTP_MAX_ALARMS) + +kernel/cgroup/freezer.c:221: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 220 could be null and is dereferenced at line 221, column 6. + 219. + 220. freezer = task_freezer(task); + 221. > if (freezer->state & CGROUP_FREEZING) + 222. freeze_task(task); + 223. + +net/ipv6/addrlabel.c:206: error: DEAD_STORE + The value written to &p is never used. + 204. int replace) + 205. { + 206. > struct ip6addrlbl_entry *last = NULL, *p = NULL; + 207. struct hlist_node *n; + 208. int ret = 0; + +net/sched/sch_api.c:206: error: DEAD_STORE + The value written to &q is never used. + 204. static struct Qdisc_ops *qdisc_lookup_default(const char *name) + 205. { + 206. > struct Qdisc_ops *q = NULL; + 207. + 208. for (q = qdisc_base; q; q = q->next) { + +security/keys/request_key.c:225: error: DEAD_STORE + The value written to &authkey is never used. + 223. kfree(cons); + 224. ret = PTR_ERR(authkey); + 225. > authkey = NULL; + 226. } else { + 227. cons->authkey = key_get(authkey); + +drivers/gpu/drm/i915/i915_guc_submission.c:220: error: DEAD_STORE + The value written to &timeout__ is never used. + 218. * to go to zero after updating db_status before we call the GuC to + 219. * release the doorbell */ + 220. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 221. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 222. + +drivers/gpu/drm/i915/intel_sideband.c:208: error: DEAD_STORE + The value written to &value is never used. + 206. enum intel_sbi_destination destination) + 207. { + 208. > u32 value = 0; + 209. WARN_ON(!mutex_is_locked(&dev_priv->sb_lock)); + 210. + +lib/rhashtable.c:209: error: DEAD_STORE + The value written to &tbl is never used. + 207. gfp_t gfp) + 208. { + 209. > struct bucket_table *tbl = NULL; + 210. size_t size; + 211. int i; + +drivers/tty/n_tty.c:209: error: DEAD_STORE + The value written to &n is never used. + 207. { + 208. struct n_tty_data *ldata = tty->disc_data; + 209. > ssize_t n = 0; + 210. + 211. if (!ldata->icanon) + +drivers/usb/core/devio.c:210: error: DEAD_STORE + The value written to &usbm is never used. + 208. static int usbdev_mmap(struct file *file, struct vm_area_struct *vma) + 209. { + 210. > struct usb_memory *usbm = NULL; + 211. struct usb_dev_state *ps = file->private_data; + 212. size_t size = vma->vm_end - vma->vm_start; + +drivers/rtc/rtc-dev.c:212: error: DEAD_STORE + The value written to &err is never used. + 210. unsigned int cmd, unsigned long arg) + 211. { + 212. > int err = 0; + 213. struct rtc_device *rtc = file->private_data; + 214. const struct rtc_class_ops *ops = rtc->ops; + +crypto/algboss.c:213: error: DEAD_STORE + The value written to &type is never used. + 211. { + 212. struct crypto_test_param *param = data; + 213. > u32 type = param->type; + 214. int err = 0; + 215. + +drivers/net/ethernet/intel/e1000e/82571.c:215: error: DEAD_STORE + The value written to &force_clear_smbi is never used. + 213. u32 swsm = 0; + 214. u32 swsm2 = 0; + 215. > bool force_clear_smbi = false; + 216. + 217. /* Set media type and media-dependent function pointers */ + +drivers/net/ethernet/intel/e1000e/82571.c:213: error: DEAD_STORE + The value written to &swsm is never used. + 211. { + 212. struct e1000_mac_info *mac = &hw->mac; + 213. > u32 swsm = 0; + 214. u32 swsm2 = 0; + 215. bool force_clear_smbi = false; + +drivers/net/ethernet/intel/e1000e/82571.c:214: error: DEAD_STORE + The value written to &swsm2 is never used. + 212. struct e1000_mac_info *mac = &hw->mac; + 213. u32 swsm = 0; + 214. > u32 swsm2 = 0; + 215. bool force_clear_smbi = false; + 216. + +drivers/pci/pcie/portdrv_core.c:213: error: DEAD_STORE + The value written to &cap_mask is never used. + 211. { + 212. int services = 0; + 213. > int cap_mask = 0; + 214. + 215. if (pcie_ports_disabled) + +init/do_mounts.c:214: error: DEAD_STORE + The value written to &res is never used. + 212. char s[32]; + 213. char *p; + 214. > dev_t res = 0; + 215. int part; + 216. + +security/lsm_audit.c:324: error: DEAD_STORE + The value written to &len is never used. + 322. struct sock *sk = a->u.net->sk; + 323. struct unix_sock *u; + 324. > int len = 0; + 325. char *p = NULL; + 326. + +security/lsm_audit.c:325: error: DEAD_STORE + The value written to &p is never used. + 323. struct unix_sock *u; + 324. int len = 0; + 325. > char *p = NULL; + 326. + 327. switch (sk->sk_family) { + +net/core/net-procfs.c:214: error: DEAD_STORE + The value written to &pt is never used. + 212. static void *ptype_get_idx(loff_t pos) + 213. { + 214. > struct packet_type *pt = NULL; + 215. loff_t i = 0; + 216. int t; + +drivers/net/ethernet/intel/e1000e/netdev.c:236: error: DEAD_STORE + The value written to &i is never used. + 234. } *u1; + 235. u32 staterr; + 236. > int i = 0; + 237. + 238. if (!netif_msg_hw(adapter)) + +drivers/video/fbdev/core/fbcvt.c:261: error: DEAD_STORE + The value written to &cnt is never used. + 259. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. > cnt -= read; + 262. offset += read; + 263. } + +drivers/video/fbdev/core/fbcvt.c:262: error: DEAD_STORE + The value written to &offset is never used. + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. cnt -= read; + 262. > offset += read; + 263. } + 264. } + +drivers/video/fbdev/core/fbcvt.c:217: error: DEAD_STORE + The value written to &read is never used. + 215. { + 216. u32 pixcount, pixcount_mod; + 217. > int cnt = 255, offset = 0, read = 0; + 218. u8 *buf = kzalloc(256, GFP_KERNEL); + 219. + +block/blk-map.c:220: error: DEAD_STORE + The value written to &do_copy is never used. + 218. int reading = rq_data_dir(rq) == READ; + 219. unsigned long addr = (unsigned long) kbuf; + 220. > int do_copy = 0; + 221. struct bio *bio, *orig_bio; + 222. int ret; + +drivers/ata/libata-sff.c:223: error: DEAD_STORE + The value written to &timeout is never used. + 221. status = ata_sff_busy_wait(ap, ATA_BUSY, 300); + 222. timer_start = jiffies; + 223. > timeout = ata_deadline(timer_start, tmout_pat); + 224. while (status != 0xff && (status & ATA_BUSY) && + 225. time_before(jiffies, timeout)) { + +drivers/ata/libata-sff.c:235: error: DEAD_STORE + The value written to &timeout is never used. + 233. status); + 234. + 235. > timeout = ata_deadline(timer_start, tmout); + 236. while (status != 0xff && (status & ATA_BUSY) && + 237. time_before(jiffies, timeout)) { + +drivers/video/fbdev/core/cfbimgblt.c:224: error: DEAD_STORE + The value written to &tab is never used. + 222. const char *s = image->data, *src; + 223. u32 __iomem *dst; + 224. > const u32 *tab = NULL; + 225. int i, j, k; + 226. + +net/xfrm/xfrm_input.c:226: error: DEAD_STORE + The value written to &family is never used. + 224. struct xfrm_mode *inner_mode; + 225. u32 mark = skb->mark; + 226. > unsigned int family = AF_UNSPEC; + 227. int decaps = 0; + 228. int async = 0; + +drivers/gpu/drm/i915/intel_atomic.c:221: error: DEAD_STORE + The value written to &plane is never used. + 219. struct intel_crtc_state *crtc_state) + 220. { + 221. > struct drm_plane *plane = NULL; + 222. struct intel_plane *intel_plane; + 223. struct intel_plane_state *plane_state = NULL; + +drivers/gpu/drm/i915/intel_atomic.c:223: error: DEAD_STORE + The value written to &plane_state is never used. + 221. struct drm_plane *plane = NULL; + 222. struct intel_plane *intel_plane; + 223. > struct intel_plane_state *plane_state = NULL; + 224. struct intel_crtc_scaler_state *scaler_state = + 225. &crtc_state->scaler_state; + +net/wireless/trace.h:217: error: DEAD_STORE + The value written to &p is never used. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +drivers/pci/pcie/aspm.c:268: error: DEAD_STORE + The value written to &start_jiffies is never used. + 266. + 267. /* Wait for link training end. Break out after waiting for timeout */ + 268. > start_jiffies = jiffies; + 269. for (;;) { + 270. pcie_capability_read_word(parent, PCI_EXP_LNKSTA, ®16); + +drivers/gpu/drm/drm_color_mgmt.c:228: error: DEAD_STORE + The value written to &ret is never used. + 226. int size; + 227. struct drm_modeset_acquire_ctx ctx; + 228. > int ret = 0; + 229. + 230. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/gpu/drm/drm_context.c:224: error: DEAD_STORE + The value written to &map is never used. + 222. { + 223. struct drm_ctx_priv_map *request = data; + 224. > struct drm_local_map *map = NULL; + 225. struct drm_map_list *r_list = NULL; + 226. + +drivers/gpu/drm/drm_context.c:225: error: DEAD_STORE + The value written to &r_list is never used. + 223. struct drm_ctx_priv_map *request = data; + 224. struct drm_local_map *map = NULL; + 225. > struct drm_map_list *r_list = NULL; + 226. + 227. if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && + +drivers/scsi/scsi_logging.c:249: error: DEAD_STORE + The value written to &off is never used. + 247. if (cmd->cmd_len > 16) { + 248. /* Print opcode in one line and use separate lines for CDB */ + 249. > off += scnprintf(logbuf + off, logbuf_len - off, "\n"); + 250. dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf); + 251. scsi_log_release_buffer(logbuf); + +net/sched/act_api.c:222: error: DEAD_STORE + The value written to &p is never used. + 220. static struct tc_action *tcf_idr_lookup(u32 index, struct tcf_idrinfo *idrinfo) + 221. { + 222. > struct tc_action *p = NULL; + 223. + 224. spin_lock_bh(&idrinfo->lock); + +drivers/gpu/drm/drm_irq.c:226: error: DEAD_STORE + The value written to &ret is never used. + 224. { + 225. struct drm_control *ctl = data; + 226. > int ret = 0, irq; + 227. + 228. /* if we haven't irq we fallback for compatibility reasons - + +net/ipv4/ip_tunnel.c:233: error: DEAD_STORE + The value written to &t is never used. + 231. __be16 flags = parms->i_flags; + 232. int link = parms->link; + 233. > struct ip_tunnel *t = NULL; + 234. struct hlist_head *head = ip_bucket(itn, parms); + 235. + +net/sunrpc/auth_generic.c:231: error: DEAD_STORE + The value written to &ret is never used. + 229. gc_base)->acred; + 230. struct rpc_cred *tcred; + 231. > int ret = 0; + 232. + 233. + +arch/x86/events/intel/bts.c:232: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 229 could be null and is dereferenced at line 232, column 7. + 230. u64 config = 0; + 231. + 232. > if (!buf->snapshot) + 233. config |= ARCH_PERFMON_EVENTSEL_INT; + 234. if (!event->attr.exclude_kernel) + +drivers/gpu/drm/i915/intel_dp_mst.c:246: error: DEAD_STORE + The value written to &ret is never used. + 244. DRM_ERROR("Timed out waiting for ACT sent\n"); + 245. + 246. > ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 247. + 248. ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + +drivers/gpu/drm/i915/intel_dp_mst.c:248: error: DEAD_STORE + The value written to &ret is never used. + 246. ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 247. + 248. > ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + 249. if (pipe_config->has_audio) + 250. intel_audio_codec_enable(encoder, pipe_config, conn_state); + +drivers/scsi/scsi_pm.c:230: error: DEAD_STORE + The value written to &err is never used. + 228. const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; + 229. struct scsi_device *sdev = to_scsi_device(dev); + 230. > int err = 0; + 231. + 232. err = blk_pre_runtime_suspend(sdev->request_queue); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:233: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 230 could be null and is dereferenced at line 233, column 6. + 231. struct intel_panel *panel = &connector->panel; + 232. + 233. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) + 234. panel->backlight.max = 0xFFFF; + 235. else + +security/keys/key.c:233: error: DEAD_STORE + The value written to &user is never used. + 231. struct key_restriction *restrict_link) + 232. { + 233. > struct key_user *user = NULL; + 234. struct key *key; + 235. size_t desclen, quotalen; + +net/ipv4/raw.c:235: error: DEAD_STORE + The value written to &err is never used. + 233. const int type = icmp_hdr(skb)->type; + 234. const int code = icmp_hdr(skb)->code; + 235. > int err = 0; + 236. int harderr = 0; + 237. + +drivers/video/backlight/backlight.c:234: error: DEAD_STORE + The value written to &rc is never used. + 232. struct device_attribute *attr, char *buf) + 233. { + 234. > int rc = -ENXIO; + 235. struct backlight_device *bd = to_backlight_device(dev); + 236. + +sound/hda/hdac_controller.c:239: error: DEAD_STORE + The value written to &loopcounter is never used. + 237. timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. > for (loopcounter = 0;; loopcounter++) { + 240. spin_lock_irq(&bus->reg_lock); + 241. if (!bus->rirb.cmds[addr]) { + +sound/hda/hdac_controller.c:239: error: DEAD_STORE + The value written to &loopcounter is never used. + 237. timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. > for (loopcounter = 0;; loopcounter++) { + 240. spin_lock_irq(&bus->reg_lock); + 241. if (!bus->rirb.cmds[addr]) { + +sound/hda/hdac_controller.c:237: error: DEAD_STORE + The value written to &timeout is never used. + 235. unsigned long loopcounter; + 236. + 237. > timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. for (loopcounter = 0;; loopcounter++) { + +kernel/kallsyms.c:236: error: DEAD_STORE + The value written to &symbol_start is never used. + 234. unsigned long *offset) + 235. { + 236. > unsigned long symbol_start = 0, symbol_end = 0; + 237. unsigned long i, low, high, mid; + 238. + +security/selinux/ss/mls.c:366: error: DEAD_STORE + The value written to &p is never used. + 364. goto out; + 365. } + 366. > *scontext = ++p; + 367. rc = 0; + 368. out: + +drivers/gpu/drm/i915/intel_hdmi.c:248: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 240 could be null and is dereferenced at line 248, column 37. + 246. return false; + 247. + 248. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->port)) + 249. return false; + 250. + +drivers/video/fbdev/core/bitblit.c:252: error: DEAD_STORE + The value written to &mode is never used. + 250. if (softback_lines) { + 251. if (y + softback_lines >= vc->vc_rows) { + 252. > mode = CM_ERASE; + 253. ops->cursor_flash = 0; + 254. return; + +drivers/video/fbdev/core/sysimgblt.c:242: error: DEAD_STORE + The value written to &pitch_index is never used. + 240. void sys_imageblit(struct fb_info *p, const struct fb_image *image) + 241. { + 242. > u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0; + 243. u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel; + 244. u32 width = image->width; + +drivers/base/cpu.c:244: error: DEAD_STORE + The value written to &n is never used. + 242. struct device_attribute *attr, char *buf) + 243. { + 244. > int n = 0, len = PAGE_SIZE-2; + 245. cpumask_var_t offline; + 246. + +net/ipv6/addrlabel.c:247: error: DEAD_STORE + The value written to &ret is never used. + 245. { + 246. struct ip6addrlbl_entry *newp; + 247. > int ret = 0; + 248. + 249. ADDRLABEL(KERN_DEBUG "%s(prefix=%pI6, prefixlen=%d, ifindex=%d, label=%u, replace=%d)\n", + +net/sunrpc/auth_gss/gss_rpc_xdr.c:253: error: DEAD_STORE + The value written to &p is never used. + 251. if (unlikely(p == NULL)) + 252. return -ENOSPC; + 253. > count = be32_to_cpup(p++); + 254. if (!count) + 255. return 0; + +kernel/softirq.c:244: error: DEAD_STORE + The value written to &end is never used. + 242. asmlinkage __visible void __softirq_entry __do_softirq(void) + 243. { + 244. > unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. int max_restart = MAX_SOFTIRQ_RESTART; + +kernel/softirq.c:246: error: DEAD_STORE + The value written to &max_restart is never used. + 244. unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. > int max_restart = MAX_SOFTIRQ_RESTART; + 247. struct softirq_action *h; + 248. bool in_hardirq; + +kernel/softirq.c:303: error: DEAD_STORE + The value written to &max_restart is never used. + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + 303. > --max_restart) + 304. goto restart; + 305. + +drivers/md/dm-stripe.c:255: error: DEAD_STORE + The value written to §or is never used. + 253. sector = *result; + 254. if (sc->chunk_size_shift < 0) + 255. > *result -= sector_div(sector, sc->chunk_size); + 256. else + 257. *result = sector & ~(sector_t)(sc->chunk_size - 1); + +drivers/video/fbdev/core/sysfillrect.c:296: error: DEAD_STORE + The value written to &fill_op is never used. + 294. } else { + 295. int right, r; + 296. > void (*fill_op)(struct fb_info *p, unsigned long *dst, + 297. int dst_idx, unsigned long pat, int left, + 298. int right, unsigned n, int bits) = NULL; + +drivers/video/fbdev/core/sysfillrect.c:271: error: DEAD_STORE + The value written to &fill_op32 is never used. + 269. p->fbops->fb_sync(p); + 270. if (!left) { + 271. > void (*fill_op32)(struct fb_info *p, unsigned long *dst, + 272. int dst_idx, unsigned long pat, unsigned n, + 273. int bits) = NULL; + +init/main.c:253: error: DEAD_STORE + The value written to &val is never used. + 251. val[-2] = '='; + 252. memmove(val-1, val, strlen(val)+1); + 253. > val--; + 254. } else + 255. BUG(); + +kernel/cgroup/freezer.c:253: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 246 could be null and is dereferenced at line 253, column 8. + 251. lockdep_assert_held(&freezer_mutex); + 252. + 253. > if (!(freezer->state & CGROUP_FREEZING) || + 254. (freezer->state & CGROUP_FROZEN)) + 255. return; + +drivers/pcmcia/yenta_socket.c:299: error: DEAD_STORE + The value written to ® is never used. + 297. exca_writeb(socket, I365_POWER, reg); + 298. } else { + 299. > u32 reg = 0; /* CB_SC_STPCLK? */ + 300. switch (state->Vcc) { + 301. case 33: + +arch/x86/events/amd/iommu.c:252: error: DEAD_STORE + The value written to ® is never used. + 250. u8 bank = hwc->iommu_bank; + 251. u8 cntr = hwc->iommu_cntr; + 252. > u64 reg = 0ULL; + 253. + 254. reg = GET_CSOURCE(hwc); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:254: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 249 could be null and is dereferenced at line 254, column 6. + 252. * the panel can support backlight control over the aux channel + 253. */ + 254. > if (intel_dp->edp_dpcd[1] & DP_EDP_TCON_BACKLIGHT_ADJUSTMENT_CAP && + 255. (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP) && + 256. !(intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_PWM_PIN_CAP)) { + +lib/iomap.c:250: error: DEAD_STORE + The value written to &port is never used. + 248. void pci_iounmap(struct pci_dev *dev, void __iomem * addr) + 249. { + 250. > IO_COND(addr, /* nothing */, iounmap(addr)); + 251. } + 252. EXPORT_SYMBOL(pci_iounmap); + +sound/core/pcm_native.c:268: error: DEAD_STORE + The value written to &old_mask is never used. + 266. + 267. if (trace_hw_mask_param_enabled()) + 268. > old_mask = *m; + 269. + 270. changed = snd_mask_refine(m, constrs_mask(constrs, k)); + +net/ipv6/mcast.c:254: error: DEAD_STORE + The value written to &idev is never used. + 252. { + 253. struct net_device *dev = NULL; + 254. > struct inet6_dev *idev = NULL; + 255. + 256. if (ifindex == 0) { + +sound/core/timer.c:254: error: DEAD_STORE + The value written to &timeri is never used. + 252. { + 253. struct snd_timer *timer; + 254. > struct snd_timer_instance *timeri = NULL; + 255. int err; + 256. + +drivers/cpufreq/acpi-cpufreq.c:258: error: DEAD_STORE + The value written to &dummy is never used. + 256. u32 val, dummy; + 257. + 258. > rdmsr(MSR_IA32_PERF_CTL, val, dummy); + 259. return val; + 260. } + +drivers/pcmcia/ds.c:260: error: DEAD_STORE + The value written to &ret is never used. + 258. struct pcmcia_socket *s; + 259. cistpl_config_t cis_config; + 260. > int ret = 0; + 261. + 262. dev = get_device(dev); + +security/keys/request_key.c:272: error: NULL_DEREFERENCE + pointer `cred` last assigned on line 257 could be null and is dereferenced at line 272, column 11. + 270. /* use a default keyring; falling through the cases until we + 271. * find one that we actually have */ + 272. > switch (cred->jit_keyring) { + 273. case KEY_REQKEY_DEFL_DEFAULT: + 274. case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: + +net/core/scm.c:264: error: DEAD_STORE + The value written to &err is never used. + 262. struct file **fp = scm->fp->fp; + 263. int __user *cmfptr; + 264. > int err = 0, i; + 265. + 266. if (MSG_CMSG_COMPAT & msg->msg_flags) { + +net/sunrpc/auth_gss/gss_mech_switch.c:257: error: DEAD_STORE + The value written to &pos is never used. + 255. int gss_mech_list_pseudoflavors(rpc_authflavor_t *array_ptr, int size) + 256. { + 257. > struct gss_api_mech *pos = NULL; + 258. int j, i = 0; + 259. + +net/wireless/trace.h:255: error: DEAD_STORE + The value written to &p is never used. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +lib/rhashtable.c:292: error: DEAD_STORE + The value written to &head is never used. + 290. + 291. spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING); + 292. > head = rht_dereference_bucket(new_tbl->buckets[new_hash], + 293. new_tbl, new_hash); + 294. + +sound/core/sound.c:263: error: DEAD_STORE + The value written to &err is never used. + 261. { + 262. int minor; + 263. > int err = 0; + 264. struct snd_minor *preg; + 265. + +crypto/jitterentropy.c:263: error: DEAD_STORE + The value written to &i is never used. + 261. unsigned char *tmpval = NULL; + 262. unsigned int wrap = 0; + 263. > __u64 i = 0; + 264. #define MAX_ACC_LOOP_BIT 7 + 265. #define MIN_ACC_LOOP_BIT 0 + +crypto/jitterentropy.c:261: error: DEAD_STORE + The value written to &tmpval is never used. + 259. static unsigned int jent_memaccess(struct rand_data *ec, __u64 loop_cnt) + 260. { + 261. > unsigned char *tmpval = NULL; + 262. unsigned int wrap = 0; + 263. __u64 i = 0; + +crypto/jitterentropy.c:262: error: DEAD_STORE + The value written to &wrap is never used. + 260. { + 261. unsigned char *tmpval = NULL; + 262. > unsigned int wrap = 0; + 263. __u64 i = 0; + 264. #define MAX_ACC_LOOP_BIT 7 + +drivers/pci/access.c:259: error: DEAD_STORE + The value written to &ret is never used. + 257. EXPORT_SYMBOL_GPL(pci_user_write_config_##size); + 258. + 259. > PCI_USER_READ_CONFIG(byte, u8) + 260. PCI_USER_READ_CONFIG(word, u16) + 261. PCI_USER_READ_CONFIG(dword, u32) + +drivers/pci/access.c:260: error: DEAD_STORE + The value written to &ret is never used. + 258. + 259. PCI_USER_READ_CONFIG(byte, u8) + 260. > PCI_USER_READ_CONFIG(word, u16) + 261. PCI_USER_READ_CONFIG(dword, u32) + 262. PCI_USER_WRITE_CONFIG(byte, u8) + +drivers/pci/slot.c:266: error: DEAD_STORE + The value written to &err is never used. + 264. struct pci_dev *dev; + 265. struct pci_slot *slot; + 266. > int err = 0; + 267. char *slot_name = NULL; + 268. + +drivers/gpu/drm/i915/intel_opregion.c:328: error: DEAD_STORE + The value written to &timeout__ is never used. + 326. /* Poll for the result. */ + 327. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 328. > if (wait_for(C, dslp)) { + 329. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 330. return -ETIMEDOUT; + +drivers/pci/access.c:261: error: DEAD_STORE + The value written to &ret is never used. + 259. PCI_USER_READ_CONFIG(byte, u8) + 260. PCI_USER_READ_CONFIG(word, u16) + 261. > PCI_USER_READ_CONFIG(dword, u32) + 262. PCI_USER_WRITE_CONFIG(byte, u8) + 263. PCI_USER_WRITE_CONFIG(word, u16) + +drivers/pci/access.c:262: error: DEAD_STORE + The value written to &ret is never used. + 260. PCI_USER_READ_CONFIG(word, u16) + 261. PCI_USER_READ_CONFIG(dword, u32) + 262. > PCI_USER_WRITE_CONFIG(byte, u8) + 263. PCI_USER_WRITE_CONFIG(word, u16) + 264. PCI_USER_WRITE_CONFIG(dword, u32) + +drivers/tty/serial/serial_core.c:283: error: NULL_DEREFERENCE + pointer `uport` last assigned on line 264 could be null and is dereferenced by call to `uart_port_dtr_rts()` at line 283, column 4. + 281. + 282. if (!tty || C_HUPCL(tty)) + 283. > uart_port_dtr_rts(uport, 0); + 284. + 285. uart_port_shutdown(port); + +drivers/pci/access.c:263: error: DEAD_STORE + The value written to &ret is never used. + 261. PCI_USER_READ_CONFIG(dword, u32) + 262. PCI_USER_WRITE_CONFIG(byte, u8) + 263. > PCI_USER_WRITE_CONFIG(word, u16) + 264. PCI_USER_WRITE_CONFIG(dword, u32) + 265. + +drivers/gpu/drm/i915/intel_dsi_pll.c:271: error: DEAD_STORE + The value written to &m is never used. + 269. u32 dsi_clock, pclk; + 270. u32 pll_ctl, pll_div; + 271. > u32 m = 0, p = 0, n; + 272. int refclk = IS_CHERRYVIEW(dev_priv) ? 100000 : 25000; + 273. int i; + +drivers/pci/access.c:264: error: DEAD_STORE + The value written to &ret is never used. + 262. PCI_USER_WRITE_CONFIG(byte, u8) + 263. PCI_USER_WRITE_CONFIG(word, u16) + 264. > PCI_USER_WRITE_CONFIG(dword, u32) + 265. + 266. /* VPD access through PCI 2.2+ VPD capability */ + +net/compat.c:271: error: DEAD_STORE + The value written to &err is never used. + 269. struct file **fp = scm->fp->fp; + 270. int __user *cmfptr; + 271. > int err = 0, i; + 272. + 273. if (fdnum < fdmax) + +sound/core/pcm_lib.c:408: error: DEAD_STORE + The value written to &hw_base is never used. + 406. /* move new_hw_ptr according jiffies not pos variable */ + 407. new_hw_ptr = old_hw_ptr; + 408. > hw_base = delta; + 409. /* use loop to avoid checks for delta overflows */ + 410. /* the delta value is small or zero in most cases */ + +drivers/video/fbdev/core/cfbimgblt.c:267: error: DEAD_STORE + The value written to &pitch_index is never used. + 265. void cfb_imageblit(struct fb_info *p, const struct fb_image *image) + 266. { + 267. > u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0; + 268. u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel; + 269. u32 width = image->width; + +net/ipv6/addrlabel.c:269: error: DEAD_STORE + The value written to &p is never used. + 267. int ifindex) + 268. { + 269. > struct ip6addrlbl_entry *p = NULL; + 270. struct hlist_node *n; + 271. int ret = -ESRCH; + +drivers/gpu/drm/i915/intel_i2c.c:283: error: DEAD_STORE + The value written to &timeout__ is never used. + 281. + 282. status |= GMBUS_SATOER; + 283. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:285: error: DEAD_STORE + The value written to &timeout__ is never used. + 283. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 286. + 287. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/drm_crtc_helper.c:281: error: DEAD_STORE + The value written to &ret is never used. + 279. bool saved_enabled; + 280. struct drm_encoder *encoder; + 281. > bool ret = true; + 282. + 283. drm_warn_on_modeset_not_all_locked(dev); + +drivers/net/ethernet/intel/e1000e/ethtool.c:321: error: DEAD_STORE + The value written to &advertising is never used. + 319. hw->phy.autoneg_advertised = advertising | + 320. ADVERTISED_TP | ADVERTISED_Autoneg; + 321. > advertising = hw->phy.autoneg_advertised; + 322. if (adapter->fc_autoneg) + 323. hw->fc.requested_mode = e1000_fc_default; + +net/wireless/trace.h:269: error: DEAD_STORE + The value written to &p is never used. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +drivers/char/agp/amd64-agp.c:273: error: DEAD_STORE + The value written to &order is never used. + 271. { + 272. u64 aper, nb_aper; + 273. > int order = 0; + 274. u32 nb_order, nb_base; + 275. u16 apsize; + +drivers/net/ethernet/intel/e1000/e1000_param.c:283: error: DEAD_STORE + The value written to &mac_type is never used. + 281. struct e1000_tx_ring *tx_ring = adapter->tx_ring; + 282. int i; + 283. > e1000_mac_type mac_type = adapter->hw.mac_type; + 284. + 285. opt = (struct e1000_option) { + +drivers/net/ethernet/intel/e1000/e1000_param.c:311: error: DEAD_STORE + The value written to &mac_type is never used. + 309. struct e1000_rx_ring *rx_ring = adapter->rx_ring; + 310. int i; + 311. > e1000_mac_type mac_type = adapter->hw.mac_type; + 312. + 313. opt = (struct e1000_option) { + +drivers/base/cpu.c:274: error: DEAD_STORE + The value written to &n is never used. + 272. struct device_attribute *attr, char *buf) + 273. { + 274. > int n = 0, len = PAGE_SIZE-2; + 275. cpumask_var_t isolated; + 276. + +drivers/cpufreq/acpi-cpufreq.c:275: error: DEAD_STORE + The value written to &dummy is never used. + 273. u32 val, dummy; + 274. + 275. > rdmsr(MSR_AMD_PERF_CTL, val, dummy); + 276. return val; + 277. } + +drivers/dma-buf/reservation.c:324: error: DEAD_STORE + The value written to &dst_list is never used. + 322. } + 323. } else { + 324. > dst_list = NULL; + 325. } + 326. + +drivers/dma-buf/reservation.c:327: error: DEAD_STORE + The value written to &new is never used. + 325. } + 326. + 327. > new = dma_fence_get_rcu_safe(&src->fence_excl); + 328. rcu_read_unlock(); + 329. + +net/ipv4/inet_hashtables.c:278: error: DEAD_STORE + The value written to &acookie is never used. + 276. const int dif, const int sdif) + 277. { + 278. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 279. const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 280. struct sock *sk; + +net/ipv4/inet_hashtables.c:279: error: DEAD_STORE + The value written to &ports is never used. + 277. { + 278. INET_ADDR_COOKIE(acookie, saddr, daddr); + 279. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 280. struct sock *sk; + 281. const struct hlist_nulls_node *node; + +drivers/gpu/drm/drm_fb_helper.c:277: error: DEAD_STORE + The value written to &helper is never used. + 275. int drm_fb_helper_debug_enter(struct fb_info *info) + 276. { + 277. > struct drm_fb_helper *helper = info->par; + 278. const struct drm_crtc_helper_funcs *funcs; + 279. int i; + +net/ipv6/calipso.c:280: error: DEAD_STORE + The value written to &entry is never used. + 278. int ret_val = -EPERM; + 279. u32 bkt; + 280. > struct calipso_map_cache_entry *entry = NULL; + 281. struct calipso_map_cache_entry *old_entry = NULL; + 282. u32 calipso_ptr_len; + +net/ipv6/calipso.c:281: error: DEAD_STORE + The value written to &old_entry is never used. + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + 281. > struct calipso_map_cache_entry *old_entry = NULL; + 282. u32 calipso_ptr_len; + 283. + +net/ipv6/calipso.c:278: error: DEAD_STORE + The value written to &ret_val is never used. + 276. const struct netlbl_lsm_secattr *secattr) + 277. { + 278. > int ret_val = -EPERM; + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + +drivers/usb/host/ehci-q.c:314: error: DEAD_STORE + The value written to &token is never used. + 312. struct ehci_qtd *qtd; + 313. struct urb *urb; + 314. > u32 token = 0; + 315. + 316. qtd = list_entry (entry, struct ehci_qtd, qtd_list); + +block/blk-lib.c:284: error: DEAD_STORE + The value written to &bi_size is never used. + 282. struct request_queue *q = bdev_get_queue(bdev); + 283. struct bio *bio = *biop; + 284. > int bi_size = 0; + 285. unsigned int sz; + 286. + +drivers/video/fbdev/core/cfbfillrect.c:333: error: DEAD_STORE + The value written to &fill_op is never used. + 331. } else { + 332. int right, r; + 333. > void (*fill_op)(struct fb_info *p, unsigned long __iomem *dst, + 334. int dst_idx, unsigned long pat, int left, + 335. int right, unsigned n, int bits) = NULL; + +drivers/video/fbdev/core/cfbfillrect.c:307: error: DEAD_STORE + The value written to &fill_op32 is never used. + 305. if (!left) { + 306. u32 bswapmask = fb_compute_bswapmask(p); + 307. > void (*fill_op32)(struct fb_info *p, + 308. unsigned long __iomem *dst, int dst_idx, + 309. unsigned long pat, unsigned n, int bits, + +net/ipv6/af_inet6.c:287: error: DEAD_STORE + The value written to &addr_type is never used. + 285. __be32 v4addr = 0; + 286. unsigned short snum; + 287. > int addr_type = 0; + 288. int err = 0; + 289. + +drivers/video/fbdev/core/fbmem.c:286: error: DEAD_STORE + The value written to &fg is never used. + 284. const u8 *src = logo->data; + 285. u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0; + 286. > u8 fg = 1, d; + 287. + 288. switch (fb_get_color_depth(&info->var, &info->fix)) { + +net/wireless/trace.h:281: error: DEAD_STORE + The value written to &p is never used. + 279. ); + 280. + 281. > DECLARE_EVENT_CLASS(wiphy_only_evt, + 282. TP_PROTO(struct wiphy *wiphy), + 283. TP_ARGS(wiphy), + +net/netfilter/nfnetlink.c:337: error: DEAD_STORE + The value written to &err is never used. + 335. memset(&extack, 0, sizeof(extack)); + 336. nlh = nlmsg_hdr(skb); + 337. > err = 0; + 338. + 339. if (nlh->nlmsg_len < NLMSG_HDRLEN || + +drivers/cpuidle/governors/menu.c:294: error: NULL_DEREFERENCE + pointer `device` last assigned on line 286 could be null and is dereferenced by call to `dev_pm_qos_raw_read_value()` at line 294, column 23. + 292. unsigned int expected_interval; + 293. unsigned long nr_iowaiters, cpu_load; + 294. > int resume_latency = dev_pm_qos_raw_read_value(device); + 295. + 296. if (data->needs_update) { + +drivers/md/dm-rq.c:288: error: DEAD_STORE + The value written to &rq_end_io is never used. + 286. int r = DM_ENDIO_DONE; + 287. struct dm_rq_target_io *tio = clone->end_io_data; + 288. > dm_request_endio_fn rq_end_io = NULL; + 289. + 290. if (tio->ti) { + +sound/core/pcm_native.c:304: error: DEAD_STORE + The value written to &old_interval is never used. + 302. + 303. if (trace_hw_interval_param_enabled()) + 304. > old_interval = *i; + 305. + 306. changed = snd_interval_refine(i, constrs_interval(constrs, k)); + +drivers/ata/libata-acpi.c:291: error: DEAD_STORE + The value written to &rc is never used. + 289. union acpi_object *out_obj; + 290. acpi_status status; + 291. > int rc = 0; + 292. acpi_handle handle = ACPI_HANDLE(&ap->tdev); + 293. + +block/partitions/efi.c:307: error: DEAD_STORE + The value written to &pte is never used. + 305. (u8 *) pte, count) < count) { + 306. kfree(pte); + 307. > pte=NULL; + 308. return NULL; + 309. } + +drivers/gpu/drm/drm_pci.c:293: error: DEAD_STORE + The value written to &pdev is never used. + 291. int drm_legacy_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) + 292. { + 293. > struct pci_dev *pdev = NULL; + 294. const struct pci_device_id *pid; + 295. int i; + +block/scsi_ioctl.c:296: error: DEAD_STORE + The value written to &ret is never used. + 294. { + 295. unsigned long start_time; + 296. > ssize_t ret = 0; + 297. int writing = 0; + 298. int at_head = 0; + +drivers/net/phy/mdio_bus.c:297: error: DEAD_STORE + The value written to &ret is never used. + 295. { + 296. struct mdio_device *mdiodev; + 297. > int ret = 0; + 298. + 299. mdiodev = mdio_device_create(bus, bi->mdio_addr); + +net/netlabel/netlabel_calipso.c:295: error: DEAD_STORE + The value written to &ret_val is never used. + 293. static int netlbl_calipso_remove(struct sk_buff *skb, struct genl_info *info) + 294. { + 295. > int ret_val = -EINVAL; + 296. struct netlbl_domhsh_walk_arg cb_arg; + 297. struct netlbl_audit audit_info; + +net/netlabel/netlabel_mgmt.c:297: error: DEAD_STORE + The value written to &ret_val is never used. + 295. struct netlbl_dom_map *entry) + 296. { + 297. > int ret_val = 0; + 298. struct nlattr *nla_a; + 299. struct nlattr *nla_b; + +net/sched/sch_generic.c:311: error: DEAD_STORE + The value written to &trans_start is never used. + 309. + 310. txq = netdev_get_tx_queue(dev, i); + 311. > trans_start = txq->trans_start; + 312. if (netif_xmit_stopped(txq) && + 313. time_after(jiffies, (trans_start + + +arch/x86/platform/efi/efi.c:342: error: DEAD_STORE + The value written to &tmp is never used. + 340. efi_systab.tables = data ? (unsigned long)data->tables : + 341. systab64->tables; + 342. > tmp |= data ? data->tables : systab64->tables; + 343. + 344. early_memunmap(systab64, sizeof(*systab64)); + +drivers/gpu/drm/i915/intel_lpe_audio.c:302: error: DEAD_STORE + The value written to &desc is never used. + 300. return; + 301. + 302. > desc = irq_to_desc(dev_priv->lpe_audio.irq); + 303. + 304. lpe_audio_platdev_destroy(dev_priv); + +usr/gen_init_cpio.c:303: error: DEAD_STORE + The value written to &file is never used. + 301. struct stat buf; + 302. long size; + 303. > int file = -1; + 304. int retval; + 305. int rc = -1; + +drivers/md/dm-io.c:315: error: NULL_DEREFERENCE + pointer `q` last assigned on line 306 could be null and is dereferenced at line 315, column 29. + 313. */ + 314. if (op == REQ_OP_DISCARD) + 315. > special_cmd_max_sectors = q->limits.max_discard_sectors; + 316. else if (op == REQ_OP_WRITE_ZEROES) + 317. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + +drivers/md/dm-io.c:317: error: NULL_DEREFERENCE + pointer `q` last assigned on line 306 could be null and is dereferenced at line 317, column 29. + 315. special_cmd_max_sectors = q->limits.max_discard_sectors; + 316. else if (op == REQ_OP_WRITE_ZEROES) + 317. > special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 318. else if (op == REQ_OP_WRITE_SAME) + 319. special_cmd_max_sectors = q->limits.max_write_same_sectors; + +drivers/md/dm-io.c:319: error: NULL_DEREFERENCE + pointer `q` last assigned on line 306 could be null and is dereferenced at line 319, column 29. + 317. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 318. else if (op == REQ_OP_WRITE_SAME) + 319. > special_cmd_max_sectors = q->limits.max_write_same_sectors; + 320. if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES || + 321. op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) { + +net/ipv6/sit.c:302: error: DEAD_STORE + The value written to &ret is never used. + 300. struct ip_tunnel_prl_entry *prl; + 301. unsigned int cmax, c = 0, ca, len; + 302. > int ret = 0; + 303. + 304. if (copy_from_user(&kprl, a, sizeof(kprl))) + +net/ipv6/sit.c:329: error: DEAD_STORE + The value written to &ret is never used. + 327. kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC); + 328. if (!kp) { + 329. > ret = -ENOMEM; + 330. goto out; + 331. } + +lib/swiotlb.c:308: error: DEAD_STORE + The value written to &rc is never used. + 306. unsigned char *vstart = NULL; + 307. unsigned int order; + 308. > int rc = 0; + 309. + 310. if (!io_tlb_nslabs) { + +drivers/edac/edac_mc.c:345: error: DEAD_STORE + The value written to &mci is never used. + 343. * hardcode everything into a single struct. + 344. */ + 345. > mci = edac_align_ptr(&ptr, sizeof(*mci), 1); + 346. layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers); + 347. for (i = 0; i < n_layers; i++) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:316: error: DEAD_STORE + The value written to &p is never used. + 314. if (unlikely(p == NULL)) + 315. return -ENOSPC; + 316. > p = xdr_decode_hyper(p, &status->major_status); + 317. + 318. /* status->mech */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:327: error: DEAD_STORE + The value written to &p is never used. + 325. if (unlikely(p == NULL)) + 326. return -ENOSPC; + 327. > p = xdr_decode_hyper(p, &status->minor_status); + 328. + 329. /* status->major_status_string */ + +drivers/hid/hid-lg4ff.c:311: error: DEAD_STORE + The value written to &new_value is never used. + 309. { + 310. struct lg4ff_device_entry *entry = drv_data->device_props; + 311. > s32 new_value = 0; + 312. + 313. if (!entry) { + +kernel/reboot.c:312: error: DEAD_STORE + The value written to &ret is never used. + 310. struct pid_namespace *pid_ns = task_active_pid_ns(current); + 311. char buffer[256]; + 312. > int ret = 0; + 313. + 314. /* We only trust the superuser with rebooting the system. */ + +kernel/reboot.c:315: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 310 could be null and is dereferenced at line 315, column 18. + 313. + 314. /* We only trust the superuser with rebooting the system. */ + 315. > if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT)) + 316. return -EPERM; + 317. + +drivers/net/ethernet/intel/e1000e/nvm.c:312: error: DEAD_STORE + The value written to &eerd is never used. + 310. { + 311. struct e1000_nvm_info *nvm = &hw->nvm; + 312. > u32 i, eerd = 0; + 313. s32 ret_val = 0; + 314. + +net/ipv4/cipso_ipv4.c:316: error: DEAD_STORE + The value written to &entry is never used. + 314. int ret_val = -EPERM; + 315. u32 bkt; + 316. > struct cipso_v4_map_cache_entry *entry = NULL; + 317. struct cipso_v4_map_cache_entry *old_entry = NULL; + 318. u32 cipso_ptr_len; + +net/ipv4/cipso_ipv4.c:317: error: DEAD_STORE + The value written to &old_entry is never used. + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + 317. > struct cipso_v4_map_cache_entry *old_entry = NULL; + 318. u32 cipso_ptr_len; + 319. + +net/ipv4/cipso_ipv4.c:314: error: DEAD_STORE + The value written to &ret_val is never used. + 312. const struct netlbl_lsm_secattr *secattr) + 313. { + 314. > int ret_val = -EPERM; + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + +net/wireless/trace.h:313: error: DEAD_STORE + The value written to &p is never used. + 311. ); + 312. + 313. > DECLARE_EVENT_CLASS(wiphy_enabled_evt, + 314. TP_PROTO(struct wiphy *wiphy, bool enabled), + 315. TP_ARGS(wiphy, enabled), + +drivers/char/hw_random/core.c:318: error: DEAD_STORE + The value written to &err is never used. + 316. const char *buf, size_t len) + 317. { + 318. > int err = -ENODEV; + 319. struct hwrng *rng; + 320. + +drivers/gpu/drm/i915/intel_pm.c:330: error: DEAD_STORE + The value written to &timeout__ is never used. + 328. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 329. + 330. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 331. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 332. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +drivers/video/fbdev/core/syscopyarea.c:320: error: DEAD_STORE + The value written to &base is never used. + 318. u32 height = area->height, width = area->width; + 319. unsigned long const bits_per_line = p->fix.line_length*8u; + 320. > unsigned long *base = NULL; + 321. int bits = BITS_PER_LONG, bytes = bits >> 3; + 322. unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + +drivers/video/fbdev/core/syscopyarea.c:322: error: DEAD_STORE + The value written to &dst_idx is never used. + 320. unsigned long *base = NULL; + 321. int bits = BITS_PER_LONG, bytes = bits >> 3; + 322. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 323. + 324. if (p->state != FBINFO_STATE_RUNNING) + +drivers/video/fbdev/core/syscopyarea.c:322: error: DEAD_STORE + The value written to &src_idx is never used. + 320. unsigned long *base = NULL; + 321. int bits = BITS_PER_LONG, bytes = bits >> 3; + 322. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 323. + 324. if (p->state != FBINFO_STATE_RUNNING) + +kernel/params.c:317: error: DEAD_STORE + The value written to &err is never used. + 315. int param_set_bool_enable_only(const char *val, const struct kernel_param *kp) + 316. { + 317. > int err = 0; + 318. bool new_value; + 319. bool orig_value = *(bool *)kp->arg; + +drivers/char/agp/isoch.c:336: error: DEAD_STORE + The value written to &arqsz is never used. + 334. return -ENODEV; + 335. + 336. > arqsz = (tstatus >> 13) & 0x7; + 337. + 338. /* + +net/ipv6/mcast.c:427: error: DEAD_STORE + The value written to &rv is never used. + 425. pmc->sflist = psl = newpsl; + 426. } + 427. > rv = 1; /* > 0 for insert logic below if sl_count is 0 */ + 428. for (i = 0; i < psl->sl_count; i++) { + 429. rv = !ipv6_addr_equal(&psl->sl_addr[i], source); + +drivers/pcmcia/ti113x.h:323: error: DEAD_STORE + The value written to &isa_irq_mask is never used. + 321. int isa_irq = -1; + 322. u8 intctl; + 323. > u32 isa_irq_mask = 0; + 324. + 325. if (!isa_probe) + +sound/core/pcm_native.c:397: error: DEAD_STORE + The value written to &old_interval is never used. + 395. if (trace_hw_interval_param_enabled()) { + 396. if (hw_is_interval(r->var)) + 397. > old_interval = *hw_param_interval(params, r->var); + 398. } + 399. + +sound/core/pcm_native.c:393: error: DEAD_STORE + The value written to &old_mask is never used. + 391. if (trace_hw_mask_param_enabled()) { + 392. if (hw_is_mask(r->var)) + 393. > old_mask = *hw_param_mask(params, r->var); + 394. } + 395. if (trace_hw_interval_param_enabled()) { + +net/ipv4/inet_hashtables.c:332: error: DEAD_STORE + The value written to &acookie is never used. + 330. struct net *net = sock_net(sk); + 331. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 332. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 333. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 334. unsigned int hash = inet_ehashfn(net, daddr, lport, + +net/ipv4/inet_hashtables.c:333: error: DEAD_STORE + The value written to &ports is never used. + 331. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 332. INET_ADDR_COOKIE(acookie, saddr, daddr); + 333. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 334. unsigned int hash = inet_ehashfn(net, daddr, lport, + 335. saddr, inet->inet_dport); + +net/ipv4/inet_hashtables.c:331: error: DEAD_STORE + The value written to &sdif is never used. + 329. int dif = sk->sk_bound_dev_if; + 330. struct net *net = sock_net(sk); + 331. > int sdif = l3mdev_master_ifindex_by_index(net, dif); + 332. INET_ADDR_COOKIE(acookie, saddr, daddr); + 333. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + +block/partitions/efi.c:334: error: DEAD_STORE + The value written to &gpt is never used. + 332. if (read_lba(state, lba, (u8 *) gpt, ssz) < ssz) { + 333. kfree(gpt); + 334. > gpt=NULL; + 335. return NULL; + 336. } + +drivers/char/agp/amd64-agp.c:335: error: DEAD_STORE + The value written to &i is never used. + 333. return -ENODEV; + 334. + 335. > i = 0; + 336. for (i = 0; i < amd_nb_num(); i++) { + 337. struct pci_dev *dev = node_to_amd_nb(i)->misc; + +net/netfilter/nf_log.c:327: error: DEAD_STORE + The value written to &net is never used. + 325. static void *seq_start(struct seq_file *seq, loff_t *pos) + 326. { + 327. > struct net *net = seq_file_net(seq); + 328. + 329. mutex_lock(&nf_log_mutex); + +drivers/gpu/drm/drm_dp_mst_topology.c:373: error: DEAD_STORE + The value written to &crc4 is never used. + 371. if (msg->curchunk_idx >= msg->curchunk_len) { + 372. /* do CRC */ + 373. > crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1); + 374. /* copy chunk into bigger msg */ + 375. memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1); + +kernel/smp.c:328: error: DEAD_STORE + The value written to &err is never used. + 326. int smp_call_function_single_async(int cpu, call_single_data_t *csd) + 327. { + 328. > int err = 0; + 329. + 330. preempt_disable(); + +net/ipv4/sysctl_net_ipv4.c:329: error: DEAD_STORE + The value written to &ret is never used. + 327. void __user *buffer, size_t *lenp, loff_t *ppos) + 328. { + 329. > int ret = 0; + 330. + 331. ret = proc_dointvec(table, write, buffer, lenp, ppos); + +sound/core/pcm_memory.c:331: error: DEAD_STORE + The value written to &dmab is never used. + 329. { + 330. struct snd_pcm_runtime *runtime; + 331. > struct snd_dma_buffer *dmab = NULL; + 332. + 333. if (PCM_RUNTIME_CHECK(substream)) + +drivers/gpu/drm/i915/intel_runtime_pm.c:333: error: DEAD_STORE + The value written to &id is never used. + 331. struct i915_power_well *power_well) + 332. { + 333. > enum i915_power_well_id id = power_well->id; + 334. bool disabled; + 335. u32 reqs; + +drivers/gpu/drm/i915/intel_runtime_pm.c:346: error: DEAD_STORE + The value written to &timeout__ is never used. + 344. * diagnostic message. + 345. */ + 346. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 347. HSW_PWR_WELL_CTL_STATE(id))) || + 348. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +lib/mpi/mpicoder.c:338: error: DEAD_STORE + The value written to &val is never used. + 336. const u8 *buff; + 337. mpi_limb_t a; + 338. > MPI val = NULL; + 339. + 340. ents = sg_nents_for_len(sgl, nbytes); + +net/ipv6/addrlabel.c:332: error: DEAD_STORE + The value written to &p is never used. + 330. static void __net_exit ip6addrlbl_net_exit(struct net *net) + 331. { + 332. > struct ip6addrlbl_entry *p = NULL; + 333. struct hlist_node *n; + 334. + +drivers/gpu/drm/i915/intel_guc_ct.c:343: error: DEAD_STORE + The value written to &timeout__ is never used. + 341. */ + 342. #define done (READ_ONCE(desc->fence) == fence) + 343. > err = wait_for_us(done, 10); + 344. if (err) + 345. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:345: error: DEAD_STORE + The value written to &timeout__ is never used. + 343. err = wait_for_us(done, 10); + 344. if (err) + 345. > err = wait_for(done, 10); + 346. #undef done + 347. + +drivers/tty/vt/vt_ioctl.c:814: error: DEAD_STORE + The value written to &arg is never used. + 812. vt_disallocate_all(); + 813. else + 814. > ret = vt_disallocate(--arg); + 815. break; + 816. + +drivers/mailbox/pcc.c:341: error: DEAD_STORE + The value written to &ret is never used. + 339. u64 doorbell_write; + 340. u32 id = chan - pcc_mbox_channels; + 341. > int ret = 0; + 342. + 343. if (id >= pcc_mbox_ctrl.num_chans) { + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &p is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &ret is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +drivers/connector/cn_proc.c:338: error: DEAD_STORE + The value written to &mc_op is never used. + 336. struct netlink_skb_parms *nsp) + 337. { + 338. > enum proc_cn_mcast_op *mc_op = NULL; + 339. int err = 0; + 340. + +drivers/char/agp/intel-gtt.c:342: error: DEAD_STORE + The value written to &stolen_size is never used. + 340. int local = 0; + 341. static const int ddt[4] = { 0, 16, 32, 64 }; + 342. > unsigned int stolen_size = 0; + 343. + 344. if (INTEL_GTT_GEN == 1) + +net/netlabel/netlabel_cipso_v4.c:340: error: DEAD_STORE + The value written to &doi_def is never used. + 338. { + 339. int ret_val; + 340. > struct cipso_v4_doi *doi_def = NULL; + 341. + 342. if (!info->attrs[NLBL_CIPSOV4_A_TAGLST]) + +net/netfilter/nf_log.c:339: error: DEAD_STORE + The value written to &net is never used. + 337. static void *seq_next(struct seq_file *s, void *v, loff_t *pos) + 338. { + 339. > struct net *net = seq_file_net(s); + 340. + 341. (*pos)++; + +drivers/input/ff-memless.c:354: error: DEAD_STORE + The value written to &effect is never used. + 352. + 353. state = &ml->states[i]; + 354. > effect = state->effect; + 355. + 356. if (!test_bit(FF_EFFECT_STARTED, &state->flags)) + +block/badblocks.c:356: error: DEAD_STORE + The value written to §ors is never used. + 354. s >>= bb->shift; + 355. target >>= bb->shift; + 356. > sectors = target - s; + 357. } + 358. + +security/keys/process_keys.c:350: error: DEAD_STORE + The value written to &key_ref is never used. + 348. * in terms of priority: success > -ENOKEY > -EAGAIN > other error + 349. */ + 350. > key_ref = NULL; + 351. ret = NULL; + 352. err = ERR_PTR(-EAGAIN); + +block/blk-sysfs.c:343: error: DEAD_STORE + The value written to &ret is never used. + 341. queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) + 342. { + 343. > ssize_t ret = -EINVAL; + 344. #ifdef CONFIG_SMP + 345. unsigned long val; + +net/netfilter/nf_nat_sip.c:368: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 351 could be null and is dereferenced at line 368, column 12. + 366. * original direction, try to use the destination port in the opposite + 367. * direction. */ + 368. > srcport = ct_sip_info->forced_dport ? : + 369. ct->tuplehash[dir].tuple.src.u.udp.port; + 370. if (exp->tuple.dst.u.udp.port == srcport) + +net/ipv4/sysctl_net_ipv4.c:345: error: DEAD_STORE + The value written to &ret is never used. + 343. void __user *buffer, size_t *lenp, loff_t *ppos) + 344. { + 345. > int ret = 0; + 346. + 347. ret = proc_dointvec(table, write, buffer, lenp, ppos); + +drivers/firmware/efi/esrt.c:352: error: DEAD_STORE + The value written to &esre is never used. + 350. + 351. for (i = 0; i < le32_to_cpu(esrt->fw_resource_count); i++) { + 352. > void *esre = NULL; + 353. if (esrt->fw_resource_version == 1) { + 354. esre = &v1_entries[i]; + +drivers/tty/tty_io.c:348: error: DEAD_STORE + The value written to &prefix_length is never used. + 346. struct tty_driver *p; + 347. int ret; + 348. > int index, prefix_length = 0; + 349. const char *str; + 350. + +crypto/jitterentropy.c:350: error: DEAD_STORE + The value written to ¤t_delta is never used. + 348. __u64 time = 0; + 349. __u64 data = 0; + 350. > __u64 current_delta = 0; + 351. + 352. /* Invoke one noise source before time measurement to add variations */ + +drivers/gpu/drm/i915/i915_gem.c:391: error: DEAD_STORE + The value written to &rps_client is never used. + 389. gen6_rps_boost(rq, rps_client); + 390. else + 391. > rps_client = NULL; + 392. } + 393. + +kernel/locking/rwsem-xadd.c:353: error: DEAD_STORE + The value written to &ret is never used. + 351. { + 352. struct task_struct *owner; + 353. > bool ret = true; + 354. + 355. if (need_resched()) + +net/wireless/trace.h:350: error: DEAD_STORE + The value written to &p is never used. + 348. ); + 349. + 350. > DECLARE_EVENT_CLASS(wiphy_wdev_evt, + 351. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 352. TP_ARGS(wiphy, wdev), + +scripts/asn1_compiler.c:361: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 361, column 3. + 359. token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token)); + 360. if (!tokens) { + 361. > perror(NULL); + 362. exit(1); + 363. } + +crypto/api.c:354: error: DEAD_STORE + The value written to &tfm is never used. + 352. u32 mask) + 353. { + 354. > struct crypto_tfm *tfm = NULL; + 355. unsigned int tfm_size; + 356. int err = -ENOMEM; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:378: error: DEAD_STORE + The value written to &err is never used. + 376. opt.value.data = LUCID_VALUE; + 377. opt.value.len = sizeof(LUCID_VALUE); + 378. > err = gssx_enc_option(xdr, &opt); + 379. + 380. /* ..and user creds */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:371: error: NULL_DEREFERENCE + pointer `p` last assigned on line 370 could be null and is dereferenced at line 371, column 2. + 369. /* ctx->options */ + 370. p = xdr_reserve_space(xdr, 4); + 371. > *p = cpu_to_be32(2); + 372. + 373. /* we want a lucid_v1 context */ + +sound/hda/hdac_controller.c:360: error: DEAD_STORE + The value written to &timeout is never used. + 358. snd_hdac_chip_updatel(bus, GCTL, AZX_GCTL_RESET, 0); + 359. + 360. > timeout = jiffies + msecs_to_jiffies(100); + 361. while ((snd_hdac_chip_readb(bus, GCTL) & AZX_GCTL_RESET) && + 362. time_before(jiffies, timeout)) + +sound/core/timer.c:356: error: DEAD_STORE + The value written to &timer is never used. + 354. static int snd_timer_close_locked(struct snd_timer_instance *timeri) + 355. { + 356. > struct snd_timer *timer = NULL; + 357. struct snd_timer_instance *slave, *tmp; + 358. + +drivers/gpu/drm/i915/intel_opregion.c:360: error: DEAD_STORE + The value written to &type is never used. + 358. struct drm_i915_private *dev_priv = to_i915(intel_encoder->base.dev); + 359. u32 parm = 0; + 360. > u32 type = 0; + 361. u32 port; + 362. + +net/sched/act_api.c:362: error: DEAD_STORE + The value written to &id is never used. + 360. struct tc_action *p; + 361. int ret; + 362. > unsigned long id = 1; + 363. + 364. idr_for_each_entry_ext(idr, p, id) { + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:394: error: DEAD_STORE + The value written to &ret_val is never used. + 392. + 393. /* ...and verify the command was successful. */ + 394. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 395. + 396. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +drivers/input/serio/i8042.c:363: error: DEAD_STORE + The value written to &retval is never used. + 361. { + 362. unsigned long flags; + 363. > int retval = 0; + 364. + 365. spin_lock_irqsave(&i8042_lock, flags); + +lib/assoc_array.c:426: error: DEAD_STORE + The value written to &cursor is never used. + 424. shortcut = assoc_array_ptr_to_shortcut(parent); + 425. BUG_ON(shortcut->next_node != cursor); + 426. > cursor = parent; + 427. parent = shortcut->back_pointer; + 428. slot = shortcut->parent_slot; + +net/sunrpc/clnt.c:367: error: DEAD_STORE + The value written to &clnt is never used. + 365. const struct rpc_program *program = args->program; + 366. const struct rpc_version *version; + 367. > struct rpc_clnt *clnt = NULL; + 368. const struct rpc_timeout *timeout; + 369. const char *nodename = args->nodename; + +drivers/usb/core/message.c:450: error: DEAD_STORE + The value written to &i is never used. + 448. urb->transfer_buffer_length = len; + 449. } + 450. > io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; + 451. + 452. /* transaction state */ + +kernel/trace/trace_uprobe.c:373: error: DEAD_STORE + The value written to &ret is never used. + 371. + 372. inode = NULL; + 373. > ret = 0; + 374. is_delete = false; + 375. is_return = false; + +kernel/trace/trace_uprobe.c:501: error: DEAD_STORE + The value written to &ret is never used. + 499. + 500. /* parse arguments */ + 501. > ret = 0; + 502. for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) { + 503. struct probe_arg *parg = &tu->tp.args[i]; + +drivers/scsi/scsi_logging.c:375: error: DEAD_STORE + The value written to &off is never used. + 373. return; + 374. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 375. > off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr); + 376. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + 377. scsi_log_release_buffer(logbuf); + +drivers/scsi/scsi_logging.c:383: error: DEAD_STORE + The value written to &off is never used. + 381. return; + 382. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 383. > off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, + 384. sshdr->asc, sshdr->ascq); + 385. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + +block/blk-lib.c:368: error: DEAD_STORE + The value written to &ret is never used. + 366. sector_t nr_sects, gfp_t gfp_mask, unsigned flags) + 367. { + 368. > int ret = 0; + 369. sector_t bs_mask; + 370. struct bio *bio; + +drivers/gpu/drm/drm_modes.c:459: error: DEAD_STORE + The value written to &hperiod is never used. + 457. vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. > hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + 460. + 461. /* 13. Find the actual Vertical field frequency: */ + +drivers/gpu/drm/drm_modes.c:452: error: DEAD_STORE + The value written to &vback_porch is never used. + 450. vsync_plus_bp = (vsync_plus_bp + 500) / 1000; + 451. /* 9. Find the number of lines in V back porch alone: */ + 452. > vback_porch = vsync_plus_bp - V_SYNC_RQD; + 453. /* 10. Find the total number of lines in Vertical field period: */ + 454. vtotal_lines = vdisplay_rnd + top_margin + bottom_margin + + +drivers/gpu/drm/drm_modes.c:457: error: DEAD_STORE + The value written to &vfieldrate_est is never used. + 455. vsync_plus_bp + GTF_MIN_V_PORCH; + 456. /* 11. Estimate the Vertical field frequency: */ + 457. > vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + +drivers/gpu/drm/drm_modes.c:465: error: DEAD_STORE + The value written to &vframe_rate is never used. + 463. /* 14. Find the Vertical frame frequency: */ + 464. if (interlaced) + 465. > vframe_rate = vfield_rate / 2; + 466. else + 467. vframe_rate = vfield_rate; + +drivers/gpu/drm/drm_modes.c:467: error: DEAD_STORE + The value written to &vframe_rate is never used. + 465. vframe_rate = vfield_rate / 2; + 466. else + 467. > vframe_rate = vfield_rate; + 468. /* 15. Find number of pixels in left margin: */ + 469. if (margins) + +drivers/pci/slot.c:368: error: DEAD_STORE + The value written to &kobj is never used. + 366. { + 367. struct hotplug_slot *slot = pci_slot->hotplug; + 368. > struct kobject *kobj = NULL; + 369. int ret; + 370. + +drivers/block/loop.c:375: error: DEAD_STORE + The value written to &ret is never used. + 373. struct page *page; + 374. ssize_t len; + 375. > int ret = 0; + 376. + 377. page = alloc_page(GFP_NOIO); + +drivers/md/dm-stripe.c:384: error: DEAD_STORE + The value written to &sz is never used. + 382. } + 383. buffer[i] = '\0'; + 384. > DMEMIT("1 %s", buffer); + 385. break; + 386. + +drivers/pcmcia/ti113x.h:417: error: DEAD_STORE + The value written to &mfunc_old is never used. + 415. dev_info(&socket->dev->dev, + 416. "TI: all-serial interrupts ok\n"); + 417. > mfunc_old = mfunc; + 418. goto out; + 419. } + +drivers/pcmcia/ti113x.h:462: error: DEAD_STORE + The value written to &mfunc_old is never used. + 460. pci_irq_status = yenta_probe_cb_irq(socket); + 461. if (pci_irq_status == 1) { + 462. > mfunc_old = mfunc; + 463. dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n"); + 464. } else { + +kernel/sched/cpuacct.c:377: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 376 could be null and is dereferenced at line 377, column 3. + 375. rcu_read_lock(); + 376. for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca)) + 377. > this_cpu_ptr(ca->cpustat)->cpustat[index] += val; + 378. rcu_read_unlock(); + 379. } + +drivers/gpu/drm/drm_framebuffer.c:376: error: DEAD_STORE + The value written to &fb is never used. + 374. void *data, struct drm_file *file_priv) + 375. { + 376. > struct drm_framebuffer *fb = NULL; + 377. struct drm_framebuffer *fbl = NULL; + 378. uint32_t *id = data; + +drivers/gpu/drm/drm_framebuffer.c:377: error: DEAD_STORE + The value written to &fbl is never used. + 375. { + 376. struct drm_framebuffer *fb = NULL; + 377. > struct drm_framebuffer *fbl = NULL; + 378. uint32_t *id = data; + 379. int found = 0; + +sound/hda/hdac_controller.c:379: error: DEAD_STORE + The value written to &timeout is never used. + 377. snd_hdac_chip_updateb(bus, GCTL, 0, AZX_GCTL_RESET); + 378. + 379. > timeout = jiffies + msecs_to_jiffies(100); + 380. while (!snd_hdac_chip_readb(bus, GCTL) && time_before(jiffies, timeout)) + 381. usleep_range(500, 1000); + +net/wireless/trace.h:374: error: DEAD_STORE + The value written to &p is never used. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +drivers/pci/access.c:379: error: DEAD_STORE + The value written to &max_sleep is never used. + 377. struct pci_vpd *vpd = dev->vpd; + 378. unsigned long timeout = jiffies + msecs_to_jiffies(125); + 379. > unsigned long max_sleep = 16; + 380. u16 status; + 381. int ret; + +drivers/pci/access.c:378: error: DEAD_STORE + The value written to &timeout is never used. + 376. { + 377. struct pci_vpd *vpd = dev->vpd; + 378. > unsigned long timeout = jiffies + msecs_to_jiffies(125); + 379. unsigned long max_sleep = 16; + 380. u16 status; + +net/netlabel/netlabel_cipso_v4.c:379: error: DEAD_STORE + The value written to &doi_def is never used. + 377. { + 378. int ret_val; + 379. > struct cipso_v4_doi *doi_def = NULL; + 380. + 381. if (!info->attrs[NLBL_CIPSOV4_A_TAGLST]) + +drivers/gpu/drm/drm_mode_object.c:381: error: DEAD_STORE + The value written to &ret is never used. + 379. struct drm_mode_obj_get_properties *arg = data; + 380. struct drm_mode_object *obj; + 381. > int ret = 0; + 382. + 383. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +lib/radix-tree.c:382: error: DEAD_STORE + The value written to &ret is never used. + 380. unsigned int count, unsigned int exceptional) + 381. { + 382. > struct radix_tree_node *ret = NULL; + 383. + 384. /* + +net/ipv6/addrlabel.c:384: error: DEAD_STORE + The value written to &err is never used. + 382. struct in6_addr *pfx; + 383. u32 label; + 384. > int err = 0; + 385. + 386. err = nlmsg_parse(nlh, sizeof(*ifal), tb, IFAL_MAX, ifal_policy, + +drivers/char/nvram.c:380: error: DEAD_STORE + The value written to &i is never used. + 378. { + 379. unsigned char contents[NVRAM_BYTES]; + 380. > int i = 0; + 381. + 382. spin_lock_irq(&rtc_lock); + +drivers/gpu/drm/drm_blend.c:384: error: DEAD_STORE + The value written to &ret is never used. + 382. struct drm_plane *plane; + 383. struct drm_plane_state *old_plane_state, *new_plane_state; + 384. > int i, ret = 0; + 385. + 386. for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) { + +drivers/pci/search.c:380: error: DEAD_STORE + The value written to &found is never used. + 378. int pci_dev_present(const struct pci_device_id *ids) + 379. { + 380. > struct pci_dev *found = NULL; + 381. + 382. WARN_ON(in_interrupt()); + +sound/pci/hda/hda_controller.c:391: error: DEAD_STORE + The value written to &timeout is never used. + 389. bool direction; + 390. u32 dma_select; + 391. > u32 timeout = 200; + 392. u32 retry_count = 0; + 393. + +kernel/cgroup/cpuset.c:382: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 382 could be null and is dereferenced by call to `parent_cs()` at line 382, column 8. + 380. { + 381. while (!nodes_intersects(cs->effective_mems, node_states[N_MEMORY])) + 382. > cs = parent_cs(cs); + 383. nodes_and(*pmask, cs->effective_mems, node_states[N_MEMORY]); + 384. } + +drivers/hid/usbhid/hid-quirks.c:383: error: DEAD_STORE + The value written to &bl_entry is never used. + 381. { + 382. u32 quirks = 0; + 383. > const struct hid_blacklist *bl_entry = NULL; + 384. + 385. /* NCR devices must not be queried for reports */ + +drivers/video/fbdev/core/cfbcopyarea.c:386: error: DEAD_STORE + The value written to &base is never used. + 384. u32 height = area->height, width = area->width; + 385. unsigned long const bits_per_line = p->fix.line_length*8u; + 386. > unsigned long __iomem *base = NULL; + 387. int bits = BITS_PER_LONG, bytes = bits >> 3; + 388. unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + +drivers/video/fbdev/core/cfbcopyarea.c:388: error: DEAD_STORE + The value written to &dst_idx is never used. + 386. unsigned long __iomem *base = NULL; + 387. int bits = BITS_PER_LONG, bytes = bits >> 3; + 388. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 389. u32 bswapmask = fb_compute_bswapmask(p); + 390. + +drivers/video/fbdev/core/cfbcopyarea.c:388: error: DEAD_STORE + The value written to &src_idx is never used. + 386. unsigned long __iomem *base = NULL; + 387. int bits = BITS_PER_LONG, bytes = bits >> 3; + 388. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 389. u32 bswapmask = fb_compute_bswapmask(p); + 390. + +drivers/gpu/drm/i915/intel_dsi_pll.c:388: error: DEAD_STORE + The value written to &ddr_clk is never used. + 386. u32 dsi_rate = 0; + 387. u32 pll_ratio = 0; + 388. > u32 ddr_clk = 0; + 389. u32 div1_value = 0; + 390. u32 div2_value = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:389: error: DEAD_STORE + The value written to &div1_value is never used. + 387. u32 pll_ratio = 0; + 388. u32 ddr_clk = 0; + 389. > u32 div1_value = 0; + 390. u32 div2_value = 0; + 391. u32 txesc1_div = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:390: error: DEAD_STORE + The value written to &div2_value is never used. + 388. u32 ddr_clk = 0; + 389. u32 div1_value = 0; + 390. > u32 div2_value = 0; + 391. u32 txesc1_div = 0; + 392. u32 txesc2_div = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:386: error: DEAD_STORE + The value written to &dsi_rate is never used. + 384. { + 385. struct drm_i915_private *dev_priv = to_i915(dev); + 386. > u32 dsi_rate = 0; + 387. u32 pll_ratio = 0; + 388. u32 ddr_clk = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:387: error: DEAD_STORE + The value written to &pll_ratio is never used. + 385. struct drm_i915_private *dev_priv = to_i915(dev); + 386. u32 dsi_rate = 0; + 387. > u32 pll_ratio = 0; + 388. u32 ddr_clk = 0; + 389. u32 div1_value = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:391: error: DEAD_STORE + The value written to &txesc1_div is never used. + 389. u32 div1_value = 0; + 390. u32 div2_value = 0; + 391. > u32 txesc1_div = 0; + 392. u32 txesc2_div = 0; + 393. + +drivers/gpu/drm/i915/intel_dsi_pll.c:392: error: DEAD_STORE + The value written to &txesc2_div is never used. + 390. u32 div2_value = 0; + 391. u32 txesc1_div = 0; + 392. > u32 txesc2_div = 0; + 393. + 394. pll_ratio = config->dsi_pll.ctrl & BXT_DSI_PLL_RATIO_MASK; + +net/sunrpc/cache.c:420: error: DEAD_STORE + The value written to &ch is never used. + 418. + 419. if (current_detail && current_index < current_detail->hash_size) { + 420. > struct cache_head *ch = NULL; + 421. struct cache_detail *d; + 422. struct hlist_head *head; + +drivers/clk/clk-divider.c:389: error: DEAD_STORE + The value written to &flags is never used. + 387. struct clk_divider *divider = to_clk_divider(hw); + 388. int value; + 389. > unsigned long flags = 0; + 390. u32 val; + 391. + +drivers/video/console/vgacon.c:386: error: DEAD_STORE + The value written to &display_desc is never used. + 384. static const char *vgacon_startup(void) + 385. { + 386. > const char *display_desc = NULL; + 387. u16 saved1, saved2; + 388. volatile u16 *p; + +lib/kobject_uevent.c:389: error: DEAD_STORE + The value written to &devpath is never used. + 387. struct kobj_uevent_env *env; + 388. const char *action_string = kobject_actions[action]; + 389. > const char *devpath = NULL; + 390. const char *subsystem; + 391. struct kobject *top_kobj; + +lib/kobject_uevent.c:394: error: DEAD_STORE + The value written to &i is never used. + 392. struct kset *kset; + 393. const struct kset_uevent_ops *uevent_ops; + 394. > int i = 0; + 395. int retval = 0; + 396. + +lib/kobject_uevent.c:395: error: DEAD_STORE + The value written to &retval is never used. + 393. const struct kset_uevent_ops *uevent_ops; + 394. int i = 0; + 395. > int retval = 0; + 396. + 397. pr_debug("kobject: '%s' (%p): %s\n", + +net/xfrm/xfrm_policy.c:390: error: DEAD_STORE + The value written to &entry0 is never used. + 388. int dir) + 389. { + 390. > struct hlist_node *tmp, *entry0 = NULL; + 391. struct xfrm_policy *pol; + 392. unsigned int h0 = 0; + +net/xfrm/xfrm_policy.c:413: error: DEAD_STORE + The value written to &entry0 is never used. + 411. hlist_add_behind_rcu(&pol->bydst, entry0); + 412. } + 413. > entry0 = &pol->bydst; + 414. } + 415. if (!hlist_empty(list)) { + +net/xfrm/xfrm_policy.c:416: error: DEAD_STORE + The value written to &entry0 is never used. + 414. } + 415. if (!hlist_empty(list)) { + 416. > entry0 = NULL; + 417. goto redo; + 418. } + +net/xfrm/xfrm_policy.c:392: error: DEAD_STORE + The value written to &h0 is never used. + 390. struct hlist_node *tmp, *entry0 = NULL; + 391. struct xfrm_policy *pol; + 392. > unsigned int h0 = 0; + 393. u8 dbits; + 394. u8 sbits; + +net/xfrm/xfrm_policy.c:406: error: DEAD_STORE + The value written to &h0 is never used. + 404. hlist_del_rcu(&pol->bydst); + 405. hlist_add_head_rcu(&pol->bydst, ndsttable + h); + 406. > h0 = h; + 407. } else { + 408. if (h != h0) + +drivers/gpu/drm/drm_mm.c:387: error: DEAD_STORE + The value written to &end is never used. + 385. int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node) + 386. { + 387. > u64 end = node->start + node->size; + 388. struct drm_mm_node *hole; + 389. u64 hole_start, hole_end; + +kernel/cgroup/freezer.c:409: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 398 could be null and is dereferenced at line 409, column 10. + 407. else + 408. freezer_apply_state(pos_f, + 409. > parent->state & CGROUP_FREEZING, + 410. CGROUP_FREEZING_PARENT); + 411. + +drivers/scsi/sr.c:388: error: DEAD_STORE + The value written to &block is never used. + 386. static int sr_init_command(struct scsi_cmnd *SCpnt) + 387. { + 388. > int block = 0, this_count, s_size; + 389. struct scsi_cd *cd; + 390. struct request *rq = SCpnt->request; + +drivers/gpu/drm/i915/i915_gem_shrinker.c:392: error: DEAD_STORE + The value written to &timeout is never used. + 390. int timeout_ms) + 391. { + 392. > unsigned long timeout = jiffies + msecs_to_jiffies_timeout(timeout_ms); + 393. + 394. do { + +security/selinux/ss/avtab.c:489: error: DEAD_STORE + The value written to &items is never used. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +crypto/rsa-pkcs1pad.c:399: error: DEAD_STORE + The value written to &digest_size is never used. + 397. const struct rsa_asn1_template *digest_info = ictx->digest_info; + 398. int err; + 399. > unsigned int ps_end, digest_size = 0; + 400. + 401. if (!ctx->key_size) + +arch/x86/power/cpu.c:393: error: DEAD_STORE + The value written to &i is never used. + 391. static int msr_init_context(const u32 *msr_id, const int total_num) + 392. { + 393. > int i = 0; + 394. struct saved_msr *msr_array; + 395. + +net/wireless/trace.h:392: error: DEAD_STORE + The value written to &p is never used. + 390. ); + 391. + 392. > DECLARE_EVENT_CLASS(key_handle, + 393. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 394. bool pairwise, const u8 *mac_addr), + +drivers/md/dm-region-hash.c:399: error: DEAD_STORE + The value written to &recovering is never used. + 397. struct dm_region *reg; + 398. region_t region = dm_rh_bio_to_region(rh, bio); + 399. > int recovering = 0; + 400. + 401. if (bio->bi_opf & REQ_PREFLUSH) { + +arch/x86/lib/insn-eval.c:397: error: DEAD_STORE + The value written to ®no is never used. + 395. enum reg_type type) + 396. { + 397. > int regno = 0; + 398. + 399. static const int regoff[] = { + +net/sunrpc/xprtsock.c:397: error: DEAD_STORE + The value written to &err is never used. + 395. { + 396. unsigned int remainder = xdr->len - base; + 397. > int err = 0; + 398. int sent = 0; + 399. + +drivers/cpuidle/sysfs.c:398: error: DEAD_STORE + The value written to &ret is never used. + 396. static int cpuidle_add_state_sysfs(struct cpuidle_device *device) + 397. { + 398. > int i, ret = -ENOMEM; + 399. struct cpuidle_state_kobj *kobj; + 400. struct cpuidle_device_kobj *kdev = device->kobj_dev; + +drivers/gpu/drm/drm_agpsupport.c:398: error: DEAD_STORE + The value written to &head is never used. + 396. struct drm_agp_head *drm_agp_init(struct drm_device *dev) + 397. { + 398. > struct drm_agp_head *head = NULL; + 399. + 400. head = kzalloc(sizeof(*head), GFP_KERNEL); + +drivers/gpu/drm/i915/dvo_ivch.c:401: error: DEAD_STORE + The value written to &vr40 is never used. + 399. { + 400. struct ivch_priv *priv = dvo->dev_priv; + 401. > uint16_t vr40 = 0; + 402. uint16_t vr01 = 0; + 403. uint16_t vr10; + +drivers/input/mouse/byd.c:403: error: DEAD_STORE + The value written to &error is never used. + 401. static int byd_reconnect(struct psmouse *psmouse) + 402. { + 403. > int retry = 0, error = 0; + 404. + 405. psmouse_dbg(psmouse, "Reconnect\n"); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:530: error: DEAD_STORE + The value written to &icr is never used. + 528. + 529. /* Clear any pending interrupt events. */ + 530. > icr = er32(ICR); + 531. + 532. /* If MWI was previously enabled, reenable it. */ + +security/selinux/ss/conditional.c:406: error: DEAD_STORE + The value written to &expr is never used. + 404. u32 len, i; + 405. int rc; + 406. > struct cond_expr *expr = NULL, *last = NULL; + 407. + 408. rc = next_entry(buf, fp, sizeof(u32) * 2); + +kernel/taskstats.c:405: error: DEAD_STORE + The value written to &rc is never used. + 403. static int cgroupstats_user_cmd(struct sk_buff *skb, struct genl_info *info) + 404. { + 405. > int rc = 0; + 406. struct sk_buff *rep_skb; + 407. struct cgroupstats *stats; + +net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c:407: error: DEAD_STORE + The value written to &ret is never used. + 405. static int __init nf_conntrack_l3proto_ipv4_init(void) + 406. { + 407. > int ret = 0; + 408. + 409. need_conntrack(); + +net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c:407: error: DEAD_STORE + The value written to &ret is never used. + 405. static int __init nf_conntrack_l3proto_ipv6_init(void) + 406. { + 407. > int ret = 0; + 408. + 409. need_conntrack(); + +net/sunrpc/auth_gss/svcauth_gss.c:417: error: DEAD_STORE + The value written to &gm is never used. + 415. time_t expiry; + 416. int status = -EINVAL; + 417. > struct gss_api_mech *gm = NULL; + 418. + 419. memset(&rsci, 0, sizeof(rsci)); + +drivers/base/cpu.c:414: error: DEAD_STORE + The value written to &dev is never used. + 412. const char *fmt, va_list args) + 413. { + 414. > struct device *dev = NULL; + 415. int retval = -ENODEV; + 416. + +drivers/base/cpu.c:415: error: DEAD_STORE + The value written to &retval is never used. + 413. { + 414. struct device *dev = NULL; + 415. > int retval = -ENODEV; + 416. + 417. dev = kzalloc(sizeof(*dev), GFP_KERNEL); + +net/core/net-sysfs.c:415: error: DEAD_STORE + The value written to &ret is never used. + 413. const struct net_device *netdev = to_net_dev(dev); + 414. char tmp[IFALIASZ]; + 415. > ssize_t ret = 0; + 416. + 417. ret = dev_get_alias(netdev, tmp, sizeof(tmp)); + +lib/kfifo.c:419: error: DEAD_STORE + The value written to &recsize is never used. + 417. l = __KFIFO_PEEK(data, fifo->out, mask); + 418. + 419. > if (--recsize) + 420. l |= __KFIFO_PEEK(data, fifo->out + 1, mask) << 8; + 421. + +net/ipv6/ip6_output.c:497: error: DEAD_STORE + The value written to &target is never used. + 495. */ + 496. if (skb->dev == dst->dev && opt->srcrt == 0 && !skb_sec_path(skb)) { + 497. > struct in6_addr *target = NULL; + 498. struct inet_peer *peer; + 499. struct rt6_info *rt; + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &bytes is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &skip is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +kernel/audit_watch.c:420: error: DEAD_STORE + The value written to &ret is never used. + 418. struct audit_parent *parent; + 419. struct path parent_path; + 420. > int h, ret = 0; + 421. + 422. mutex_unlock(&audit_filter_mutex); + +drivers/cpufreq/acpi-cpufreq.c:423: error: DEAD_STORE + The value written to &next_perf_state is never used. + 421. struct acpi_processor_performance *perf; + 422. const struct cpumask *mask; + 423. > unsigned int next_perf_state = 0; /* Index into perf table */ + 424. int result = 0; + 425. + +net/netlabel/netlabel_domainhash.c:420: error: DEAD_STORE + The value written to &ret_val is never used. + 418. struct netlbl_audit *audit_info) + 419. { + 420. > int ret_val = 0; + 421. struct netlbl_dom_map *entry_old, *entry_b; + 422. struct netlbl_af4list *iter4; + +drivers/char/hpet.c:422: error: DEAD_STORE + The value written to &irq is never used. + 420. struct hpet_dev *devp; + 421. struct hpet_timer __iomem *timer; + 422. > int irq = 0; + 423. + 424. devp = file->private_data; + +drivers/scsi/scsi_scan.c:422: error: DEAD_STORE + The value written to &dev is never used. + 420. { + 421. struct Scsi_Host *shost = dev_to_shost(parent); + 422. > struct device *dev = NULL; + 423. unsigned long flags; + 424. const int size = sizeof(struct scsi_target) + +kernel/time/posix-cpu-timers.c:423: error: DEAD_STORE + The value written to &head is never used. + 421. cleanup_timers_list(head); + 422. cleanup_timers_list(++head); + 423. > cleanup_timers_list(++head); + 424. } + 425. + +net/ipv6/raw.c:430: error: NULL_DEREFERENCE + pointer `rp` last assigned on line 422 could be null and is dereferenced at line 430, column 7. + 428. } + 429. + 430. > if (!rp->checksum) + 431. skb->ip_summed = CHECKSUM_UNNECESSARY; + 432. + +net/ipv6/icmp.c:436: error: DEAD_STORE + The value written to &addr_type is never used. + 434. struct ipcm6_cookie ipc6; + 435. int iif = 0; + 436. > int addr_type = 0; + 437. int len; + 438. u32 mark = IP6_REPLY_MARK(net, skb->mark); + +net/ipv6/icmp.c:424: error: DEAD_STORE + The value written to &idev is never used. + 422. { + 423. struct net *net = dev_net(skb->dev); + 424. > struct inet6_dev *idev = NULL; + 425. struct ipv6hdr *hdr = ipv6_hdr(skb); + 426. struct sock *sk; + +net/ipv6/icmp.c:435: error: DEAD_STORE + The value written to &iif is never used. + 433. struct sockcm_cookie sockc_unused = {0}; + 434. struct ipcm6_cookie ipc6; + 435. > int iif = 0; + 436. int addr_type = 0; + 437. int len; + +crypto/jitterentropy.c:442: error: DEAD_STORE + The value written to &i is never used. + 440. */ + 441. union c mixer; + 442. > unsigned int i = 0; + 443. + 444. /* + +kernel/events/core.c:428: error: DEAD_STORE + The value written to &tmp is never used. + 426. tmp = div_u64(tmp, 100); + 427. if (!tmp) + 428. > tmp = 1; + 429. + 430. WRITE_ONCE(perf_sample_allowed_ns, tmp); + +drivers/gpu/drm/i915/intel_guc_ct.c:425: error: DEAD_STORE + The value written to &dev_priv is never used. + 423. int intel_guc_enable_ct(struct intel_guc *guc) + 424. { + 425. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 426. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 427. int err; + +block/blk-merge.c:445: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 430 could be null and is dereferenced at line 445, column 3. + 443. (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1; + 444. + 445. > sg->length += pad_len; + 446. rq->extra_len += pad_len; + 447. } + +block/blk-merge.c:453: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 430 could be null and is dereferenced by call to `sg_unmark_end()` at line 453, column 3. + 451. memset(q->dma_drain_buffer, 0, q->dma_drain_size); + 452. + 453. > sg_unmark_end(sg); + 454. sg = sg_next(sg); + 455. sg_set_page(sg, virt_to_page(q->dma_drain_buffer), + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:463: error: DEAD_STORE + The value written to &ret_val is never used. + 461. + 462. /* ...and verify the command was successful. */ + 463. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 464. + 465. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:437: error: DEAD_STORE + The value written to &p is never used. + 435. if (unlikely(p == NULL)) + 436. return -ENOSPC; + 437. > count = be32_to_cpup(p++); + 438. for (i = 0; i < count; i++) { + 439. gssx_dec_name_attr(xdr, &dummy); + +arch/x86/events/intel/pt.c:432: error: DEAD_STORE + The value written to &range is never used. + 430. struct pt_filters *filters = event->hw.addr_filters; + 431. struct pt *pt = this_cpu_ptr(&pt_ctx); + 432. > unsigned int range = 0; + 433. u64 rtit_ctl = 0; + 434. + +drivers/scsi/scsi_logging.c:476: error: DEAD_STORE + The value written to &off is never used. + 474. + 475. if (db_string) + 476. > off += scnprintf(logbuf + off, logbuf_len - off, + 477. "driverbyte=%s", db_string); + 478. else + +drivers/scsi/scsi_logging.c:479: error: DEAD_STORE + The value written to &off is never used. + 477. "driverbyte=%s", db_string); + 478. else + 479. > off += scnprintf(logbuf + off, logbuf_len - off, + 480. "driverbyte=0x%02x", driver_byte(cmd->result)); + 481. out_printk: + +drivers/gpu/drm/i915/intel_dsi_pll.c:435: error: DEAD_STORE + The value written to &dsi_rate is never used. + 433. struct drm_i915_private *dev_priv = to_i915(dev); + 434. u32 tmp; + 435. > u32 dsi_rate = 0; + 436. u32 pll_ratio = 0; + 437. u32 rx_div; + +drivers/gpu/drm/i915/intel_dsi_pll.c:436: error: DEAD_STORE + The value written to &pll_ratio is never used. + 434. u32 tmp; + 435. u32 dsi_rate = 0; + 436. > u32 pll_ratio = 0; + 437. u32 rx_div; + 438. u32 tx_div; + +net/netfilter/nf_log.c:436: error: DEAD_STORE + The value written to &r is never used. + 434. const struct nf_logger *logger; + 435. char buf[NFLOGGER_NAME_LEN]; + 436. > int r = 0; + 437. int tindex = (unsigned long)table->extra1; + 438. struct net *net = table->extra2; + +drivers/md/dm-stripe.c:437: error: DEAD_STORE + The value written to &ret is never used. + 435. { + 436. struct stripe_c *sc = ti->private; + 437. > int ret = 0; + 438. unsigned i = 0; + 439. + +kernel/events/hw_breakpoint.c:438: error: DEAD_STORE + The value written to &err is never used. + 436. u64 old_len = bp->attr.bp_len; + 437. int old_type = bp->attr.bp_type; + 438. > int err = 0; + 439. + 440. /* + +kernel/irq/irqdesc.c:436: error: DEAD_STORE + The value written to &mask is never used. + 434. const struct cpumask *affinity, struct module *owner) + 435. { + 436. > const struct cpumask *mask = NULL; + 437. struct irq_desc *desc; + 438. unsigned int flags; + +net/wireless/trace.h:433: error: DEAD_STORE + The value written to &p is never used. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +drivers/cpuidle/sysfs.c:441: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 438 could be null and is dereferenced at line 441, column 18. + 439. int i; + 440. + 441. > for (i = 0; i < drv->state_count; i++) + 442. cpuidle_free_state_kobj(device, i); + 443. } + +net/ipv4/fib_semantics.c:441: error: DEAD_STORE + The value written to &state is never used. + 439. { + 440. struct neighbour *n; + 441. > int state = NUD_NONE; + 442. + 443. n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev); + +kernel/cgroup/freezer.c:442: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 440 could be null and is dereferenced at line 442, column 16. + 440. struct freezer *freezer = css_freezer(css); + 441. + 442. > return (bool)(freezer->state & CGROUP_FREEZING_SELF); + 443. } + 444. + +drivers/gpu/drm/drm_property.c:444: error: DEAD_STORE + The value written to &value_count is never used. + 442. struct drm_property *property; + 443. int enum_count = 0; + 444. > int value_count = 0; + 445. int i, copied; + 446. struct drm_property_enum *prop_enum; + +drivers/gpu/drm/i915/intel_hdmi.c:459: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 443 could be null and is dereferenced at line 459, column 2. + 457. len++; + 458. + 459. > intel_dig_port->write_infoframe(encoder, crtc_state, frame->any.type, buffer, len); + 460. } + 461. + +kernel/auditfilter.c:442: error: DEAD_STORE + The value written to &err is never used. + 440. size_t datasz) + 441. { + 442. > int err = 0; + 443. struct audit_entry *entry; + 444. void *bufp; + +drivers/gpu/drm/i915/intel_bios.c:445: error: DEAD_STORE + The value written to &count is never used. + 443. struct sdvo_device_mapping *mapping; + 444. const struct child_device_config *child; + 445. > int i, count = 0; + 446. + 447. /* + +drivers/hid/usbhid/hiddev.c:444: error: DEAD_STORE + The value written to &uref_multi is never used. + 442. struct hid_device *hid = hiddev->hid; + 443. struct hiddev_report_info rinfo; + 444. > struct hiddev_usage_ref_multi *uref_multi = NULL; + 445. struct hiddev_usage_ref *uref; + 446. struct hid_report *report; + +net/netfilter/nf_conntrack_helper.c:449: error: NULL_DEREFERENCE + pointer `help` last assigned on line 442 could be null and is dereferenced at line 449, column 9. + 447. return true; + 448. + 449. > this = rcu_dereference_protected(help->helper, + 450. lockdep_is_held(&nf_conntrack_expect_lock)); + 451. return this == me; + +kernel/relay.c:443: error: DEAD_STORE + The value written to &buf is never used. + 441. static struct rchan_buf *relay_open_buf(struct rchan *chan, unsigned int cpu) + 442. { + 443. > struct rchan_buf *buf = NULL; + 444. struct dentry *dentry; + 445. + +net/xfrm/xfrm_policy.c:456: error: DEAD_STORE + The value written to &odst is never used. + 454. write_seqcount_begin(&xfrm_policy_hash_generation); + 455. + 456. > odst = rcu_dereference_protected(net->xfrm.policy_bydst[dir].table, + 457. lockdep_is_held(&net->xfrm.xfrm_policy_lock)); + 458. + +kernel/power/swap.c:445: error: DEAD_STORE + The value written to &error is never used. + 443. struct hib_bio_batch *hb) + 444. { + 445. > int error = 0; + 446. sector_t offset; + 447. + +crypto/api.c:447: error: DEAD_STORE + The value written to &tfm is never used. + 445. { + 446. char *mem; + 447. > struct crypto_tfm *tfm = NULL; + 448. unsigned int tfmsize; + 449. unsigned int total; + +net/ipv6/seg6.c:445: error: DEAD_STORE + The value written to &err is never used. + 443. int __init seg6_init(void) + 444. { + 445. > int err = -ENOMEM; + 446. + 447. err = genl_register_family(&seg6_genl_family); + +net/netfilter/nf_conntrack_proto.c:447: error: DEAD_STORE + The value written to &pn is never used. + 445. { + 446. int ret = 0; + 447. > struct nf_proto_net *pn = NULL; + 448. + 449. if (l4proto->init_net) { + +kernel/cgroup/freezer.c:450: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 448 could be null and is dereferenced at line 450, column 16. + 448. struct freezer *freezer = css_freezer(css); + 449. + 450. > return (bool)(freezer->state & CGROUP_FREEZING_PARENT); + 451. } + 452. + +drivers/gpu/drm/i915/intel_guc_ct.c:448: error: DEAD_STORE + The value written to &dev_priv is never used. + 446. void intel_guc_disable_ct(struct intel_guc *guc) + 447. { + 448. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 449. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 450. + +drivers/mailbox/pcc.c:454: error: DEAD_STORE + The value written to &status is never used. + 452. int count, i, rc; + 453. int sum = 0; + 454. > acpi_status status = AE_OK; + 455. + 456. /* Search for PCCT */ + +drivers/gpu/drm/i915/intel_sdvo.c:457: error: DEAD_STORE + The value written to &ret is never used. + 455. u8 *buf, status; + 456. struct i2c_msg *msgs; + 457. > int i, ret = true; + 458. + 459. /* Would be simpler to allocate both in one go ? */ + +net/sunrpc/auth.c:456: error: DEAD_STORE + The value written to &expired is never used. + 454. spinlock_t *cache_lock; + 455. struct rpc_cred *cred, *next; + 456. > unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; + 457. long freed = 0; + 458. + +net/sunrpc/auth.c:461: error: DEAD_STORE + The value written to &nr_to_scan is never used. + 459. list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { + 460. + 461. > if (nr_to_scan-- == 0) + 462. break; + 463. /* + +sound/core/seq/seq_queue.c:454: error: DEAD_STORE + The value written to &result is never used. + 452. int snd_seq_queue_timer_open(int queueid) + 453. { + 454. > int result = 0; + 455. struct snd_seq_queue *queue; + 456. struct snd_seq_timer *tmr; + +net/sunrpc/clnt.c:456: error: DEAD_STORE + The value written to &clnt is never used. + 454. struct rpc_xprt *xprt) + 455. { + 456. > struct rpc_clnt *clnt = NULL; + 457. struct rpc_xprt_switch *xps; + 458. + +drivers/gpu/drm/drm_plane.c:466: error: DEAD_STORE + The value written to &config is never used. + 464. return -EINVAL; + 465. + 466. > config = &dev->mode_config; + 467. plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr); + 468. + +security/keys/request_key.c:491: error: DEAD_STORE + The value written to &ret is never used. + 489. } + 490. } else if (ret == -EINPROGRESS) { + 491. > ret = 0; + 492. } else { + 493. goto error_put_dest_keyring; + +lib/kobject.c:458: error: DEAD_STORE + The value written to &devpath is never used. + 456. { + 457. int error = 0; + 458. > const char *devpath = NULL; + 459. const char *dup_name = NULL, *name; + 460. char *devpath_string = NULL; + +lib/kobject.c:457: error: DEAD_STORE + The value written to &error is never used. + 455. int kobject_rename(struct kobject *kobj, const char *new_name) + 456. { + 457. > int error = 0; + 458. const char *devpath = NULL; + 459. const char *dup_name = NULL, *name; + +lib/swiotlb.c:466: error: DEAD_STORE + The value written to &sz is never used. + 464. unsigned int offset = orig_addr & ~PAGE_MASK; + 465. char *buffer; + 466. > unsigned int sz = 0; + 467. unsigned long flags; + 468. + +drivers/i2c/i2c-core-acpi.c:463: error: DEAD_STORE + The value written to &ret is never used. + 461. struct i2c_msg msgs[1]; + 462. u8 *buffer; + 463. > int ret = AE_OK; + 464. + 465. buffer = kzalloc(data_len + 1, GFP_KERNEL); + +net/wireless/trace.h:457: error: DEAD_STORE + The value written to &p is never used. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +drivers/base/regmap/regcache.c:470: error: DEAD_STORE + The value written to &ret is never used. + 468. unsigned int max) + 469. { + 470. > int ret = 0; + 471. + 472. if (!map->cache_ops || !map->cache_ops->drop) + +drivers/net/ethernet/intel/e1000e/phy.c:473: error: DEAD_STORE + The value written to &ret_val is never used. + 471. + 472. if (!locked) { + 473. > s32 ret_val = 0; + 474. + 475. if (!hw->phy.ops.acquire) + +drivers/usb/core/devices.c:480: error: DEAD_STORE + The value written to &childdev is never used. + 478. unsigned int length; + 479. ssize_t total_written = 0; + 480. > struct usb_device *childdev = NULL; + 481. + 482. /* don't bother with anything else if we're not writing any data */ + +net/ipv4/tcp_fastopen.c:475: error: DEAD_STORE + The value written to &tfo_bh_timeout is never used. + 473. bool tcp_fastopen_active_should_disable(struct sock *sk) + 474. { + 475. > unsigned int tfo_bh_timeout = sock_net(sk)->ipv4.sysctl_tcp_fastopen_blackhole_timeout; + 476. int tfo_da_times = atomic_read(&sock_net(sk)->ipv4.tfo_active_disable_times); + 477. unsigned long timeout; + +net/xfrm/xfrm_state.c:480: error: DEAD_STORE + The value written to &err is never used. + 478. long next = LONG_MAX; + 479. int warn = 0; + 480. > int err = 0; + 481. + 482. spin_lock(&x->lock); + +net/wireless/trace.h:474: error: DEAD_STORE + The value written to &p is never used. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +crypto/jitterentropy.c:483: error: DEAD_STORE + The value written to &data is never used. + 481. + 482. while (1) { + 483. > __u64 data = 0; + 484. + 485. if (ec->disable_unbias == 1) + +drivers/pci/access.c:482: error: DEAD_STORE + The value written to &ret is never used. + 480. const u8 *buf = arg; + 481. loff_t end = pos + count; + 482. > int ret = 0; + 483. + 484. if (pos < 0 || (pos & 3) || (count & 3)) + +drivers/base/bus.c:480: error: DEAD_STORE + The value written to &error is never used. + 478. { + 479. struct bus_type *bus = bus_get(dev->bus); + 480. > int error = 0; + 481. + 482. if (bus) { + +arch/x86/platform/efi/efi.c:482: error: DEAD_STORE + The value written to &i is never used. + 480. efi_char16_t *c16; + 481. char vendor[100] = "unknown"; + 482. > int i = 0; + 483. void *tmp; + 484. + +drivers/cpuidle/cpuidle.c:484: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 482 could be null and is dereferenced at line 484, column 22. + 482. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 483. + 484. > if (!try_module_get(drv->owner)) + 485. return -EINVAL; + 486. + +net/ipv6/exthdrs.c:496: error: DEAD_STORE + The value written to &accept_source_route is never used. + 494. idev = __in6_dev_get(skb->dev); + 495. if (idev && accept_source_route > idev->cnf.accept_source_route) + 496. > accept_source_route = idev->cnf.accept_source_route; + 497. + 498. if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) || + +net/ipv6/exthdrs.c:485: error: DEAD_STORE + The value written to &addr is never used. + 483. { + 484. struct inet6_skb_parm *opt = IP6CB(skb); + 485. > struct in6_addr *addr = NULL; + 486. struct in6_addr daddr; + 487. struct inet6_dev *idev; + +drivers/hid/hid-debug.c:486: error: DEAD_STORE + The value written to &buf is never used. + 484. char *hid_resolv_usage(unsigned usage, struct seq_file *f) { + 485. const struct hid_usage_entry *p; + 486. > char *buf = NULL; + 487. int len = 0; + 488. + +drivers/i2c/i2c-core-smbus.c:506: error: DEAD_STORE + The value written to &orig_jiffies is never used. + 504. + 505. /* Retry automatically on arbitration loss */ + 506. > orig_jiffies = jiffies; + 507. for (res = 0, try = 0; try <= adapter->retries; try++) { + 508. res = adapter->algo->smbus_xfer(adapter, addr, flags, + +drivers/pcmcia/pcmcia_resource.c:493: error: DEAD_STORE + The value written to &option is never used. + 491. unsigned char status = 0; + 492. unsigned char ext_status = 0; + 493. > unsigned char option = 0; + 494. unsigned int flags = p_dev->config_flags; + 495. + +drivers/gpu/drm/i915/intel_cdclk.c:511: error: DEAD_STORE + The value written to &timeout__ is never used. + 509. val |= (cmd << DSPFREQGUAR_SHIFT); + 510. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 511. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 512. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 513. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:532: error: DEAD_STORE + The value written to &timeout__ is never used. + 530. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 531. + 532. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 533. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 534. 50)) + +kernel/trace/blktrace.c:490: error: DEAD_STORE + The value written to &bt is never used. + 488. struct blk_user_trace_setup *buts) + 489. { + 490. > struct blk_trace *bt = NULL; + 491. struct dentry *dir = NULL; + 492. int ret; + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:525: error: DEAD_STORE + The value written to &ret_val is never used. + 523. * only the first byte of the word is being modified + 524. */ + 525. > ret_val = e1000_read_eeprom(hw, last_word, 1, + 526. &eeprom_buff[last_word - first_word]); + 527. } + +net/sunrpc/cache.c:492: error: DEAD_STORE + The value written to &ch is never used. + 490. void cache_purge(struct cache_detail *detail) + 491. { + 492. > struct cache_head *ch = NULL; + 493. struct hlist_head *head = NULL; + 494. struct hlist_node *tmp = NULL; + +net/sunrpc/cache.c:493: error: DEAD_STORE + The value written to &head is never used. + 491. { + 492. struct cache_head *ch = NULL; + 493. > struct hlist_head *head = NULL; + 494. struct hlist_node *tmp = NULL; + 495. int i = 0; + +net/sunrpc/cache.c:495: error: DEAD_STORE + The value written to &i is never used. + 493. struct hlist_head *head = NULL; + 494. struct hlist_node *tmp = NULL; + 495. > int i = 0; + 496. + 497. write_lock(&detail->hash_lock); + +net/sunrpc/cache.c:494: error: DEAD_STORE + The value written to &tmp is never used. + 492. struct cache_head *ch = NULL; + 493. struct hlist_head *head = NULL; + 494. > struct hlist_node *tmp = NULL; + 495. int i = 0; + 496. + +block/blk-core.c:531: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 531, column 33. + 529. */ + 530. if (drain_all) { + 531. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 532. drain |= !list_empty(&q->queue_head); + 533. for (i = 0; i < 2; i++) { + +drivers/firmware/dmi_scan.c:511: error: DEAD_STORE + The value written to &c is never used. + 509. dmi_get_system_info(DMI_BIOS_VERSION)); + 510. c += scnprintf(buf + c, len - c, " "); + 511. > c += print_filtered(buf + c, len - c, + 512. dmi_get_system_info(DMI_BIOS_DATE)); + 513. } + +drivers/gpu/drm/drm_lease.c:504: error: DEAD_STORE + The value written to &fd is never used. + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + 504. > int fd = -1; + 505. uint32_t *object_ids; + 506. + +drivers/gpu/drm/drm_lease.c:500: error: DEAD_STORE + The value written to &lessee is never used. + 498. struct idr leases; + 499. struct drm_master *lessor = lessor_priv->master; + 500. > struct drm_master *lessee = NULL; + 501. struct file *lessee_file = NULL; + 502. struct file *lessor_file = lessor_priv->filp; + +drivers/gpu/drm/drm_lease.c:501: error: DEAD_STORE + The value written to &lessee_file is never used. + 499. struct drm_master *lessor = lessor_priv->master; + 500. struct drm_master *lessee = NULL; + 501. > struct file *lessee_file = NULL; + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + +drivers/gpu/drm/drm_lease.c:497: error: DEAD_STORE + The value written to &ret is never used. + 495. struct drm_mode_create_lease *cl = data; + 496. size_t object_count; + 497. > int ret = 0; + 498. struct idr leases; + 499. struct drm_master *lessor = lessor_priv->master; + +drivers/gpu/drm/i915/intel_crt.c:498: error: DEAD_STORE + The value written to &tries is never used. + 496. u32 stat; + 497. bool ret = false; + 498. > int i, tries = 0; + 499. + 500. if (HAS_PCH_SPLIT(dev_priv)) + +drivers/gpu/drm/i915/i915_guc_submission.c:509: error: DEAD_STORE + The value written to &count is never used. + 507. rq = port_unpack(&port[n], &count); + 508. if (rq && count == 0) { + 509. > port_set(&port[n], port_pack(rq, ++count)); + 510. + 511. if (i915_vma_is_map_and_fenceable(rq->ring->vma)) + +drivers/pci/pcie/aer/aerdrv_core.c:495: error: DEAD_STORE + The value written to &result is never used. + 493. static void do_recovery(struct pci_dev *dev, int severity) + 494. { + 495. > pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED; + 496. enum pci_channel_state state; + 497. + +tools/lib/subcmd/parse-options.c:544: error: NULL_DEREFERENCE + pointer `*ctx->argv[0]` last assigned on line 543 could be null and is dereferenced at line 544, column 6. + 542. */ + 543. ctx->argv[0] = strdup(ctx->opt - 1); + 544. > *(char *)ctx->argv[0] = '-'; + 545. goto unknown; + 546. case -3: + +kernel/locking/rwsem-xadd.c:504: error: DEAD_STORE + The value written to &count is never used. + 502. + 503. /* undo write bias from down_write operation, stop active locking */ + 504. > count = atomic_long_sub_return(RWSEM_ACTIVE_WRITE_BIAS, &sem->count); + 505. + 506. /* do optimistic spinning and steal lock if possible */ + +net/ipv6/addrlabel.c:502: error: DEAD_STORE + The value written to &err is never used. + 500. struct in6_addr *addr; + 501. u32 lseq; + 502. > int err = 0; + 503. struct ip6addrlbl_entry *p; + 504. struct sk_buff *skb; + +security/selinux/hooks.c:499: error: DEAD_STORE + The value written to &rc is never used. + 497. struct dentry *root = sb->s_root; + 498. struct inode *root_inode = d_backing_inode(root); + 499. > int rc = 0; + 500. + 501. if (sbsec->behavior == SECURITY_FS_USE_XATTR) { + +kernel/sched/deadline.c:497: error: DEAD_STORE + The value written to &later_rq is never used. + 495. static struct rq *dl_task_offline_migration(struct rq *rq, struct task_struct *p) + 496. { + 497. > struct rq *later_rq = NULL; + 498. + 499. later_rq = find_lock_later_rq(p, rq); + +block/partition-generic.c:504: error: DEAD_STORE + The value written to &state is never used. + 502. if (state && !IS_ERR(state)) { + 503. free_partitions(state); + 504. > state = NULL; + 505. } + 506. + +kernel/rcu/srcutree.c:531: error: DEAD_STORE + The value written to &idxnext is never used. + 529. /* Initiate callback invocation as needed. */ + 530. idx = rcu_seq_ctr(gpseq) % ARRAY_SIZE(snp->srcu_have_cbs); + 531. > idxnext = (idx + 1) % ARRAY_SIZE(snp->srcu_have_cbs); + 532. rcu_for_each_node_breadth_first(sp, snp) { + 533. raw_spin_lock_irq_rcu_node(snp); + +net/ipv6/ndisc.c:518: error: DEAD_STORE + The value written to &override is never used. + 516. src_addr = solicited_addr; + 517. if (ifp->flags & IFA_F_OPTIMISTIC) + 518. > override = false; + 519. inc_opt |= ifp->idev->cnf.force_tllao; + 520. in6_ifa_put(ifp); + +drivers/gpu/drm/i915/intel_pipe_crc.c:517: error: DEAD_STORE + The value written to &ret is never used. + 515. struct drm_atomic_state *state; + 516. struct drm_modeset_acquire_ctx ctx; + 517. > int ret = 0; + 518. + 519. drm_modeset_acquire_init(&ctx, 0); + +block/blk-mq-sched.c:512: error: DEAD_STORE + The value written to &set is never used. + 510. static void blk_mq_sched_tags_teardown(struct request_queue *q) + 511. { + 512. > struct blk_mq_tag_set *set = q->tag_set; + 513. struct blk_mq_hw_ctx *hctx; + 514. int i; + +drivers/gpu/drm/drm_prime.c:516: error: DEAD_STORE + The value written to &ret is never used. + 514. { + 515. struct drm_gem_object *obj; + 516. > int ret = 0; + 517. struct dma_buf *dmabuf; + 518. + +net/socket.c:534: error: DEAD_STORE + The value written to &buffer is never used. + 532. return -ERANGE; + 533. memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len); + 534. > buffer += len; + 535. } + 536. + +lib/bitmap.c:525: error: DEAD_STORE + The value written to &group_size is never used. + 523. totaldigits = c = 0; + 524. old_a = old_b = 0; + 525. > group_size = used_size = 0; + 526. bitmap_zero(maskp, nmaskbits); + 527. do { + +drivers/gpu/drm/drm_crtc_helper.c:524: error: DEAD_STORE + The value written to &count is never used. + 522. struct drm_connector *connector; + 523. struct drm_connector_list_iter conn_iter; + 524. > int count = 0, ro, fail = 0; + 525. const struct drm_crtc_helper_funcs *crtc_funcs; + 526. struct drm_mode_set save_set; + +drivers/gpu/drm/drm_crtc_helper.c:632: error: DEAD_STORE + The value written to &count is never used. + 630. + 631. /* a) traverse passed in connector list and get encoders for them */ + 632. > count = 0; + 633. drm_connector_list_iter_begin(dev, &conn_iter); + 634. drm_for_each_connector_iter(connector, &conn_iter) { + +drivers/gpu/drm/drm_crtc_helper.c:674: error: DEAD_STORE + The value written to &count is never used. + 672. } + 673. + 674. > count = 0; + 675. drm_connector_list_iter_begin(dev, &conn_iter); + 676. drm_for_each_connector_iter(connector, &conn_iter) { + +net/ipv6/ip6_flowlabel.c:520: error: DEAD_STORE + The value written to &sfl1 is never used. + 518. struct ipv6_pinfo *np = inet6_sk(sk); + 519. struct in6_flowlabel_req freq; + 520. > struct ipv6_fl_socklist *sfl1 = NULL; + 521. struct ipv6_fl_socklist *sfl; + 522. struct ipv6_fl_socklist __rcu **sflp; + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &p is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &ret is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +lib/kobject.c:521: error: DEAD_STORE + The value written to &devpath is never used. + 519. int error; + 520. struct kobject *old_parent; + 521. > const char *devpath = NULL; + 522. char *devpath_string = NULL; + 523. char *envp[2]; + +lib/rhashtable.c:550: error: DEAD_STORE + The value written to &head is never used. + 548. + 549. RCU_INIT_POINTER(list->next, plist); + 550. > head = rht_dereference_bucket(head->next, tbl, hash); + 551. RCU_INIT_POINTER(list->rhead.next, head); + 552. rcu_assign_pointer(*pprev, obj); + +lib/rhashtable.c:547: error: DEAD_STORE + The value written to &plist is never used. + 545. + 546. list = container_of(obj, struct rhlist_head, rhead); + 547. > plist = container_of(head, struct rhlist_head, rhead); + 548. + 549. RCU_INIT_POINTER(list->next, plist); + +include/net/sock.h:525: error: DEAD_STORE + The value written to &off is never used. + 523. + 524. if (unlikely(off >= 0)) { + 525. > off = max_t(s32, off - val, 0); + 526. WRITE_ONCE(sk->sk_peek_off, off); + 527. } + +block/blk-flush.c:526: error: DEAD_STORE + The value written to &ret is never used. + 524. struct request_queue *q; + 525. struct bio *bio; + 526. > int ret = 0; + 527. + 528. if (bdev->bd_disk == NULL) + +drivers/ata/libata-transport.c:527: error: DEAD_STORE + The value written to &i is never used. + 525. { + 526. struct ata_device *ata_dev = transport_class_to_dev(dev); + 527. > int written = 0, i = 0; + 528. + 529. if (ata_dev->class == ATA_DEV_PMP) + +kernel/profile.c:532: error: DEAD_STORE + The value written to &err is never used. + 530. #endif + 531. + 532. > int err = 0; + 533. + 534. if (!prof_on) + +drivers/gpu/drm/i915/intel_hdmi.c:539: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 535 could be null and is dereferenced at line 539, column 13. + 537. i915_reg_t reg = VIDEO_DIP_CTL; + 538. u32 val = I915_READ(reg); + 539. > u32 port = VIDEO_DIP_PORT(intel_dig_port->port); + 540. + 541. assert_hdmi_port_disabled(intel_hdmi); + +tools/objtool/elf.c:533: error: DEAD_STORE + The value written to &idx is never used. + 531. { + 532. struct rela *rela; + 533. > int nr, idx = 0, size; + 534. GElf_Rela *relas; + 535. + +drivers/input/evdev.c:537: error: DEAD_STORE + The value written to &retval is never used. + 535. struct evdev *evdev = client->evdev; + 536. struct input_event event; + 537. > int retval = 0; + 538. + 539. if (count != 0 && count < input_event_size()) + +drivers/usb/host/ehci-sched.c:552: error: DEAD_STORE + The value written to &type is never used. + 550. __hc32 *hw_p = &ehci->periodic[i]; + 551. union ehci_shadow here = *prev; + 552. > __hc32 type = 0; + 553. + 554. /* skip the iso nodes at list head */ + +security/keys/process_keys.c:710: error: DEAD_STORE + The value written to &ret is never used. + 708. * the permission checks as it is only concerned with the keyring */ + 709. if (lflags & KEY_LOOKUP_FOR_UNLINK) { + 710. > ret = 0; + 711. goto error; + 712. } + +net/sunrpc/sched.c:538: error: DEAD_STORE + The value written to &task is never used. + 536. bool (*func)(struct rpc_task *, void *), void *data) + 537. { + 538. > struct rpc_task *task = NULL; + 539. + 540. dprintk("RPC: wake_up_first(%p \"%s\")\n", + +drivers/gpu/drm/i915/intel_fbdev.c:634: error: DEAD_STORE + The value written to &intel_crtc is never used. + 632. /* Final pass to check if any active pipes don't have fbs */ + 633. for_each_crtc(dev, crtc) { + 634. > intel_crtc = to_intel_crtc(crtc); + 635. + 636. if (!crtc->state->active) + +net/core/dev_addr_lists.c:539: error: DEAD_STORE + The value written to &err is never used. + 537. int dev_uc_sync(struct net_device *to, struct net_device *from) + 538. { + 539. > int err = 0; + 540. + 541. if (to->addr_len != from->addr_len) + +drivers/net/ethernet/intel/e1000e/phy.c:546: error: DEAD_STORE + The value written to &ret_val is never used. + 544. + 545. if (!locked) { + 546. > s32 ret_val = 0; + 547. + 548. if (!hw->phy.ops.acquire) + +drivers/ata/libata-transport.c:546: error: DEAD_STORE + The value written to &i is never used. + 544. { + 545. struct ata_device *ata_dev = transport_class_to_dev(dev); + 546. > int written = 0, i = 0; + 547. + 548. if (ata_dev->class != ATA_DEV_PMP) + +drivers/iommu/dmar.c:544: error: DEAD_STORE + The value written to &status is never used. + 542. static int __init dmar_table_detect(void) + 543. { + 544. > acpi_status status = AE_OK; + 545. + 546. /* if we could find DMAR table, then there are DMAR devices */ + +net/sched/act_api.c:545: error: DEAD_STORE + The value written to &err is never used. + 543. tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) + 544. { + 545. > int err = -EINVAL; + 546. unsigned char *b = skb_tail_pointer(skb); + 547. struct nlattr *nest; + +net/netfilter/nf_conntrack_ftp.c:557: error: NULL_DEREFERENCE + pointer `ftp` last assigned on line 551 could be null and is dereferenced at line 557, column 2. + 555. * failover breaks. + 556. */ + 557. > ftp->flags[IP_CT_DIR_ORIGINAL] |= NF_CT_FTP_SEQ_PICKUP; + 558. ftp->flags[IP_CT_DIR_REPLY] |= NF_CT_FTP_SEQ_PICKUP; + 559. return 0; + +net/packet/af_packet.c:554: error: DEAD_STORE + The value written to &mbits is never used. + 552. { + 553. struct net_device *dev; + 554. > unsigned int mbits = 0, msec = 0, div = 0, tmo = 0; + 555. struct ethtool_link_ksettings ecmd; + 556. int err; + +net/packet/af_packet.c:554: error: DEAD_STORE + The value written to &tmo is never used. + 552. { + 553. struct net_device *dev; + 554. > unsigned int mbits = 0, msec = 0, div = 0, tmo = 0; + 555. struct ethtool_link_ksettings ecmd; + 556. int err; + +drivers/base/dd.c:553: error: DEAD_STORE + The value written to &ret is never used. + 551. int driver_probe_device(struct device_driver *drv, struct device *dev) + 552. { + 553. > int ret = 0; + 554. + 555. if (!device_is_registered(dev)) + +security/selinux/ss/services.c:563: error: DEAD_STORE + The value written to &masked is never used. + 561. struct type_datum *source; + 562. struct type_datum *target; + 563. > u32 masked = 0; + 564. + 565. source = flex_array_get_ptr(policydb.type_val_to_struct_array, + +drivers/gpu/drm/drm_bufs.c:568: error: DEAD_STORE + The value written to &r_list is never used. + 566. if (r_list->master == master) { + 567. drm_legacy_rmmap_locked(dev, r_list->map); + 568. > r_list = NULL; + 569. } + 570. } + +drivers/input/mouse/alps.c:586: error: DEAD_STORE + The value written to &z is never used. + 584. x = (s8)(((packet[0] & 0x20) << 2) | (packet[1] & 0x7f)); + 585. y = (s8)(((packet[0] & 0x10) << 3) | (packet[2] & 0x7f)); + 586. > z = (packet[4] & 0x7c) >> 2; + 587. + 588. /* + +kernel/exit.c:565: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 564 could be null and is dereferenced at line 565, column 31. + 563. { + 564. struct pid_namespace *pid_ns = task_active_pid_ns(father); + 565. > struct task_struct *reaper = pid_ns->child_reaper; + 566. + 567. if (likely(reaper != father)) + +drivers/gpu/drm/i915/intel_cdclk.c:598: error: DEAD_STORE + The value written to &timeout__ is never used. + 596. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 597. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 598. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 599. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 600. 50)) { + +net/core/sock.c:564: error: DEAD_STORE + The value written to &ret is never used. + 562. int optlen) + 563. { + 564. > int ret = -ENOPROTOOPT; + 565. #ifdef CONFIG_NETDEVICES + 566. struct net *net = sock_net(sk); + +net/wireless/trace.h:561: error: DEAD_STORE + The value written to &p is never used. + 559. ); + 560. + 561. > DECLARE_EVENT_CLASS(wiphy_netdev_evt, + 562. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 563. TP_ARGS(wiphy, netdev), + +drivers/mailbox/pcc.c:564: error: DEAD_STORE + The value written to &ret is never used. + 562. static int pcc_mbox_probe(struct platform_device *pdev) + 563. { + 564. > int ret = 0; + 565. + 566. pcc_mbox_ctrl.chans = pcc_mbox_channels; + +lib/rhashtable.c:596: error: DEAD_STORE + The value written to &head is never used. + 594. return ERR_PTR(-ENOMEM); + 595. + 596. > head = rht_dereference_bucket(*pprev, tbl, hash); + 597. + 598. RCU_INIT_POINTER(obj->next, head); + +net/core/dev_addr_lists.c:569: error: DEAD_STORE + The value written to &err is never used. + 567. int dev_uc_sync_multiple(struct net_device *to, struct net_device *from) + 568. { + 569. > int err = 0; + 570. + 571. if (to->addr_len != from->addr_len) + +drivers/gpu/drm/drm_plane.c:578: error: DEAD_STORE + The value written to &ret is never used. + 576. struct drm_modeset_acquire_ctx *ctx) + 577. { + 578. > int ret = 0; + 579. + 580. /* No fb means shut it down */ + +arch/x86/events/intel/rapl.c:578: error: NULL_DEREFERENCE + pointer `pmu` last assigned on line 571 could be null and is dereferenced at line 578, column 2. + 576. return 0; + 577. + 578. > pmu->cpu = -1; + 579. /* Find a new cpu to collect rapl events */ + 580. target = cpumask_any_but(topology_core_cpumask(cpu), cpu); + +net/netfilter/nf_conntrack_proto.c:581: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 574 could be null and is dereferenced by call to `nf_ct_l4proto_register_sysctl()` at line 581, column 8. + 579. if (err < 0) + 580. return err; + 581. > err = nf_ct_l4proto_register_sysctl(net, + 582. pn, + 583. &nf_conntrack_l4proto_generic); + +drivers/char/hw_random/core.c:576: error: DEAD_STORE + The value written to &ret is never used. + 574. static int __init hwrng_modinit(void) + 575. { + 576. > int ret = -ENOMEM; + 577. + 578. /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ + +net/sched/act_api.c:578: error: DEAD_STORE + The value written to &err is never used. + 576. { + 577. struct tc_action *a; + 578. > int err = -EINVAL; + 579. struct nlattr *nest; + 580. + +security/selinux/hooks.c:578: error: DEAD_STORE + The value written to &rc is never used. + 576. struct security_mnt_opts *opts) + 577. { + 578. > int rc = 0, i; + 579. struct superblock_security_struct *sbsec = sb->s_security; + 580. char *context = NULL; + +net/netfilter/nf_conntrack_ftp.c:578: error: DEAD_STORE + The value written to &ret is never used. + 576. static int __init nf_conntrack_ftp_init(void) + 577. { + 578. > int i, ret = 0; + 579. + 580. NF_CT_HELPER_BUILD_BUG_ON(sizeof(struct nf_ct_ftp_master)); + +drivers/char/hpet.c:594: error: DEAD_STORE + The value written to &hpet is never used. + 592. case HPET_IRQFREQ: + 593. timer = devp->hd_timer; + 594. > hpet = devp->hd_hpet; + 595. hpetp = devp->hd_hpets; + 596. break; + +kernel/time/posix-timers.c:588: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 588, column 9. + 586. return do_timer_create(which_clock, &event, created_timer_id); + 587. } + 588. > return do_timer_create(which_clock, NULL, created_timer_id); + 589. } + 590. + +net/sunrpc/auth_gss/gss_rpc_xdr.c:620: error: DEAD_STORE + The value written to &p is never used. + 618. + 619. /* ctx->ctx_flags */ + 620. > p = xdr_encode_hyper(p, ctx->ctx_flags); + 621. + 622. /* ctx->locally_initiated */ + +arch/x86/events/amd/ibs.c:645: error: DEAD_STORE + The value written to &buf is never used. + 643. } + 644. if (ibs_caps & IBS_CAPS_OPDATA4) { + 645. > rdmsrl(MSR_AMD64_IBSOPDATA4, *buf++); + 646. size++; + 647. } + +drivers/clk/clk.c:581: error: DEAD_STORE + The value written to &ret is never used. + 579. static int clk_core_prepare(struct clk_core *core) + 580. { + 581. > int ret = 0; + 582. + 583. lockdep_assert_held(&prepare_lock); + +drivers/gpu/drm/i915/intel_fbc.c:583: error: DEAD_STORE + The value written to &compressed_llb is never used. + 581. struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 582. struct intel_fbc *fbc = &dev_priv->fbc; + 583. > struct drm_mm_node *uninitialized_var(compressed_llb); + 584. int size, fb_cpp, ret; + 585. + +drivers/md/md-bitmap.c:588: error: DEAD_STORE + The value written to &err is never used. + 586. int nodes = 0; + 587. unsigned long sectors_reserved = 0; + 588. > int err = -EINVAL; + 589. struct page *sb_page; + 590. loff_t offset = bitmap->mddev->bitmap_info.offset; + +sound/core/pcm_native.c:609: error: DEAD_STORE + The value written to &old_interval is never used. + 607. if (trace_hw_interval_param_enabled()) { + 608. if (hw_is_interval(*v)) + 609. > old_interval = *hw_param_interval(params, *v); + 610. } + 611. if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) + +sound/core/pcm_native.c:605: error: DEAD_STORE + The value written to &old_mask is never used. + 603. if (trace_hw_mask_param_enabled()) { + 604. if (hw_is_mask(*v)) + 605. > old_mask = *hw_param_mask(params, *v); + 606. } + 607. if (trace_hw_interval_param_enabled()) { + +net/ipv6/esp6.c:595: error: DEAD_STORE + The value written to &ret is never used. + 593. int assoclen; + 594. int seqhilen; + 595. > int ret = 0; + 596. void *tmp; + 597. __be32 *seqhi; + +sound/core/seq/seq_clientmgr.c:589: error: DEAD_STORE + The value written to &dest is never used. + 587. int filter, int atomic, int hop) + 588. { + 589. > struct snd_seq_client *dest = NULL; + 590. struct snd_seq_client_port *dest_port = NULL; + 591. int result = -ENOENT; + +block/bsg.c:600: error: DEAD_STORE + The value written to &rq is never used. + 598. + 599. nr_commands = count / sizeof(struct sg_io_v4); + 600. > rq = NULL; + 601. bc = NULL; + 602. ret = 0; + +block/bsg.c:624: error: DEAD_STORE + The value written to &rq is never used. + 622. if (IS_ERR(rq)) { + 623. ret = PTR_ERR(rq); + 624. > rq = NULL; + 625. break; + 626. } + +block/bsg.c:630: error: DEAD_STORE + The value written to &rq is never used. + 628. bsg_add_command(bd, q, bc, rq); + 629. bc = NULL; + 630. > rq = NULL; + 631. nr_commands--; + 632. buf += sizeof(struct sg_io_v4); + +include/linux/pagemap.h:609: error: DEAD_STORE + The value written to &c is never used. + 607. if (((unsigned long)uaddr & PAGE_MASK) == + 608. ((unsigned long)end & PAGE_MASK)) { + 609. > return __get_user(c, end); + 610. } + 611. + +drivers/usb/host/ohci-q.c:682: error: DEAD_STORE + The value written to &cnt is never used. + 680. && cnt < urb_priv->length) { + 681. td_fill (ohci, info, 0, 0, urb, cnt); + 682. > cnt++; + 683. } + 684. /* maybe kickstart bulk list */ + +drivers/usb/host/ohci-q.c:706: error: DEAD_STORE + The value written to &cnt is never used. + 704. ? TD_CC | TD_DP_IN | TD_T_DATA1 + 705. : TD_CC | TD_DP_OUT | TD_T_DATA1; + 706. > td_fill (ohci, info, data, 0, urb, cnt++); + 707. /* maybe kickstart control list */ + 708. wmb (); + +drivers/usb/host/ohci-q.c:600: error: DEAD_STORE + The value written to &info is never used. + 598. int data_len = urb->transfer_buffer_length; + 599. int cnt = 0; + 600. > u32 info = 0; + 601. int is_out = usb_pipeout (urb->pipe); + 602. int periodic = 0; + +net/netfilter/nf_conntrack_proto.c:596: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 593 could be null and is dereferenced at line 596, column 2. + 594. &nf_conntrack_l4proto_generic); + 595. + 596. > pn->users--; + 597. nf_ct_l4proto_unregister_sysctl(net, + 598. pn, + +drivers/net/phy/phy_device.c:596: error: DEAD_STORE + The value written to &mode is never used. + 594. { + 595. struct phy_device *phydev = to_phy_device(dev); + 596. > const char *mode = NULL; + 597. + 598. if (phy_is_internal(phydev)) + +kernel/time/posix-timers.c:603: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 603, column 9. + 601. return do_timer_create(which_clock, &event, created_timer_id); + 602. } + 603. > return do_timer_create(which_clock, NULL, created_timer_id); + 604. } + 605. #endif + +net/ipv6/ip6_fib.c:601: error: DEAD_STORE + The value written to &pn is never used. + 599. { + 600. struct fib6_node *fn, *in, *ln; + 601. > struct fib6_node *pn = NULL; + 602. struct rt6key *key; + 603. int bit; + +drivers/dma/dmaengine.c:595: error: DEAD_STORE + The value written to &err is never used. + 593. struct dma_chan *dma_get_slave_channel(struct dma_chan *chan) + 594. { + 595. > int err = -EBUSY; + 596. + 597. /* lock against __dma_request_channel */ + +net/ipv4/ip_sockglue.c:809: error: DEAD_STORE + The value written to &dev is never used. + 807. case IP_UNICAST_IF: + 808. { + 809. > struct net_device *dev = NULL; + 810. int ifindex; + 811. + +net/ipv4/ip_sockglue.c:839: error: DEAD_STORE + The value written to &dev is never used. + 837. { + 838. struct ip_mreqn mreq; + 839. > struct net_device *dev = NULL; + 840. int midx; + 841. + +net/ipv4/ip_sockglue.c:1081: error: DEAD_STORE + The value written to &gsf is never used. + 1079. struct sockaddr_in *psin; + 1080. struct ip_msfilter *msf = NULL; + 1081. > struct group_filter *gsf = NULL; + 1082. int msize, i, ifindex; + 1083. + +net/ipv6/ip6_output.c:605: error: DEAD_STORE + The value written to &err is never used. + 603. int hroom, troom; + 604. __be32 frag_id; + 605. > int ptr, offset = 0, err = 0; + 606. u8 *prevhdr, nexthdr = 0; + 607. + +net/ipv6/ip6_output.c:606: error: DEAD_STORE + The value written to &nexthdr is never used. + 604. __be32 frag_id; + 605. int ptr, offset = 0, err = 0; + 606. > u8 *prevhdr, nexthdr = 0; + 607. + 608. err = ip6_find_1stfragopt(skb, &prevhdr); + +kernel/sched/cputime.c:624: error: DEAD_STORE + The value written to &utime is never used. + 622. */ + 623. if (stime == 0) { + 624. > utime = rtime; + 625. goto update; + 626. } + +kernel/smp.c:599: error: DEAD_STORE + The value written to &ret is never used. + 597. { + 598. unsigned long flags; + 599. > int ret = 0; + 600. + 601. preempt_disable(); + +lib/iov_iter.c:608: error: DEAD_STORE + The value written to &skip is never used. + 606. if (iter_is_iovec(i)) + 607. might_fault(); + 608. > iterate_all_kinds(i, bytes, v, ({ + 609. if (copyin((to += v.iov_len) - v.iov_len, + 610. v.iov_base, v.iov_len)) + +block/partitions/efi.c:600: error: DEAD_STORE + The value written to &good_pgpt is never used. + 598. gpt_entry **ptes) + 599. { + 600. > int good_pgpt = 0, good_agpt = 0, good_pmbr = 0; + 601. gpt_header *pgpt = NULL, *agpt = NULL; + 602. gpt_entry *pptes = NULL, *aptes = NULL; + +block/partitions/efi.c:600: error: DEAD_STORE + The value written to &good_pmbr is never used. + 598. gpt_entry **ptes) + 599. { + 600. > int good_pgpt = 0, good_agpt = 0, good_pmbr = 0; + 601. gpt_header *pgpt = NULL, *agpt = NULL; + 602. gpt_entry *pptes = NULL, *aptes = NULL; + +drivers/ata/libata-scsi.c:601: error: DEAD_STORE + The value written to &sensebuf is never used. + 599. int rc = 0; + 600. u8 scsi_cmd[MAX_COMMAND_SIZE]; + 601. > u8 args[4], *argbuf = NULL, *sensebuf = NULL; + 602. int argsize = 0; + 603. enum dma_data_direction data_dir; + +net/ipv4/tcp_ipv4.c:610: error: DEAD_STORE + The value written to &hash_location is never used. + 608. #ifdef CONFIG_TCP_MD5SIG + 609. struct tcp_md5sig_key *key = NULL; + 610. > const __u8 *hash_location = NULL; + 611. unsigned char newhash[16]; + 612. int genhash; + +net/ipv4/tcp_ipv4.c:613: error: DEAD_STORE + The value written to &sk1 is never used. + 611. unsigned char newhash[16]; + 612. int genhash; + 613. > struct sock *sk1 = NULL; + 614. #endif + 615. struct net *net; + +drivers/gpu/drm/drm_dp_mst_topology.c:620: error: DEAD_STORE + The value written to &idx is never used. + 618. msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1; + 619. msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7); + 620. > idx++; + 621. return true; + 622. fail_len: + +net/ipv4/devinet.c:609: error: DEAD_STORE + The value written to &err is never used. + 607. struct ifaddrmsg *ifm; + 608. struct in_ifaddr *ifa, **ifap; + 609. > int err = -EINVAL; + 610. + 611. ASSERT_RTNL(); + +crypto/drbg.c:608: error: DEAD_STORE + The value written to &i is never used. + 606. { + 607. int ret = -EFAULT; + 608. > int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + 610. LIST_HEAD(seedlist); + +crypto/drbg.c:607: error: DEAD_STORE + The value written to &ret is never used. + 605. int reseed) + 606. { + 607. > int ret = -EFAULT; + 608. int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + +drivers/thermal/thermal_core.c:608: error: DEAD_STORE + The value written to &cdev is never used. + 606. const char *cdev_type, size_t size) + 607. { + 608. > struct thermal_cooling_device *cdev = NULL; + 609. + 610. mutex_lock(&thermal_list_lock); + +net/netlabel/netlabel_mgmt.c:610: error: DEAD_STORE + The value written to &ans_skb is never used. + 608. { + 609. int ret_val = -ENOMEM; + 610. > struct sk_buff *ans_skb = NULL; + 611. void *data; + 612. struct netlbl_dom_map *entry; + +kernel/trace/trace_kprobe.c:635: error: DEAD_STORE + The value written to &event is never used. + 633. int i, ret = 0; + 634. bool is_return = false, is_delete = false; + 635. > char *symbol = NULL, *event = NULL, *group = NULL; + 636. int maxactive = 0; + 637. char *arg; + +kernel/trace/trace_kprobe.c:633: error: DEAD_STORE + The value written to &ret is never used. + 631. */ + 632. struct trace_kprobe *tk; + 633. > int i, ret = 0; + 634. bool is_return = false, is_delete = false; + 635. char *symbol = NULL, *event = NULL, *group = NULL; + +kernel/trace/trace_kprobe.c:759: error: DEAD_STORE + The value written to &ret is never used. + 757. + 758. /* parse arguments */ + 759. > ret = 0; + 760. for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) { + 761. struct probe_arg *parg = &tk->tp.args[i]; + +drivers/pcmcia/ds.c:614: error: DEAD_STORE + The value written to &ret is never used. + 612. cistpl_longlink_mfc_t mfc; + 613. unsigned int no_funcs, i, no_chains; + 614. > int ret = -EAGAIN; + 615. + 616. mutex_lock(&s->ops_mutex); + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &p is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &ret is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +tools/lib/subcmd/parse-options.c:659: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 63, column 22) -> ShellExec(execvp at line 180, column 2). + 657. else + 658. astrcatf(&error_buf, "unknown switch `%c'", *ctx.opt); + 659. > usage_with_options(usagestr, options); + 660. } + 661. + +drivers/tty/pty.c:617: error: DEAD_STORE + The value written to &fd is never used. + 615. int ptm_open_peer(struct file *master, struct tty_struct *tty, int flags) + 616. { + 617. > int fd = -1; + 618. struct file *filp; + 619. int retval = -EINVAL; + +drivers/tty/pty.c:619: error: DEAD_STORE + The value written to &retval is never used. + 617. int fd = -1; + 618. struct file *filp; + 619. > int retval = -EINVAL; + 620. struct path path; + 621. + +net/netfilter/nf_conntrack_core.c:626: error: DEAD_STORE + The value written to &zone is never used. + 624. unsigned int sequence; + 625. + 626. > zone = nf_ct_zone(ct); + 627. + 628. local_bh_disable(); + +net/core/sock.c:622: error: DEAD_STORE + The value written to &ret is never used. + 620. int __user *optlen, int len) + 621. { + 622. > int ret = -ENOPROTOOPT; + 623. #ifdef CONFIG_NETDEVICES + 624. struct net *net = sock_net(sk); + +net/sunrpc/svc_xprt.c:649: error: DEAD_STORE + The value written to &i is never used. + 647. } + 648. rqstp->rq_page_end = &rqstp->rq_pages[i]; + 649. > rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */ + 650. + 651. /* Make arg->head point to first page and arg->pages point to rest */ + +net/ipv4/udp.c:642: error: DEAD_STORE + The value written to &err is never used. + 640. } + 641. + 642. > err = 0; + 643. harderr = 0; + 644. inet = inet_sk(sk); + +net/netlabel/netlabel_kapi.c:624: error: DEAD_STORE + The value written to &iter is never used. + 622. int netlbl_catmap_walk(struct netlbl_lsm_catmap *catmap, u32 offset) + 623. { + 624. > struct netlbl_lsm_catmap *iter = catmap; + 625. u32 idx; + 626. u32 bit; + +net/wireless/util.c:630: error: DEAD_STORE + The value written to &frame is never used. + 628. { + 629. unsigned int hlen = ALIGN(extra_headroom, 4); + 630. > struct sk_buff *frame = NULL; + 631. u16 ethertype; + 632. u8 *payload; + +drivers/thermal/thermal_core.c:628: error: DEAD_STORE + The value written to &cdev is never used. + 626. const char *cdev_type, size_t size) + 627. { + 628. > struct thermal_cooling_device *cdev = NULL; + 629. + 630. mutex_lock(&thermal_list_lock); + +drivers/gpu/drm/drm_dp_mst_topology.c:643: error: DEAD_STORE + The value written to &idx is never used. + 641. + 642. msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]); + 643. > idx++; + 644. return true; + 645. fail_len: + +sound/core/info.c:635: error: DEAD_STORE + The value written to &c is never used. + 633. int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) + 634. { + 635. > int c = -1; + 636. + 637. if (snd_BUG_ON(!buffer || !buffer->buffer)) + +security/selinux/ss/avtab.c:638: error: DEAD_STORE + The value written to &rc is never used. + 636. { + 637. unsigned int i; + 638. > int rc = 0; + 639. struct avtab_node *cur; + 640. __le32 buf[1]; + +drivers/base/bus.c:640: error: DEAD_STORE + The value written to &error is never used. + 638. struct bus_type *bus; + 639. struct driver_private *priv; + 640. > int error = 0; + 641. + 642. bus = bus_get(drv->bus); + +drivers/gpu/drm/i915/intel_dpio_phy.c:645: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 644 could be null and is dereferenced at line 645, column 34. + 643. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 644. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 645. > struct intel_crtc *intel_crtc = to_intel_crtc(dport->base.base.crtc); + 646. enum dpio_channel ch = vlv_dport_to_channel(dport); + 647. enum pipe pipe = intel_crtc->pipe; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:683: error: DEAD_STORE + The value written to &p is never used. + 681. + 682. /* ctx->ctx_flags */ + 683. > p = xdr_decode_hyper(p, &ctx->ctx_flags); + 684. + 685. /* ctx->locally_initiated */ + +drivers/cpufreq/acpi-cpufreq.c:647: error: DEAD_STORE + The value written to &result is never used. + 645. unsigned int cpu = policy->cpu; + 646. struct acpi_cpufreq_data *data; + 647. > unsigned int result = 0; + 648. struct cpuinfo_x86 *c = &cpu_data(policy->cpu); + 649. struct acpi_processor_performance *perf; + +drivers/char/agp/frontend.c:660: error: DEAD_STORE + The value written to &controller is never used. + 658. agp_controller_release_current(controller, priv); + 659. agp_remove_controller(controller); + 660. > controller = NULL; + 661. } + 662. } + +drivers/platform/x86/eeepc-laptop.c:645: error: DEAD_STORE + The value written to &status is never used. + 643. static void eeepc_rfkill_hotplug_update(struct eeepc_laptop *eeepc, char *node) + 644. { + 645. > acpi_status status = AE_OK; + 646. acpi_handle handle; + 647. + +drivers/gpu/drm/i915/intel_cdclk.c:676: error: DEAD_STORE + The value written to &timeout__ is never used. + 674. * However, extensive testing shows that this can take longer. + 675. */ + 676. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 677. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 678. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:711: error: DEAD_STORE + The value written to &timeout__ is never used. + 709. I915_WRITE(LCPLL_CTL, val); + 710. + 711. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 712. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 713. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/i915_gem_stolen.c:704: error: DEAD_STORE + The value written to &ret is never used. + 702. vma = i915_vma_instance(obj, &ggtt->base, NULL); + 703. if (IS_ERR(vma)) { + 704. > ret = PTR_ERR(vma); + 705. goto err_pages; + 706. } + +net/ipv6/netfilter/nf_conntrack_reasm.c:647: error: DEAD_STORE + The value written to &ret is never used. + 645. int nf_ct_frag6_init(void) + 646. { + 647. > int ret = 0; + 648. + 649. nf_frags.hashfn = nf_hashfn; + +security/commoncap.c:655: error: DEAD_STORE + The value written to &rc is never used. + 653. static int get_file_caps(struct linux_binprm *bprm, bool *effective, bool *has_fcap) + 654. { + 655. > int rc = 0; + 656. struct cpu_vfs_cap_data vcaps; + 657. + +crypto/jitterentropy.c:659: error: DEAD_STORE + The value written to &entropy_collector is never used. + 657. entropy_collector->mem = NULL; + 658. jent_zfree(entropy_collector); + 659. > entropy_collector = NULL; + 660. } + 661. + +crypto/drbg.c:676: error: DEAD_STORE + The value written to &outlen is never used. + 674. list_add_tail(&data.list, &datalist); + 675. while (len < buflen) { + 676. > unsigned int outlen = 0; + 677. /* 10.1.2.5 step 4.1 */ + 678. ret = drbg_kcapi_hash(drbg, drbg->V, &datalist); + +crypto/drbg.c:662: error: DEAD_STORE + The value written to &ret is never used. + 660. { + 661. int len = 0; + 662. > int ret = 0; + 663. struct drbg_string data; + 664. LIST_HEAD(datalist); + +security/selinux/avc.c:672: error: DEAD_STORE + The value written to &rc is never used. + 670. struct hlist_head *head; + 671. spinlock_t *lock; + 672. > int rc = 0; + 673. + 674. hvalue = avc_hash(ssid, tsid, tclass); + +drivers/tty/vt/consolemap.c:660: error: DEAD_STORE + The value written to &err is never used. + 658. int con_set_default_unimap(struct vc_data *vc) + 659. { + 660. > int i, j, err = 0, err1; + 661. u16 *q; + 662. struct uni_pagedir *p; + +net/sunrpc/auth_gss/svcauth_gss.c:666: error: DEAD_STORE + The value written to &flavor is never used. + 664. struct xdr_buf rpchdr; + 665. struct xdr_netobj checksum; + 666. > u32 flavor = 0; + 667. struct kvec *argv = &rqstp->rq_arg.head[0]; + 668. struct kvec iov; + +crypto/jitterentropy.c:699: error: DEAD_STORE + The value written to &delta is never used. + 697. __u64 time2 = 0; + 698. __u64 folded = 0; + 699. > __u64 delta = 0; + 700. unsigned int lowdelta = 0; + 701. + +crypto/jitterentropy.c:700: error: DEAD_STORE + The value written to &lowdelta is never used. + 698. __u64 folded = 0; + 699. __u64 delta = 0; + 700. > unsigned int lowdelta = 0; + 701. + 702. jent_get_nstime(&time); + +lib/iov_iter.c:673: error: DEAD_STORE + The value written to &skip is never used. + 671. if (unlikely(i->count < bytes)) + 672. return false; + 673. > iterate_all_kinds(i, bytes, v, ({ + 674. if (__copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len, + 675. v.iov_base, v.iov_len)) + +net/ipv4/netfilter/ip_tables.c:674: error: DEAD_STORE + The value written to &ret is never used. + 672. unsigned int *offsets; + 673. unsigned int i; + 674. > int ret = 0; + 675. + 676. newinfo->size = repl->size; + +net/ipv4/ipconfig.c:742: error: DEAD_STORE + The value written to &e is never used. + 740. } + 741. + 742. > *e++ = 255; /* End of the list */ + 743. } + 744. + +net/ipv6/icmp.c:673: error: DEAD_STORE + The value written to &saddr is never used. + 671. struct inet6_dev *idev; + 672. struct ipv6_pinfo *np; + 673. > const struct in6_addr *saddr = NULL; + 674. struct icmp6hdr *icmph = icmp6_hdr(skb); + 675. struct icmp6hdr tmp_hdr; + +ipc/sem.c:717: error: DEAD_STORE + The value written to &result is never used. + 715. curr = &sma->sems[sop->sem_num]; + 716. sem_op = sop->sem_op; + 717. > result = curr->semval; + 718. + 719. if (sop->sem_flg & SEM_UNDO) { + +drivers/rtc/rtc-cmos.c:674: error: DEAD_STORE + The value written to &retval is never used. + 672. { + 673. struct cmos_rtc_board_info *info = dev_get_platdata(dev); + 674. > int retval = 0; + 675. unsigned char rtc_control; + 676. unsigned address_space; + +drivers/gpu/drm/drm_property.c:679: error: DEAD_STORE + The value written to &old_blob is never used. + 677. { + 678. struct drm_property_blob *new_blob = NULL; + 679. > struct drm_property_blob *old_blob = NULL; + 680. int ret; + 681. + +net/wireless/chan.c:676: error: DEAD_STORE + The value written to &t1 is never used. + 674. { + 675. int width; + 676. > unsigned int t1 = 0, t2 = 0; + 677. + 678. if (WARN_ON(!cfg80211_chandef_valid(chandef))) + +net/wireless/chan.c:676: error: DEAD_STORE + The value written to &t2 is never used. + 674. { + 675. int width; + 676. > unsigned int t1 = 0, t2 = 0; + 677. + 678. if (WARN_ON(!cfg80211_chandef_valid(chandef))) + +kernel/kexec_core.c:759: error: DEAD_STORE + The value written to &addr is never used. + 757. continue; + 758. } + 759. > addr = old_addr; + 760. page = old_page; + 761. break; + +net/core/ethtool.c:677: error: DEAD_STORE + The value written to &err is never used. + 675. void __user *useraddr) + 676. { + 677. > int err = 0; + 678. struct ethtool_link_ksettings link_ksettings; + 679. + +net/ipv6/tcp_ipv6.c:678: error: DEAD_STORE + The value written to &hash_location is never used. + 676. { + 677. #ifdef CONFIG_TCP_MD5SIG + 678. > const __u8 *hash_location = NULL; + 679. struct tcp_md5sig_key *hash_expected; + 680. const struct ipv6hdr *ip6h = ipv6_hdr(skb); + +lib/decompress_bunzip2.c:686: error: DEAD_STORE + The value written to &i is never used. + 684. { + 685. struct bunzip_data *bd; + 686. > int i = -1; + 687. unsigned char *inbuf; + 688. + +drivers/gpu/drm/i915/intel_hdmi.c:690: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 686 could be null and is dereferenced at line 690, column 13. + 688. i915_reg_t reg = TVIDEO_DIP_CTL(intel_crtc->pipe); + 689. u32 val = I915_READ(reg); + 690. > u32 port = VIDEO_DIP_PORT(intel_dig_port->port); + 691. + 692. assert_hdmi_port_disabled(intel_hdmi); + +net/ipv4/arp.c:687: error: DEAD_STORE + The value written to &tha is never used. + 685. struct rtable *rt; + 686. unsigned char *sha; + 687. > unsigned char *tha = NULL; + 688. __be32 sip, tip; + 689. u16 dev_type = dev->type; + +drivers/net/ethernet/intel/e1000e/ethtool.c:687: error: DEAD_STORE + The value written to &set_rx is never used. + 685. struct e1000_ring *temp_tx = NULL, *temp_rx = NULL; + 686. int err = 0, size = sizeof(struct e1000_ring); + 687. > bool set_tx = false, set_rx = false; + 688. u16 new_rx_count, new_tx_count; + 689. + +drivers/net/ethernet/intel/e1000e/ethtool.c:687: error: DEAD_STORE + The value written to &set_tx is never used. + 685. struct e1000_ring *temp_tx = NULL, *temp_rx = NULL; + 686. int err = 0, size = sizeof(struct e1000_ring); + 687. > bool set_tx = false, set_rx = false; + 688. u16 new_rx_count, new_tx_count; + 689. + +kernel/cgroup/cgroup-v1.c:700: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 698 could be null and is dereferenced at line 700, column 7. + 698. for_each_subsys(ss, i) + 699. seq_printf(m, "%s\t%d\t%d\t%d\n", + 700. > ss->legacy_name, ss->root->hierarchy_id, + 701. atomic_read(&ss->root->nr_cgrps), + 702. cgroup_ssid_enabled(i)); + +net/ipv6/netfilter/ip6_tables.c:693: error: DEAD_STORE + The value written to &ret is never used. + 691. unsigned int *offsets; + 692. unsigned int i; + 693. > int ret = 0; + 694. + 695. newinfo->size = repl->size; + +drivers/gpu/drm/i915/i915_gem_gtt.c:693: error: DEAD_STORE + The value written to &ret is never used. + 691. { + 692. struct i915_page_directory_pointer *pdp; + 693. > int ret = -ENOMEM; + 694. + 695. WARN_ON(!use_4lvl(vm)); + +drivers/input/mouse/alps.c:692: error: DEAD_STORE + The value written to &palm_data is never used. + 690. struct psmouse *psmouse) + 691. { + 692. > u64 palm_data = 0; + 693. struct alps_data *priv = psmouse->private; + 694. + +drivers/platform/x86/eeepc-laptop.c:693: error: DEAD_STORE + The value written to &status is never used. + 691. char *node) + 692. { + 693. > acpi_status status = AE_OK; + 694. acpi_handle handle; + 695. + +drivers/iommu/intel-iommu.c:694: error: DEAD_STORE + The value written to &agaw is never used. + 692. { + 693. unsigned long sagaw; + 694. > int agaw = -1; + 695. + 696. sagaw = cap_sagaw(iommu->cap); + +kernel/resource.c:695: error: DEAD_STORE + The value written to &err is never used. + 693. struct resource_constraint *constraint) + 694. { + 695. > int err=0; + 696. struct resource new = *old; + 697. struct resource *conflict; + +drivers/base/dd.c:694: error: DEAD_STORE + The value written to &ret is never used. + 692. static int __device_attach(struct device *dev, bool allow_async) + 693. { + 694. > int ret = 0; + 695. + 696. device_lock(dev); + +net/ipv6/ndisc.c:715: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 698 could be null and is dereferenced by call to `ndisc_send_ns()` at line 715, column 3. + 713. __func__, target); + 714. } + 715. > ndisc_send_ns(dev, target, target, saddr, 0); + 716. } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) { + 717. neigh_app_ns(neigh); + +net/ipv6/ndisc.c:720: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 698 could be null and is dereferenced by call to `ndisc_send_ns()` at line 720, column 3. + 718. } else { + 719. addrconf_addr_solict_mult(target, &mcaddr); + 720. > ndisc_send_ns(dev, target, &mcaddr, saddr, 0); + 721. } + 722. } + +sound/pci/hda/hda_proc.c:699: error: DEAD_STORE + The value written to &curr is never used. + 697. struct hda_codec *codec, hda_nid_t nid) + 698. { + 699. > int i, curr = -1; + 700. u8 dev_list[AC_MAX_DEV_LIST_LEN]; + 701. int devlist_len; + +net/ipv4/ping.c:709: error: DEAD_STORE + The value written to &rt is never used. + 707. struct icmphdr user_icmph; + 708. struct pingfakehdr pfh; + 709. > struct rtable *rt = NULL; + 710. struct ip_options_data opt_copy; + 711. int free = 0; + +sound/core/pcm.c:728: error: DEAD_STORE + The value written to &prev is never used. + 726. } + 727. } + 728. > prev = NULL; + 729. for (idx = 0, prev = NULL; idx < substream_count; idx++) { + 730. substream = kzalloc(sizeof(*substream), GFP_KERNEL); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:711: error: DEAD_STORE + The value written to &p is never used. + 709. if (!p) + 710. return -ENOSPC; + 711. > p = xdr_encode_hyper(p, cb->initiator_addrtype); + 712. + 713. /* cb->initiator_address */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:722: error: DEAD_STORE + The value written to &p is never used. + 720. if (!p) + 721. return -ENOSPC; + 722. > p = xdr_encode_hyper(p, cb->acceptor_addrtype); + 723. + 724. /* cb->acceptor_address */ + +drivers/ata/libata-scsi.c:708: error: DEAD_STORE + The value written to &sensebuf is never used. + 706. int rc = 0; + 707. u8 scsi_cmd[MAX_COMMAND_SIZE]; + 708. > u8 args[7], *sensebuf = NULL; + 709. struct scsi_sense_hdr sshdr; + 710. int cmd_result; + +net/ipv6/ip6_flowlabel.c:706: error: DEAD_STORE + The value written to &fl is never used. + 704. static struct ip6_flowlabel *ip6fl_get_first(struct seq_file *seq) + 705. { + 706. > struct ip6_flowlabel *fl = NULL; + 707. struct ip6fl_iter_state *state = ip6fl_seq_private(seq); + 708. struct net *net = seq_file_net(seq); + +net/netlabel/netlabel_cipso_v4.c:706: error: DEAD_STORE + The value written to &ret_val is never used. + 704. static int netlbl_cipsov4_remove(struct sk_buff *skb, struct genl_info *info) + 705. { + 706. > int ret_val = -EINVAL; + 707. struct netlbl_domhsh_walk_arg cb_arg; + 708. struct netlbl_audit audit_info; + +net/xfrm/xfrm_state.c:706: error: DEAD_STORE + The value written to &err is never used. + 704. int xfrm_state_flush(struct net *net, u8 proto, bool task_valid) + 705. { + 706. > int i, err = 0, cnt = 0; + 707. + 708. spin_lock_bh(&net->xfrm.xfrm_state_lock); + +drivers/clk/clk.c:708: error: DEAD_STORE + The value written to &ret is never used. + 706. static int clk_core_enable(struct clk_core *core) + 707. { + 708. > int ret = 0; + 709. + 710. lockdep_assert_held(&enable_lock); + +net/ipv4/igmp.c:732: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `ip_route_output_ports()` at line 732, column 7. + 730. dst = group; + 731. + 732. > rt = ip_route_output_ports(net, &fl4, NULL, dst, 0, + 733. 0, 0, + 734. IPPROTO_IGMP, 0, dev->ifindex); + +net/ipv6/udp.c:717: error: DEAD_STORE + The value written to &dif is never used. + 715. unsigned int offset = offsetof(typeof(*sk), sk_node); + 716. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 717. > int dif = inet6_iif(skb); + 718. struct hlist_node *node; + 719. struct sk_buff *nskb; + +net/ipv6/udp.c:715: error: DEAD_STORE + The value written to &offset is never used. + 713. unsigned short hnum = ntohs(uh->dest); + 714. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 715. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 716. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 717. int dif = inet6_iif(skb); + +net/ipv6/udp.c:727: error: DEAD_STORE + The value written to &offset is never used. + 725. start_lookup: + 726. hslot = &udptable->hash2[hash2]; + 727. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 728. } + 729. + +drivers/char/agp/intel-gtt.c:710: error: DEAD_STORE + The value written to &timeout is never used. + 708. static void i830_chipset_flush(void) + 709. { + 710. > unsigned long timeout = jiffies + msecs_to_jiffies(1000); + 711. + 712. /* Forcibly evict everything from the CPU write buffers. + +include/linux/rhashtable.h:766: error: DEAD_STORE + The value written to &head is never used. + 764. + 765. RCU_INIT_POINTER(list->next, plist); + 766. > head = rht_dereference_bucket(head->next, tbl, hash); + 767. RCU_INIT_POINTER(list->rhead.next, head); + 768. rcu_assign_pointer(*pprev, obj); + +include/linux/rhashtable.h:783: error: DEAD_STORE + The value written to &head is never used. + 781. goto slow_path; + 782. + 783. > head = rht_dereference_bucket(*pprev, tbl, hash); + 784. + 785. RCU_INIT_POINTER(obj->next, head); + +include/linux/rhashtable.h:763: error: DEAD_STORE + The value written to &plist is never used. + 761. + 762. list = container_of(obj, struct rhlist_head, rhead); + 763. > plist = container_of(head, struct rhlist_head, rhead); + 764. + 765. RCU_INIT_POINTER(list->next, plist); + +net/wireless/scan.c:719: error: DEAD_STORE + The value written to &now is never used. + 717. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); + 718. struct cfg80211_internal_bss *bss, *res = NULL; + 719. > unsigned long now = jiffies; + 720. int bss_privacy; + 721. + +net/wireless/trace.h:710: error: DEAD_STORE + The value written to &p is never used. + 708. ); + 709. + 710. > DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, + 711. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 712. TP_ARGS(wiphy, netdev, mac), + +arch/x86/events/intel/p4.c:724: error: NULL_DEREFERENCE + pointer `bind` last assigned on line 723 could be null and is dereferenced at line 724, column 9. + 722. config = p4_general_events[hw_event]; + 723. bind = p4_config_get_bind(config); + 724. > esel = P4_OPCODE_ESEL(bind->opcode); + 725. config |= p4_config_pack_cccr(P4_CCCR_ESEL(esel)); + 726. + +drivers/pcmcia/rsrc_nonstatic.c:720: error: DEAD_STORE + The value written to &ret is never used. + 718. unsigned int align, struct resource **parent) + 719. { + 720. > int i, ret = 0; + 721. + 722. /* Check for an already-allocated window that must conflict with + +net/sunrpc/svcsock.c:753: error: DEAD_STORE + The value written to &err is never used. + 751. BUG(); + 752. } + 753. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 754. (char *)&one, sizeof(one)); + 755. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/netfilter/nf_conntrack_core.c:748: error: DEAD_STORE + The value written to &zone is never used. + 746. return NF_ACCEPT; + 747. + 748. > zone = nf_ct_zone(ct); + 749. local_bh_disable(); + 750. + +drivers/char/agp/intel-agp.c:728: error: DEAD_STORE + The value written to &cap_ptr is never used. + 726. { + 727. struct agp_bridge_data *bridge; + 728. > u8 cap_ptr = 0; + 729. struct resource *r; + 730. int i, err; + +drivers/edac/edac_mc_sysfs.c:732: error: DEAD_STORE + The value written to &new_bw is never used. + 730. struct mem_ctl_info *mci = to_mci(dev); + 731. unsigned long bandwidth = 0; + 732. > int new_bw = 0; + 733. + 734. if (kstrtoul(data, 10, &bandwidth) < 0) + +drivers/firmware/efi/efivars.c:729: error: DEAD_STORE + The value written to &error is never used. + 727. { + 728. struct kobject *parent_kobj = efivars_kobject(); + 729. > int error = 0; + 730. + 731. if (!efi_enabled(EFI_RUNTIME_SERVICES)) + +net/wireless/trace.h:727: error: DEAD_STORE + The value written to &p is never used. + 725. ); + 726. + 727. > DECLARE_EVENT_CLASS(station_del, + 728. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 729. struct station_del_parameters *params), + +arch/x86/events/amd/ibs.c:738: error: DEAD_STORE + The value written to &attr is never used. + 736. if (ibs_caps & IBS_CAPS_OPCNT) { + 737. perf_ibs_op.config_mask |= IBS_OP_CNT_CTL; + 738. > *attr++ = &format_attr_cnt_ctl.attr; + 739. } + 740. perf_ibs_pmu_init(&perf_ibs_op, "ibs_op"); + +drivers/gpu/drm/drm_plane.c:736: error: DEAD_STORE + The value written to &fb is never used. + 734. { + 735. struct drm_device *dev = crtc->dev; + 736. > struct drm_framebuffer *fb = NULL; + 737. struct drm_mode_fb_cmd2 fbreq = { + 738. .width = req->width, + +drivers/gpu/drm/drm_plane.c:747: error: DEAD_STORE + The value written to &ret is never used. + 745. uint32_t crtc_w = 0, crtc_h = 0; + 746. uint32_t src_w = 0, src_h = 0; + 747. > int ret = 0; + 748. + 749. BUG_ON(!crtc->cursor); + +include/net/xfrm.h:735: error: DEAD_STORE + The value written to &audit_buf is never used. + 733. static inline struct audit_buffer *xfrm_audit_start(const char *op) + 734. { + 735. > struct audit_buffer *audit_buf = NULL; + 736. + 737. if (audit_enabled == 0) + +kernel/rcu/srcutree.c:762: error: DEAD_STORE + The value written to &t is never used. + 760. + 761. /* First, see if enough time has passed since the last GP. */ + 762. > t = ktime_get_mono_fast_ns(); + 763. if (exp_holdoff == 0 || + 764. time_in_range_open(t, sp->srcu_last_gp_end, + +net/netlabel/netlabel_mgmt.c:742: error: DEAD_STORE + The value written to &ans_skb is never used. + 740. { + 741. int ret_val = -ENOMEM; + 742. > struct sk_buff *ans_skb = NULL; + 743. void *data; + 744. + +net/sunrpc/sched.c:745: error: DEAD_STORE + The value written to &status is never used. + 743. struct rpc_wait_queue *queue; + 744. int task_is_async = RPC_IS_ASYNC(task); + 745. > int status = 0; + 746. + 747. dprintk("RPC: %5u __rpc_execute flags=0x%x\n", + +arch/x86/events/intel/lbr.c:744: error: DEAD_STORE + The value written to &ret is never used. + 742. int intel_pmu_setup_lbr_filter(struct perf_event *event) + 743. { + 744. > int ret = 0; + 745. + 746. /* + +drivers/pcmcia/ti113x.h:780: error: DEAD_STORE + The value written to &mfunc is never used. + 778. default: + 779. if (operation == HOOK_POWER_PRE) + 780. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + +drivers/pcmcia/ti113x.h:782: error: DEAD_STORE + The value written to &mfunc is never used. + 780. mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + 783. } + 784. + +net/xfrm/xfrm_state.c:747: error: DEAD_STORE + The value written to &err is never used. + 745. int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid) + 746. { + 747. > int i, err = 0, cnt = 0; + 748. + 749. spin_lock_bh(&net->xfrm.xfrm_state_lock); + +net/ipv4/ipconfig.c:775: error: DEAD_STORE + The value written to &e is never used. + 773. *e++ = 150; + 774. + 775. > *e++ = 255; /* End of the list */ + 776. } + 777. + +drivers/usb/host/ehci-q.c:758: error: DEAD_STORE + The value written to &maxp is never used. + 756. u32 info1 = 0, info2 = 0; + 757. int is_input, type; + 758. > int maxp = 0; + 759. int mult; + 760. struct usb_tt *tt = urb->dev->tt; + +drivers/video/fbdev/core/fbmem.c:795: error: DEAD_STORE + The value written to &dst is never used. + 793. dst = buffer; + 794. fb_memcpy_fromfb(dst, src, c); + 795. > dst += c; + 796. src += c; + 797. + +arch/x86/include/asm/processor.h:751: error: DEAD_STORE + The value written to &debugctlmsr is never used. + 749. static inline unsigned long get_debugctlmsr(void) + 750. { + 751. > unsigned long debugctlmsr = 0; + 752. + 753. #ifndef CONFIG_X86_DEBUGCTLMSR + +drivers/edac/edac_mc_sysfs.c:755: error: DEAD_STORE + The value written to &bandwidth is never used. + 753. { + 754. struct mem_ctl_info *mci = to_mci(dev); + 755. > int bandwidth = 0; + 756. + 757. bandwidth = mci->get_sdram_scrub_rate(mci); + +drivers/char/agp/amd64-agp.c:755: error: DEAD_STORE + The value written to &err is never used. + 753. int __init agp_amd64_init(void) + 754. { + 755. > int err = 0; + 756. + 757. if (agp_off) + +net/ipv6/raw.c:766: error: DEAD_STORE + The value written to &dst is never used. + 764. struct ipv6_txoptions *opt = NULL; + 765. struct ip6_flowlabel *flowlabel = NULL; + 766. > struct dst_entry *dst = NULL; + 767. struct raw6_frag_vec rfv; + 768. struct flowi6 fl6; + +drivers/usb/host/ohci-q.c:759: error: DEAD_STORE + The value written to &cc is never used. + 757. { + 758. u32 tdINFO = hc32_to_cpup (ohci, &td->hwINFO); + 759. > int cc = 0; + 760. int status = -EINPROGRESS; + 761. + +drivers/usb/host/ohci-q.c:767: error: DEAD_STORE + The value written to &dlen is never used. + 765. if (tdINFO & TD_ISO) { + 766. u16 tdPSW = ohci_hwPSW(ohci, td, 0); + 767. > int dlen = 0; + 768. + 769. /* NOTE: assumes FC in tdINFO == 0, and that + +kernel/printk/printk.c:809: error: DEAD_STORE + The value written to &len is never used. + 807. facility = LOG_FACILITY(u); + 808. endp++; + 809. > len -= endp - line; + 810. line = endp; + 811. } + +sound/core/timer.c:763: error: DEAD_STORE + The value written to &use_tasklet is never used. + 761. struct list_head *p, *ack_list_head; + 762. unsigned long flags; + 763. > int use_tasklet = 0; + 764. + 765. if (timer == NULL) + +net/core/dev_addr_lists.c:760: error: DEAD_STORE + The value written to &err is never used. + 758. int dev_mc_sync(struct net_device *to, struct net_device *from) + 759. { + 760. > int err = 0; + 761. + 762. if (to->addr_len != from->addr_len) + +drivers/gpu/drm/drm_framebuffer.c:769: error: DEAD_STORE + The value written to &ret is never used. + 767. struct drm_connector *conn; + 768. struct drm_connector_state *conn_state; + 769. > int i, ret = 0; + 770. unsigned plane_mask; + 771. + +arch/x86/events/intel/pt.c:769: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 765 could be null and is dereferenced at line 769, column 9. + 767. + 768. /* offset of the first region in this table from the beginning of buf */ + 769. > base = buf->cur->offset + buf->output_off; + 770. + 771. /* offset of the current output region within this table */ + +drivers/gpu/drm/drm_property.c:769: error: DEAD_STORE + The value written to &ret is never used. + 767. struct drm_mode_create_blob *out_resp = data; + 768. struct drm_property_blob *blob; + 769. > int ret = 0; + 770. + 771. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/i2c/busses/i2c-i801.c:770: error: DEAD_STORE + The value written to &result is never used. + 768. int command, int hwpec) + 769. { + 770. > int result = 0; + 771. unsigned char hostc; + 772. + +kernel/time/alarmtimer.c:776: error: DEAD_STORE + The value written to &ret is never used. + 774. struct alarm alarm; + 775. ktime_t exp; + 776. > int ret = 0; + 777. + 778. if (!alarmtimer_get_rtcdev()) + +kernel/kexec_core.c:779: error: DEAD_STORE + The value written to &result is never used. + 777. unsigned char *kbuf = NULL; + 778. + 779. > result = 0; + 780. if (image->file_mode) + 781. kbuf = segment->kbuf; + +kernel/auditfilter.c:774: error: DEAD_STORE + The value written to &ret is never used. + 772. struct audit_field *sf) + 773. { + 774. > int ret = 0; + 775. char *lsm_str; + 776. + +net/wireless/trace.h:772: error: DEAD_STORE + The value written to &p is never used. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +lib/iov_iter.c:786: error: DEAD_STORE + The value written to &skip is never used. + 784. return 0; + 785. } + 786. > iterate_all_kinds(i, bytes, v, + 787. copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len), + 788. memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page, + +net/sched/act_api.c:776: error: DEAD_STORE + The value written to &err is never used. + 774. int compat_mode) + 775. { + 776. > int err = 0; + 777. struct gnet_dump d; + 778. + +drivers/usb/core/usb.c:777: error: DEAD_STORE + The value written to &jiffies_expire is never used. + 775. const struct usb_interface *iface) + 776. { + 777. > unsigned long jiffies_expire = jiffies + HZ; + 778. + 779. if (udev->state == USB_STATE_NOTATTACHED) + +net/ipv4/tcp_input.c:799: error: DEAD_STORE + The value written to &rate is never used. + 797. + 798. if (likely(tp->srtt_us)) + 799. > do_div(rate, tp->srtt_us); + 800. + 801. /* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate + +drivers/md/md-bitmap.c:781: error: DEAD_STORE + The value written to &offset is never used. + 779. int slot_number) + 780. { + 781. > int pnum, offset = 0; + 782. unsigned long num_pages; + 783. unsigned long bytes; + +arch/x86/events/intel/lbr.c:787: error: DEAD_STORE + The value written to &is64 is never used. + 785. int ext, to_plm, from_plm; + 786. u8 buf[MAX_INSN_SIZE]; + 787. > int is64 = 0; + 788. + 789. to_plm = kernel_ip(to) ? X86_BR_KERNEL : X86_BR_USER; + +drivers/md/dm-ioctl.c:783: error: DEAD_STORE + The value written to &hc is never used. + 781. static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param) + 782. { + 783. > struct hash_cell *hc = NULL; + 784. + 785. if (*param->uuid) { + +drivers/gpu/drm/i915/intel_overlay.c:789: error: DEAD_STORE + The value written to &scale_changed is never used. + 787. int ret, tmp_width; + 788. struct overlay_registers __iomem *regs; + 789. > bool scale_changed = false; + 790. struct drm_i915_private *dev_priv = overlay->i915; + 791. u32 swidth, swidthsw, sheight, ostride; + +net/ipv6/udp.c:790: error: DEAD_STORE + The value written to &ulen is never used. + 788. struct udphdr *uh; + 789. struct sock *sk; + 790. > u32 ulen = 0; + 791. + 792. if (!pskb_may_pull(skb, sizeof(struct udphdr))) + +net/wireless/sme.c:850: error: DEAD_STORE + The value written to &next is never used. + 848. ev->cr.pmkid = next; + 849. memcpy((void *)ev->cr.pmkid, params->pmkid, WLAN_PMKID_LEN); + 850. > next += WLAN_PMKID_LEN; + 851. } + 852. ev->cr.update_erp_next_seq_num = params->update_erp_next_seq_num; + +drivers/ata/libata-scsi.c:789: error: DEAD_STORE + The value written to &rc is never used. + 787. { + 788. unsigned long val; + 789. > int rc = -EINVAL; + 790. unsigned long flags; + 791. + +drivers/input/serio/i8042.c:787: error: DEAD_STORE + The value written to &retval is never used. + 785. static int __init i8042_check_aux(void) + 786. { + 787. > int retval = -1; + 788. bool irq_registered = false; + 789. bool aux_loop_broken = false; + +tools/lib/subcmd/parse-options.c:788: error: DEAD_STORE + The value written to &o is never used. + 786. { + 787. int nr_opts = 0, len; + 788. > const struct option *o = opts; + 789. struct option *ordered; + 790. + +drivers/gpu/drm/i915/intel_runtime_pm.c:811: error: DEAD_STORE + The value written to &timeout__ is never used. + 809. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 810. + 811. > if (wait_for(COND, 100)) + 812. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 813. state, + +net/ipv4/udp.c:795: error: DEAD_STORE + The value written to &csum is never used. + 793. int offset = skb_transport_offset(skb); + 794. int len = skb->len - offset; + 795. > __wsum csum = 0; + 796. + 797. /* + +net/ipv4/udp.c:791: error: DEAD_STORE + The value written to &err is never used. + 789. struct inet_sock *inet = inet_sk(sk); + 790. struct udphdr *uh; + 791. > int err = 0; + 792. int is_udplite = IS_UDPLITE(sk); + 793. int offset = skb_transport_offset(skb); + +net/core/dev_addr_lists.c:790: error: DEAD_STORE + The value written to &err is never used. + 788. int dev_mc_sync_multiple(struct net_device *to, struct net_device *from) + 789. { + 790. > int err = 0; + 791. + 792. if (to->addr_len != from->addr_len) + +sound/pci/hda/hda_controller.c:802: error: DEAD_STORE + The value written to &loopcounter is never used. + 800. timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. > for (loopcounter = 0;; loopcounter++) { + 803. spin_lock_irq(&bus->reg_lock); + 804. if (chip->polling_mode || do_poll) + +sound/pci/hda/hda_controller.c:802: error: DEAD_STORE + The value written to &loopcounter is never used. + 800. timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. > for (loopcounter = 0;; loopcounter++) { + 803. spin_lock_irq(&bus->reg_lock); + 804. if (chip->polling_mode || do_poll) + +sound/pci/hda/hda_controller.c:800: error: DEAD_STORE + The value written to &timeout is never used. + 798. + 799. again: + 800. > timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. for (loopcounter = 0;; loopcounter++) { + +drivers/gpu/drm/i915/intel_audio.c:818: error: DEAD_STORE + The value written to &pipe is never used. + 816. /* pipe passed from the audio driver will be -1 for Non-MST case */ + 817. crtc = to_intel_crtc(intel_encoder->base.crtc); + 818. > pipe = crtc->pipe; + 819. + 820. adjusted_mode = &crtc->config->base.adjusted_mode; + +net/wireless/trace.h:793: error: DEAD_STORE + The value written to &p is never used. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +block/blk-mq.c:799: error: DEAD_STORE + The value written to &data is never used. + 797. struct request *rq, void *priv, bool reserved) + 798. { + 799. > struct blk_mq_timeout_data *data = priv; + 800. unsigned long deadline; + 801. + +drivers/usb/core/config.c:801: error: DEAD_STORE + The value written to &result is never used. + 799. struct device *ddev = &dev->dev; + 800. int ncfg = dev->descriptor.bNumConfigurations; + 801. > int result = 0; + 802. unsigned int cfgno, length; + 803. unsigned char *bigbuffer; + +drivers/usb/core/config.c:833: error: DEAD_STORE + The value written to &result is never used. + 831. goto err2; + 832. + 833. > result = 0; + 834. for (; cfgno < ncfg; cfgno++) { + 835. /* We grab just the first descriptor so we know how long + +kernel/time/posix-cpu-timers.c:820: error: DEAD_STORE + The value written to &timers is never used. + 818. tsk_expires->virt_exp = expires; + 819. + 820. > tsk_expires->sched_exp = check_timers_list(++timers, firing, + 821. tsk->se.sum_exec_runtime); + 822. + +drivers/gpu/drm/drm_prime.c:802: error: DEAD_STORE + The value written to &sg is never used. + 800. struct sg_table *drm_prime_pages_to_sg(struct page **pages, unsigned int nr_pages) + 801. { + 802. > struct sg_table *sg = NULL; + 803. int ret; + 804. + +drivers/gpu/drm/drm_property.c:804: error: DEAD_STORE + The value written to &blob is never used. + 802. { + 803. struct drm_mode_destroy_blob *out_resp = data; + 804. > struct drm_property_blob *blob = NULL, *bt; + 805. bool found = false; + 806. int ret = 0; + +drivers/gpu/drm/drm_property.c:806: error: DEAD_STORE + The value written to &ret is never used. + 804. struct drm_property_blob *blob = NULL, *bt; + 805. bool found = false; + 806. > int ret = 0; + 807. + 808. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/usb/mon/mon_bin.c:849: error: DEAD_STORE + The value written to &buf is never used. + 847. } + 848. nbytes -= step_len; + 849. > buf += step_len; + 850. rp->b_read += step_len; + 851. done += step_len; + +drivers/usb/mon/mon_bin.c:848: error: DEAD_STORE + The value written to &nbytes is never used. + 846. return -EFAULT; + 847. } + 848. > nbytes -= step_len; + 849. buf += step_len; + 850. rp->b_read += step_len; + +security/keys/key.c:814: error: DEAD_STORE + The value written to &key is never used. + 812. struct assoc_array_edit *edit; + 813. const struct cred *cred = current_cred(); + 814. > struct key *keyring, *key = NULL; + 815. key_ref_t key_ref; + 816. int ret; + +arch/x86/events/intel/p4.c:804: error: DEAD_STORE + The value written to &rc is never used. + 802. { + 803. int cpu = get_cpu(); + 804. > int rc = 0; + 805. u32 escr, cccr; + 806. + +net/ipv6/af_inet6.c:803: error: DEAD_STORE + The value written to &err is never used. + 801. static int __net_init inet6_net_init(struct net *net) + 802. { + 803. > int err = 0; + 804. + 805. net->ipv6.sysctl.bindv6only = 0; + +drivers/gpu/drm/drm_plane.c:812: error: DEAD_STORE + The value written to &ret is never used. + 810. struct drm_crtc *crtc; + 811. struct drm_modeset_acquire_ctx ctx; + 812. > int ret = 0; + 813. + 814. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/gpu/drm/drm_syncobj.c:812: error: DEAD_STORE + The value written to &ret is never used. + 810. { + 811. signed long timeout = drm_timeout_abs_to_jiffies(wait->timeout_nsec); + 812. > signed long ret = 0; + 813. uint32_t first = ~0; + 814. + +net/ipv4/ipmr.c:821: error: DEAD_STORE + The value written to &now is never used. + 819. goto out; + 820. + 821. > now = jiffies; + 822. expires = 10*HZ; + 823. + +net/sunrpc/svc_xprt.c:810: error: DEAD_STORE + The value written to &xprt is never used. + 808. int svc_recv(struct svc_rqst *rqstp, long timeout) + 809. { + 810. > struct svc_xprt *xprt = NULL; + 811. struct svc_serv *serv = rqstp->rq_server; + 812. int len, err; + +arch/x86/events/intel/pt.c:832: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 832, column 32. + 830. */ + 831. if (!pt_cap_get(PT_CAP_topa_multiple_entries) || + 832. > buf->output_off == sizes(TOPA_ENTRY(buf->cur, buf->cur_idx)->size)) { + 833. perf_aux_output_flag(&pt->handle, + 834. PERF_AUX_FLAG_TRUNCATED); + +arch/x86/events/intel/pt.c:843: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 843, column 52. + 841. * before the output reaches its output region's boundary. + 842. */ + 843. > if (!pt_cap_get(PT_CAP_topa_multiple_entries) && !buf->snapshot && + 844. pt_buffer_region_size(buf) - buf->output_off <= TOPA_PMI_MARGIN) { + 845. void *head = pt_buffer_region(buf); + +net/wireless/trace.h:810: error: DEAD_STORE + The value written to &p is never used. + 808. ); + 809. + 810. > DECLARE_EVENT_CLASS(mpath_evt, + 811. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 812. u8 *next_hop), + +net/netfilter/nf_conntrack_netlink.c:819: error: DEAD_STORE + The value written to &l3proto is never used. + 817. struct hlist_nulls_node *n; + 818. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 819. > u_int8_t l3proto = nfmsg->nfgen_family; + 820. struct nf_conn *nf_ct_evict[8]; + 821. int res, i; + +net/netfilter/nf_conntrack_netlink.c:814: error: DEAD_STORE + The value written to &net is never used. + 812. ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) + 813. { + 814. > struct net *net = sock_net(skb->sk); + 815. struct nf_conn *ct, *last; + 816. struct nf_conntrack_tuple_hash *h; + +drivers/video/fbdev/core/fbmem.c:873: error: DEAD_STORE + The value written to &src is never used. + 871. fb_memcpy_tofb(dst, src, c); + 872. dst += c; + 873. > src += c; + 874. *ppos += c; + 875. buf += c; + +kernel/cgroup/cgroup-v1.c:818: error: DEAD_STORE + The value written to &agentbuf is never used. + 816. struct cgroup *cgrp = + 817. container_of(work, struct cgroup, release_agent_work); + 818. > char *pathbuf = NULL, *agentbuf = NULL; + 819. char *argv[3], *envp[3]; + 820. int ret; + +kernel/cgroup/cgroup-v1.c:818: error: DEAD_STORE + The value written to &pathbuf is never used. + 816. struct cgroup *cgrp = + 817. container_of(work, struct cgroup, release_agent_work); + 818. > char *pathbuf = NULL, *agentbuf = NULL; + 819. char *argv[3], *envp[3]; + 820. int ret; + +drivers/i2c/busses/i2c-i801.c:824: error: DEAD_STORE + The value written to &ret is never used. + 822. int hwpec; + 823. int block = 0; + 824. > int ret = 0, xact = 0; + 825. struct i801_priv *priv = i2c_get_adapdata(adap); + 826. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:891: error: DEAD_STORE + The value written to &ret_val is never used. + 889. + 890. data &= ~I82579_LPI_100_PLL_SHUT; + 891. > ret_val = e1000_write_emi_reg_locked(hw, I82579_LPI_PLL_SHUT, + 892. data); + 893. } + +drivers/net/ethernet/intel/e1000e/82571.c:827: error: DEAD_STORE + The value written to &eewr is never used. + 825. { + 826. struct e1000_nvm_info *nvm = &hw->nvm; + 827. > u32 i, eewr = 0; + 828. s32 ret_val = 0; + 829. + +sound/core/info.c:826: error: DEAD_STORE + The value written to &p is never used. + 824. int snd_info_register(struct snd_info_entry * entry) + 825. { + 826. > struct proc_dir_entry *root, *p = NULL; + 827. + 828. if (snd_BUG_ON(!entry)) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:829: error: DEAD_STORE + The value written to &txcw is never used. + 827. u32 ctrl; + 828. u32 status; + 829. > u32 txcw = 0; + 830. u32 i; + 831. u32 signal = 0; + +drivers/net/phy/phy.c:831: error: DEAD_STORE + The value written to &err is never used. + 829. void phy_start(struct phy_device *phydev) + 830. { + 831. > int err = 0; + 832. + 833. mutex_lock(&phydev->lock); + +net/xfrm/xfrm_user.c:837: error: DEAD_STORE + The value written to &ret is never used. + 835. struct sk_buff *skb) + 836. { + 837. > int ret = 0; + 838. + 839. copy_to_user_state(x, p); + +drivers/pci/pci-sysfs.c:904: error: DEAD_STORE + The value written to &off is never used. + 902. pci_user_read_config_byte(dev, off, &val); + 903. data[off - init_off] = val; + 904. > off++; + 905. --size; + 906. } + +drivers/pci/pci-sysfs.c:905: error: DEAD_STORE + The value written to &size is never used. + 903. data[off - init_off] = val; + 904. off++; + 905. > --size; + 906. } + 907. + +scripts/asn1_compiler.c:843: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 843, column 3. + 841. struct element *e = calloc(1, sizeof(*e)); + 842. if (!e) { + 843. > perror(NULL); + 844. exit(1); + 845. } + +net/netfilter/nf_conntrack_core.c:853: error: DEAD_STORE + The value written to &zone is never used. + 851. struct nf_conn *ct; + 852. + 853. > zone = nf_ct_zone(ignored_conntrack); + 854. + 855. rcu_read_lock(); + +drivers/tty/vt/vt.c:846: error: DEAD_STORE + The value written to &err is never used. + 844. unsigned int cols, unsigned int lines) + 845. { + 846. > unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0; + 847. unsigned long end; + 848. unsigned int old_rows, old_row_size; + +kernel/seccomp.c:848: error: DEAD_STORE + The value written to &prepared is never used. + 846. { + 847. const unsigned long seccomp_mode = SECCOMP_MODE_FILTER; + 848. > struct seccomp_filter *prepared = NULL; + 849. long ret = -EINVAL; + 850. + +kernel/time/alarmtimer.c:849: error: DEAD_STORE + The value written to &error is never used. + 847. { + 848. struct platform_device *pdev; + 849. > int error = 0; + 850. int i; + 851. + +net/sunrpc/rpcb_clnt.c:858: error: NULL_DEREFERENCE + pointer `p` last assigned on line 858 could be null and is dereferenced at line 858, column 2. + 856. + 857. p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2); + 858. > *p++ = cpu_to_be32(rpcb->r_prog); + 859. *p++ = cpu_to_be32(rpcb->r_vers); + 860. *p++ = cpu_to_be32(rpcb->r_prot); + +drivers/char/agp/generic.c:867: error: DEAD_STORE + The value written to &size is never used. + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + 867. > size = page_order = num_entries = 0; + 868. + 869. if (bridge->driver->size_type != FIXED_APER_SIZE) { + +drivers/char/agp/generic.c:873: error: DEAD_STORE + The value written to &size is never used. + 871. switch (bridge->driver->size_type) { + 872. case U8_APER_SIZE: + 873. > size = A_SIZE_8(temp)->size; + 874. page_order = + 875. A_SIZE_8(temp)->page_order; + +drivers/char/agp/generic.c:880: error: DEAD_STORE + The value written to &size is never used. + 878. break; + 879. case U16_APER_SIZE: + 880. > size = A_SIZE_16(temp)->size; + 881. page_order = A_SIZE_16(temp)->page_order; + 882. num_entries = A_SIZE_16(temp)->num_entries; + +drivers/char/agp/generic.c:885: error: DEAD_STORE + The value written to &size is never used. + 883. break; + 884. case U32_APER_SIZE: + 885. > size = A_SIZE_32(temp)->size; + 886. page_order = A_SIZE_32(temp)->page_order; + 887. num_entries = A_SIZE_32(temp)->num_entries; + +drivers/char/agp/generic.c:893: error: DEAD_STORE + The value written to &size is never used. + 891. case LVL2_APER_SIZE: + 892. default: + 893. > size = page_order = num_entries = 0; + 894. break; + 895. } + +drivers/char/agp/generic.c:923: error: DEAD_STORE + The value written to &size is never used. + 921. } while (!table && (i < bridge->driver->num_aperture_sizes)); + 922. } else { + 923. > size = ((struct aper_size_info_fixed *) temp)->size; + 924. page_order = ((struct aper_size_info_fixed *) temp)->page_order; + 925. num_entries = ((struct aper_size_info_fixed *) temp)->num_entries; + +drivers/char/agp/generic.c:864: error: DEAD_STORE + The value written to &table is never used. + 862. return -EINVAL; + 863. + 864. > table = NULL; + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + +net/wireless/trace.h:849: error: DEAD_STORE + The value written to &p is never used. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +drivers/net/phy/phy_device.c:852: error: DEAD_STORE + The value written to &ret is never used. + 850. int phy_init_hw(struct phy_device *phydev) + 851. { + 852. > int ret = 0; + 853. + 854. if (!phydev->drv || !phydev->drv->config_init) + +kernel/cpu.c:858: error: DEAD_STORE + The value written to &ret is never used. + 856. { + 857. struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu); + 858. > int prev_state, ret = 0; + 859. + 860. if (num_online_cpus() == 1) + +drivers/block/loop.c:912: error: DEAD_STORE + The value written to &error is never used. + 910. goto out_putf; + 911. + 912. > error = 0; + 913. + 914. set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0); + +drivers/iommu/amd_iommu_init.c:859: error: DEAD_STORE + The value written to &old_devtb is never used. + 857. { + 858. u64 int_ctl, int_tab_len, entry = 0, last_entry = 0; + 859. > struct dev_table_entry *old_devtb = NULL; + 860. u32 lo, hi, devid, old_devtb_size; + 861. phys_addr_t old_devtb_phys; + +net/sunrpc/rpc_pipe.c:864: error: DEAD_STORE + The value written to &error is never used. + 862. struct dentry *parent; + 863. struct inode *dir; + 864. > int error = 0; + 865. + 866. parent = dget_parent(dentry); + +drivers/pcmcia/rsrc_nonstatic.c:864: error: DEAD_STORE + The value written to &ret is never used. + 862. struct socket_data *data = s->resource_data; + 863. unsigned long size = end - start + 1; + 864. > int ret = 0; + 865. + 866. if (end < start) + +drivers/platform/x86/eeepc-laptop.c:862: error: DEAD_STORE + The value written to &result is never used. + 860. static int eeepc_rfkill_init(struct eeepc_laptop *eeepc) + 861. { + 862. > int result = 0; + 863. + 864. mutex_init(&eeepc->hotplug_lock); + +drivers/usb/host/ehci-hub.c:1108: error: DEAD_STORE + The value written to &temp1 is never used. + 1106. // status may be from integrated TT + 1107. if (ehci->has_hostpc) { + 1108. > temp1 = ehci_readl(ehci, hostpc_reg); + 1109. status |= ehci_port_speed(ehci, temp1); + 1110. } else + +kernel/sched/topology.c:890: error: NULL_DEREFERENCE + pointer `last` last assigned on line 863 could be null and is dereferenced at line 890, column 2. + 888. last = sg; + 889. } + 890. > last->next = first; + 891. sd->groups = first; + 892. + +drivers/iommu/intel-iommu.c:863: error: DEAD_STORE + The value written to &drhd is never used. + 861. static struct intel_iommu *device_to_iommu(struct device *dev, u8 *bus, u8 *devfn) + 862. { + 863. > struct dmar_drhd_unit *drhd = NULL; + 864. struct intel_iommu *iommu; + 865. struct device *tmp; + +kernel/time/clocksource.c:867: error: DEAD_STORE + The value written to &count is never used. + 865. struct device_attribute *attr, char *buf) + 866. { + 867. > ssize_t count = 0; + 868. + 869. mutex_lock(&clocksource_mutex); + +drivers/gpu/drm/i915/i915_drv.c:873: error: DEAD_STORE + The value written to &ret is never used. + 871. (struct intel_device_info *)ent->driver_data; + 872. struct intel_device_info *device_info; + 873. > int ret = 0; + 874. + 875. if (i915_inject_load_failure()) + +net/ipv4/af_inet.c:871: error: DEAD_STORE + The value written to &err is never used. + 869. { + 870. struct sock *sk = sock->sk; + 871. > int err = 0; + 872. struct net *net = sock_net(sk); + 873. + +net/ipv4/route.c:884: error: DEAD_STORE + The value written to &log_martians is never used. + 882. return; + 883. } + 884. > log_martians = IN_DEV_LOG_MARTIANS(in_dev); + 885. vif = l3mdev_master_ifindex_rcu(rt->dst.dev); + 886. rcu_read_unlock(); + +kernel/time/posix-timers.c:878: error: DEAD_STORE + The value written to &error is never used. + 876. struct k_itimer *timr; + 877. unsigned long flag; + 878. > int error = 0; + 879. + 880. if (!timespec64_valid(&new_spec64->it_interval) || + +net/wireless/trace.h:873: error: DEAD_STORE + The value written to &p is never used. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/ipv6/ip6_fib.c:883: error: DEAD_STORE + The value written to &iter is never used. + 881. struct rt6_info *leaf = rcu_dereference_protected(fn->leaf, + 882. lockdep_is_held(&rt->rt6i_table->tb6_lock)); + 883. > struct rt6_info *iter = NULL; + 884. struct rt6_info __rcu **ins; + 885. struct rt6_info __rcu **fallback_ins = NULL; + +drivers/md/dm-raid1.c:887: error: DEAD_STORE + The value written to &ms is never used. + 885. { + 886. size_t len; + 887. > struct mirror_set *ms = NULL; + 888. + 889. len = sizeof(*ms) + (sizeof(ms->mirror[0]) * nr_mirrors); + +net/ipv6/tcp_ipv6.c:889: error: DEAD_STORE + The value written to &hash_location is never used. + 887. struct tcp_md5sig_key *key = NULL; + 888. #ifdef CONFIG_TCP_MD5SIG + 889. > const __u8 *hash_location = NULL; + 890. struct ipv6hdr *ipv6h = ipv6_hdr(skb); + 891. unsigned char newhash[16]; + +net/ipv6/tcp_ipv6.c:893: error: DEAD_STORE + The value written to &sk1 is never used. + 891. unsigned char newhash[16]; + 892. int genhash; + 893. > struct sock *sk1 = NULL; + 894. #endif + 895. int oif = 0; + +drivers/gpu/drm/drm_syncobj.c:890: error: DEAD_STORE + The value written to &ret is never used. + 888. struct drm_syncobj_wait *args = data; + 889. struct drm_syncobj **syncobjs; + 890. > int ret = 0; + 891. + 892. if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) + +net/wireless/scan.c:891: error: DEAD_STORE + The value written to &found is never used. + 889. bool signal_valid) + 890. { + 891. > struct cfg80211_internal_bss *found = NULL; + 892. + 893. if (WARN_ON(!tmp->pub.channel)) + +drivers/thermal/thermal_core.c:891: error: DEAD_STORE + The value written to &pos is never used. + 889. int i, ret; + 890. const struct thermal_zone_params *tzp; + 891. > struct thermal_zone_device *pos = NULL; + 892. + 893. mutex_lock(&thermal_list_lock); + +net/sunrpc/cache.c:894: error: DEAD_STORE + The value written to &ret is never used. + 892. struct page *page; + 893. char *kaddr; + 894. > ssize_t ret = -ENOMEM; + 895. + 896. if (count >= PAGE_SIZE) + +drivers/usb/core/driver.c:892: error: DEAD_STORE + The value written to &retval is never used. + 890. struct module *owner) + 891. { + 892. > int retval = 0; + 893. + 894. if (usb_disabled()) + +kernel/cgroup/cgroup-v1.c:897: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 895 could be null and is dereferenced at line 897, column 25. + 895. for_each_subsys(ss, ssid) + 896. if (root->subsys_mask & (1 << ssid)) + 897. > seq_show_option(seq, ss->legacy_name, NULL); + 898. if (root->flags & CGRP_ROOT_NOPREFIX) + 899. seq_puts(seq, ",noprefix"); + +drivers/md/dm.c:902: error: DEAD_STORE + The value written to &offset is never used. + 900. offset = dm_target_offset(ti, sector); + 901. if (unlikely(ti->max_io_len & (ti->max_io_len - 1))) + 902. > max_len = sector_div(offset, ti->max_io_len); + 903. else + 904. max_len = offset & (ti->max_io_len - 1); + +drivers/net/ethernet/intel/e1000e/82571.c:919: error: DEAD_STORE + The value written to &ret_val is never used. + 917. } else { + 918. data &= ~IGP02E1000_PM_D0_LPLU; + 919. > ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data); + 920. /* LPLU and SmartSpeed are mutually exclusive. LPLU is used + 921. * during Dx states where the power conservation is most + +net/wireless/trace.h:894: error: DEAD_STORE + The value written to &p is never used. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +drivers/hid/hid-ntrig.c:956: error: DEAD_STORE + The value written to &ret is never used. + 954. ntrig_report_version(hdev); + 955. + 956. > ret = sysfs_create_group(&hdev->dev.kobj, + 957. &ntrig_attribute_group); + 958. + +drivers/pci/setup-bus.c:904: error: DEAD_STORE + The value written to &size0 is never used. + 902. struct resource *b_res = find_free_bus_resource(bus, IORESOURCE_IO, + 903. IORESOURCE_IO); + 904. > resource_size_t size = 0, size0 = 0, size1 = 0; + 905. resource_size_t children_add_size = 0; + 906. resource_size_t min_align, align; + +kernel/time/posix-cpu-timers.c:932: error: DEAD_STORE + The value written to &timers is never used. + 930. prof_expires = check_timers_list(timers, firing, ptime); + 931. virt_expires = check_timers_list(++timers, firing, utime); + 932. > sched_expires = check_timers_list(++timers, firing, sum_sched_runtime); + 933. + 934. /* + +net/unix/af_unix.c:911: error: DEAD_STORE + The value written to &err is never used. + 909. struct sock *u; + 910. struct path path; + 911. > int err = 0; + 912. + 913. if (sunname->sun_path[0]) { + +drivers/gpu/drm/drm_plane.c:915: error: DEAD_STORE + The value written to &ret is never used. + 913. u32 target_vblank = page_flip->sequence; + 914. struct drm_modeset_acquire_ctx ctx; + 915. > int ret = -EINVAL; + 916. + 917. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +net/core/neighbour.c:917: error: DEAD_STORE + The value written to &next is never used. + 915. state = neigh->nud_state; + 916. now = jiffies; + 917. > next = now + HZ; + 918. + 919. if (!(state & NUD_IN_TIMER)) + +net/core/neighbour.c:926: error: DEAD_STORE + The value written to &next is never used. + 924. neigh->confirmed + neigh->parms->reachable_time)) { + 925. neigh_dbg(2, "neigh %p is still alive\n", neigh); + 926. > next = neigh->confirmed + neigh->parms->reachable_time; + 927. } else if (time_before_eq(now, + 928. neigh->used + + +net/core/neighbour.c:934: error: DEAD_STORE + The value written to &next is never used. + 932. neigh->updated = jiffies; + 933. neigh_suspect(neigh); + 934. > next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); + 935. } else { + 936. neigh_dbg(2, "neigh %p is suspected\n", neigh); + +net/core/neighbour.c:951: error: DEAD_STORE + The value written to &next is never used. + 949. neigh_connect(neigh); + 950. notify = 1; + 951. > next = neigh->confirmed + neigh->parms->reachable_time; + 952. } else { + 953. neigh_dbg(2, "neigh %p is probed\n", neigh); + +net/core/neighbour.c:958: error: DEAD_STORE + The value written to &next is never used. + 956. atomic_set(&neigh->probes, 0); + 957. notify = 1; + 958. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 959. } + 960. } else { + +net/core/neighbour.c:962: error: DEAD_STORE + The value written to &next is never used. + 960. } else { + 961. /* NUD_PROBE|NUD_INCOMPLETE */ + 962. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 963. } + 964. + +kernel/time/posix-timers.c:913: error: DEAD_STORE + The value written to &error is never used. + 911. struct itimerspec64 new_spec, old_spec; + 912. struct itimerspec64 *rtn = old_setting ? &old_spec : NULL; + 913. > int error = 0; + 914. + 915. if (!new_setting) + +drivers/gpu/drm/i915/intel_uncore.c:908: error: DEAD_STORE + The value written to &val is never used. + 906. } + 907. + 908. > __gen5_read(8) + 909. __gen5_read(16) + 910. __gen5_read(32) + +net/sunrpc/rpcb_clnt.c:920: error: NULL_DEREFERENCE + pointer `p` last assigned on line 919 could be null and is dereferenced by call to `xdr_encode_opaque()` at line 920, column 2. + 918. len = maxstrlen; + 919. p = xdr_reserve_space(xdr, 4 + len); + 920. > xdr_encode_opaque(p, string, len); + 921. } + 922. + +drivers/gpu/drm/i915/intel_uncore.c:909: error: DEAD_STORE + The value written to &val is never used. + 907. + 908. __gen5_read(8) + 909. > __gen5_read(16) + 910. __gen5_read(32) + 911. __gen5_read(64) + +drivers/gpu/drm/i915/intel_uncore.c:910: error: DEAD_STORE + The value written to &val is never used. + 908. __gen5_read(8) + 909. __gen5_read(16) + 910. > __gen5_read(32) + 911. __gen5_read(64) + 912. __gen2_read(8) + +drivers/gpu/drm/i915/intel_uncore.c:911: error: DEAD_STORE + The value written to &val is never used. + 909. __gen5_read(16) + 910. __gen5_read(32) + 911. > __gen5_read(64) + 912. __gen2_read(8) + 913. __gen2_read(16) + +net/netfilter/nf_conntrack_netlink.c:916: error: DEAD_STORE + The value written to &ret is never used. + 914. struct nlattr *tb[CTA_IP_MAX+1]; + 915. struct nf_conntrack_l3proto *l3proto; + 916. > int ret = 0; + 917. + 918. ret = nla_parse_nested(tb, CTA_IP_MAX, attr, NULL, NULL); + +drivers/gpu/drm/i915/intel_uncore.c:912: error: DEAD_STORE + The value written to &val is never used. + 910. __gen5_read(32) + 911. __gen5_read(64) + 912. > __gen2_read(8) + 913. __gen2_read(16) + 914. __gen2_read(32) + +drivers/gpu/drm/i915/intel_uncore.c:913: error: DEAD_STORE + The value written to &val is never used. + 911. __gen5_read(64) + 912. __gen2_read(8) + 913. > __gen2_read(16) + 914. __gen2_read(32) + 915. __gen2_read(64) + +drivers/pci/pci-sysfs.c:965: error: DEAD_STORE + The value written to &off is never used. + 963. if (size) { + 964. pci_user_write_config_byte(dev, off, data[off - init_off]); + 965. > off++; + 966. --size; + 967. } + +drivers/pci/pci-sysfs.c:966: error: DEAD_STORE + The value written to &size is never used. + 964. pci_user_write_config_byte(dev, off, data[off - init_off]); + 965. off++; + 966. > --size; + 967. } + 968. + +drivers/usb/early/ehci-dbgp.c:954: error: DEAD_STORE + The value written to &ret is never used. + 952. } + 953. if (chunk > 0) { + 954. > ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, + 955. dbgp_endpoint_out, buf, chunk); + 956. } + +drivers/gpu/drm/i915/intel_uncore.c:914: error: DEAD_STORE + The value written to &val is never used. + 912. __gen2_read(8) + 913. __gen2_read(16) + 914. > __gen2_read(32) + 915. __gen2_read(64) + 916. + +drivers/gpu/drm/i915/intel_uncore.c:915: error: DEAD_STORE + The value written to &val is never used. + 913. __gen2_read(16) + 914. __gen2_read(32) + 915. > __gen2_read(64) + 916. + 917. #undef __gen5_read + +net/core/net-sysfs.c:919: error: DEAD_STORE + The value written to &error is never used. + 917. struct netdev_rx_queue *queue = dev->_rx + index; + 918. struct kobject *kobj = &queue->kobj; + 919. > int error = 0; + 920. + 921. kobj->kset = dev->queues_kset; + +drivers/gpu/drm/i915/intel_pipe_crc.c:926: error: DEAD_STORE + The value written to &ret is never used. + 924. enum intel_pipe_crc_source source; + 925. u32 val = 0; /* shut up gcc */ + 926. > int ret = 0; + 927. + 928. if (display_crc_ctl_parse_source(source_name, &source) < 0) { + +kernel/cgroup/cgroup-v1.c:922: error: DEAD_STORE + The value written to &mask is never used. + 920. char *token, *o = data; + 921. bool all_ss = false, one_ss = false; + 922. > u16 mask = U16_MAX; + 923. struct cgroup_subsys *ss; + 924. int nr_opts = 0; + +net/wireless/trace.h:918: error: DEAD_STORE + The value written to &p is never used. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/core/ethtool.c:925: error: DEAD_STORE + The value written to &info_buf is never used. + 923. u64 sset_mask; + 924. int i, idx = 0, n_bits = 0, ret, rc; + 925. > u32 *info_buf = NULL; + 926. + 927. if (copy_from_user(&info, useraddr, sizeof(info))) + +net/core/ethtool.c:924: error: DEAD_STORE + The value written to &n_bits is never used. + 922. struct ethtool_sset_info info; + 923. u64 sset_mask; + 924. > int i, idx = 0, n_bits = 0, ret, rc; + 925. u32 *info_buf = NULL; + 926. + +drivers/gpu/drm/drm_mm.c:923: error: DEAD_STORE + The value written to &total is never used. + 921. { + 922. const struct drm_mm_node *entry; + 923. > u64 total_used = 0, total_free = 0, total = 0; + 924. + 925. total_free += drm_mm_dump_hole(p, &mm->head_node); + +drivers/video/fbdev/core/fbcon.c:927: error: DEAD_STORE + The value written to &font is never used. + 925. struct display *p = &fb_display[fg_console]; + 926. struct vc_data *vc = vc_cons[fg_console].d; + 927. > const struct font_desc *font = NULL; + 928. struct module *owner; + 929. struct fb_info *info = NULL; + +drivers/video/fbdev/core/fbcon.c:929: error: DEAD_STORE + The value written to &info is never used. + 927. const struct font_desc *font = NULL; + 928. struct module *owner; + 929. > struct fb_info *info = NULL; + 930. struct fbcon_ops *ops; + 931. int rows, cols; + +net/sunrpc/rpcb_clnt.c:936: error: NULL_DEREFERENCE + pointer `p` last assigned on line 936 could be null and is dereferenced at line 936, column 2. + 934. + 935. p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2); + 936. > *p++ = cpu_to_be32(rpcb->r_prog); + 937. *p = cpu_to_be32(rpcb->r_vers); + 938. + +arch/x86/platform/efi/efi.c:927: error: DEAD_STORE + The value written to &new_memmap is never used. + 925. { + 926. int count = 0, pg_shift = 0; + 927. > void *new_memmap = NULL; + 928. efi_status_t status; + 929. unsigned long pa; + +net/xfrm/xfrm_policy.c:927: error: DEAD_STORE + The value written to &err is never used. + 925. int xfrm_policy_flush(struct net *net, u8 type, bool task_valid) + 926. { + 927. > int dir, err = 0, cnt = 0; + 928. + 929. spin_lock_bh(&net->xfrm.xfrm_policy_lock); + +drivers/iommu/iommu.c:932: error: DEAD_STORE + The value written to &group is never used. + 930. struct group_for_pci_data data; + 931. struct pci_bus *bus; + 932. > struct iommu_group *group = NULL; + 933. u64 devfns[4] = { 0 }; + 934. + +drivers/gpu/drm/i915/intel_lvds.c:939: error: DEAD_STORE + The value written to &fixed_mode is never used. + 937. struct drm_encoder *encoder; + 938. struct drm_display_mode *scan; /* *modes, *bios_mode; */ + 939. > struct drm_display_mode *fixed_mode = NULL; + 940. struct drm_display_mode *downclock_mode = NULL; + 941. struct edid *edid; + +kernel/time/posix-timers.c:936: error: DEAD_STORE + The value written to &error is never used. + 934. struct itimerspec64 new_spec, old_spec; + 935. struct itimerspec64 *rtn = old ? &old_spec : NULL; + 936. > int error = 0; + 937. + 938. if (!new) + +sound/hda/hdac_device.c:934: error: DEAD_STORE + The value written to &val is never used. + 932. { + 933. int i; + 934. > unsigned int val = 0, rate, stream; + 935. + 936. val = query_pcm_param(codec, nid); + +drivers/usb/host/ohci-q.c:938: error: DEAD_STORE + The value written to &td is never used. + 936. { + 937. u32 td_dma; + 938. > struct td *td = NULL; + 939. + 940. td_dma = hc32_to_cpup (ohci, &ohci->hcca->done_head); + +drivers/iommu/dmar.c:938: error: DEAD_STORE + The value written to &err is never used. + 936. static int map_iommu(struct intel_iommu *iommu, u64 phys_addr) + 937. { + 938. > int map_size, err=0; + 939. + 940. iommu->reg_phys = phys_addr; + +drivers/net/ethernet/broadcom/tg3.c:954: error: DEAD_STORE + The value written to &apedata is never used. + 952. APE_HOST_SEG_LEN_MAGIC); + 953. apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT); + 954. > tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata); + 955. tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID, + 956. APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM)); + +drivers/rtc/interface.c:943: error: DEAD_STORE + The value written to &ret is never used. + 941. ktime_t expires, ktime_t period) + 942. { + 943. > int ret = 0; + 944. mutex_lock(&rtc->ops_lock); + 945. if (timer->enabled) + +drivers/thermal/thermal_core.c:947: error: DEAD_STORE + The value written to &pos is never used. + 945. { + 946. struct thermal_cooling_device *cdev; + 947. > struct thermal_zone_device *pos = NULL; + 948. int result; + 949. + +net/netfilter/nf_conntrack_netlink.c:946: error: DEAD_STORE + The value written to &ret is never used. + 944. const struct nf_conntrack_l4proto *l4proto; + 945. struct nlattr *tb[CTA_PROTO_MAX+1]; + 946. > int ret = 0; + 947. + 948. ret = nla_parse_nested(tb, CTA_PROTO_MAX, attr, proto_nla_policy, + +drivers/gpu/drm/i915/intel_dpio_phy.c:947: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 944 could be null and is dereferenced at line 947, column 6. + 945. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 946. + 947. > if (dport->release_cl2_override) { + 948. chv_phy_powergate_ch(dev_priv, DPIO_PHY0, DPIO_CH1, false); + 949. dport->release_cl2_override = false; + +drivers/net/ethernet/realtek/8139too.c:945: error: DEAD_STORE + The value written to &dev is never used. + 943. const struct pci_device_id *ent) + 944. { + 945. > struct net_device *dev = NULL; + 946. struct rtl8139_private *tp; + 947. int i, addr_len, option; + +kernel/time/timer.c:948: error: DEAD_STORE + The value written to &ret is never used. + 946. unsigned int idx = UINT_MAX; + 947. unsigned long clk = 0, flags; + 948. > int ret = 0; + 949. + 950. BUG_ON(!timer->function); + +drivers/usb/core/hub.c:956: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 955 could be null and is dereferenced at line 956, column 9. + 954. return -EINVAL; + 955. hub = usb_hub_to_struct_hub(udev->parent); + 956. > intf = to_usb_interface(hub->intfdev); + 957. + 958. usb_autopm_get_interface(intf); + +drivers/usb/core/driver.c:953: error: DEAD_STORE + The value written to &retval is never used. + 951. const char *mod_name) + 952. { + 953. > int retval = 0; + 954. + 955. if (usb_disabled()) + +net/ipv4/ipconfig.c:1015: error: DEAD_STORE + The value written to &h is never used. + 1013. + 1014. b = (struct bootp_pkt *)skb_network_header(skb); + 1015. > h = &b->iph; + 1016. + 1017. /* One reply at a time, please. */ + +net/wireless/trace.h:956: error: DEAD_STORE + The value written to &p is never used. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +drivers/gpu/drm/i915/intel_opregion.c:963: error: DEAD_STORE + The value written to &err is never used. + 961. u32 asls, mboxes; + 962. char buf[sizeof(OPREGION_SIGNATURE)]; + 963. > int err = 0; + 964. void *base; + 965. const void *vbt; + +net/ipv4/netfilter/ip_tables.c:985: error: DEAD_STORE + The value written to &ret is never used. + 983. + 984. if (compat) { + 985. > ret = compat_table_info(private, &tmp); + 986. xt_compat_flush_offsets(AF_INET); + 987. private = &tmp; + +net/unix/af_unix.c:964: error: DEAD_STORE + The value written to &err is never used. + 962. struct dentry *dentry; + 963. struct path path; + 964. > int err = 0; + 965. /* + 966. * Get the parent directory, calculate the hash for last + +drivers/i2c/i2c-core-base.c:987: error: DEAD_STORE + The value written to &blank is never used. + 985. + 986. /* Parse remaining parameters, reject extra parameters */ + 987. > res = sscanf(++blank, "%hi%c", &info.addr, &end); + 988. if (res < 1) { + 989. dev_err(dev, "%s: Can't parse I2C address\n", "new_device"); + +ipc/mqueue.c:1036: error: DEAD_STORE + The value written to &new_leaf is never used. + 1034. INIT_LIST_HEAD(&new_leaf->msg_list); + 1035. info->node_cache = new_leaf; + 1036. > new_leaf = NULL; + 1037. } else { + 1038. kfree(new_leaf); + +block/bsg.c:973: error: DEAD_STORE + The value written to &class_dev is never used. + 971. dev_t dev; + 972. int ret; + 973. > struct device *class_dev = NULL; + 974. const char *devname; + 975. + +drivers/hid/usbhid/hid-core.c:974: error: DEAD_STORE + The value written to &quirks is never used. + 972. struct usb_device *dev = interface_to_usbdev (intf); + 973. struct hid_descriptor *hdesc; + 974. > u32 quirks = 0; + 975. unsigned int rsize = 0; + 976. char *rdesc; + +net/core/skbuff.c:1000: error: DEAD_STORE + The value written to &next is never used. + 998. uarg->len++; + 999. uarg->bytelen = bytelen; + 1000. > atomic_set(&sk->sk_zckey, ++next); + 1001. sock_zerocopy_get(uarg); + 1002. return uarg; + +net/wireless/trace.h:973: error: DEAD_STORE + The value written to &p is never used. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &size is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &skip is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +net/ipv6/netfilter/ip6_tables.c:1003: error: DEAD_STORE + The value written to &ret is never used. + 1001. + 1002. if (compat) { + 1003. > ret = compat_table_info(private, &tmp); + 1004. xt_compat_flush_offsets(AF_INET6); + 1005. private = &tmp; + +net/netfilter/nf_conntrack_core.c:982: error: DEAD_STORE + The value written to &nf_conntrack_max95 is never used. + 980. unsigned int min_interval = max(HZ / GC_MAX_BUCKETS_DIV, 1u); + 981. unsigned int i, goal, buckets = 0, expired_count = 0; + 982. > unsigned int nf_conntrack_max95 = 0; + 983. struct conntrack_gc_work *gc_work; + 984. unsigned int ratio, scanned = 0; + +net/netfilter/nf_conntrack_core.c:992: error: DEAD_STORE + The value written to &nf_conntrack_max95 is never used. + 990. i = gc_work->last_bucket; + 991. if (gc_work->early_drop) + 992. > nf_conntrack_max95 = nf_conntrack_max / 100u * 95u; + 993. + 994. do { + +drivers/gpu/drm/i915/intel_uncore.c:979: error: DEAD_STORE + The value written to &val is never used. + 977. #define __fwtable_read(x) __gen_read(fwtable, x) + 978. + 979. > __fwtable_read(8) + 980. __fwtable_read(16) + 981. __fwtable_read(32) + +drivers/gpu/drm/i915/intel_uncore.c:980: error: DEAD_STORE + The value written to &val is never used. + 978. + 979. __fwtable_read(8) + 980. > __fwtable_read(16) + 981. __fwtable_read(32) + 982. __fwtable_read(64) + +drivers/gpu/drm/i915/intel_uncore.c:981: error: DEAD_STORE + The value written to &val is never used. + 979. __fwtable_read(8) + 980. __fwtable_read(16) + 981. > __fwtable_read(32) + 982. __fwtable_read(64) + 983. __gen6_read(8) + +drivers/gpu/drm/i915/intel_uncore.c:982: error: DEAD_STORE + The value written to &val is never used. + 980. __fwtable_read(16) + 981. __fwtable_read(32) + 982. > __fwtable_read(64) + 983. __gen6_read(8) + 984. __gen6_read(16) + +drivers/gpu/drm/i915/intel_uncore.c:983: error: DEAD_STORE + The value written to &val is never used. + 981. __fwtable_read(32) + 982. __fwtable_read(64) + 983. > __gen6_read(8) + 984. __gen6_read(16) + 985. __gen6_read(32) + +drivers/md/md-bitmap.c:989: error: DEAD_STORE + The value written to &set is never used. + 987. void *paddr; + 988. unsigned long chunk = block >> bitmap->counts.chunkshift; + 989. > int set = 0; + 990. + 991. page = filemap_get_page(&bitmap->storage, chunk); + +drivers/gpu/drm/i915/intel_uncore.c:984: error: DEAD_STORE + The value written to &val is never used. + 982. __fwtable_read(64) + 983. __gen6_read(8) + 984. > __gen6_read(16) + 985. __gen6_read(32) + 986. __gen6_read(64) + +drivers/cpufreq/cpufreq.c:988: error: DEAD_STORE + The value written to &ret is never used. + 986. { + 987. struct freq_attr **drv_attr; + 988. > int ret = 0; + 989. + 990. /* set up files for this cpu device */ + +drivers/gpu/drm/i915/intel_uncore.c:985: error: DEAD_STORE + The value written to &val is never used. + 983. __gen6_read(8) + 984. __gen6_read(16) + 985. > __gen6_read(32) + 986. __gen6_read(64) + 987. + +drivers/gpu/drm/i915/intel_dpio_phy.c:993: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 992 could be null and is dereferenced by call to `vlv_dport_to_channel()` at line 993, column 27. + 991. struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc); + 992. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 993. > enum dpio_channel port = vlv_dport_to_channel(dport); + 994. int pipe = intel_crtc->pipe; + 995. + +drivers/gpu/drm/i915/intel_uncore.c:986: error: DEAD_STORE + The value written to &val is never used. + 984. __gen6_read(16) + 985. __gen6_read(32) + 986. > __gen6_read(64) + 987. + 988. #undef __fwtable_read + +kernel/relay.c:997: error: DEAD_STORE + The value written to &consumed is never used. + 995. size_t n_subbufs = buf->chan->n_subbufs; + 996. size_t produced = buf->subbufs_produced; + 997. > size_t consumed = buf->subbufs_consumed; + 998. + 999. relay_file_read_consume(buf, read_pos, 0); + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &size is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &skip is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +net/wireless/trace.h:993: error: DEAD_STORE + The value written to &p is never used. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/netfilter/x_tables.c:996: error: DEAD_STORE + The value written to &info is never used. + 994. struct xt_table_info *xt_alloc_table_info(unsigned int size) + 995. { + 996. > struct xt_table_info *info = NULL; + 997. size_t sz = sizeof(*info) + size; + 998. + +net/ipv6/udp.c:1003: error: DEAD_STORE + The value written to &csum is never used. + 1001. struct udphdr *uh = udp_hdr(skb); + 1002. struct sk_buff *frags = skb_shinfo(skb)->frag_list; + 1003. > __wsum csum = 0; + 1004. + 1005. if (!frags) { + +net/ipv6/addrconf.c:1009: error: DEAD_STORE + The value written to &err is never used. + 1007. struct inet6_ifaddr *ifa = NULL; + 1008. struct rt6_info *rt = NULL; + 1009. > int err = 0; + 1010. int addr_type = ipv6_addr_type(addr); + 1011. + +security/selinux/avc.c:1022: error: DEAD_STORE + The value written to &node is never used. + 1020. node = avc_lookup(ssid, tsid, tclass); + 1021. if (unlikely(!node)) { + 1022. > node = avc_compute_av(ssid, tsid, tclass, &avd, xp_node); + 1023. } else { + 1024. memcpy(&avd, &node->ae.avd, sizeof(avd)); + +net/sunrpc/svcsock.c:1005: error: DEAD_STORE + The value written to &req is never used. + 1003. { + 1004. struct rpc_xprt *bc_xprt = svsk->sk_xprt.xpt_bc_xprt; + 1005. > struct rpc_rqst *req = NULL; + 1006. struct kvec *src, *dst; + 1007. __be32 *p = (__be32 *)rqstp->rq_arg.head[0].iov_base; + +drivers/ata/ata_piix.c:1009: error: DEAD_STORE + The value written to &rc is never used. + 1007. struct ata_host *host = pci_get_drvdata(pdev); + 1008. unsigned long flags; + 1009. > int rc = 0; + 1010. + 1011. rc = ata_host_suspend(host, mesg); + +drivers/pci/pci.c:1027: error: DEAD_STORE + The value written to &i is never used. + 1025. pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]); + 1026. pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]); + 1027. > pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]); + 1028. + 1029. return 0; + +drivers/pci/setup-bus.c:1019: error: DEAD_STORE + The value written to &children_add_align is never used. + 1017. mask | IORESOURCE_PREFETCH, type); + 1018. resource_size_t children_add_size = 0; + 1019. > resource_size_t children_add_align = 0; + 1020. resource_size_t add_align = 0; + 1021. + +block/elevator.c:1010: error: DEAD_STORE + The value written to &old_registered is never used. + 1008. { + 1009. struct elevator_queue *old = q->elevator; + 1010. > bool old_registered = false; + 1011. int err; + 1012. + +include/linux/rhashtable.h:1047: error: DEAD_STORE + The value written to &list is never used. + 1045. continue; + 1046. + 1047. > list = rht_dereference_bucket(list->next, tbl, hash); + 1048. RCU_INIT_POINTER(*lpprev, list); + 1049. err = 0; + +drivers/usb/host/ehci-q.c:1017: error: DEAD_STORE + The value written to &qh is never used. + 1015. ) + 1016. { + 1017. > struct ehci_qh *qh = NULL; + 1018. __hc32 qh_addr_mask = cpu_to_hc32(ehci, 0x7f); + 1019. + +net/wireless/trace.h:1012: error: DEAD_STORE + The value written to &p is never used. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +sound/core/pcm_native.c:1022: error: DEAD_STORE + The value written to &s is never used. + 1020. int state, int do_lock) + 1021. { + 1022. > struct snd_pcm_substream *s = NULL; + 1023. struct snd_pcm_substream *s1; + 1024. int res = 0, depth = 1; + +drivers/iommu/dmar.c:1023: error: DEAD_STORE + The value written to &agaw is never used. + 1021. struct intel_iommu *iommu; + 1022. u32 ver, sts; + 1023. > int agaw = 0; + 1024. int msagaw = 0; + 1025. int err; + +drivers/iommu/dmar.c:1024: error: DEAD_STORE + The value written to &msagaw is never used. + 1022. u32 ver, sts; + 1023. int agaw = 0; + 1024. > int msagaw = 0; + 1025. int err; + 1026. + +arch/x86/events/intel/ds.c:1027: error: DEAD_STORE + The value written to &is_64bit is never used. + 1025. unsigned long old_to, to = cpuc->lbr_entries[0].to; + 1026. unsigned long ip = regs->ip; + 1027. > int is_64bit = 0; + 1028. void *kaddr; + 1029. int size; + +drivers/cpufreq/cpufreq.c:1024: error: DEAD_STORE + The value written to &gov is never used. + 1022. static int cpufreq_init_policy(struct cpufreq_policy *policy) + 1023. { + 1024. > struct cpufreq_governor *gov = NULL; + 1025. struct cpufreq_policy new_policy; + 1026. + +drivers/gpu/drm/i915/intel_display.c:1024: error: DEAD_STORE + The value written to &dev_priv is never used. + 1022. static void wait_for_pipe_scanline_moving(struct intel_crtc *crtc, bool state) + 1023. { + 1024. > struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 1025. enum pipe pipe = crtc->pipe; + 1026. + +drivers/gpu/drm/i915/intel_display.c:1028: error: DEAD_STORE + The value written to &timeout__ is never used. + 1026. + 1027. /* Wait for the display line to settle/start moving */ + 1028. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1029. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1030. pipe_name(pipe), onoff(state)); + +net/ipv4/ping.c:1027: error: DEAD_STORE + The value written to &net is never used. + 1025. struct sock *sk; + 1026. struct ping_iter_state *state = seq->private; + 1027. > struct net *net = seq_file_net(seq); + 1028. + 1029. for (state->bucket = start; state->bucket < PING_HTABLE_SIZE; + +lib/vsprintf.c:1079: error: DEAD_STORE + The value written to &needcolon is never used. + 1077. if (needcolon) { + 1078. *p++ = ':'; + 1079. > needcolon = false; + 1080. } + 1081. /* hex u16 without leading 0s */ + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1067: error: DEAD_STORE + The value written to &ret_val is never used. + 1065. if ((hw->mac_type == e1000_82545_rev_3) || + 1066. (hw->mac_type == e1000_82546_rev_3)) { + 1067. > ret_val = + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1070: error: DEAD_STORE + The value written to &ret_val is never used. + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + 1070. > ret_val = + 1071. e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); + 1072. } + +drivers/video/fbdev/core/fbcon.c:1071: error: DEAD_STORE + The value written to &font is never used. + 1069. REFCOUNT(p->fontdata)++; + 1070. } else { + 1071. > const struct font_desc *font = NULL; + 1072. + 1073. if (!fontname[0] || !(font = find_font(fontname))) + +drivers/nvmem/core.c:1052: error: DEAD_STORE + The value written to &rc is never used. + 1050. + 1051. /* setup the first byte with lsb bits from nvmem */ + 1052. > rc = nvmem_reg_read(nvmem, cell->offset, &v, 1); + 1053. *b++ |= GENMASK(bit_offset - 1, 0) & v; + 1054. + +drivers/nvmem/core.c:1069: error: DEAD_STORE + The value written to &rc is never used. + 1067. if ((nbits + bit_offset) % BITS_PER_BYTE) { + 1068. /* setup the last byte with msb bits from nvmem */ + 1069. > rc = nvmem_reg_read(nvmem, + 1070. cell->offset + cell->bytes - 1, &v, 1); + 1071. *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v; + +drivers/pci/pci.c:1049: error: DEAD_STORE + The value written to &i is never used. + 1047. pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]); + 1048. pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]); + 1049. > pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]); + 1050. } + 1051. + +net/ipv6/udp.c:1043: error: DEAD_STORE + The value written to &csum is never used. + 1041. int err = 0; + 1042. int is_udplite = IS_UDPLITE(sk); + 1043. > __wsum csum = 0; + 1044. int offset = skb_transport_offset(skb); + 1045. int len = skb->len - offset; + +net/ipv6/udp.c:1041: error: DEAD_STORE + The value written to &err is never used. + 1039. struct sock *sk = skb->sk; + 1040. struct udphdr *uh; + 1041. > int err = 0; + 1042. int is_udplite = IS_UDPLITE(sk); + 1043. __wsum csum = 0; + +net/ipv6/tcp_ipv6.c:1072: error: DEAD_STORE + The value written to &newinet is never used. + 1070. inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; + 1071. + 1072. > newinet = inet_sk(newsk); + 1073. newnp = inet6_sk(newsk); + 1074. newtp = tcp_sk(newsk); + +drivers/gpu/drm/i915/intel_dpio_phy.c:1054: error: DEAD_STORE + The value written to &val is never used. + 1052. + 1053. /* Enable clock channels for this port */ + 1054. > val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(port)); + 1055. val = 0; + 1056. if (pipe) + +kernel/events/core.c:1044: error: DEAD_STORE + The value written to &rotations is never used. + 1042. { + 1043. struct perf_cpu_context *cpuctx; + 1044. > int rotations = 0; + 1045. + 1046. lockdep_assert_irqs_disabled(); + +drivers/iommu/intel-iommu.c:1046: error: DEAD_STORE + The value written to &pte is never used. + 1044. int level, int *large_page) + 1045. { + 1046. > struct dma_pte *parent, *pte = NULL; + 1047. int total = agaw_to_level(domain->agaw); + 1048. int offset; + +kernel/cpu.c:1044: error: DEAD_STORE + The value written to &err is never used. + 1042. static int do_cpu_up(unsigned int cpu, enum cpuhp_state target) + 1043. { + 1044. > int err = 0; + 1045. + 1046. if (!cpu_possible(cpu)) { + +net/wireless/trace.h:1042: error: DEAD_STORE + The value written to &p is never used. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/ipv6/route.c:1061: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1060 could be null and is dereferenced by call to `dev_net()` at line 1061, column 23. + 1059. rcu_read_lock(); + 1060. dev = ip6_rt_get_dev_rcu(ort); + 1061. > rt = __ip6_dst_alloc(dev_net(dev), dev, 0); + 1062. rcu_read_unlock(); + 1063. if (!rt) + +net/ipv6/sit.c:1058: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `ip_route_output_ports()` at line 1058, column 23. + 1056. + 1057. if (iph->daddr) { + 1058. > struct rtable *rt = ip_route_output_ports(tunnel->net, &fl4, + 1059. NULL, + 1060. iph->daddr, iph->saddr, + +net/sched/act_api.c:1053: error: DEAD_STORE + The value written to &err is never used. + 1051. { + 1052. struct sk_buff *skb; + 1053. > int err = 0; + 1054. + 1055. skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); + +drivers/video/console/vgacon.c:1057: error: DEAD_STORE + The value written to &font_select is never used. + 1055. { + 1056. unsigned short video_port_status = vga_video_port_reg + 6; + 1057. > int font_select = 0x00, beg, i; + 1058. char *charmap; + 1059. bool clear_attribs = false; + +kernel/cgroup/cgroup-v1.c:1056: error: DEAD_STORE + The value written to &ret is never used. + 1054. static int cgroup1_remount(struct kernfs_root *kf_root, int *flags, char *data) + 1055. { + 1056. > int ret = 0; + 1057. struct cgroup_root *root = cgroup_root_from_kf(kf_root); + 1058. struct cgroup_sb_opts opts; + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &maxsize is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &skip is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_ddi.c:1068: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1065 could be null and is dereferenced at line 1068, column 17. + 1066. enc_to_dig_port(&encoder->base); + 1067. + 1068. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1069. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1070. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +drivers/gpu/drm/i915/intel_ddi.c:1068: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 1064 could be null and is dereferenced at line 1068, column 2. + 1066. enc_to_dig_port(&encoder->base); + 1067. + 1068. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1069. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1070. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +drivers/thermal/thermal_core.c:1070: error: DEAD_STORE + The value written to &pos is never used. + 1068. const struct thermal_zone_params *tzp; + 1069. struct thermal_zone_device *tz; + 1070. > struct thermal_cooling_device *pos = NULL; + 1071. + 1072. if (!cdev) + +net/xfrm/xfrm_state.c:1074: error: DEAD_STORE + The value written to &x is never used. + 1072. { + 1073. unsigned int h; + 1074. > struct xfrm_state *rx = NULL, *x = NULL; + 1075. + 1076. spin_lock_bh(&net->xfrm.xfrm_state_lock); + +net/wireless/trace.h:1069: error: DEAD_STORE + The value written to &p is never used. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +block/elevator.c:1083: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `elevator_switch()` at line 1083, column 10. + 1081. */ + 1082. if (q->mq_ops && !strncmp(name, "none", 4)) + 1083. > return elevator_switch(q, NULL); + 1084. + 1085. strlcpy(elevator_name, name, sizeof(elevator_name)); + +drivers/gpu/drm/drm_dp_mst_topology.c:1079: error: DEAD_STORE + The value written to &ret is never used. + 1077. case DP_PEER_DEVICE_SST_SINK: + 1078. /* add i2c over sideband */ + 1079. > ret = drm_dp_mst_register_i2c_bus(&port->aux); + 1080. break; + 1081. case DP_PEER_DEVICE_MST_BRANCHING: + +drivers/md/dm-raid1.c:1142: error: DEAD_STORE + The value written to &argv is never used. + 1140. goto err_destroy_wq; + 1141. + 1142. > argv += args_used; + 1143. argc -= args_used; + 1144. + +kernel/power/snapshot.c:1073: error: DEAD_STORE + The value written to &error is never used. + 1071. { + 1072. struct memory_bitmap *bm1, *bm2; + 1073. > int error = 0; + 1074. + 1075. if (forbidden_pages_map && free_pages_map) + +net/sunrpc/svc.c:1083: error: DEAD_STORE + The value written to &error is never used. + 1081. */ + 1082. if (error == -EPROTONOSUPPORT) + 1083. > error = rpcb_register(net, program, version, 0, 0); + 1084. + 1085. dprintk("svc: %s(%sv%u), error %d\n", + +net/sched/act_api.c:1075: error: DEAD_STORE + The value written to &ret is never used. + 1073. struct nlmsghdr *n, u32 portid, int ovr) + 1074. { + 1075. > int ret = 0; + 1076. LIST_HEAD(actions); + 1077. + +drivers/iommu/intel-iommu.c:1078: error: DEAD_STORE + The value written to &large_page is never used. + 1076. unsigned long last_pfn) + 1077. { + 1078. > unsigned int large_page = 1; + 1079. struct dma_pte *first_pte, *pte; + 1080. + +drivers/pci/pci.c:1086: error: DEAD_STORE + The value written to &i is never used. + 1084. cap = (u16 *)&save_state->cap.data[0]; + 1085. + 1086. > pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]); + 1087. } + 1088. + +drivers/gpu/drm/i915/intel_dsi.c:1153: error: DEAD_STORE + The value written to &vbp is never used. + 1151. vfp = I915_READ(MIPI_VFP_COUNT(port)); + 1152. vsync = I915_READ(MIPI_VSYNC_PADDING_COUNT(port)); + 1153. > vbp = I915_READ(MIPI_VBP_COUNT(port)); + 1154. + 1155. adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp; + +drivers/firmware/efi/vars.c:1089: error: DEAD_STORE + The value written to &err is never used. + 1087. struct list_head *head, void *data) + 1088. { + 1089. > int err = 0; + 1090. + 1091. err = efivar_entry_iter_begin(); + +net/netfilter/nf_conntrack_sip.c:1099: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1094 could be null and is dereferenced at line 1099, column 11. + 1097. (code >= 200 && code <= 299)) + 1098. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1099. > else if (ct_sip_info->invite_cseq == cseq) + 1100. flush_expectations(ct, true); + 1101. return NF_ACCEPT; + +net/wireless/trace.h:1087: error: DEAD_STORE + The value written to &p is never used. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/ipv6/route.c:1095: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1094 could be null and is dereferenced by call to `dev_net()` at line 1095, column 28. + 1093. rcu_read_lock(); + 1094. dev = ip6_rt_get_dev_rcu(rt); + 1095. > pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags); + 1096. rcu_read_unlock(); + 1097. if (!pcpu_rt) + +crypto/gcm.c:1098: error: DEAD_STORE + The value written to &err is never used. + 1096. struct crypto_skcipher *null; + 1097. unsigned long align; + 1098. > int err = 0; + 1099. + 1100. aead = crypto_spawn_aead(spawn); + +drivers/video/fbdev/core/fbmem.c:1100: error: DEAD_STORE + The value written to &ret is never used. + 1098. struct fb_event event; + 1099. void __user *argp = (void __user *)arg; + 1100. > long ret = 0; + 1101. + 1102. switch (cmd) { + +security/selinux/ss/services.c:1098: error: DEAD_STORE + The value written to &scontext is never used. + 1096. { + 1097. u16 tclass; + 1098. > struct context *scontext = NULL, *tcontext = NULL; + 1099. + 1100. read_lock(&policy_rwlock); + +security/selinux/ss/services.c:1098: error: DEAD_STORE + The value written to &tcontext is never used. + 1096. { + 1097. u16 tclass; + 1098. > struct context *scontext = NULL, *tcontext = NULL; + 1099. + 1100. read_lock(&policy_rwlock); + +drivers/pcmcia/rsrc_nonstatic.c:1099: error: DEAD_STORE + The value written to &ret is never used. + 1097. unsigned long start_addr, end_addr; + 1098. unsigned int add = ADD_MANAGED_RESOURCE; + 1099. > ssize_t ret = 0; + 1100. + 1101. ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); + +net/sched/act_api.c:1098: error: DEAD_STORE + The value written to &ret is never used. + 1096. struct nlattr *tca[TCA_ROOT_MAX + 1]; + 1097. u32 portid = skb ? NETLINK_CB(skb).portid : 0; + 1098. > int ret = 0, ovr = 0; + 1099. + 1100. if ((n->nlmsg_type != RTM_GETACTION) && + +drivers/gpu/drm/drm_dp_mst_topology.c:1102: error: DEAD_STORE + The value written to &ret is never used. + 1100. if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) { + 1101. if (mstb->port_parent) { + 1102. > ret = drm_dp_send_dpcd_write( + 1103. mstb->mgr, + 1104. mstb->port_parent, + +drivers/gpu/drm/drm_dp_mst_topology.c:1110: error: DEAD_STORE + The value written to &ret is never used. + 1108. } else { + 1109. + 1110. > ret = drm_dp_dpcd_write( + 1111. mstb->mgr->aux, + 1112. DP_GUID, + +security/selinux/avc.c:1110: error: DEAD_STORE + The value written to &node is never used. + 1108. node = avc_lookup(ssid, tsid, tclass); + 1109. if (unlikely(!node)) + 1110. > node = avc_compute_av(ssid, tsid, tclass, avd, &xp_node); + 1111. else + 1112. memcpy(avd, &node->ae.avd, sizeof(*avd)); + +net/wireless/reg.c:1097: error: DEAD_STORE + The value written to ®_rule is never used. + 1095. static bool is_valid_rd(const struct ieee80211_regdomain *rd) + 1096. { + 1097. > const struct ieee80211_reg_rule *reg_rule = NULL; + 1098. unsigned int i; + 1099. + +drivers/input/mouse/alps.c:1113: error: DEAD_STORE + The value written to &z is never used. + 1111. y = (packet[3] & 0x07) | (packet[4] & 0xb8) | + 1112. ((packet[3] & 0x20) << 1); + 1113. > z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1); + 1114. + 1115. left = (packet[1] & 0x01); + +kernel/signal.c:1100: error: DEAD_STORE + The value written to &from_ancestor_ns is never used. + 1098. int group) + 1099. { + 1100. > int from_ancestor_ns = 0; + 1101. + 1102. #ifdef CONFIG_PID_NS + +net/packet/af_packet.c:1101: error: DEAD_STORE + The value written to &curr is never used. + 1099. int status, unsigned int len) + 1100. { + 1101. > char *curr = NULL; + 1102. switch (po->tp_version) { + 1103. case TPACKET_V1: + +drivers/char/random.c:1113: error: DEAD_STORE + The value written to &idx is never used. + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + 1113. > ptr += idx++; + 1114. WRITE_ONCE(f->reg_idx, idx); + 1115. return *ptr; + +net/wireless/trace.h:1103: error: DEAD_STORE + The value written to &p is never used. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/netfilter/nf_conntrack_sip.c:1116: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1111 could be null and is dereferenced at line 1116, column 11. + 1114. (code >= 200 && code <= 299)) + 1115. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1116. > else if (ct_sip_info->invite_cseq == cseq) + 1117. flush_expectations(ct, true); + 1118. return NF_ACCEPT; + +drivers/base/property.c:1114: error: DEAD_STORE + The value written to &attr is never used. + 1112. enum dev_dma_attr device_get_dma_attr(struct device *dev) + 1113. { + 1114. > enum dev_dma_attr attr = DEV_DMA_NOT_SUPPORTED; + 1115. + 1116. if (IS_ENABLED(CONFIG_OF) && dev->of_node) { + +drivers/thermal/thermal_core.c:1115: error: DEAD_STORE + The value written to &pos is never used. + 1113. { + 1114. int i, ret; + 1115. > struct thermal_cooling_device *pos = NULL; + 1116. const struct thermal_zone_params *tzp = tz->tzp; + 1117. + +net/sunrpc/sched.c:1117: error: DEAD_STORE + The value written to &wq is never used. + 1115. static void rpciod_stop(void) + 1116. { + 1117. > struct workqueue_struct *wq = NULL; + 1118. + 1119. if (rpciod_workqueue == NULL) + +kernel/auditfilter.c:1119: error: DEAD_STORE + The value written to &err is never used. + 1117. int audit_rule_change(int type, int seq, void *data, size_t datasz) + 1118. { + 1119. > int err = 0; + 1120. struct audit_entry *entry; + 1121. + +drivers/hid/hid-lg4ff.c:1127: error: DEAD_STORE + The value written to &state is never used. + 1125. struct lg_drv_data *drv_data = hid_get_drvdata(hid); + 1126. struct lg4ff_device_entry *entry; + 1127. > int i, state = 0; + 1128. + 1129. if (!drv_data) { + +security/keys/keyctl.c:1138: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `keyctl_instantiate_key_common()` at line 1138, column 9. + 1136. } + 1137. + 1138. > return keyctl_instantiate_key_common(id, NULL, ringid); + 1139. } + 1140. + +net/netfilter/nf_conntrack_sip.c:1133: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1128 could be null and is dereferenced at line 1133, column 11. + 1131. (code >= 200 && code <= 299)) + 1132. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1133. > else if (ct_sip_info->invite_cseq == cseq) + 1134. flush_expectations(ct, true); + 1135. return NF_ACCEPT; + +drivers/gpu/drm/i915/intel_ddi.c:1127: error: DEAD_STORE + The value written to &refclk is never used. + 1125. i915_reg_t reg) + 1126. { + 1127. > int refclk = LC_FREQ; + 1128. int n, p, r; + 1129. u32 wrpll; + +drivers/iommu/amd_iommu_init.c:1129: error: DEAD_STORE + The value written to &devid is never used. + 1127. u8 *p = (u8 *)h; + 1128. u8 *end = p, flags = 0; + 1129. > u16 devid = 0, devid_start = 0, devid_to = 0; + 1130. u32 dev_i, ext_flags = 0; + 1131. bool alias = false; + +net/sched/sch_api.c:1128: error: DEAD_STORE + The value written to &err is never used. + 1126. { + 1127. struct qdisc_size_table *ostab, *stab = NULL; + 1128. > int err = 0; + 1129. + 1130. if (tca[TCA_OPTIONS]) { + +net/wireless/trace.h:1127: error: DEAD_STORE + The value written to &p is never used. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/ipv6/ip6_fib.c:1138: error: DEAD_STORE + The value written to &err is never used. + 1136. struct fib6_table *table = rt->rt6i_table; + 1137. struct fib6_node *fn, *pn = NULL; + 1138. > int err = -ENOMEM; + 1139. int allow_create = 1; + 1140. int replace_required = 0; + +net/ipv6/ip6_fib.c:1137: error: DEAD_STORE + The value written to &pn is never used. + 1135. { + 1136. struct fib6_table *table = rt->rt6i_table; + 1137. > struct fib6_node *fn, *pn = NULL; + 1138. int err = -ENOMEM; + 1139. int allow_create = 1; + +net/ipv6/ip6_fib.c:1167: error: DEAD_STORE + The value written to &pn is never used. + 1165. } + 1166. + 1167. > pn = fn; + 1168. + 1169. #ifdef CONFIG_IPV6_SUBTREES + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &maxsize is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &skip is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_tv.c:1192: error: DEAD_STORE + The value written to &type is never used. + 1190. intel_wait_for_vblank(dev_priv, intel_crtc->pipe); + 1191. + 1192. > type = -1; + 1193. tv_dac = I915_READ(TV_DAC); + 1194. DRM_DEBUG_KMS("TV detected: %x, %x\n", tv_ctl, tv_dac); + +net/netfilter/nf_conntrack_sip.c:1151: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1145 could be null and is dereferenced at line 1151, column 3. + 1149. ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1150. if (ret == NF_ACCEPT) + 1151. > ct_sip_info->invite_cseq = cseq; + 1152. return ret; + 1153. } + +security/selinux/ss/services.c:1145: error: DEAD_STORE + The value written to &scontext is never used. + 1143. struct av_decision *avd) + 1144. { + 1145. > struct context *scontext = NULL, *tcontext = NULL; + 1146. + 1147. read_lock(&policy_rwlock); + +security/selinux/ss/services.c:1145: error: DEAD_STORE + The value written to &tcontext is never used. + 1143. struct av_decision *avd) + 1144. { + 1145. > struct context *scontext = NULL, *tcontext = NULL; + 1146. + 1147. read_lock(&policy_rwlock); + +kernel/cgroup/cpuset.c:1165: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 1156 could be null and is dereferenced at line 1165, column 16. + 1163. */ + 1164. if (is_in_v2_mode() && nodes_empty(*new_mems)) + 1165. > *new_mems = parent->effective_mems; + 1166. + 1167. /* Skip the whole subtree if the nodemask remains the same. */ + +net/sunrpc/svc.c:1155: error: DEAD_STORE + The value written to &procp is never used. + 1153. struct svc_program *progp; + 1154. const struct svc_version *versp = NULL; /* compiler food */ + 1155. > const struct svc_procedure *procp = NULL; + 1156. struct svc_serv *serv = rqstp->rq_server; + 1157. __be32 *statp; + +net/sunrpc/svc.c:1163: error: DEAD_STORE + The value written to &rpc_stat is never used. + 1161. __be32 *reply_statp; + 1162. + 1163. > rpc_stat = rpc_success; + 1164. + 1165. if (argv->iov_len < 6*4) + +net/sunrpc/svc.c:1154: error: DEAD_STORE + The value written to &versp is never used. + 1152. { + 1153. struct svc_program *progp; + 1154. > const struct svc_version *versp = NULL; /* compiler food */ + 1155. const struct svc_procedure *procp = NULL; + 1156. struct svc_serv *serv = rqstp->rq_server; + +crypto/drbg.c:1153: error: DEAD_STORE + The value written to &ret is never used. + 1151. static inline int drbg_alloc_state(struct drbg_state *drbg) + 1152. { + 1153. > int ret = -ENOMEM; + 1154. unsigned int sb_size = 0; + 1155. + +crypto/drbg.c:1154: error: DEAD_STORE + The value written to &sb_size is never used. + 1152. { + 1153. int ret = -ENOMEM; + 1154. > unsigned int sb_size = 0; + 1155. + 1156. switch (drbg->core->flags & DRBG_TYPE_MASK) { + +net/ipv6/sit.c:1157: error: DEAD_STORE + The value written to &err is never used. + 1155. ipip6_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) + 1156. { + 1157. > int err = 0; + 1158. struct ip_tunnel_parm p; + 1159. struct ip_tunnel_prl prl; + +net/wireless/trace.h:1157: error: DEAD_STORE + The value written to &p is never used. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +drivers/pcmcia/rsrc_nonstatic.c:1165: error: DEAD_STORE + The value written to &ret is never used. + 1163. unsigned long start_addr, end_addr; + 1164. unsigned int add = ADD_MANAGED_RESOURCE; + 1165. > ssize_t ret = 0; + 1166. + 1167. ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); + +net/sunrpc/auth_gss/svcauth_gss.c:1165: error: DEAD_STORE + The value written to &gm is never used. + 1163. static atomic64_t ctxhctr; + 1164. long long ctxh; + 1165. > struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. int status = -EINVAL; + +net/sunrpc/auth_gss/svcauth_gss.c:1167: error: DEAD_STORE + The value written to &status is never used. + 1165. struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. > int status = -EINVAL; + 1168. + 1169. memset(&rsci, 0, sizeof(rsci)); + +net/sunrpc/auth_gss/svcauth_gss.c:1205: error: DEAD_STORE + The value written to &status is never used. + 1203. rsci.cred.cr_gss_mech = gm; + 1204. + 1205. > status = -EINVAL; + 1206. /* mech-specific data: */ + 1207. status = gss_import_sec_context(ud->out_handle.data, + +net/xfrm/xfrm_policy.c:1171: error: DEAD_STORE + The value written to &err is never used. + 1169. if (pol != NULL) { + 1170. bool match; + 1171. > int err = 0; + 1172. + 1173. if (pol->family != family) { + +net/sched/act_api.c:1183: error: DEAD_STORE + The value written to &act_count is never used. + 1181. struct nla_bitfield32 bf; + 1182. u32 msecs_since = 0; + 1183. > u32 act_count = 0; + 1184. + 1185. ret = nlmsg_parse(cb->nlh, sizeof(struct tcamsg), tb, TCA_ROOT_MAX, + +net/sched/act_api.c:1178: error: DEAD_STORE + The value written to &count_attr is never used. + 1176. struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1177. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1178. > struct nlattr *count_attr = NULL; + 1179. unsigned long jiffy_since = 0; + 1180. struct nlattr *kind = NULL; + +net/sched/act_api.c:1180: error: DEAD_STORE + The value written to &kind is never used. + 1178. struct nlattr *count_attr = NULL; + 1179. unsigned long jiffy_since = 0; + 1180. > struct nlattr *kind = NULL; + 1181. struct nla_bitfield32 bf; + 1182. u32 msecs_since = 0; + +net/sched/act_api.c:1175: error: DEAD_STORE + The value written to &ret is never used. + 1173. struct nlattr *nest; + 1174. struct tc_action_ops *a_o; + 1175. > int ret = 0; + 1176. struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1177. struct nlattr *tb[TCA_ROOT_MAX + 1]; + +net/sched/act_api.c:1176: error: DEAD_STORE + The value written to &t is never used. + 1174. struct tc_action_ops *a_o; + 1175. int ret = 0; + 1176. > struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1177. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1178. struct nlattr *count_attr = NULL; + +drivers/tty/vt/vt_ioctl.c:1177: error: DEAD_STORE + The value written to &ret is never used. + 1175. void __user *up = (void __user *)arg; + 1176. int perm; + 1177. > int ret = 0; + 1178. + 1179. console = vc->vc_num; + +drivers/md/dm-table.c:1174: error: DEAD_STORE + The value written to &dd is never used. + 1172. { + 1173. struct list_head *devices = dm_table_get_devices(t); + 1174. > struct dm_dev_internal *dd = NULL; + 1175. struct gendisk *prev_disk = NULL, *template_disk = NULL; + 1176. unsigned i; + +drivers/net/ethernet/broadcom/tg3.c:1207: error: DEAD_STORE + The value written to &frame_val is never used. + 1205. if ((frame_val & MI_COM_BUSY) == 0) { + 1206. udelay(5); + 1207. > frame_val = tr32(MAC_MI_COM); + 1208. break; + 1209. } + +net/core/dev.c:1177: error: DEAD_STORE + The value written to &err is never used. + 1175. unsigned char old_assign_type; + 1176. char oldname[IFNAMSIZ]; + 1177. > int err = 0; + 1178. int ret; + 1179. struct net *net; + +security/selinux/hooks.c:1176: error: DEAD_STORE + The value written to &rc is never used. + 1174. static int superblock_doinit(struct super_block *sb, void *data) + 1175. { + 1176. > int rc = 0; + 1177. char *options = data; + 1178. struct security_mnt_opts opts; + +drivers/cpufreq/cpufreq.c:1307: error: DEAD_STORE + The value written to &new_policy is never used. + 1305. __func__, cpu, ret); + 1306. /* cpufreq_policy_free() will notify based on this */ + 1307. > new_policy = false; + 1308. goto out_exit_policy; + 1309. } + +drivers/net/phy/phy_device.c:1181: error: DEAD_STORE + The value written to &ret is never used. + 1179. { + 1180. struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver); + 1181. > int ret = 0; + 1182. + 1183. mutex_lock(&phydev->lock); + +net/wireless/trace.h:1178: error: DEAD_STORE + The value written to &p is never used. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/netfilter/nf_conntrack_netlink.c:1240: error: DEAD_STORE + The value written to &err is never used. + 1238. ct = nf_ct_tuplehash_to_ctrack(h); + 1239. + 1240. > err = -ENOMEM; + 1241. skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); + 1242. if (skb2 == NULL) { + +net/netfilter/nf_conntrack_netlink.c:1194: error: DEAD_STORE + The value written to &skb2 is never used. + 1192. struct nf_conntrack_tuple tuple; + 1193. struct nf_conn *ct; + 1194. > struct sk_buff *skb2 = NULL; + 1195. struct nfgenmsg *nfmsg = nlmsg_data(nlh); + 1196. u_int8_t u3 = nfmsg->nfgen_family; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1232: error: DEAD_STORE + The value written to &batch is never used. + 1230. *batch++ = lower_32_bits(addr); + 1231. *batch++ = upper_32_bits(addr); + 1232. > *batch++ = upper_32_bits(target_offset); + 1233. } else { + 1234. *batch++ = (MI_STORE_DWORD_IMM_GEN4 | (1 << 21)) + 1; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1238: error: DEAD_STORE + The value written to &batch is never used. + 1236. *batch++ = upper_32_bits(addr); + 1237. *batch++ = lower_32_bits(target_offset); + 1238. > *batch++ = upper_32_bits(target_offset); + 1239. } + 1240. } else if (gen >= 6) { + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1244: error: DEAD_STORE + The value written to &batch is never used. + 1242. *batch++ = 0; + 1243. *batch++ = addr; + 1244. > *batch++ = target_offset; + 1245. } else if (gen >= 4) { + 1246. *batch++ = MI_STORE_DWORD_IMM_GEN4 | MI_USE_GGTT; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1249: error: DEAD_STORE + The value written to &batch is never used. + 1247. *batch++ = 0; + 1248. *batch++ = addr; + 1249. > *batch++ = target_offset; + 1250. } else { + 1251. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1253: error: DEAD_STORE + The value written to &batch is never used. + 1251. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + 1252. *batch++ = addr; + 1253. > *batch++ = target_offset; + 1254. } + 1255. + +arch/x86/pci/irq.c:1196: error: DEAD_STORE + The value written to &msg is never used. + 1194. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin); + 1195. if (pin && !pcibios_lookup_irq(dev, 1)) { + 1196. > char *msg = ""; + 1197. + 1198. if (!io_apic_assign_pci_irqs && dev->irq) + +kernel/relay.c:1204: error: DEAD_STORE + The value written to &pos is never used. + 1202. uint64_t pos = (uint64_t) *ppos; + 1203. uint32_t alloc_size = (uint32_t) rbuf->chan->alloc_size; + 1204. > size_t read_start = (size_t) do_div(pos, alloc_size); + 1205. size_t read_subbuf = read_start / subbuf_size; + 1206. size_t padding = rbuf->padding[read_subbuf]; + +drivers/iommu/intel-iommu.c:1244: error: DEAD_STORE + The value written to &last_pte is never used. + 1242. if (first_pte) + 1243. domain_flush_cache(domain, first_pte, + 1244. > (void *)++last_pte - (void *)first_pte); + 1245. + 1246. return freelist; + +kernel/irq/irqdomain.c:1208: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1207 could be null and is dereferenced at line 1208, column 9. + 1206. for (i = 0; i < nr_irqs; i++) { + 1207. irq_data = irq_get_irq_data(virq + i); + 1208. > tmp = irq_data->parent_data; + 1209. irq_data->parent_data = NULL; + 1210. irq_data->domain = NULL; + +net/wireless/trace.h:1206: error: DEAD_STORE + The value written to &p is never used. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/ipv6/calipso.c:1216: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1212 could be null and is dereferenced at line 1216, column 6. + 1214. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1215. + 1216. > if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt) + 1217. old = req_inet->ipv6_opt->hopopt; + 1218. else + +net/ipv4/tcp_ipv4.c:1221: error: DEAD_STORE + The value written to &hash_location is never used. + 1219. * o MD5 hash and its wrong. + 1220. */ + 1221. > const __u8 *hash_location = NULL; + 1222. struct tcp_md5sig_key *hash_expected; + 1223. const struct iphdr *iph = ip_hdr(skb); + +drivers/md/dm-table.c:1218: error: DEAD_STORE + The value written to &template_disk is never used. + 1216. { + 1217. struct mapped_device *md = t->md; + 1218. > struct gendisk *template_disk = NULL; + 1219. + 1220. /* If target handles integrity itself do not register it here. */ + +drivers/scsi/scsi_transport_spi.c:1223: error: DEAD_STORE + The value written to &msg is never used. + 1221. if (cmd->flags & SCMD_TAGGED) { + 1222. *msg++ = SIMPLE_QUEUE_TAG; + 1223. > *msg++ = cmd->request->tag; + 1224. return 2; + 1225. } + +kernel/irq/irqdomain.c:1230: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1229 could be null and is dereferenced at line 1230, column 3. + 1228. for (i = 0; i < nr_irqs; i++) { + 1229. irq_data = irq_get_irq_data(virq + i); + 1230. > irq_data->domain = domain; + 1231. + 1232. for (parent = domain->parent; parent; parent = parent->parent) { + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &next is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &skip is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1226: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 1224. { + 1225. struct e1000_hw *hw = &adapter->hw; + 1226. > u32 ctrl_reg = 0; + 1227. u32 stat_reg = 0; + 1228. + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1241: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 1239. } + 1240. + 1241. > ctrl_reg = er32(CTRL); + 1242. + 1243. /* force 1000, set loopback */ + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1227: error: DEAD_STORE + The value written to &stat_reg is never used. + 1225. struct e1000_hw *hw = &adapter->hw; + 1226. u32 ctrl_reg = 0; + 1227. > u32 stat_reg = 0; + 1228. + 1229. hw->autoneg = false; + +net/wireless/trace.h:1224: error: DEAD_STORE + The value written to &p is never used. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +drivers/net/ethernet/intel/e1000e/netdev.c:1230: error: DEAD_STORE + The value written to &hw is never used. + 1228. struct e1000_adapter *adapter = tx_ring->adapter; + 1229. struct net_device *netdev = adapter->netdev; + 1230. > struct e1000_hw *hw = &adapter->hw; + 1231. struct e1000_tx_desc *tx_desc, *eop_desc; + 1232. struct e1000_buffer *buffer_info; + +drivers/ata/libahci.c:1248: error: DEAD_STORE + The value written to &tmp is never used. + 1246. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1247. writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL); + 1248. > tmp = readl(mmio + HOST_CTL); + 1249. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1250. } + +net/ipv4/netfilter/ip_tables.c:1239: error: DEAD_STORE + The value written to &ret is never used. + 1237. compat_uint_t origsize; + 1238. const struct xt_entry_match *ematch; + 1239. > int ret = 0; + 1240. + 1241. origsize = *size; + +kernel/locking/rtmutex.c:1237: error: DEAD_STORE + The value written to &ret is never used. + 1235. struct rt_mutex_waiter waiter; + 1236. unsigned long flags; + 1237. > int ret = 0; + 1238. + 1239. rt_mutex_init_waiter(&waiter); + +drivers/md/dm-raid1.c:1246: error: DEAD_STORE + The value written to &bd is never used. + 1244. struct mirror_set *ms = (struct mirror_set *) ti->private; + 1245. struct mirror *m = NULL; + 1246. > struct dm_bio_details *bd = NULL; + 1247. struct dm_raid1_bio_record *bio_record = + 1248. dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record)); + +drivers/md/dm-raid1.c:1245: error: DEAD_STORE + The value written to &m is never used. + 1243. int rw = bio_data_dir(bio); + 1244. struct mirror_set *ms = (struct mirror_set *) ti->private; + 1245. > struct mirror *m = NULL; + 1246. struct dm_bio_details *bd = NULL; + 1247. struct dm_raid1_bio_record *bio_record = + +crypto/drbg.c:1247: error: DEAD_STORE + The value written to &len is never used. + 1245. struct drbg_string *addtl) + 1246. { + 1247. > int len = 0; + 1248. LIST_HEAD(addtllist); + 1249. + +net/wireless/trace.h:1245: error: DEAD_STORE + The value written to &p is never used. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/ipv6/netfilter/ip6_tables.c:1257: error: DEAD_STORE + The value written to &ret is never used. + 1255. compat_uint_t origsize; + 1256. const struct xt_entry_match *ematch; + 1257. > int ret = 0; + 1258. + 1259. origsize = *size; + +net/ipv6/calipso.c:1257: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1252 could be null and is dereferenced at line 1257, column 7. + 1255. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1256. + 1257. > if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt) + 1258. return; + 1259. + +drivers/iommu/intel-iommu.c:1256: error: DEAD_STORE + The value written to &freelist is never used. + 1254. unsigned long last_pfn) + 1255. { + 1256. > struct page *freelist = NULL; + 1257. + 1258. BUG_ON(!domain_pfn_supported(domain, start_pfn)); + +security/selinux/selinuxfs.c:1257: error: DEAD_STORE + The value written to &dentry is never used. + 1255. int i, ret; + 1256. ssize_t len; + 1257. > struct dentry *dentry = NULL; + 1258. struct dentry *dir = bool_dir; + 1259. struct inode *inode = NULL; + +security/selinux/selinuxfs.c:1259: error: DEAD_STORE + The value written to &inode is never used. + 1257. struct dentry *dentry = NULL; + 1258. struct dentry *dir = bool_dir; + 1259. > struct inode *inode = NULL; + 1260. struct inode_security_struct *isec; + 1261. char **names = NULL, *page; + +drivers/md/dm-ioctl.c:1261: error: DEAD_STORE + The value written to &i is never used. + 1259. { + 1260. int r; + 1261. > unsigned int i = 0; + 1262. struct dm_target_spec *spec = (struct dm_target_spec *) param; + 1263. uint32_t next = param->data_start; + +drivers/gpu/drm/i915/i915_irq.c:1271: error: DEAD_STORE + The value written to &slice is never used. + 1269. char *parity_event[6]; + 1270. uint32_t misccpctl; + 1271. > uint8_t slice = 0; + 1272. + 1273. /* We must turn off DOP level clock gating to access the L3 registers. + +net/ipv4/tcp_ipv4.c:1272: error: DEAD_STORE + The value written to &net is never used. + 1270. { + 1271. struct inet_request_sock *ireq = inet_rsk(req); + 1272. > struct net *net = sock_net(sk_listener); + 1273. + 1274. sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr); + +net/netfilter/nf_conntrack_sip.c:1293: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1276 could be null and is dereferenced at line 1293, column 6. + 1291. * request and compare it here. + 1292. */ + 1293. > if (ct_sip_info->register_cseq != cseq) + 1294. return NF_ACCEPT; + 1295. + +net/netfilter/nf_conntrack_netlink.c:1282: error: DEAD_STORE + The value written to &l3proto is never used. + 1280. struct hlist_nulls_node *n; + 1281. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 1282. > u_int8_t l3proto = nfmsg->nfgen_family; + 1283. int res; + 1284. int cpu; + +net/wireless/trace.h:1280: error: DEAD_STORE + The value written to &p is never used. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +drivers/gpu/drm/i915/intel_sprite.c:1285: error: DEAD_STORE + The value written to &intel_plane is never used. + 1283. enum pipe pipe, int plane) + 1284. { + 1285. > struct intel_plane *intel_plane = NULL; + 1286. struct intel_plane_state *state = NULL; + 1287. unsigned long possible_crtcs; + +drivers/dma/dmaengine.c:1287: error: DEAD_STORE + The value written to &dma_sync_wait_timeout is never used. + 1285. dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx) + 1286. { + 1287. > unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000); + 1288. + 1289. if (!tx) + +drivers/net/ethernet/intel/e1000e/82571.c:1292: error: DEAD_STORE + The value written to &vfta_value is never used. + 1290. { + 1291. u32 offset; + 1292. > u32 vfta_value = 0; + 1293. u32 vfta_offset = 0; + 1294. u32 vfta_bit_in_reg = 0; + +drivers/pcmcia/cistpl.c:1291: error: DEAD_STORE + The value written to &ret is never used. + 1289. int pcmcia_parse_tuple(tuple_t *tuple, cisparse_t *parse) + 1290. { + 1291. > int ret = 0; + 1292. + 1293. if (tuple->TupleDataLen > tuple->TupleDataMax) + +kernel/signal.c:1300: error: DEAD_STORE + The value written to &p is never used. + 1298. int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp) + 1299. { + 1300. > struct task_struct *p = NULL; + 1301. int retval, success; + 1302. + +net/wireless/trace.h:1298: error: DEAD_STORE + The value written to &p is never used. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +drivers/iommu/iommu.c:1315: error: NULL_DEREFERENCE + pointer `group` last assigned on line 1305 could be null and is dereferenced by call to `__iommu_attach_group()` at line 1315, column 8. + 1313. goto out_unlock; + 1314. + 1315. > ret = __iommu_attach_group(domain, group); + 1316. + 1317. out_unlock: + +drivers/gpu/drm/i915/intel_ddi.c:1305: error: DEAD_STORE + The value written to &link_clock is never used. + 1303. { + 1304. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 1305. > int link_clock = 0; + 1306. uint32_t cfgcr0; + 1307. enum intel_dpll_id pll_id; + +kernel/kprobes.c:1306: error: DEAD_STORE + The value written to &ret is never used. + 1304. static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p) + 1305. { + 1306. > int ret = 0; + 1307. struct kprobe *ap = orig_p; + 1308. + +drivers/thermal/thermal_core.c:1311: error: DEAD_STORE + The value written to &pos is never used. + 1309. const struct thermal_zone_params *tzp; + 1310. struct thermal_cooling_device *cdev; + 1311. > struct thermal_zone_device *pos = NULL; + 1312. + 1313. if (!tz) + +drivers/usb/host/ehci-hub.c:1313: error: DEAD_STORE + The value written to &portnum is never used. + 1311. if (ehci_is_TDI(ehci)) + 1312. return; + 1313. > set_owner(ehci, --portnum, PORT_OWNER); + 1314. } + 1315. + +lib/vsprintf.c:1317: error: DEAD_STORE + The value written to &fmt is never used. + 1315. bool uc = false; + 1316. + 1317. > switch (*(++fmt)) { + 1318. case 'L': + 1319. uc = true; /* fall-through */ + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &size is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &skip is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +block/bio.c:1340: error: DEAD_STORE + The value written to &ret is never used. + 1338. + 1339. if (unlikely(offs & queue_dma_alignment(q))) { + 1340. > ret = -EINVAL; + 1341. j = 0; + 1342. } else { + +drivers/gpu/drm/drm_fb_helper.c:1320: error: DEAD_STORE + The value written to &ret is never used. + 1318. struct drm_crtc *crtc; + 1319. u16 *r, *g, *b; + 1320. > int i, ret = 0; + 1321. bool replaced; + 1322. + +net/ipv4/ip_sockglue.c:1315: error: DEAD_STORE + The value written to &err is never used. + 1313. struct inet_sock *inet = inet_sk(sk); + 1314. bool needs_rtnl = getsockopt_needs_rtnl(optname); + 1315. > int val, err = 0; + 1316. int len; + 1317. + +net/sunrpc/auth_gss/auth_gss.c:1325: error: DEAD_STORE + The value written to &cred is never used. + 1323. { + 1324. struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth); + 1325. > struct gss_cred *cred = NULL; + 1326. int err = -ENOMEM; + 1327. + +net/wireless/trace.h:1321: error: DEAD_STORE + The value written to &p is never used. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +security/selinux/ss/services.c:1333: error: DEAD_STORE + The value written to &rc is never used. + 1331. struct user_datum *usrdatum; + 1332. char *scontextp, *p, oldc; + 1333. > int rc = 0; + 1334. + 1335. context_init(ctx); + +ipc/sem.c:1351: error: DEAD_STORE + The value written to &err is never used. + 1349. goto out_rcu_wakeup; + 1350. + 1351. > err = -EACCES; + 1352. switch (cmd) { + 1353. case GETALL: + +net/core/net-sysfs.c:1329: error: DEAD_STORE + The value written to &error is never used. + 1327. struct netdev_queue *queue = dev->_tx + index; + 1328. struct kobject *kobj = &queue->kobj; + 1329. > int error = 0; + 1330. + 1331. kobj->kset = dev->queues_kset; + +net/sunrpc/rpc_pipe.c:1331: error: DEAD_STORE + The value written to &pipe_dentry is never used. + 1329. struct dentry *gssd_dentry; + 1330. struct dentry *clnt_dentry = NULL; + 1331. > struct dentry *pipe_dentry = NULL; + 1332. struct qstr q = QSTR_INIT(files[RPCAUTH_gssd].name, + 1333. strlen(files[RPCAUTH_gssd].name)); + +net/sunrpc/rpc_pipe.c:1328: error: DEAD_STORE + The value written to &ret is never used. + 1326. rpc_gssd_dummy_populate(struct dentry *root, struct rpc_pipe *pipe_data) + 1327. { + 1328. > int ret = 0; + 1329. struct dentry *gssd_dentry; + 1330. struct dentry *clnt_dentry = NULL; + +drivers/net/ethernet/intel/e1000e/ethtool.c:1334: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 1332. { + 1333. struct e1000_hw *hw = &adapter->hw; + 1334. > u32 ctrl_reg = 0; + 1335. u16 phy_reg = 0; + 1336. s32 ret_val = 0; + +drivers/net/ethernet/intel/e1000e/ethtool.c:1336: error: DEAD_STORE + The value written to &ret_val is never used. + 1334. u32 ctrl_reg = 0; + 1335. u16 phy_reg = 0; + 1336. > s32 ret_val = 0; + 1337. + 1338. hw->mac.autoneg = 0; + +arch/x86/events/intel/p4.c:1347: error: DEAD_STORE + The value written to &high is never used. + 1345. BUILD_BUG_ON(ARCH_P4_MAX_CCCR > INTEL_PMC_MAX_GENERIC); + 1346. + 1347. > rdmsr(MSR_IA32_MISC_ENABLE, low, high); + 1348. if (!(low & (1 << 7))) { + 1349. pr_cont("unsupported Netburst CPU model %d ", + +drivers/iommu/iommu.c:1351: error: NULL_DEREFERENCE + pointer `group` last assigned on line 1343 could be null and is dereferenced by call to `__iommu_detach_group()` at line 1351, column 2. + 1349. } + 1350. + 1351. > __iommu_detach_group(domain, group); + 1352. + 1353. out_unlock: + +net/wireless/trace.h:1343: error: DEAD_STORE + The value written to &p is never used. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +drivers/cpufreq/intel_pstate.c:1356: error: DEAD_STORE + The value written to &pstate is never used. + 1354. + 1355. update_turbo_state(); + 1356. > pstate = intel_pstate_get_base_pstate(cpu); + 1357. pstate = max(cpu->pstate.min_pstate, cpu->max_perf_ratio); + 1358. intel_pstate_set_pstate(cpu, pstate); + +drivers/gpu/drm/i915/intel_ddi.c:1359: error: DEAD_STORE + The value written to &link_clock is never used. + 1357. { + 1358. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 1359. > int link_clock = 0; + 1360. uint32_t dpll_ctl1; + 1361. enum intel_dpll_id pll_id; + +net/ipv4/tcp_input.c:1363: error: DEAD_STORE + The value written to &pcount is never used. + 1361. struct sk_buff *prev; + 1362. int mss; + 1363. > int pcount = 0; + 1364. int len; + 1365. int in_sack; + +net/ipv4/tcp_input.c:1479: error: DEAD_STORE + The value written to &pcount is never used. + 1477. len = skb->len; + 1478. if (skb_shift(prev, skb, len)) { + 1479. > pcount += tcp_skb_pcount(skb); + 1480. tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb), + 1481. len, mss, 0); + +drivers/net/ethernet/intel/e100.c:1368: error: DEAD_STORE + The value written to &err is never used. + 1366. { + 1367. const struct firmware *fw; + 1368. > int err = 0, counter = 50; + 1369. struct cb *cb = nic->cb_to_clean; + 1370. + +drivers/gpu/drm/drm_connector.c:1376: error: DEAD_STORE + The value written to &copied is never used. + 1374. int encoders_count = 0; + 1375. int ret = 0; + 1376. > int copied = 0; + 1377. int i; + 1378. struct drm_mode_modeinfo u_mode; + +drivers/gpu/drm/drm_connector.c:1375: error: DEAD_STORE + The value written to &ret is never used. + 1373. int mode_count = 0; + 1374. int encoders_count = 0; + 1375. > int ret = 0; + 1376. int copied = 0; + 1377. int i; + +drivers/rtc/rtc-cmos.c:1368: error: DEAD_STORE + The value written to &retval is never used. + 1366. static int __init cmos_init(void) + 1367. { + 1368. > int retval = 0; + 1369. + 1370. #ifdef CONFIG_PNP + +net/wireless/trace.h:1366: error: DEAD_STORE + The value written to &p is never used. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +crypto/drbg.c:1378: error: DEAD_STORE + The value written to &chunk is never used. + 1376. do { + 1377. int err = 0; + 1378. > unsigned int chunk = 0; + 1379. slice = ((buflen - len) / drbg_max_request_bytes(drbg)); + 1380. chunk = slice ? drbg_max_request_bytes(drbg) : (buflen - len); + +crypto/drbg.c:1377: error: DEAD_STORE + The value written to &err is never used. + 1375. unsigned int slice = 0; + 1376. do { + 1377. > int err = 0; + 1378. unsigned int chunk = 0; + 1379. slice = ((buflen - len) / drbg_max_request_bytes(drbg)); + +crypto/drbg.c:1375: error: DEAD_STORE + The value written to &slice is never used. + 1373. { + 1374. unsigned int len = 0; + 1375. > unsigned int slice = 0; + 1376. do { + 1377. int err = 0; + +drivers/thermal/thermal_core.c:1373: error: DEAD_STORE + The value written to &pos is never used. + 1371. struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name) + 1372. { + 1373. > struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL); + 1374. unsigned int found = 0; + 1375. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:1378: error: DEAD_STORE + The value written to &emi_val is never used. + 1376. struct e1000_mac_info *mac = &hw->mac; + 1377. s32 ret_val, tipg_reg = 0; + 1378. > u16 emi_addr, emi_val = 0; + 1379. bool link; + 1380. u16 phy_reg; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:1377: error: DEAD_STORE + The value written to &tipg_reg is never used. + 1375. { + 1376. struct e1000_mac_info *mac = &hw->mac; + 1377. > s32 ret_val, tipg_reg = 0; + 1378. u16 emi_addr, emi_val = 0; + 1379. bool link; + +drivers/pcmcia/cistpl.c:1381: error: DEAD_STORE + The value written to &count is never used. + 1379. tuple_t *tuple; + 1380. cisparse_t *p; + 1381. > unsigned int count = 0; + 1382. int ret, reserved, dev_ok = 0, ident_ok = 0; + 1383. + +net/core/net-sysfs.c:1386: error: DEAD_STORE + The value written to &error is never used. + 1384. static int register_queue_kobjects(struct net_device *dev) + 1385. { + 1386. > int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0; + 1387. + 1388. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1386: error: DEAD_STORE + The value written to &real_rx is never used. + 1384. static int register_queue_kobjects(struct net_device *dev) + 1385. { + 1386. > int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0; + 1387. + 1388. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1386: error: DEAD_STORE + The value written to &real_tx is never used. + 1384. static int register_queue_kobjects(struct net_device *dev) + 1385. { + 1386. > int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0; + 1387. + 1388. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1405: error: DEAD_STORE + The value written to &txq is never used. + 1403. if (error) + 1404. goto error; + 1405. > txq = real_tx; + 1406. + 1407. return 0; + +net/wireless/trace.h:1384: error: DEAD_STORE + The value written to &p is never used. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +drivers/gpu/drm/i915/intel_overlay.c:1429: error: DEAD_STORE + The value written to &ret is never used. + 1427. if (IS_ERR(vma)) { + 1428. DRM_ERROR("failed to pin overlay register bo\n"); + 1429. > ret = PTR_ERR(vma); + 1430. goto out_free_bo; + 1431. } + +net/wireless/reg.c:1402: error: DEAD_STORE + The value written to &bw_fits is never used. + 1400. int i; + 1401. bool band_rule_found = false; + 1402. > bool bw_fits = false; + 1403. + 1404. if (!regd) + +net/wireless/reg.c:1409: error: DEAD_STORE + The value written to &fr is never used. + 1407. for (i = 0; i < regd->n_reg_rules; i++) { + 1408. const struct ieee80211_reg_rule *rr; + 1409. > const struct ieee80211_freq_range *fr = NULL; + 1410. + 1411. rr = ®d->reg_rules[i]; + +drivers/gpu/drm/i915/intel_runtime_pm.c:1422: error: DEAD_STORE + The value written to &timeout__ is never used. + 1420. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1421. + 1422. > if (wait_for(COND, 100)) + 1423. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1424. state, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1449: error: DEAD_STORE + The value written to &l is never used. + 1447. if (!ret_val) + 1448. good_cnt++; + 1449. > if (unlikely(++l == rxdr->count)) + 1450. l = 0; + 1451. /* time + 20 msecs (200 msecs on 2.4) is more than + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1450: error: DEAD_STORE + The value written to &l is never used. + 1448. good_cnt++; + 1449. if (unlikely(++l == rxdr->count)) + 1450. > l = 0; + 1451. /* time + 20 msecs (200 msecs on 2.4) is more than + 1452. * enough time to complete the receives, if it's + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1435: error: DEAD_STORE + The value written to &time is never used. + 1433. E1000_WRITE_FLUSH(); + 1434. msleep(200); + 1435. > time = jiffies; /* set the start time for the receive */ + 1436. good_cnt = 0; + 1437. do { /* receive the sent packets */ + +net/netfilter/nf_conntrack_sip.c:1423: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1405 could be null and is dereferenced at line 1423, column 3. + 1421. port != ct->tuplehash[dir].tuple.src.u.udp.port && + 1422. nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3)) + 1423. > ct_sip_info->forced_dport = port; + 1424. + 1425. for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) { + +drivers/md/dm-raid1.c:1422: error: DEAD_STORE + The value written to &sz is never used. + 1420. (unsigned long long)ms->nr_regions, buffer); + 1421. + 1422. > sz += log->type->status(log, type, result+sz, maxlen-sz); + 1423. + 1424. break; + +drivers/md/dm-raid1.c:1441: error: DEAD_STORE + The value written to &sz is never used. + 1439. DMEMIT(" handle_errors"); + 1440. if (keep_log(ms)) + 1441. > DMEMIT(" keep_log"); + 1442. } + 1443. + +drivers/gpu/drm/i915/intel_ddi.c:1408: error: DEAD_STORE + The value written to &link_clock is never used. + 1406. { + 1407. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 1408. > int link_clock = 0; + 1409. u32 val, pll; + 1410. + +security/selinux/ss/services.c:1410: error: DEAD_STORE + The value written to &rc is never used. + 1408. char *scontext2, *str = NULL; + 1409. struct context context; + 1410. > int rc = 0; + 1411. + 1412. /* An empty security context is never valid. */ + +net/wireless/trace.h:1405: error: DEAD_STORE + The value written to &p is never used. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +drivers/net/ethernet/broadcom/tg3.c:1415: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 1414 could be null and is dereferenced at line 1415, column 10. + 1413. + 1414. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 1415. > switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) { + 1416. case PHY_ID_BCM50610: + 1417. case PHY_ID_BCM50610M: + +net/core/net-sysfs.c:1417: error: DEAD_STORE + The value written to &real_rx is never used. + 1415. static void remove_queue_kobjects(struct net_device *dev) + 1416. { + 1417. > int real_rx = 0, real_tx = 0; + 1418. + 1419. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1417: error: DEAD_STORE + The value written to &real_tx is never used. + 1415. static void remove_queue_kobjects(struct net_device *dev) + 1416. { + 1417. > int real_rx = 0, real_tx = 0; + 1418. + 1419. #ifdef CONFIG_SYSFS + +drivers/gpu/drm/i915/intel_tv.c:1430: error: NULL_DEREFERENCE + pointer `old_state` last assigned on line 1427 could be null and is dereferenced at line 1430, column 6. + 1428. new_crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc); + 1429. + 1430. > if (old_state->tv.mode != new_state->tv.mode || + 1431. old_state->tv.margins.left != new_state->tv.margins.left || + 1432. old_state->tv.margins.right != new_state->tv.margins.right || + +net/ipv6/netfilter/ip6_tables.c:1431: error: DEAD_STORE + The value written to &ret is never used. + 1429. struct ip6t_replace repl; + 1430. unsigned int size; + 1431. > int ret = 0; + 1432. + 1433. info = *pinfo; + +net/wireless/trace.h:1421: error: DEAD_STORE + The value written to &p is never used. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/sunrpc/auth_gss/auth_gss.c:1431: error: DEAD_STORE + The value written to &ret is never used. + 1429. struct gss_cl_ctx *ctx; + 1430. unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ); + 1431. > int ret = 0; + 1432. + 1433. rcu_read_lock(); + +net/sunrpc/auth_gss/auth_gss.c:1430: error: DEAD_STORE + The value written to &timeout is never used. + 1428. struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base); + 1429. struct gss_cl_ctx *ctx; + 1430. > unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ); + 1431. int ret = 0; + 1432. + +sound/core/seq/seq_clientmgr.c:1435: error: DEAD_STORE + The value written to &receiver is never used. + 1433. struct snd_seq_port_subscribe *subs = arg; + 1434. int result = -EINVAL; + 1435. > struct snd_seq_client *receiver = NULL, *sender = NULL; + 1436. struct snd_seq_client_port *sport = NULL, *dport = NULL; + 1437. + +drivers/gpu/drm/i915/intel_uncore.c:1443: error: DEAD_STORE + The value written to &timeout__ is never used. + 1441. pci_write_config_byte(pdev, I915_GDRST, 0); + 1442. + 1443. > return wait_for(i915_reset_complete(pdev), 500); + 1444. } + 1445. + +drivers/gpu/drm/drm_fb_helper.c:1441: error: DEAD_STORE + The value written to &ret is never used. + 1439. struct drm_mode_set *mode_set; + 1440. struct drm_crtc *crtc; + 1441. > int ret = 0; + 1442. + 1443. mutex_lock(&fb_helper->lock); + +drivers/pci/probe.c:1443: error: DEAD_STORE + The value written to &pos is never used. + 1441. u16 cmd; + 1442. u8 hdr_type; + 1443. > int pos = 0; + 1444. struct pci_bus_region region; + 1445. struct resource *res; + +kernel/cgroup/cgroup.c:1452: error: DEAD_STORE + The value written to &ssid is never used. + 1450. u16 new_ss_mask = cur_ss_mask; + 1451. + 1452. > do_each_subsys_mask(ss, ssid, cur_ss_mask) { + 1453. new_ss_mask |= ss->depends_on; + 1454. } while_each_subsys_mask(); + +net/wireless/trace.h:1441: error: DEAD_STORE + The value written to &p is never used. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +kernel/resource.c:1447: error: DEAD_STORE + The value written to &dr is never used. + 1445. resource_size_t n, const char *name) + 1446. { + 1447. > struct region_devres *dr = NULL; + 1448. struct resource *res; + 1449. + +drivers/gpu/drm/drm_vblank.c:1548: error: DEAD_STORE + The value written to &end is never used. + 1546. DRM_DEBUG("waiting on vblank count %llu, crtc %u\n", + 1547. req_seq, pipe); + 1548. > DRM_WAIT_ON(ret, vblank->queue, 3 * HZ, + 1549. vblank_passed(drm_vblank_count(dev, pipe), + 1550. req_seq) || + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &bytes is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &skip is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +net/ipv4/devinet.c:1471: error: DEAD_STORE + The value written to &in_dev is never used. + 1469. /* Re-enabling IP */ + 1470. if (inetdev_valid_mtu(dev->mtu)) + 1471. > in_dev = inetdev_init(dev); + 1472. } + 1473. goto out; + +net/sunrpc/svcsock.c:1456: error: DEAD_STORE + The value written to &svsk is never used. + 1454. int err = 0; + 1455. struct socket *so = sockfd_lookup(fd, &err); + 1456. > struct svc_sock *svsk = NULL; + 1457. struct sockaddr_storage addr; + 1458. struct sockaddr *sin = (struct sockaddr *)&addr; + +drivers/gpu/drm/i915/intel_uncore.c:1459: error: DEAD_STORE + The value written to &timeout__ is never used. + 1457. + 1458. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1459. > return wait_for(g4x_reset_complete(pdev), 500); + 1460. } + 1461. + +net/xfrm/xfrm_policy.c:1461: error: DEAD_STORE + The value written to &tos is never used. + 1459. { + 1460. const struct xfrm_policy_afinfo *afinfo; + 1461. > int tos = 0; + 1462. + 1463. afinfo = xfrm_policy_get_afinfo(family); + +net/wireless/trace.h:1461: error: DEAD_STORE + The value written to &p is never used. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +sound/core/pcm_native.c:1464: error: DEAD_STORE + The value written to &err is never used. + 1462. { + 1463. struct snd_pcm_substream *substream; + 1464. > int stream, err = 0; + 1465. + 1466. if (! pcm) + +drivers/gpu/drm/i915/intel_uncore.c:1474: error: DEAD_STORE + The value written to &timeout__ is never used. + 1472. pci_write_config_byte(pdev, I915_GDRST, + 1473. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1474. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1475. if (ret) { + 1476. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1482: error: DEAD_STORE + The value written to &timeout__ is never used. + 1480. pci_write_config_byte(pdev, I915_GDRST, + 1481. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1482. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1483. if (ret) { + 1484. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/net/ethernet/intel/e100.c:1472: error: DEAD_STORE + The value written to &stat is never used. + 1470. nic->mii.phy_id = (addr == 0) ? 1 : (addr == 1) ? 0 : addr; + 1471. bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR); + 1472. > stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1473. stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1474. if (!((bmcr == 0xFFFF) || ((stat == 0) && (bmcr == 0)))) + +block/blk-core.c:1471: error: DEAD_STORE + The value written to &ret is never used. + 1469. gfp_t gfp_mask = flags & BLK_MQ_REQ_NOWAIT ? GFP_ATOMIC : + 1470. __GFP_DIRECT_RECLAIM; + 1471. > int ret = 0; + 1472. + 1473. WARN_ON_ONCE(q->mq_ops); + +lib/assoc_array.c:1530: error: DEAD_STORE + The value written to &new_ptr_pp is never used. + 1528. new_n->parent_slot = node->parent_slot; + 1529. *new_ptr_pp = new_parent = assoc_array_node_to_ptr(new_n); + 1530. > new_ptr_pp = NULL; + 1531. slot = 0; + 1532. + +drivers/net/phy/phy_device.c:1476: error: DEAD_STORE + The value written to &lpagb is never used. + 1474. int err; + 1475. int lpa; + 1476. > int lpagb = 0; + 1477. int common_adv; + 1478. int common_adv_gb = 0; + +drivers/scsi/sg.c:1478: error: DEAD_STORE + The value written to &cdev is never used. + 1476. struct gendisk *disk; + 1477. Sg_device *sdp = NULL; + 1478. > struct cdev * cdev = NULL; + 1479. int error; + 1480. unsigned long iflags; + +drivers/scsi/sg.c:1477: error: DEAD_STORE + The value written to &sdp is never used. + 1475. struct scsi_device *scsidp = to_scsi_device(cl_dev->parent); + 1476. struct gendisk *disk; + 1477. > Sg_device *sdp = NULL; + 1478. struct cdev * cdev = NULL; + 1479. int error; + +sound/core/seq/seq_clientmgr.c:1477: error: DEAD_STORE + The value written to &receiver is never used. + 1475. struct snd_seq_port_subscribe *subs = arg; + 1476. int result = -ENXIO; + 1477. > struct snd_seq_client *receiver = NULL, *sender = NULL; + 1478. struct snd_seq_client_port *sport = NULL, *dport = NULL; + 1479. + +net/wireless/reg.c:1479: error: DEAD_STORE + The value written to &freq_range is never used. + 1477. const struct ieee80211_channel *chan) + 1478. { + 1479. > const struct ieee80211_freq_range *freq_range = NULL; + 1480. u32 max_bandwidth_khz, bw_flags = 0; + 1481. + +drivers/cpufreq/intel_pstate.c:1480: error: DEAD_STORE + The value written to &max_pstate is never used. + 1478. static int intel_pstate_prepare_request(struct cpudata *cpu, int pstate) + 1479. { + 1480. > int max_pstate = intel_pstate_get_base_pstate(cpu); + 1481. int min_pstate; + 1482. + +kernel/irq/irqdomain.c:1484: error: DEAD_STORE + The value written to &rv is never used. + 1482. struct irq_data *root_irq_data = irq_get_irq_data(virq); + 1483. struct irq_desc *desc; + 1484. > int rv = 0; + 1485. + 1486. /* + +security/selinux/hooks.c:1489: error: DEAD_STORE + The value written to &context is never used. + 1487. struct dentry *dentry; + 1488. #define INITCONTEXTLEN 255 + 1489. > char *context = NULL; + 1490. unsigned len = 0; + 1491. int rc = 0; + +security/selinux/hooks.c:1490: error: DEAD_STORE + The value written to &len is never used. + 1488. #define INITCONTEXTLEN 255 + 1489. char *context = NULL; + 1490. > unsigned len = 0; + 1491. int rc = 0; + 1492. + +security/selinux/hooks.c:1483: error: DEAD_STORE + The value written to &sbsec is never used. + 1481. static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry) + 1482. { + 1483. > struct superblock_security_struct *sbsec = NULL; + 1484. struct inode_security_struct *isec = inode->i_security; + 1485. u32 task_sid, sid = 0; + +security/selinux/hooks.c:1485: error: DEAD_STORE + The value written to &sid is never used. + 1483. struct superblock_security_struct *sbsec = NULL; + 1484. struct inode_security_struct *isec = inode->i_security; + 1485. > u32 task_sid, sid = 0; + 1486. u16 sclass; + 1487. struct dentry *dentry; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1502: error: DEAD_STORE + The value written to &c is never used. + 1500. end = addr + size; + 1501. for (; addr < end; addr += PAGE_SIZE) { + 1502. > int err = __get_user(c, addr); + 1503. if (err) + 1504. return err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1506: error: DEAD_STORE + The value written to &c is never used. + 1504. return err; + 1505. } + 1506. > return __get_user(c, end - 1); + 1507. } + 1508. + +include/linux/blkdev.h:1493: error: DEAD_STORE + The value written to §or is never used. + 1491. { + 1492. unsigned int granularity = max(lim->physical_block_size, lim->io_min); + 1493. > unsigned int alignment = sector_div(sector, granularity >> 9) << 9; + 1494. + 1495. return (granularity + lim->alignment_offset - alignment) % granularity; + +net/sunrpc/auth_gss/auth_gss.c:1500: error: DEAD_STORE + The value written to &maj_stat is never used. + 1498. struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); + 1499. __be32 *cred_len; + 1500. > u32 maj_stat = 0; + 1501. struct xdr_netobj mic; + 1502. struct kvec iov; + +kernel/sched/rt.c:1496: error: DEAD_STORE + The value written to &next is never used. + 1494. { + 1495. struct rt_prio_array *array = &rt_rq->active; + 1496. > struct sched_rt_entity *next = NULL; + 1497. struct list_head *queue; + 1498. int idx; + +security/keys/keyctl.c:1518: error: DEAD_STORE + The value written to &keyring_r is never used. + 1516. + 1517. cred->session_keyring = key_ref_to_ptr(keyring_r); + 1518. > keyring_r = NULL; + 1519. init_task_work(newwork, key_change_session_keyring); + 1520. + +drivers/gpu/drm/i915/intel_cdclk.c:1506: error: DEAD_STORE + The value written to &timeout__ is never used. + 1504. + 1505. /* Timeout 200us */ + 1506. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1507. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1508. + +kernel/cgroup/cpuset.c:1503: error: DEAD_STORE + The value written to &cs is never used. + 1501. + 1502. cgroup_taskset_first(tset, &css); + 1503. > cs = css_cs(css); + 1504. + 1505. mutex_lock(&cpuset_mutex); + +net/wireless/trace.h:1506: error: DEAD_STORE + The value written to &p is never used. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/ipv4/ip_output.c:1518: error: DEAD_STORE + The value written to &rt is never used. + 1516. struct ipcm_cookie ipc; + 1517. struct flowi4 fl4; + 1518. > struct rtable *rt = skb_rtable(skb); + 1519. struct net *net = sock_net(sk); + 1520. struct sk_buff *nskb; + +drivers/clk/clk.c:1514: error: DEAD_STORE + The value written to &ret is never used. + 1512. { + 1513. struct clk_core *child, *tmp_clk, *fail_clk = NULL; + 1514. > int ret = NOTIFY_DONE; + 1515. + 1516. if (core->rate == core->new_rate) + +kernel/time/timer.c:1513: error: DEAD_STORE + The value written to &base is never used. + 1511. u64 get_next_timer_interrupt(unsigned long basej, u64 basem) + 1512. { + 1513. > struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]); + 1514. u64 expires = KTIME_MAX; + 1515. unsigned long nextevt; + +drivers/gpu/drm/i915/intel_cdclk.c:1524: error: DEAD_STORE + The value written to &timeout__ is never used. + 1522. + 1523. /* Timeout 200us */ + 1524. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1525. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1526. + +kernel/time/hrtimer.c:1518: error: DEAD_STORE + The value written to &ret is never used. + 1516. struct restart_block *restart; + 1517. struct hrtimer_sleeper t; + 1518. > int ret = 0; + 1519. u64 slack; + 1520. + +block/bio.c:1525: error: DEAD_STORE + The value written to &nr_pages is never used. + 1523. struct bio *bio; + 1524. void *p = data; + 1525. > int nr_pages = 0; + 1526. + 1527. /* + +net/wireless/reg.c:1521: error: DEAD_STORE + The value written to &bw_flags is never used. + 1519. struct ieee80211_channel *chan) + 1520. { + 1521. > u32 flags, bw_flags = 0; + 1522. const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. const struct ieee80211_power_rule *power_rule = NULL; + +net/wireless/reg.c:1523: error: DEAD_STORE + The value written to &power_rule is never used. + 1521. u32 flags, bw_flags = 0; + 1522. const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. > const struct ieee80211_power_rule *power_rule = NULL; + 1524. struct wiphy *request_wiphy = NULL; + 1525. struct regulatory_request *lr = get_last_request(); + +net/wireless/reg.c:1522: error: DEAD_STORE + The value written to ®_rule is never used. + 1520. { + 1521. u32 flags, bw_flags = 0; + 1522. > const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. const struct ieee80211_power_rule *power_rule = NULL; + 1524. struct wiphy *request_wiphy = NULL; + +net/wireless/reg.c:1524: error: DEAD_STORE + The value written to &request_wiphy is never used. + 1522. const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. const struct ieee80211_power_rule *power_rule = NULL; + 1524. > struct wiphy *request_wiphy = NULL; + 1525. struct regulatory_request *lr = get_last_request(); + 1526. const struct ieee80211_regdomain *regd; + +include/linux/blkdev.h:1533: error: DEAD_STORE + The value written to §or is never used. + 1531. + 1532. /* Offset of the partition start in 'granularity' sectors */ + 1533. > offset = sector_div(sector, granularity); + 1534. + 1535. /* And why do we do this modulus *again* in blkdev_issue_discard()? */ + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1651: error: DEAD_STORE + The value written to &mii_1000t_ctrl_reg is never used. + 1649. + 1650. if (hw->phy_type == e1000_phy_8201) { + 1651. > mii_1000t_ctrl_reg = 0; + 1652. } else { + 1653. ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, + +net/wireless/trace.h:1524: error: DEAD_STORE + The value written to &p is never used. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +drivers/pci/setup-bus.c:1533: error: DEAD_STORE + The value written to &idx is never used. + 1531. unsigned old_flags = 0; + 1532. struct resource *b_res; + 1533. > int idx = 1; + 1534. + 1535. b_res = &dev->resource[PCI_BRIDGE_RESOURCES]; + +drivers/pci/setup-bus.c:1531: error: DEAD_STORE + The value written to &old_flags is never used. + 1529. struct pci_dev *dev = bus->self; + 1530. struct resource *r; + 1531. > unsigned old_flags = 0; + 1532. struct resource *b_res; + 1533. int idx = 1; + +net/wireless/trace.h:1545: error: DEAD_STORE + The value written to &p is never used. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/xfrm/xfrm_policy.c:1633: error: NULL_DEREFERENCE + pointer `dst_prev` last assigned on line 1554 could be null and is dereferenced at line 1633, column 2. + 1631. } + 1632. + 1633. > dst_prev->child = dst; + 1634. dst0->path = dst; + 1635. + +drivers/gpu/drm/drm_edid.c:1552: error: DEAD_STORE + The value written to &j is never used. + 1550. void *data) + 1551. { + 1552. > int i, j = 0, valid_extensions = 0; + 1553. u8 *edid, *new; + 1554. struct edid *override = NULL; + +drivers/gpu/drm/drm_edid.c:1552: error: DEAD_STORE + The value written to &valid_extensions is never used. + 1550. void *data) + 1551. { + 1552. > int i, j = 0, valid_extensions = 0; + 1553. u8 *edid, *new; + 1554. struct edid *override = NULL; + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1565: error: DEAD_STORE + The value written to &timeout__ is never used. + 1563. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1564. + 1565. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1566. PORT_PLL_POWER_STATE), 200)) + 1567. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/hid/hid-core.c:1554: error: DEAD_STORE + The value written to &ret is never used. + 1552. struct hid_driver *hdrv; + 1553. struct hid_report *report; + 1554. > int ret = 0; + 1555. + 1556. if (!hid) + +drivers/net/ethernet/intel/e100.c:1557: error: DEAD_STORE + The value written to &err is never used. + 1555. static int e100_hw_init(struct nic *nic) + 1556. { + 1557. > int err = 0; + 1558. + 1559. e100_hw_reset(nic); + +net/ipv4/cipso_ipv4.c:1571: error: DEAD_STORE + The value written to &doi_def is never used. + 1569. u8 opt_len; + 1570. u8 tag_len; + 1571. > struct cipso_v4_doi *doi_def = NULL; + 1572. u32 tag_iter; + 1573. + +net/wireless/trace.h:1564: error: DEAD_STORE + The value written to &p is never used. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +drivers/md/dm-table.c:1576: error: DEAD_STORE + The value written to &template_disk is never used. + 1574. static void dm_table_verify_integrity(struct dm_table *t) + 1575. { + 1576. > struct gendisk *template_disk = NULL; + 1577. + 1578. if (t->integrity_added) + +net/core/net-sysfs.c:1578: error: DEAD_STORE + The value written to &error is never used. + 1576. struct device *dev = &ndev->dev; + 1577. const struct attribute_group **groups = ndev->sysfs_groups; + 1578. > int error = 0; + 1579. + 1580. device_initialize(dev); + +net/core/net-sysfs.c:1596: error: DEAD_STORE + The value written to &groups is never used. + 1594. #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211) + 1595. if (ndev->ieee80211_ptr) + 1596. > *groups++ = &wireless_group; + 1597. #if IS_ENABLED(CONFIG_WIRELESS_EXT) + 1598. else if (ndev->wireless_handlers) + +security/selinux/ss/services.c:1585: error: DEAD_STORE + The value written to &roletr is never used. + 1583. struct class_datum *cladatum = NULL; + 1584. struct context *scontext = NULL, *tcontext = NULL, newcontext; + 1585. > struct role_trans *roletr = NULL; + 1586. struct avtab_key avkey; + 1587. struct avtab_datum *avdatum; + +security/selinux/ss/services.c:1584: error: DEAD_STORE + The value written to &scontext is never used. + 1582. { + 1583. struct class_datum *cladatum = NULL; + 1584. > struct context *scontext = NULL, *tcontext = NULL, newcontext; + 1585. struct role_trans *roletr = NULL; + 1586. struct avtab_key avkey; + +security/selinux/ss/services.c:1584: error: DEAD_STORE + The value written to &tcontext is never used. + 1582. { + 1583. struct class_datum *cladatum = NULL; + 1584. > struct context *scontext = NULL, *tcontext = NULL, newcontext; + 1585. struct role_trans *roletr = NULL; + 1586. struct avtab_key avkey; + +drivers/scsi/scsi_lib.c:1587: error: NULL_DEREFERENCE + pointer `cmd` last assigned on line 1578 could be null and is dereferenced at line 1587, column 9. + 1585. scmd_printk(KERN_INFO, cmd, "killing request\n"); + 1586. + 1587. > sdev = cmd->device; + 1588. starget = scsi_target(sdev); + 1589. shost = sdev->host; + +kernel/trace/trace.c:1582: error: DEAD_STORE + The value written to &ret is never used. + 1580. { + 1581. struct tracer *t; + 1582. > int ret = 0; + 1583. + 1584. if (!type->name) { + +net/netfilter/nf_conntrack_netlink.c:1592: error: DEAD_STORE + The value written to &err is never used. + 1590. const struct nf_conntrack_l4proto *l4proto; + 1591. struct nlattr *tb[CTA_PROTOINFO_MAX+1]; + 1592. > int err = 0; + 1593. + 1594. err = nla_parse_nested(tb, CTA_PROTOINFO_MAX, attr, protoinfo_policy, + +net/wireless/trace.h:1587: error: DEAD_STORE + The value written to &p is never used. + 1585. ); + 1586. + 1587. > DECLARE_EVENT_CLASS(tx_rx_evt, + 1588. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1589. TP_ARGS(wiphy, rx, tx), + +drivers/gpu/drm/drm_dp_mst_topology.c:1605: error: DEAD_STORE + The value written to &len is never used. + 1603. + 1604. txmsg->dst = mstb; + 1605. > len = build_link_address(txmsg); + 1606. + 1607. mstb->link_address_sent = true; + +kernel/trace/trace_events.c:1599: error: DEAD_STORE + The value written to &filtered_pids is never used. + 1597. struct seq_file *m = filp->private_data; + 1598. struct trace_array *tr = m->private; + 1599. > struct trace_pid_list *filtered_pids = NULL; + 1600. struct trace_pid_list *pid_list; + 1601. struct trace_event_file *file; + +drivers/scsi/scsi_transport_spi.c:1613: error: DEAD_STORE + The value written to &error is never used. + 1611. if (error) + 1612. return error; + 1613. > error = anon_transport_class_register(&spi_device_class); + 1614. return transport_class_register(&spi_host_class); + 1615. } + +net/sunrpc/auth_gss/svcauth_gss.c:1616: error: DEAD_STORE + The value written to &p is never used. + 1614. BUG_ON(integ_len % 4); + 1615. *p++ = htonl(integ_len); + 1616. > *p++ = htonl(gc->gc_seq); + 1617. if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset, integ_len)) { + 1618. WARN_ON_ONCE(1); + +drivers/net/ethernet/intel/e1000e/mac.c:1599: error: DEAD_STORE + The value written to &ledctl_blink is never used. + 1597. s32 e1000e_blink_led_generic(struct e1000_hw *hw) + 1598. { + 1599. > u32 ledctl_blink = 0; + 1600. u32 i; + 1601. + +drivers/gpu/drm/drm_atomic_helper.c:1605: error: DEAD_STORE + The value written to &completed is never used. + 1603. { + 1604. struct drm_crtc_commit *commit, *stall_commit = NULL; + 1605. > bool completed = true; + 1606. int i; + 1607. long ret = 0; + +drivers/gpu/drm/drm_atomic_helper.c:1607: error: DEAD_STORE + The value written to &ret is never used. + 1605. bool completed = true; + 1606. int i; + 1607. > long ret = 0; + 1608. + 1609. spin_lock(&crtc->commit_lock); + +kernel/cpu.c:1609: error: DEAD_STORE + The value written to &ret is never used. + 1607. bool multi_instance) + 1608. { + 1609. > int cpu, ret = 0; + 1610. bool dynstate; + 1611. + +kernel/cgroup/cpuset.c:1614: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1609 could be null and is dereferenced by call to `is_cpuset_online()` at line 1614, column 7. + 1612. + 1613. mutex_lock(&cpuset_mutex); + 1614. > if (!is_cpuset_online(cs)) { + 1615. retval = -ENODEV; + 1616. goto out_unlock; + +drivers/scsi/scsi_lib.c:1610: error: DEAD_STORE + The value written to &wait_for is never used. + 1608. { + 1609. struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); + 1610. > unsigned long wait_for = (cmd->allowed + 1) * rq->timeout; + 1611. int disposition; + 1612. + +net/wireless/trace.h:1609: error: DEAD_STORE + The value written to &p is never used. + 1607. ); + 1608. + 1609. > DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, + 1610. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1611. TP_ARGS(wiphy, netdev, id), + +net/sched/sch_api.c:1617: error: DEAD_STORE + The value written to &err is never used. + 1615. u32 portid = oskb ? NETLINK_CB(oskb).portid : 0; + 1616. struct sk_buff *skb; + 1617. > int err = 0; + 1618. + 1619. if (!cops->delete) + +crypto/drbg.c:1619: error: DEAD_STORE + The value written to &input is never used. + 1617. { + 1618. struct sdesc *sdesc = (struct sdesc *)drbg->priv_data; + 1619. > struct drbg_string *input = NULL; + 1620. + 1621. crypto_shash_init(&sdesc->shash); + +drivers/gpu/drm/i915/intel_uncore.c:1635: error: DEAD_STORE + The value written to &timeout__ is never used. + 1633. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1634. if (ret && slow_timeout_ms) + 1635. > ret = wait_for(done, slow_timeout_ms); + 1636. + 1637. if (out_value) + +kernel/trace/blktrace.c:1619: error: DEAD_STORE + The value written to &bt is never used. + 1617. struct block_device *bdev) + 1618. { + 1619. > struct blk_trace *bt = NULL; + 1620. int ret = -ENOMEM; + 1621. + +kernel/trace/ring_buffer.c:1621: error: DEAD_STORE + The value written to &err is never used. + 1619. struct ring_buffer_per_cpu *cpu_buffer; + 1620. unsigned long nr_pages; + 1621. > int cpu, err = 0; + 1622. + 1623. /* + +net/ipv6/mcast.c:1658: error: DEAD_STORE + The value written to &payload_len is never used. + 1656. goto err_out; + 1657. + 1658. > payload_len = skb->len; + 1659. + 1660. err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, + +kernel/cgroup/cgroup.c:1632: error: DEAD_STORE + The value written to &ssid is never used. + 1630. lockdep_assert_held(&cgroup_mutex); + 1631. + 1632. > do_each_subsys_mask(ss, ssid, ss_mask) { + 1633. /* + 1634. * If @ss has non-root csses attached to it, can't move. + +kernel/cgroup/cgroup.c:1647: error: DEAD_STORE + The value written to &ssid is never used. + 1645. } while_each_subsys_mask(); + 1646. + 1647. > do_each_subsys_mask(ss, ssid, ss_mask) { + 1648. struct cgroup_root *src_root = ss->root; + 1649. struct cgroup *scgrp = &src_root->cgrp; + +kernel/trace/trace_events_filter.c:1635: error: DEAD_STORE + The value written to &n_preds is never used. + 1633. struct pred_stack stack = { }; /* init to NULL */ + 1634. int err; + 1635. > int n_preds = 0; + 1636. + 1637. n_preds = count_preds(ps); + +net/ipv4/tcp_input.c:1637: error: DEAD_STORE + The value written to &found_dup_sack is never used. + 1635. int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3); + 1636. int used_sacks; + 1637. > bool found_dup_sack = false; + 1638. int i, j; + 1639. int first_sack_index; + +drivers/base/power/runtime.c:1631: error: DEAD_STORE + The value written to &ret is never used. + 1629. { + 1630. int (*callback)(struct device *); + 1631. > int ret = 0; + 1632. + 1633. pm_runtime_disable(dev); + +net/wireless/trace.h:1636: error: DEAD_STORE + The value written to &p is never used. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +drivers/hid/usbhid/hid-core.c:1642: error: DEAD_STORE + The value written to &retval is never used. + 1640. static int __init hid_init(void) + 1641. { + 1642. > int retval = -ENOMEM; + 1643. + 1644. retval = usbhid_quirks_init(quirks_param); + +drivers/clk/clk.c:1650: error: DEAD_STORE + The value written to &ret is never used. + 1648. struct clk_core *top, *fail_clk; + 1649. unsigned long rate = req_rate; + 1650. > int ret = 0; + 1651. + 1652. if (!core) + +drivers/net/ethernet/intel/e1000e/ethtool.c:1706: error: DEAD_STORE + The value written to &l is never used. + 1704. l++; + 1705. if (l == rx_ring->count) + 1706. > l = 0; + 1707. /* time + 20 msecs (200 msecs on 2.4) is more than + 1708. * enough time to complete the receives, if it's + +drivers/net/ethernet/intel/e1000e/ethtool.c:1690: error: DEAD_STORE + The value written to &time is never used. + 1688. e1e_flush(); + 1689. msleep(200); + 1690. > time = jiffies; /* set the start time for the receive */ + 1691. good_cnt = 0; + 1692. /* receive the sent packets */ + +net/netfilter/nf_conntrack_netlink.c:1650: error: DEAD_STORE + The value written to &ret is never used. + 1648. { + 1649. struct nf_conn_seqadj *seqadj = nfct_seqadj(ct); + 1650. > int ret = 0; + 1651. + 1652. if (!seqadj) + +net/sunrpc/auth_gss/svcauth_gss.c:1651: error: DEAD_STORE + The value written to &inpages is never used. + 1649. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1650. struct xdr_buf *resbuf = &rqstp->rq_res; + 1651. > struct page **inpages = NULL; + 1652. __be32 *p, *len; + 1653. int offset; + +net/sunrpc/auth_gss/svcauth_gss.c:1661: error: DEAD_STORE + The value written to &p is never used. + 1659. len = p++; + 1660. offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base; + 1661. > *p++ = htonl(gc->gc_seq); + 1662. inpages = resbuf->pages; + 1663. /* XXX: Would be better to write some xdr helper functions for + +drivers/gpu/drm/drm_dp_mst_topology.c:1659: error: DEAD_STORE + The value written to &len is never used. + 1657. + 1658. txmsg->dst = mstb; + 1659. > len = build_enum_path_resources(txmsg, port->port_num); + 1660. + 1661. drm_dp_queue_down_tx(mgr, txmsg); + +drivers/scsi/scsi_lib.c:1656: error: DEAD_STORE + The value written to &rtn is never used. + 1654. { + 1655. struct Scsi_Host *host = cmd->device->host; + 1656. > int rtn = 0; + 1657. + 1658. atomic_inc(&cmd->device->iorequest_cnt); + +kernel/cgroup/cpuset.c:1661: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1656 could be null and is dereferenced by call to `is_cpuset_online()` at line 1661, column 7. + 1659. + 1660. mutex_lock(&cpuset_mutex); + 1661. > if (!is_cpuset_online(cs)) + 1662. goto out_unlock; + 1663. + +drivers/gpu/drm/i915/intel_hdmi.c:1664: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1659 could be null and is dereferenced at line 1664, column 2. + 1662. intel_hdmi_prepare(encoder, pipe_config); + 1663. + 1664. > intel_dig_port->set_infoframes(&encoder->base, + 1665. pipe_config->has_infoframe, + 1666. pipe_config, conn_state); + +drivers/gpu/drm/i915/intel_uncore.c:1684: error: DEAD_STORE + The value written to &timeout__ is never used. + 1682. + 1683. if (ret) + 1684. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1685. timeout_ms); + 1686. + +drivers/net/ethernet/broadcom/tg3.c:1693: error: DEAD_STORE + The value written to &data is never used. + 1691. else + 1692. val = 0; + 1693. > *data++ = val; + 1694. } + 1695. + +security/selinux/selinuxfs.c:1671: error: DEAD_STORE + The value written to &dentry is never used. + 1669. struct dentry *dir) + 1670. { + 1671. > struct dentry *dentry = NULL; + 1672. struct inode *inode = NULL; + 1673. int rc; + +security/selinux/selinuxfs.c:1672: error: DEAD_STORE + The value written to &inode is never used. + 1670. { + 1671. struct dentry *dentry = NULL; + 1672. > struct inode *inode = NULL; + 1673. int rc; + 1674. + +drivers/gpu/drm/i915/intel_hdmi.c:1683: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1673 could be null and is dereferenced at line 1683, column 2. + 1681. 0x2b247878); + 1682. + 1683. > dport->set_infoframes(&encoder->base, + 1684. pipe_config->has_infoframe, + 1685. pipe_config, conn_state); + +drivers/usb/host/uhci-q.c:1689: error: DEAD_STORE + The value written to &status is never used. + 1687. if (qh->state != QH_STATE_ACTIVE) { + 1688. urbp = NULL; + 1689. > status = 0; + 1690. + 1691. } else { + +drivers/usb/host/uhci-q.c:1671: error: DEAD_STORE + The value written to &urbp is never used. + 1669. static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh) + 1670. { + 1671. > struct urb_priv *urbp = NULL; + 1672. struct uhci_td *td; + 1673. int ret = 1; + +drivers/usb/host/uhci-q.c:1688: error: DEAD_STORE + The value written to &urbp is never used. + 1686. * test whether such queues have advanced. */ + 1687. if (qh->state != QH_STATE_ACTIVE) { + 1688. > urbp = NULL; + 1689. status = 0; + 1690. + +drivers/hid/hid-core.c:1723: error: DEAD_STORE + The value written to &len is never used. + 1721. ((struct hiddev *)hdev->hiddev)->minor); + 1722. if (hdev->claimed & HID_CLAIMED_HIDRAW) + 1723. > len += sprintf(buf + len, "%shidraw%d", len ? "," : "", + 1724. ((struct hidraw *)hdev->hidraw)->minor); + 1725. + +net/wireless/trace.h:1675: error: DEAD_STORE + The value written to &p is never used. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +sound/core/timer.c:1685: error: DEAD_STORE + The value written to &err is never used. + 1683. struct snd_timer_select tselect; + 1684. char str[32]; + 1685. > int err = 0; + 1686. + 1687. tu = file->private_data; + +net/sunrpc/auth_gss/auth_gss.c:1690: error: DEAD_STORE + The value written to &integ_len is never used. + 1688. struct xdr_buf *snd_buf = &rqstp->rq_snd_buf; + 1689. struct xdr_buf integ_buf; + 1690. > __be32 *integ_len = NULL; + 1691. struct xdr_netobj mic; + 1692. u32 offset; + +net/sunrpc/auth_gss/auth_gss.c:1695: error: DEAD_STORE + The value written to &maj_stat is never used. + 1693. __be32 *q; + 1694. struct kvec *iov; + 1695. > u32 maj_stat = 0; + 1696. int status = -EIO; + 1697. + +security/selinux/hooks.c:1687: error: DEAD_STORE + The value written to &perm is never used. + 1685. static inline u32 signal_to_av(int sig) + 1686. { + 1687. > u32 perm = 0; + 1688. + 1689. switch (sig) { + +kernel/power/snapshot.c:1690: error: DEAD_STORE + The value written to &pages is never used. + 1688. { + 1689. struct zone *zone; + 1690. > unsigned long saveable, size, max_size, count, highmem, pages = 0; + 1691. unsigned long alloc, save_highmem, pages_highmem, avail_normal; + 1692. ktime_t start, stop; + +net/wireless/trace.h:1692: error: DEAD_STORE + The value written to &p is never used. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +kernel/cgroup/cgroup.c:1698: error: DEAD_STORE + The value written to &buf is never used. + 1696. { + 1697. int len = 0; + 1698. > char *buf = NULL; + 1699. struct cgroup_root *kf_cgroot = cgroup_root_from_kf(kf_root); + 1700. struct cgroup *ns_cgroup; + +kernel/cgroup/cgroup.c:1697: error: DEAD_STORE + The value written to &len is never used. + 1695. struct kernfs_root *kf_root) + 1696. { + 1697. > int len = 0; + 1698. char *buf = NULL; + 1699. struct cgroup_root *kf_cgroot = cgroup_root_from_kf(kf_root); + +net/sched/sch_api.c:1709: error: DEAD_STORE + The value written to &q is never used. + 1707. struct nlattr *tca[TCA_MAX + 1]; + 1708. struct net_device *dev; + 1709. > struct Qdisc *q = NULL; + 1710. const struct Qdisc_class_ops *cops; + 1711. unsigned long cl = 0; + +net/sunrpc/auth_gss/svcauth_gss.c:1716: error: DEAD_STORE + The value written to &stat is never used. + 1714. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1715. struct xdr_buf *resbuf = &rqstp->rq_res; + 1716. > int stat = -EINVAL; + 1717. struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id); + 1718. + +drivers/gpu/drm/drm_dp_mst_topology.c:1747: error: DEAD_STORE + The value written to &len is never used. + 1745. + 1746. txmsg->dst = mstb; + 1747. > len = build_allocate_payload(txmsg, port_num, + 1748. id, + 1749. pbn, port->num_sdp_streams, sinks); + +drivers/block/loop.c:1717: error: DEAD_STORE + The value written to &ret is never used. + 1715. const bool write = op_is_write(req_op(cmd->rq)); + 1716. struct loop_device *lo = cmd->rq->q->queuedata; + 1717. > int ret = 0; + 1718. + 1719. if (write && (lo->lo_flags & LO_FLAGS_READ_ONLY)) { + +drivers/gpu/drm/drm_fb_helper.c:1719: error: DEAD_STORE + The value written to &crtc_count is never used. + 1717. { + 1718. int ret = 0; + 1719. > int crtc_count = 0; + 1720. int i; + 1721. struct drm_fb_helper_surface_size sizes; + +drivers/gpu/drm/drm_fb_helper.c:1718: error: DEAD_STORE + The value written to &ret is never used. + 1716. int preferred_bpp) + 1717. { + 1718. > int ret = 0; + 1719. int crtc_count = 0; + 1720. int i; + +drivers/video/fbdev/core/fbmem.c:1722: error: DEAD_STORE + The value written to &ret is never used. + 1720. { + 1721. struct fb_event event; + 1722. > int i, ret = 0; + 1723. + 1724. i = fb_info->node; + +drivers/md/dm-ioctl.c:1751: error: DEAD_STORE + The value written to &dmi is never used. + 1749. * Use kmalloc() rather than vmalloc() when we can. + 1750. */ + 1751. > dmi = NULL; + 1752. noio_flag = memalloc_noio_save(); + 1753. dmi = kvmalloc(param_kernel->data_size, GFP_KERNEL | __GFP_HIGH); + +sound/core/seq/seq_clientmgr.c:1725: error: DEAD_STORE + The value written to &result is never used. + 1723. { + 1724. struct snd_seq_queue_timer *timer = arg; + 1725. > int result = 0; + 1726. + 1727. if (timer->type != SNDRV_SEQ_TIMER_ALSA) + +drivers/usb/host/ehci-sched.c:1728: error: DEAD_STORE + The value written to &type is never used. + 1726. __hc32 *hw_p = &ehci->periodic[frame]; + 1727. union ehci_shadow here = *prev; + 1728. > __hc32 type = 0; + 1729. + 1730. /* skip any iso nodes which might belong to previous microframes */ + +net/wireless/trace.h:1732: error: DEAD_STORE + The value written to &p is never used. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +security/selinux/selinuxfs.c:1738: error: DEAD_STORE + The value written to &dentry is never used. + 1736. { + 1737. unsigned int iter; + 1738. > struct dentry *dentry = NULL; + 1739. struct inode *inode = NULL; + 1740. + +security/selinux/selinuxfs.c:1739: error: DEAD_STORE + The value written to &inode is never used. + 1737. unsigned int iter; + 1738. struct dentry *dentry = NULL; + 1739. > struct inode *inode = NULL; + 1740. + 1741. sel_remove_entries(policycap_dir); + +drivers/base/core.c:1743: error: DEAD_STORE + The value written to &glue_dir is never used. + 1741. struct class_interface *class_intf; + 1742. int error = -EINVAL; + 1743. > struct kobject *glue_dir = NULL; + 1744. + 1745. dev = get_device(dev); + +drivers/gpu/drm/i915/intel_hdmi.c:1754: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1744 could be null and is dereferenced at line 1754, column 2. + 1752. chv_set_phy_signal_level(encoder, 128, 102, false); + 1753. + 1754. > dport->set_infoframes(&encoder->base, + 1755. pipe_config->has_infoframe, + 1756. pipe_config, conn_state); + +net/xfrm/xfrm_state.c:1779: error: DEAD_STORE + The value written to &spi is never used. + 1777. x->id.spi = minspi; + 1778. } else { + 1779. > u32 spi = 0; + 1780. for (h = 0; h < high-low+1; h++) { + 1781. spi = low + prandom_u32()%(high-low+1); + +net/wireless/trace.h:1752: error: DEAD_STORE + The value written to &p is never used. + 1750. ); + 1751. + 1752. > DECLARE_EVENT_CLASS(rdev_pmksa, + 1753. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1754. struct cfg80211_pmksa *pmksa), + +kernel/workqueue.c:1758: error: DEAD_STORE + The value written to &id is never used. + 1756. { + 1757. struct worker *worker = NULL; + 1758. > int id = -1; + 1759. char id_buf[16]; + 1760. + +drivers/block/loop.c:1783: error: DEAD_STORE + The value written to &err is never used. + 1781. i = err; + 1782. + 1783. > err = -ENOMEM; + 1784. lo->tag_set.ops = &loop_mq_ops; + 1785. lo->tag_set.nr_hw_queues = 1; + +drivers/net/ethernet/intel/e100.c:1775: error: DEAD_STORE + The value written to &skb is never used. + 1773. if (pci_dma_mapping_error(nic->pdev, dma_addr)) { + 1774. dev_kfree_skb_any(skb); + 1775. > skb = NULL; + 1776. return -ENOMEM; + 1777. } + +kernel/sched/deadline.c:1768: error: DEAD_STORE + The value written to &p is never used. + 1766. { + 1767. struct rb_node *next_node = rq->dl.pushable_dl_tasks_root.rb_leftmost; + 1768. > struct task_struct *p = NULL; + 1769. + 1770. if (!has_pushable_dl_tasks(rq)) + +drivers/gpu/drm/drm_dp_mst_topology.c:1784: error: DEAD_STORE + The value written to &len is never used. + 1782. + 1783. txmsg->dst = port->parent; + 1784. > len = build_power_updown_phy(txmsg, port->port_num, power_up); + 1785. drm_dp_queue_down_tx(mgr, txmsg); + 1786. + +sound/core/pcm_native.c:1776: error: DEAD_STORE + The value written to &result is never used. + 1774. struct snd_pcm_substream *s; + 1775. wait_queue_entry_t wait; + 1776. > int result = 0; + 1777. int nonblock = 0; + 1778. + +net/wireless/trace.h:1770: error: DEAD_STORE + The value written to &p is never used. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +drivers/iommu/iommu.c:1790: error: DEAD_STORE + The value written to &ret is never used. + 1788. enum iommu_attr attr, void *data) + 1789. { + 1790. > int ret = 0; + 1791. u32 *count; + 1792. + +crypto/drbg.c:1794: error: DEAD_STORE + The value written to &i is never used. + 1792. int *coreref, bool *pr) + 1793. { + 1794. > int i = 0; + 1795. size_t start = 0; + 1796. int len = 0; + +crypto/drbg.c:1796: error: DEAD_STORE + The value written to &len is never used. + 1794. int i = 0; + 1795. size_t start = 0; + 1796. > int len = 0; + 1797. + 1798. *pr = true; + +crypto/drbg.c:1795: error: DEAD_STORE + The value written to &start is never used. + 1793. { + 1794. int i = 0; + 1795. > size_t start = 0; + 1796. int len = 0; + 1797. + +drivers/usb/core/hub.c:1816: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1802 could be null and is dereferenced at line 1816, column 9. + 1814. info->nports = hdev->maxchild; + 1815. for (i = 0; i < info->nports; i++) { + 1816. > if (hub->ports[i]->child == NULL) + 1817. info->port[i] = 0; + 1818. else + +net/wireless/trace.h:1800: error: DEAD_STORE + The value written to &p is never used. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +drivers/gpu/drm/i915/i915_debugfs.c:1807: error: DEAD_STORE + The value written to &ret is never used. + 1805. struct drm_i915_private *dev_priv = node_to_i915(m->private); + 1806. struct intel_rps *rps = &dev_priv->gt_pm.rps; + 1807. > int ret = 0; + 1808. int gpu_freq, ia_freq; + 1809. unsigned int max_gpu_freq, min_gpu_freq; + +kernel/futex.c:1809: error: DEAD_STORE + The value written to &top_waiter is never used. + 1807. struct futex_pi_state **ps, int set_waiters) + 1808. { + 1809. > struct futex_q *top_waiter = NULL; + 1810. u32 curval; + 1811. int ret, vpid; + +kernel/cgroup/cpuset.c:1817: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1813 could be null and is dereferenced at line 1817, column 10. + 1815. switch (type) { + 1816. case FILE_SCHED_RELAX_DOMAIN_LEVEL: + 1817. > return cs->relax_domain_level; + 1818. default: + 1819. BUG(); + +drivers/gpu/drm/drm_atomic.c:1817: error: DEAD_STORE + The value written to &e is never used. + 1815. struct drm_crtc *crtc, uint64_t user_data) + 1816. { + 1817. > struct drm_pending_vblank_event *e = NULL; + 1818. + 1819. e = kzalloc(sizeof *e, GFP_KERNEL); + +drivers/iommu/amd_iommu.c:1821: error: DEAD_STORE + The value written to &flags is never used. + 1819. { + 1820. u64 pte_root = 0; + 1821. > u64 flags = 0; + 1822. + 1823. if (domain->mode != PAGE_MODE_NONE) + +net/ipv4/af_inet.c:1823: error: DEAD_STORE + The value written to &rc is never used. + 1821. struct inet_protosw *q; + 1822. struct list_head *r; + 1823. > int rc = -EINVAL; + 1824. + 1825. sock_skb_cb_check_size(sizeof(struct inet_skb_parm)); + +drivers/md/dm-ioctl.c:1827: error: DEAD_STORE + The value written to &fn is never used. + 1825. unsigned int cmd; + 1826. struct dm_ioctl *uninitialized_var(param); + 1827. > ioctl_fn fn = NULL; + 1828. size_t input_param_size; + 1829. struct dm_ioctl param_kernel; + +drivers/md/dm-ioctl.c:1822: error: DEAD_STORE + The value written to &r is never used. + 1820. static int ctl_ioctl(struct file *file, uint command, struct dm_ioctl __user *user) + 1821. { + 1822. > int r = 0; + 1823. int ioctl_flags; + 1824. int param_flags; + +net/wireless/trace.h:1821: error: DEAD_STORE + The value written to &p is never used. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/ipv4/cipso_ipv4.c:1831: error: DEAD_STORE + The value written to &buf is never used. + 1829. { + 1830. int ret_val = -EPERM; + 1831. > unsigned char *buf = NULL; + 1832. u32 buf_len; + 1833. u32 opt_len; + +net/ipv4/cipso_ipv4.c:1874: error: DEAD_STORE + The value written to &buf is never used. + 1872. opt->opt.cipso = sizeof(struct iphdr); + 1873. kfree(buf); + 1874. > buf = NULL; + 1875. + 1876. sk_inet = inet_sk(sk); + +net/ipv4/cipso_ipv4.c:1830: error: DEAD_STORE + The value written to &ret_val is never used. + 1828. const struct netlbl_lsm_secattr *secattr) + 1829. { + 1830. > int ret_val = -EPERM; + 1831. unsigned char *buf = NULL; + 1832. u32 buf_len; + +net/sunrpc/xprtsock.c:1834: error: DEAD_STORE + The value written to &port is never used. + 1832. if (port <= xprt_min_resvport || port > xprt_max_resvport) + 1833. return xprt_max_resvport; + 1834. > return --port; + 1835. } + 1836. static int xs_bind(struct sock_xprt *transport, struct socket *sock) + +drivers/usb/host/ehci-sched.c:1888: error: DEAD_STORE + The value written to &dev is never used. + 1886. + 1887. /* give urb back to the driver; completion often (re)submits */ + 1888. > dev = urb->dev; + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + +drivers/usb/host/ehci-sched.c:1891: error: DEAD_STORE + The value written to &urb is never used. + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + 1891. > urb = NULL; + 1892. + 1893. --ehci->isoc_count; + +kernel/sys.c:1835: error: DEAD_STORE + The value written to &mm is never used. + 1833. { + 1834. unsigned long mmap_max_addr = TASK_SIZE; + 1835. > struct mm_struct *mm = current->mm; + 1836. int error = -EINVAL, i; + 1837. + +net/unix/af_unix.c:1836: error: DEAD_STORE + The value written to &other is never used. + 1834. { + 1835. struct sock *sk = sock->sk; + 1836. > struct sock *other = NULL; + 1837. int err, size; + 1838. struct sk_buff *skb; + +drivers/iommu/dmar.c:1836: error: DEAD_STORE + The value written to &ret is never used. + 1834. dmar_res_handler_t handler, void *arg) + 1835. { + 1836. > int ret = -ENODEV; + 1837. union acpi_object *obj; + 1838. struct acpi_dmar_header *start; + +drivers/gpu/drm/i915/intel_ddi.c:1839: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1838 could be null and is dereferenced at line 1839, column 46. + 1837. { + 1838. struct intel_digital_port *intel_dig_port = enc_to_dig_port(&encoder->base); + 1839. > struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev); + 1840. enum port port = intel_dig_port->port; + 1841. uint8_t iboost; + +drivers/iommu/amd_iommu_init.c:1840: error: DEAD_STORE + The value written to &ret is never used. + 1838. { + 1839. struct amd_iommu *iommu; + 1840. > int ret = 0; + 1841. + 1842. for_each_iommu(iommu) { + +drivers/usb/core/hub.c:1850: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1840 could be null and is dereferenced at line 1850, column 15. + 1848. * will always have maxchild equal to 0. + 1849. */ + 1850. > *ppowner = &(hub->ports[port1 - 1]->port_owner); + 1851. return 0; + 1852. } + +net/wireless/trace.h:1838: error: DEAD_STORE + The value written to &p is never used. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +drivers/tty/tty_io.c:1850: error: DEAD_STORE + The value written to &driver is never used. + 1848. { + 1849. struct tty_struct *tty; + 1850. > struct tty_driver *driver = NULL; + 1851. int index = -1; + 1852. + +drivers/iommu/intel-iommu.c:1851: error: DEAD_STORE + The value written to &count is never used. + 1849. struct intel_iommu *iommu) + 1850. { + 1851. > int num, count = INT_MAX; + 1852. + 1853. assert_spin_locked(&device_domain_lock); + +drivers/scsi/sg.c:1851: error: DEAD_STORE + The value written to &ret_sz is never used. + 1849. sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size) + 1850. { + 1851. > int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems; + 1852. int sg_tablesize = sfp->parentdp->sg_tablesize; + 1853. int blk_size = buff_size, order; + +kernel/kprobes.c:1853: error: DEAD_STORE + The value written to &flags is never used. + 1851. { + 1852. struct kretprobe *rp = container_of(p, struct kretprobe, kp); + 1853. > unsigned long hash, flags = 0; + 1854. struct kretprobe_instance *ri; + 1855. + +net/wireless/trace.h:1855: error: DEAD_STORE + The value written to &p is never used. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +security/selinux/ss/services.c:1913: error: DEAD_STORE + The value written to &rc is never used. + 1911. + 1912. /* Convert the user. */ + 1913. > rc = -EINVAL; + 1914. usrdatum = hashtab_search(args->newp->p_users.table, + 1915. sym_name(args->oldp, SYM_USERS, c->user - 1)); + +security/selinux/ss/services.c:1921: error: DEAD_STORE + The value written to &rc is never used. + 1919. + 1920. /* Convert the role. */ + 1921. > rc = -EINVAL; + 1922. role = hashtab_search(args->newp->p_roles.table, + 1923. sym_name(args->oldp, SYM_ROLES, c->role - 1)); + +security/selinux/ss/services.c:1929: error: DEAD_STORE + The value written to &rc is never used. + 1927. + 1928. /* Convert the type. */ + 1929. > rc = -EINVAL; + 1930. typdatum = hashtab_search(args->newp->p_types.table, + 1931. sym_name(args->oldp, SYM_TYPES, c->type - 1)); + +security/selinux/ss/services.c:1959: error: DEAD_STORE + The value written to &rc is never used. + 1957. while (oc && oc->sid[0] != SECINITSID_UNLABELED) + 1958. oc = oc->next; + 1959. > rc = -EINVAL; + 1960. if (!oc) { + 1961. printk(KERN_ERR "SELinux: unable to look up" + +ipc/sem.c:1864: error: DEAD_STORE + The value written to &error is never used. + 1862. unsigned nsops, const struct timespec64 *timeout) + 1863. { + 1864. > int error = -EINVAL; + 1865. struct sem_array *sma; + 1866. struct sembuf fast_sops[SEMOPM_FAST]; + +net/core/skbuff.c:1907: error: DEAD_STORE + The value written to &insp is never used. + 1905. struct sk_buff *list = skb_shinfo(skb)->frag_list; + 1906. struct sk_buff *clone = NULL; + 1907. > struct sk_buff *insp = NULL; + 1908. + 1909. do { + +drivers/gpu/drm/drm_edid.c:1872: error: DEAD_STORE + The value written to &n is never used. + 1870. cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure) + 1871. { + 1872. > int i, n = 0; + 1873. u8 d = ext[0x02]; + 1874. u8 *det_base = ext + d; + +drivers/i2c/i2c-core-base.c:1893: error: DEAD_STORE + The value written to &orig_jiffies is never used. + 1891. + 1892. /* Retry automatically on arbitration loss */ + 1893. > orig_jiffies = jiffies; + 1894. for (ret = 0, try = 0; try <= adap->retries; try++) { + 1895. ret = adap->algo->master_xfer(adap, msgs, num); + +include/net/tcp.h:1886: error: NULL_DEREFERENCE + pointer `skb` last assigned on line 1884 could be null and is dereferenced at line 1886, column 26. + 1884. const struct sk_buff *skb = tcp_rtx_queue_head(sk); + 1885. u32 rto = inet_csk(sk)->icsk_rto; + 1886. > u64 rto_time_stamp_us = skb->skb_mstamp + jiffies_to_usecs(rto); + 1887. + 1888. return rto_time_stamp_us - tcp_sk(sk)->tcp_mstamp; + +net/wireless/trace.h:1885: error: DEAD_STORE + The value written to &p is never used. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +drivers/usb/core/hub.c:1893: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1889 could be null and is dereferenced at line 1893, column 7. + 1891. + 1892. for (n = 0; n < hdev->maxchild; n++) { + 1893. > if (hub->ports[n]->port_owner == owner) + 1894. hub->ports[n]->port_owner = NULL; + 1895. } + +kernel/trace/trace_events_filter.c:1894: error: DEAD_STORE + The value written to &ps is never used. + 1892. { + 1893. struct event_filter *filter; + 1894. > struct filter_parse_state *ps = NULL; + 1895. int err = 0; + 1896. + +drivers/cpufreq/cpufreq.c:1897: error: DEAD_STORE + The value written to &retval is never used. + 1895. unsigned int intermediate_freq = 0; + 1896. unsigned int newfreq = policy->freq_table[index].frequency; + 1897. > int retval = -EINVAL; + 1898. bool notify; + 1899. + +sound/core/seq/seq_clientmgr.c:1899: error: DEAD_STORE + The value written to &sender is never used. + 1897. struct snd_seq_port_subscribe *subs = arg; + 1898. int result; + 1899. > struct snd_seq_client *sender = NULL; + 1900. struct snd_seq_client_port *sport = NULL; + 1901. struct snd_seq_subscribers *p; + +crypto/drbg.c:1902: error: DEAD_STORE + The value written to &drbg is never used. + 1900. #define OUTBUFLEN 16 + 1901. unsigned char buf[OUTBUFLEN]; + 1902. > struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. int rc = -EFAULT; + +crypto/drbg.c:1899: error: DEAD_STORE + The value written to &len is never used. + 1897. static inline int __init drbg_healthcheck_sanity(void) + 1898. { + 1899. > int len = 0; + 1900. #define OUTBUFLEN 16 + 1901. unsigned char buf[OUTBUFLEN]; + +crypto/drbg.c:1904: error: DEAD_STORE + The value written to &rc is never used. + 1902. struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. > int rc = -EFAULT; + 1905. bool pr = false; + 1906. int coreref = 0; + +crypto/drbg.c:1903: error: DEAD_STORE + The value written to &ret is never used. + 1901. unsigned char buf[OUTBUFLEN]; + 1902. struct drbg_state *drbg = NULL; + 1903. > int ret = -EFAULT; + 1904. int rc = -EFAULT; + 1905. bool pr = false; + +drivers/tty/tty_io.c:1902: error: DEAD_STORE + The value written to &driver is never used. + 1900. { + 1901. struct tty_struct *tty; + 1902. > struct tty_driver *driver = NULL; + 1903. int index = -1; + 1904. int retval; + +drivers/usb/core/hub.c:1907: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1906 could be null and is dereferenced at line 1907, column 11. + 1905. return false; + 1906. hub = usb_hub_to_struct_hub(udev->parent); + 1907. > return !!hub->ports[udev->portnum - 1]->port_owner; + 1908. } + 1909. + +net/wireless/trace.h:1908: error: DEAD_STORE + The value written to &p is never used. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +drivers/usb/core/hub.c:1916: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1912 could be null and is dereferenced at line 1916, column 7. + 1914. + 1915. for (i = 0; i < udev->maxchild; ++i) { + 1916. > if (hub->ports[i]->child) + 1917. recursively_mark_NOTATTACHED(hub->ports[i]->child); + 1918. } + +net/ipv4/cipso_ipv4.c:1916: error: DEAD_STORE + The value written to &buf is never used. + 1914. { + 1915. int ret_val = -EPERM; + 1916. > unsigned char *buf = NULL; + 1917. u32 buf_len; + 1918. u32 opt_len; + +net/ipv4/cipso_ipv4.c:1951: error: DEAD_STORE + The value written to &buf is never used. + 1949. opt->opt.cipso = sizeof(struct iphdr); + 1950. kfree(buf); + 1951. > buf = NULL; + 1952. + 1953. req_inet = inet_rsk(req); + +net/ipv4/cipso_ipv4.c:1915: error: DEAD_STORE + The value written to &ret_val is never used. + 1913. const struct netlbl_lsm_secattr *secattr) + 1914. { + 1915. > int ret_val = -EPERM; + 1916. unsigned char *buf = NULL; + 1917. u32 buf_len; + +kernel/kprobes.c:1922: error: DEAD_STORE + The value written to &ret is never used. + 1920. int register_kretprobe(struct kretprobe *rp) + 1921. { + 1922. > int ret = 0; + 1923. struct kretprobe_instance *inst; + 1924. int i; + +drivers/cdrom/cdrom.c:1927: error: DEAD_STORE + The value written to &ret is never used. + 1925. struct packet_command *cgc) + 1926. { + 1927. > int ret = 0, size; + 1928. u_char *buf; + 1929. const struct cdrom_device_ops *cdo = cdi->ops; + +drivers/md/dm-table.c:1928: error: DEAD_STORE + The value written to &r is never used. + 1926. int dm_table_resume_targets(struct dm_table *t) + 1927. { + 1928. > int i, r = 0; + 1929. + 1930. lockdep_assert_held(&t->md->suspend_lock); + +drivers/video/fbdev/core/fbmem.c:1934: error: DEAD_STORE + The value written to &err is never used. + 1932. struct fb_modelist *modelist; + 1933. struct fb_videomode *m, mode; + 1934. > int err = 1; + 1935. + 1936. list_for_each_safe(pos, n, &info->modelist) { + +sound/core/seq/seq_clientmgr.c:1932: error: DEAD_STORE + The value written to &cptr is never used. + 1930. struct snd_seq_query_subs *subs = arg; + 1931. int result = -ENXIO; + 1932. > struct snd_seq_client *cptr = NULL; + 1933. struct snd_seq_client_port *port = NULL; + 1934. struct snd_seq_port_subs_info *group; + +net/wireless/trace.h:1939: error: DEAD_STORE + The value written to &p is never used. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +drivers/ata/libahci.c:1944: error: DEAD_STORE + The value written to &rc is never used. + 1942. struct ata_host *host = dev_instance; + 1943. struct ahci_host_priv *hpriv; + 1944. > unsigned int rc = 0; + 1945. void __iomem *mmio; + 1946. u32 irq_stat, irq_masked; + +drivers/input/mouse/alps.c:1948: error: DEAD_STORE + The value written to &ret is never used. + 1946. { + 1947. u16 reg_val = 0x181; + 1948. > int ret = -1; + 1949. + 1950. /* enter monitor mode, to write the register */ + +drivers/base/core.c:1951: error: DEAD_STORE + The value written to &glue_dir is never used. + 1949. { + 1950. struct device *parent = dev->parent; + 1951. > struct kobject *glue_dir = NULL; + 1952. struct class_interface *class_intf; + 1953. + +drivers/gpu/drm/i915/intel_sdvo.c:1955: error: DEAD_STORE + The value written to &format_map is never used. + 1953. const struct drm_connector_state *conn_state = connector->state; + 1954. struct intel_sdvo_sdtv_resolution_request tv_res; + 1955. > uint32_t reply = 0, format_map = 0; + 1956. int i; + 1957. + +drivers/md/md-bitmap.c:1954: error: DEAD_STORE + The value written to &rv is never used. + 1952. struct bitmap *get_bitmap_from_slot(struct mddev *mddev, int slot) + 1953. { + 1954. > int rv = 0; + 1955. struct bitmap *bitmap; + 1956. + +net/ipv4/udp.c:1963: error: DEAD_STORE + The value written to &dif is never used. + 1961. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1962. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1963. > int dif = skb->dev->ifindex; + 1964. int sdif = inet_sdif(skb); + 1965. struct hlist_node *node; + +net/ipv4/udp.c:1962: error: DEAD_STORE + The value written to &offset is never used. + 1960. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 1961. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1962. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 1963. int dif = skb->dev->ifindex; + 1964. int sdif = inet_sdif(skb); + +net/ipv4/udp.c:1974: error: DEAD_STORE + The value written to &offset is never used. + 1972. start_lookup: + 1973. hslot = &udptable->hash2[hash2]; + 1974. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 1975. } + 1976. + +net/ipv4/udp.c:1964: error: DEAD_STORE + The value written to &sdif is never used. + 1962. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1963. int dif = skb->dev->ifindex; + 1964. > int sdif = inet_sdif(skb); + 1965. struct hlist_node *node; + 1966. struct sk_buff *nskb; + +net/sunrpc/auth_gss/auth_gss.c:1965: error: DEAD_STORE + The value written to &status is never used. + 1963. struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; + 1964. int savedlen = head->iov_len; + 1965. > int status = -EIO; + 1966. + 1967. if (ctx->gc_proc != RPC_GSS_PROC_DATA) + +block/blk-mq.c:1964: error: NULL_DEREFERENCE + pointer `hctx` last assigned on line 1963 could be null and is dereferenced at line 1964, column 25. + 1962. + 1963. hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead); + 1964. > ctx = __blk_mq_get_ctx(hctx->queue, cpu); + 1965. + 1966. spin_lock(&ctx->lock); + +drivers/usb/core/hcd.c:1964: error: DEAD_STORE + The value written to &alt is never used. + 1962. { + 1963. int num_intfs, i, j; + 1964. > struct usb_host_interface *alt = NULL; + 1965. int ret = 0; + 1966. struct usb_hcd *hcd; + +drivers/usb/core/hcd.c:1965: error: DEAD_STORE + The value written to &ret is never used. + 1963. int num_intfs, i, j; + 1964. struct usb_host_interface *alt = NULL; + 1965. > int ret = 0; + 1966. struct usb_hcd *hcd; + 1967. struct usb_host_endpoint *ep; + +net/wireless/trace.h:1961: error: DEAD_STORE + The value written to &p is never used. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +drivers/net/ethernet/broadcom/tg3.c:1967: error: DEAD_STORE + The value written to &flowctrl is never used. + 1965. { + 1966. u8 autoneg; + 1967. > u8 flowctrl = 0; + 1968. u32 old_rx_mode = tp->rx_mode; + 1969. u32 old_tx_mode = tp->tx_mode; + +crypto/drbg.c:1971: error: DEAD_STORE + The value written to &pos is never used. + 1969. const struct drbg_core *core, int pr) + 1970. { + 1971. > int pos = 0; + 1972. static int priority = 200; + 1973. + +kernel/cgroup/cpuset.c:1974: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1973 could be null and is dereferenced by call to `parent_cs()` at line 1974, column 26. + 1972. { + 1973. struct cpuset *cs = css_cs(css); + 1974. > struct cpuset *parent = parent_cs(cs); + 1975. struct cpuset *tmp_cs; + 1976. struct cgroup_subsys_state *pos_css; + +net/netlink/af_netlink.c:1978: error: DEAD_STORE + The value written to &listeners is never used. + 1976. struct sock *sk; + 1977. struct netlink_sock *nlk; + 1978. > struct listeners *listeners = NULL; + 1979. struct mutex *cb_mutex = cfg ? cfg->cb_mutex : NULL; + 1980. unsigned int groups; + +drivers/iommu/amd_iommu_init.c:1975: error: DEAD_STORE + The value written to &e is never used. + 1973. static int __init init_unity_map_range(struct ivmd_header *m) + 1974. { + 1975. > struct unity_map_entry *e = NULL; + 1976. char *s; + 1977. + +net/ipv4/cipso_ipv4.c:1979: error: DEAD_STORE + The value written to &hdr_delta is never used. + 1977. { + 1978. struct ip_options_rcu *opt = rcu_dereference_protected(*opt_ptr, 1); + 1979. > int hdr_delta = 0; + 1980. + 1981. if (!opt || opt->opt.cipso == 0) + +drivers/iommu/intel-iommu.c:1990: error: DEAD_STORE + The value written to &freelist is never used. + 1988. static void domain_exit(struct dmar_domain *domain) + 1989. { + 1990. > struct page *freelist = NULL; + 1991. + 1992. /* Domain 0 is reserved, so dont process it */ + +drivers/cpufreq/cpufreq.c:1993: error: DEAD_STORE + The value written to &ret is never used. + 1991. unsigned int relation) + 1992. { + 1993. > int ret = -EINVAL; + 1994. + 1995. down_write(&policy->rwsem); + +drivers/gpu/drm/i915/i915_irq.c:2006: error: DEAD_STORE + The value written to &ier is never used. + 2004. u32 pipe_stats[I915_MAX_PIPES] = {}; + 2005. u32 hotplug_status = 0; + 2006. > u32 ier = 0; + 2007. + 2008. gt_iir = I915_READ(GTIIR); + +lib/vsprintf.c:2056: error: DEAD_STORE + The value written to &fmt is never used. + 2054. /* it's the next argument */ + 2055. spec->type = FORMAT_TYPE_WIDTH; + 2056. > return ++fmt - start; + 2057. } + 2058. + +lib/vsprintf.c:2071: error: DEAD_STORE + The value written to &fmt is never used. + 2069. /* it's the next argument */ + 2070. spec->type = FORMAT_TYPE_PRECISION; + 2071. > return ++fmt - start; + 2072. } + 2073. } + +lib/vsprintf.c:2097: error: DEAD_STORE + The value written to &fmt is never used. + 2095. case 'c': + 2096. spec->type = FORMAT_TYPE_CHAR; + 2097. > return ++fmt - start; + 2098. + 2099. case 's': + +lib/vsprintf.c:2101: error: DEAD_STORE + The value written to &fmt is never used. + 2099. case 's': + 2100. spec->type = FORMAT_TYPE_STR; + 2101. > return ++fmt - start; + 2102. + 2103. case 'p': + +lib/vsprintf.c:2105: error: DEAD_STORE + The value written to &fmt is never used. + 2103. case 'p': + 2104. spec->type = FORMAT_TYPE_PTR; + 2105. > return ++fmt - start; + 2106. + 2107. case '%': + +lib/vsprintf.c:2109: error: DEAD_STORE + The value written to &fmt is never used. + 2107. case '%': + 2108. spec->type = FORMAT_TYPE_PERCENT_CHAR; + 2109. > return ++fmt - start; + 2110. + 2111. /* integer number formats - set up the flags and "break" */ + +lib/vsprintf.c:2163: error: DEAD_STORE + The value written to &fmt is never used. + 2161. } + 2162. + 2163. > return ++fmt - start; + 2164. } + 2165. + +net/wireless/trace.h:1990: error: DEAD_STORE + The value written to &p is never used. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +drivers/tty/n_tty.c:2001: error: DEAD_STORE + The value written to &found is never used. + 1999. size_t eol; + 2000. size_t tail; + 2001. > int ret, found = 0; + 2002. + 2003. /* N.B. avoid overrun if nr == 0 */ + +drivers/net/ethernet/intel/e1000e/netdev.c:2002: error: DEAD_STORE + The value written to &ivar is never used. + 2000. struct e1000_ring *tx_ring = adapter->tx_ring; + 2001. int vector = 0; + 2002. > u32 ctrl_ext, ivar = 0; + 2003. + 2004. adapter->eiac_mask = 0; + +drivers/gpu/drm/drm_dp_mst_topology.c:2019: error: DEAD_STORE + The value written to &len is never used. + 2017. } + 2018. + 2019. > len = build_dpcd_write(txmsg, port->port_num, offset, size, bytes); + 2020. txmsg->dst = mstb; + 2021. + +net/ipv4/tcp_ipv4.c:2004: error: DEAD_STORE + The value written to &net is never used. + 2002. { + 2003. struct tcp_iter_state *st = seq->private; + 2004. > struct net *net = seq_file_net(seq); + 2005. void *rc = NULL; + 2006. + +net/xfrm/xfrm_user.c:2009: error: DEAD_STORE + The value written to &mark is never used. + 2007. struct km_event c; + 2008. int err = -EINVAL; + 2009. > u32 mark = 0; + 2010. struct xfrm_mark m; + 2011. struct xfrm_aevent_id *p = nlmsg_data(nlh); + +drivers/net/ethernet/broadcom/tg3.c:2017: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2008 could be null and is dereferenced at line 2017, column 6. + 2015. oldflowctrl = tp->link_config.active_flowctrl; + 2016. + 2017. > if (phydev->link) { + 2018. lcl_adv = 0; + 2019. rmt_adv = 0; + +crypto/drbg.c:2008: error: DEAD_STORE + The value written to &j is never used. + 2006. { + 2007. unsigned int i = 0; /* pointer to drbg_algs */ + 2008. > unsigned int j = 0; /* pointer to drbg_cores */ + 2009. int ret; + 2010. + +kernel/cgroup/cgroup.c:2022: error: NULL_DEREFERENCE + pointer `ns` last assigned on line 2015 could be null and is dereferenced at line 2022, column 18. + 2020. + 2021. /* Check if the caller has permission to mount. */ + 2022. > if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN)) { + 2023. put_cgroup_ns(ns); + 2024. return ERR_PTR(-EPERM); + +net/wireless/trace.h:2011: error: DEAD_STORE + The value written to &p is never used. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2017: error: DEAD_STORE + The value written to &blocked is never used. + 2015. static s32 e1000_check_reset_block_ich8lan(struct e1000_hw *hw) + 2016. { + 2017. > bool blocked = false; + 2018. int i = 0; + 2019. + +sound/core/seq/seq_clientmgr.c:2023: error: DEAD_STORE + The value written to &port is never used. + 2021. struct snd_seq_port_info *info = arg; + 2022. struct snd_seq_client *cptr; + 2023. > struct snd_seq_client_port *port = NULL; + 2024. + 2025. cptr = snd_seq_client_use_ptr(info->addr.client); + +net/sunrpc/xprtsock.c:2026: error: DEAD_STORE + The value written to &status is never used. + 2024. struct rpc_xprt *xprt = &transport->xprt; + 2025. struct socket *sock; + 2026. > int status = -EIO; + 2027. + 2028. status = __sock_create(xprt->xprt_net, AF_LOCAL, + +drivers/gpu/drm/drm_edid.c:2034: error: DEAD_STORE + The value written to &mode is never used. + 2032. { + 2033. struct drm_device *dev = connector->dev; + 2034. > struct drm_display_mode *m, *mode = NULL; + 2035. int hsize, vsize; + 2036. int vrefresh_rate; + +drivers/hid/hid-sony.c:2075: error: DEAD_STORE + The value written to &offset is never used. + 2073. /* If both delay values are zero the DualShock 4 disables blinking. */ + 2074. buf[offset++] = sc->led_delay_on[3]; + 2075. > buf[offset++] = sc->led_delay_off[3]; + 2076. + 2077. if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) + +net/wireless/trace.h:2029: error: DEAD_STORE + The value written to &p is never used. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/ipv4/tcp_ipv4.c:2037: error: DEAD_STORE + The value written to &net is never used. + 2035. struct hlist_nulls_node *node; + 2036. struct tcp_iter_state *st = seq->private; + 2037. > struct net *net = seq_file_net(seq); + 2038. + 2039. ++st->num; + +security/selinux/ss/services.c:2050: error: DEAD_STORE + The value written to &rc is never used. + 2048. u32 seqno; + 2049. u16 map_size; + 2050. > int rc = 0; + 2051. struct policy_file file = { data, len }, *fp = &file; + 2052. + +net/xfrm/xfrm_policy.c:2050: error: DEAD_STORE + The value written to &num_pols is never used. + 2048. { + 2049. struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX]; + 2050. > int num_pols = 0, num_xfrms = 0, err; + 2051. struct xfrm_dst *xdst; + 2052. + +net/wireless/trace.h:2047: error: DEAD_STORE + The value written to &p is never used. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +drivers/gpu/drm/drm_fb_helper.c:2056: error: DEAD_STORE + The value written to &i is never used. + 2054. bool any_enabled = false; + 2055. struct drm_connector *connector; + 2056. > int i = 0; + 2057. + 2058. drm_fb_helper_for_each_connector(fb_helper, i) { + +drivers/net/ethernet/intel/e1000e/ethtool.c:2072: error: DEAD_STORE + The value written to &p is never used. + 2070. struct rtnl_link_stats64 net_stats; + 2071. int i; + 2072. > char *p = NULL; + 2073. + 2074. pm_runtime_get_sync(netdev->dev.parent); + +drivers/usb/core/hub.c:2073: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2068 could be null and is dereferenced at line 2073, column 7. + 2071. /* Free up all the children before we remove this device */ + 2072. for (i = 0; i < udev->maxchild; i++) { + 2073. > if (hub->ports[i]->child) + 2074. usb_disconnect(&hub->ports[i]->child); + 2075. } + +drivers/ata/libata-core.c:2073: error: DEAD_STORE + The value written to &dma is never used. + 2071. struct ata_taskfile tf; + 2072. unsigned int err_mask; + 2073. > bool dma = false; + 2074. + 2075. DPRINTK("read log page - log 0x%x, page 0x%x\n", log, page); + +net/wireless/trace.h:2067: error: DEAD_STORE + The value written to &p is never used. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/sunrpc/auth_gss/auth_gss.c:2073: error: DEAD_STORE + The value written to &err is never used. + 2071. static int __init init_rpcsec_gss(void) + 2072. { + 2073. > int err = 0; + 2074. + 2075. err = rpcauth_register(&authgss_ops); + +net/core/rtnetlink.c:2256: error: DEAD_STORE + The value written to &err is never used. + 2254. } + 2255. } + 2256. > err = 0; + 2257. + 2258. if (tb[IFLA_VF_PORTS]) { + +net/core/rtnetlink.c:2289: error: DEAD_STORE + The value written to &err is never used. + 2287. } + 2288. } + 2289. > err = 0; + 2290. + 2291. if (tb[IFLA_PORT_SELF]) { + +kernel/time/timekeeping.c:2080: error: DEAD_STORE + The value written to &shift is never used. + 2078. struct timekeeper *tk = &shadow_timekeeper; + 2079. u64 offset; + 2080. > int shift = 0, maxshift; + 2081. unsigned int clock_set = 0; + 2082. unsigned long flags; + +drivers/gpu/drm/drm_fb_helper.c:2082: error: DEAD_STORE + The value written to &can_clone is never used. + 2080. { + 2081. int count, i, j; + 2082. > bool can_clone = false; + 2083. struct drm_fb_helper_connector *fb_helper_conn; + 2084. struct drm_display_mode *dmt_mode, *mode; + +drivers/net/ethernet/nvidia/forcedeth.c:2081: error: DEAD_STORE + The value written to &tx_status is never used. + 2079. u32 reg; + 2080. u32 low; + 2081. > int tx_status = 0; + 2082. + 2083. reg = readl(base + NvRegSlotTime) & ~NVREG_SLOTTIME_MASK; + +drivers/gpu/drm/i915/i915_irq.c:2094: error: DEAD_STORE + The value written to &ier is never used. + 2092. u32 pipe_stats[I915_MAX_PIPES] = {}; + 2093. u32 hotplug_status = 0; + 2094. > u32 ier = 0; + 2095. + 2096. master_ctl = I915_READ(GEN8_MASTER_IRQ) & ~GEN8_MASTER_IRQ_CONTROL; + +net/wireless/reg.c:2085: error: DEAD_STORE + The value written to &bw_flags is never used. + 2083. const struct ieee80211_regdomain *regd) + 2084. { + 2085. > u32 bw_flags = 0; + 2086. const struct ieee80211_reg_rule *reg_rule = NULL; + 2087. const struct ieee80211_power_rule *power_rule = NULL; + +net/wireless/reg.c:2087: error: DEAD_STORE + The value written to &power_rule is never used. + 2085. u32 bw_flags = 0; + 2086. const struct ieee80211_reg_rule *reg_rule = NULL; + 2087. > const struct ieee80211_power_rule *power_rule = NULL; + 2088. u32 bw; + 2089. + +net/xfrm/xfrm_user.c:2089: error: DEAD_STORE + The value written to &err is never used. + 2087. struct xfrm_userpolicy_info *p = &up->pol; + 2088. u8 type = XFRM_POLICY_TYPE_MAIN; + 2089. > int err = -ENOENT; + 2090. struct xfrm_mark m; + 2091. u32 mark = xfrm_mark_get(attrs, &m); + +drivers/net/ethernet/broadcom/tg3.c:2100: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2097 could be null and is dereferenced by call to `phydev_name()` at line 2100, column 32. + 2098. + 2099. /* Attach the MAC to the PHY. */ + 2100. > phydev = phy_connect(tp->dev, phydev_name(phydev), + 2101. tg3_adjust_link, phydev->interface); + 2102. if (IS_ERR(phydev)) { + +net/wireless/trace.h:2087: error: DEAD_STORE + The value written to &p is never used. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +drivers/scsi/sd.c:2094: error: DEAD_STORE + The value written to &spintime_expire is never used. + 2092. { + 2093. unsigned char cmd[10]; + 2094. > unsigned long spintime_expire = 0; + 2095. int retries, spintime; + 2096. unsigned int the_result; + +drivers/scsi/sd.c:2170: error: DEAD_STORE + The value written to &spintime_expire is never used. + 2168. SD_TIMEOUT, SD_MAX_RETRIES, + 2169. NULL); + 2170. > spintime_expire = jiffies + 100 * HZ; + 2171. spintime = 1; + 2172. } + +drivers/scsi/sd.c:2186: error: DEAD_STORE + The value written to &spintime_expire is never used. + 2184. sshdr.asc == 0x28) { + 2185. if (!spintime) { + 2186. > spintime_expire = jiffies + 5 * HZ; + 2187. spintime = 1; + 2188. } + +net/ipv4/route.c:2131: error: NULL_DEREFERENCE + pointer `in_dev` last assigned on line 2109 could be null and is dereferenced at line 2131, column 8. + 2129. || + 2130. (!ipv4_is_local_multicast(daddr) && + 2131. > IN_DEV_MFORWARD(in_dev)) + 2132. #endif + 2133. ) { + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &p is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &ret is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +drivers/tty/n_tty.c:2168: error: DEAD_STORE + The value written to &nr is never used. + 2166. } + 2167. b++; + 2168. > nr--; + 2169. break; + 2170. } + +net/core/ethtool.c:2117: error: DEAD_STORE + The value written to &data is never used. + 2115. struct ethtool_dump dump, tmp; + 2116. const struct ethtool_ops *ops = dev->ethtool_ops; + 2117. > void *data = NULL; + 2118. + 2119. if (!ops->get_dump_data || !ops->get_dump_flag) + +drivers/usb/core/devio.c:2118: error: DEAD_STORE + The value written to &intf is never used. + 2116. void *buf = NULL; + 2117. int retval = 0; + 2118. > struct usb_interface *intf = NULL; + 2119. struct usb_driver *driver = NULL; + 2120. + +kernel/cgroup/cpuset.c:2119: error: DEAD_STORE + The value written to &err is never used. + 2117. int __init cpuset_init(void) + 2118. { + 2119. > int err = 0; + 2120. + 2121. BUG_ON(!alloc_cpumask_var(&top_cpuset.cpus_allowed, GFP_KERNEL)); + +drivers/net/ethernet/intel/e1000e/netdev.c:2133: error: DEAD_STORE + The value written to &err is never used. + 2131. { + 2132. struct net_device *netdev = adapter->netdev; + 2133. > int err = 0, vector = 0; + 2134. + 2135. if (strlen(netdev->name) < (IFNAMSIZ - 5)) + +block/blk-mq.c:2136: error: DEAD_STORE + The value written to &ret is never used. + 2134. static bool __blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, int hctx_idx) + 2135. { + 2136. > int ret = 0; + 2137. + 2138. set->tags[hctx_idx] = blk_mq_alloc_rq_map(set, hctx_idx, + +drivers/md/md.c:2144: error: DEAD_STORE + The value written to &bi_rdev is never used. + 2142. return 0; + 2143. + 2144. > bi_rdev = bdev_get_integrity(rdev->bdev); + 2145. bi_mddev = blk_get_integrity(mddev->gendisk); + 2146. + +drivers/net/ethernet/broadcom/tg3.c:2148: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2144 could be null and is dereferenced at line 2148, column 3. + 2146. if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) { + 2147. tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER; + 2148. > phydev->speed = tp->link_config.speed; + 2149. phydev->duplex = tp->link_config.duplex; + 2150. phydev->autoneg = tp->link_config.autoneg; + +drivers/net/ethernet/broadcom/tg3.c:2154: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2144 could be null and is dereferenced by call to `phy_start()` at line 2154, column 2. + 2152. } + 2153. + 2154. > phy_start(phydev); + 2155. + 2156. phy_start_aneg(phydev); + +drivers/tty/serial/serial_core.c:2150: error: NULL_DEREFERENCE + pointer `tty_dev` last assigned on line 2149 could be null and is dereferenced by call to `device_may_wakeup()` at line 2150, column 27. + 2148. + 2149. tty_dev = device_find_child(uport->dev, &match, serial_match_port); + 2150. > if (!uport->suspended && device_may_wakeup(tty_dev)) { + 2151. if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) + 2152. disable_irq_wake(uport->irq); + +net/wireless/trace.h:2139: error: DEAD_STORE + The value written to &p is never used. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +kernel/cgroup/cpuset.c:2160: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 2157 could be null and is dereferenced by call to `parent_cs()` at line 2160, column 12. + 2158. while (cpumask_empty(parent->cpus_allowed) || + 2159. nodes_empty(parent->mems_allowed)) + 2160. > parent = parent_cs(parent); + 2161. + 2162. if (cgroup_transfer_tasks(parent->css.cgroup, cs->css.cgroup)) { + +net/wireless/trace.h:2157: error: DEAD_STORE + The value written to &p is never used. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/core/dev.c:2215: error: DEAD_STORE + The value written to &map is never used. + 2213. for (i = tc, tci = cpu * num_tc; dev_maps && i--; tci++) { + 2214. /* fill in the new device map from the old device map */ + 2215. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2216. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2217. } + +net/core/dev.c:2242: error: DEAD_STORE + The value written to &map is never used. + 2240. } else if (dev_maps) { + 2241. /* fill in the new device map from the old device map */ + 2242. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2243. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2244. } + +net/core/dev.c:2249: error: DEAD_STORE + The value written to &map is never used. + 2247. for (i = num_tc - tc, tci++; dev_maps && --i; tci++) { + 2248. /* fill in the new device map from the old device map */ + 2249. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2250. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2251. } + +net/wireless/trace.h:2175: error: DEAD_STORE + The value written to &p is never used. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/xfrm/xfrm_user.c:2219: error: DEAD_STORE + The value written to &err is never used. + 2217. t->ealgos = ua->ealgos; + 2218. t->calgos = ua->calgos; + 2219. > err = km_query(x, t, xp); + 2220. + 2221. } + +drivers/gpu/drm/drm_atomic.c:2206: error: DEAD_STORE + The value written to &ret is never used. + 2204. struct drm_out_fence_state *fence_state; + 2205. unsigned plane_mask; + 2206. > int ret = 0; + 2207. unsigned int i, j, num_fences; + 2208. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2199: error: DEAD_STORE + The value written to &ret_val is never used. + 2197. static s32 e1000_k1_gig_workaround_hv(struct e1000_hw *hw, bool link) + 2198. { + 2199. > s32 ret_val = 0; + 2200. u16 status_reg = 0; + 2201. bool k1_enable = hw->dev_spec.ich8lan.nvm_k1_enabled; + +block/cfq-iosched.c:2213: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced at line 2213, column 12. + 2211. if (cfq_class_idle(cfqq)) { + 2212. rb_key = CFQ_IDLE_DELAY; + 2213. > parent = st->rb_rightmost; + 2214. if (parent && parent != &cfqq->rb_node) { + 2215. __cfqq = rb_entry(parent, struct cfq_queue, rb_node); + +block/cfq-iosched.c:2231: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced by call to `cfq_rb_first()` at line 2231, column 12. + 2229. } else { + 2230. rb_key = -NSEC_PER_SEC; + 2231. > __cfqq = cfq_rb_first(st); + 2232. rb_key += __cfqq ? __cfqq->rb_key : now; + 2233. } + +net/wireless/trace.h:2200: error: DEAD_STORE + The value written to &p is never used. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +drivers/gpu/drm/drm_dp_mst_topology.c:2210: error: DEAD_STORE + The value written to &ret is never used. + 2208. int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr) + 2209. { + 2210. > int ret = 0; + 2211. + 2212. mutex_lock(&mgr->lock); + +net/wireless/trace.h:2220: error: DEAD_STORE + The value written to &p is never used. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +kernel/kprobes.c:2226: error: DEAD_STORE + The value written to &err is never used. + 2224. static int __init init_kprobes(void) + 2225. { + 2226. > int i, err = 0; + 2227. + 2228. /* FIXME allocate the probe table, currently defined statically */ + +drivers/usb/host/ehci-sched.c:2270: error: DEAD_STORE + The value written to &dev is never used. + 2268. + 2269. /* give urb back to the driver; completion often (re)submits */ + 2270. > dev = urb->dev; + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + +drivers/usb/host/ehci-sched.c:2273: error: DEAD_STORE + The value written to &urb is never used. + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + 2273. > urb = NULL; + 2274. + 2275. --ehci->isoc_count; + +drivers/iommu/intel-iommu.c:2235: error: DEAD_STORE + The value written to &lvl_pages is never used. + 2233. unsigned long sg_res = 0; + 2234. unsigned int largepage_lvl = 0; + 2235. > unsigned long lvl_pages = 0; + 2236. + 2237. BUG_ON(!domain_pfn_supported(domain, iov_pfn + nr_pages - 1)); + +security/selinux/hooks.c:2245: error: DEAD_STORE + The value written to &rc is never used. + 2243. { + 2244. const struct cred *cred = current_cred(); + 2245. > int rc = 0; + 2246. + 2247. if (!sb) + +drivers/net/ethernet/intel/e1000e/phy.c:2245: error: DEAD_STORE + The value written to &phy_type is never used. + 2243. enum e1000_phy_type e1000e_get_phy_type_from_id(u32 phy_id) + 2244. { + 2245. > enum e1000_phy_type phy_type = e1000_phy_unknown; + 2246. + 2247. switch (phy_id) { + +net/wireless/trace.h:2244: error: DEAD_STORE + The value written to &p is never used. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/ipv4/igmp.c:2255: error: DEAD_STORE + The value written to &in_dev is never used. + 2253. __be32 addr = mreqs->imr_multiaddr; + 2254. struct ip_mc_socklist *pmc; + 2255. > struct in_device *in_dev = NULL; + 2256. struct inet_sock *inet = inet_sk(sk); + 2257. struct ip_sf_socklist *psl; + +net/unix/af_unix.c:2365: error: DEAD_STORE + The value written to &sunaddr is never used. + 2363. /* Copy address just once */ + 2364. if (state->msg && state->msg->msg_name) { + 2365. > DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + +net/unix/af_unix.c:2368: error: DEAD_STORE + The value written to &sunaddr is never used. + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + 2368. > sunaddr = NULL; + 2369. } + 2370. + +drivers/gpu/drm/drm_dp_mst_topology.c:2276: error: DEAD_STORE + The value written to &origlen is never used. + 2274. replylen = msg->curchunk_len + msg->curchunk_hdrlen; + 2275. + 2276. > origlen = replylen; + 2277. replylen -= len; + 2278. curreply = len; + +net/wireless/trace.h:2262: error: DEAD_STORE + The value written to &ret is never used. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +kernel/rcu/tree.c:2314: error: DEAD_STORE + The value written to &ret is never used. + 2312. TPS("fqswait")); + 2313. rsp->gp_state = RCU_GP_WAIT_FQS; + 2314. > ret = swait_event_idle_timeout(rsp->gp_wq, + 2315. rcu_gp_fqs_check_wake(rsp, &gf), j); + 2316. rsp->gp_state = RCU_GP_DOING_FQS; + +net/wireless/nl80211.c:2271: error: DEAD_STORE + The value written to &rem_txq_params is never used. + 2269. struct net_device *netdev = NULL; + 2270. struct wireless_dev *wdev; + 2271. > int result = 0, rem_txq_params = 0; + 2272. struct nlattr *nl_txq_params; + 2273. u32 changed; + +drivers/scsi/scsi_error.c:2275: error: DEAD_STORE + The value written to &error is never used. + 2273. struct request *rq; + 2274. unsigned long flags; + 2275. > int error = 0, rtn, val; + 2276. + 2277. if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) + +kernel/cgroup/cgroup.c:2279: error: DEAD_STORE + The value written to &ssid is never used. + 2277. /* check that we can legitimately attach to the cgroup */ + 2278. if (tset->nr_tasks) { + 2279. > do_each_subsys_mask(ss, ssid, mgctx->ss_mask) { + 2280. if (ss->can_attach) { + 2281. tset->ssid = ssid; + +kernel/cgroup/cgroup.c:2319: error: DEAD_STORE + The value written to &ssid is never used. + 2317. + 2318. if (tset->nr_tasks) { + 2319. > do_each_subsys_mask(ss, ssid, mgctx->ss_mask) { + 2320. if (ss->attach) { + 2321. tset->ssid = ssid; + +kernel/cgroup/cgroup.c:2332: error: DEAD_STORE + The value written to &ssid is never used. + 2330. out_cancel_attach: + 2331. if (tset->nr_tasks) { + 2332. > do_each_subsys_mask(ss, ssid, mgctx->ss_mask) { + 2333. if (ssid == failed_ssid) + 2334. break; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2278: error: DEAD_STORE + The value written to &ctrl_ext is never used. + 2276. s32 ret_val; + 2277. u32 ctrl_reg = 0; + 2278. > u32 ctrl_ext = 0; + 2279. u32 reg = 0; + 2280. u16 kmrn_reg = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2277: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 2275. { + 2276. s32 ret_val; + 2277. > u32 ctrl_reg = 0; + 2278. u32 ctrl_ext = 0; + 2279. u32 reg = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2279: error: DEAD_STORE + The value written to ® is never used. + 2277. u32 ctrl_reg = 0; + 2278. u32 ctrl_ext = 0; + 2279. > u32 reg = 0; + 2280. u16 kmrn_reg = 0; + 2281. + +security/selinux/ss/policydb.c:2338: error: DEAD_STORE + The value written to &policydb_str is never used. + 2336. /* Done with policydb_str. */ + 2337. kfree(policydb_str); + 2338. > policydb_str = NULL; + 2339. + 2340. /* Read the version and table sizes. */ + +security/selinux/ss/policydb.c:2447: error: DEAD_STORE + The value written to &rc is never used. + 2445. goto bad; + 2446. + 2447. > rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + +kernel/sysctl.c:2297: error: DEAD_STORE + The value written to &kbuf is never used. + 2295. size_t left; + 2296. bool neg; + 2297. > char *kbuf = NULL, *p; + 2298. + 2299. left = *lenp; + +kernel/sysctl.c:2331: error: DEAD_STORE + The value written to &left is never used. + 2329. + 2330. if (!err && left) + 2331. > left -= proc_skip_spaces(&p); + 2332. + 2333. out_free: + +drivers/net/ethernet/intel/e1000e/phy.c:2301: error: DEAD_STORE + The value written to &phy_addr is never used. + 2299. s32 e1000e_determine_phy_address(struct e1000_hw *hw) + 2300. { + 2301. > u32 phy_addr = 0; + 2302. u32 i; + 2303. enum e1000_phy_type phy_type = e1000_phy_unknown; + +drivers/gpu/drm/drm_dp_mst_topology.c:2314: error: DEAD_STORE + The value written to &slot is never used. + 2312. struct drm_dp_sideband_msg_tx *txmsg; + 2313. struct drm_dp_mst_branch *mstb; + 2314. > int slot = -1; + 2315. mstb = drm_dp_get_mst_branch_device(mgr, + 2316. mgr->down_rep_recv.initial_hdr.lct, + +net/wireless/trace.h:2301: error: DEAD_STORE + The value written to &p is never used. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/ipv4/route.c:2314: error: DEAD_STORE + The value written to &err is never used. + 2312. unsigned int flags = 0; + 2313. struct rtable *rth; + 2314. > int err = -ENETUNREACH; + 2315. + 2316. if (fl4->saddr) { + +drivers/iommu/amd_iommu.c:2329: error: DEAD_STORE + The value written to &prot is never used. + 2327. dma_addr_t address, start, ret; + 2328. unsigned int pages; + 2329. > int prot = 0; + 2330. int i; + 2331. + +drivers/gpu/drm/i915/intel_ddi.c:2331: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2326 could be null and is dereferenced at line 2331, column 2. + 2329. intel_disable_ddi_buf(encoder); + 2330. + 2331. > dig_port->set_infoframes(&encoder->base, false, + 2332. old_crtc_state, old_conn_state); + 2333. + +net/wireless/trace.h:2326: error: DEAD_STORE + The value written to &p is never used. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +kernel/kprobes.c:2331: error: DEAD_STORE + The value written to &sym is never used. + 2329. struct hlist_head *head; + 2330. struct kprobe *p, *kp; + 2331. > const char *sym = NULL; + 2332. unsigned int i = *(loff_t *) v; + 2333. unsigned long offset = 0; + +drivers/usb/core/hub.c:2345: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2339 could be null and is dereferenced at line 2345, column 10. + 2343. * use that to determine whether it's removable. + 2344. */ + 2345. > switch (hub->ports[udev->portnum - 1]->connect_type) { + 2346. case USB_PORT_CONNECT_TYPE_HOT_PLUG: + 2347. udev->removable = USB_DEVICE_REMOVABLE; + +net/xfrm/xfrm_policy.c:2344: error: DEAD_STORE + The value written to &idx is never used. + 2342. for (; idx < sp->len; idx++) { + 2343. if (xfrm_state_ok(tmpl, sp->xvec[idx], family)) + 2344. > return ++idx; + 2345. if (sp->xvec[idx]->props.mode != XFRM_MODE_TRANSPORT) { + 2346. if (start == -1) + +drivers/gpu/drm/i915/i915_drv.c:2346: error: DEAD_STORE + The value written to &timeout__ is never used. + 2344. * valleyview_enable_rps) so use a 3ms timeout. + 2345. */ + 2346. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2347. 3); + 2348. } + +net/wireless/trace.h:2338: error: DEAD_STORE + The value written to &p is never used. + 2336. ); + 2337. + 2338. > DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, + 2339. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2340. TP_ARGS(netdev, macaddr), + +net/sunrpc/clnt.c:2391: error: DEAD_STORE + The value written to &len is never used. + 2389. goto out_err; + 2390. } + 2391. > if (--len < 0) + 2392. goto out_overflow; + 2393. switch ((n = ntohl(*p++))) { + +net/sunrpc/clnt.c:2393: error: DEAD_STORE + The value written to &p is never used. + 2391. if (--len < 0) + 2392. goto out_overflow; + 2393. > switch ((n = ntohl(*p++))) { + 2394. case RPC_AUTH_REJECTEDCRED: + 2395. case RPC_AUTH_REJECTEDVERF: + +drivers/net/ethernet/nvidia/forcedeth.c:2359: error: DEAD_STORE + The value written to &start_tx_ctx is never used. + 2357. struct ring_desc_ex *prev_tx; + 2358. struct nv_skb_map *prev_tx_ctx; + 2359. > struct nv_skb_map *start_tx_ctx = NULL; + 2360. struct nv_skb_map *tmp_tx_ctx = NULL; + 2361. unsigned long flags; + +kernel/sysctl.c:2354: error: DEAD_STORE + The value written to &err is never used. + 2352. { + 2353. unsigned long lval; + 2354. > int err = 0; + 2355. size_t left; + 2356. + +net/core/skbuff.c:2354: error: DEAD_STORE + The value written to &ret is never used. + 2352. int skb_send_sock(struct sock *sk, struct sk_buff *skb, int offset, int len) + 2353. { + 2354. > int ret = 0; + 2355. + 2356. lock_sock(sk); + +net/wireless/trace.h:2358: error: DEAD_STORE + The value written to &p is never used. + 2356. ); + 2357. + 2358. > DECLARE_EVENT_CLASS(netdev_evt_only, + 2359. TP_PROTO(struct net_device *netdev), + 2360. TP_ARGS(netdev), + +net/wireless/reg.c:2365: error: DEAD_STORE + The value written to &last_wiphy is never used. + 2363. struct regulatory_request *country_ie_request) + 2364. { + 2365. > struct wiphy *last_wiphy = NULL; + 2366. struct regulatory_request *lr = get_last_request(); + 2367. + +drivers/cpufreq/cpufreq.c:2373: error: DEAD_STORE + The value written to &ret is never used. + 2371. { + 2372. unsigned long flags; + 2373. > int ret = 0; + 2374. + 2375. if (cpufreq_driver->boost_enabled == state) + +net/core/ethtool.c:2377: error: DEAD_STORE + The value written to &backup is never used. + 2375. int i, ret = 0; + 2376. int n_queue; + 2377. > struct ethtool_coalesce *backup = NULL, *tmp = NULL; + 2378. DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE); + 2379. + +net/core/ethtool.c:2377: error: DEAD_STORE + The value written to &tmp is never used. + 2375. int i, ret = 0; + 2376. int n_queue; + 2377. > struct ethtool_coalesce *backup = NULL, *tmp = NULL; + 2378. DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE); + 2379. + +net/wireless/trace.h:2375: error: DEAD_STORE + The value written to &p is never used. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/sunrpc/xprtsock.c:2398: error: DEAD_STORE + The value written to &status is never used. + 2396. struct socket *sock = transport->sock; + 2397. struct rpc_xprt *xprt = &transport->xprt; + 2398. > int status = -EIO; + 2399. + 2400. if (!sock) { + +net/wireless/trace.h:2392: error: DEAD_STORE + The value written to &p is never used. + 2390. ); + 2391. + 2392. > DECLARE_EVENT_CLASS(netdev_frame_event, + 2393. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2394. TP_ARGS(netdev, buf, len), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2407: error: DEAD_STORE + The value written to &ctrl is never used. + 2405. u16 phy_data; + 2406. + 2407. > ctrl = er32(CTRL); + 2408. status = er32(STATUS); + 2409. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2468: error: DEAD_STORE + The value written to &ret_val is never used. + 2466. hw->forced_speed_duplex == e1000_10_half)) { + 2467. ew32(IMC, 0xffffffff); + 2468. > ret_val = + 2469. e1000_polarity_reversal_workaround(hw); + 2470. icr = er32(ICR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2398: error: DEAD_STORE + The value written to &rxcw is never used. + 2396. s32 e1000_check_for_link(struct e1000_hw *hw) + 2397. { + 2398. > u32 rxcw = 0; + 2399. u32 ctrl; + 2400. u32 status; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2416: error: DEAD_STORE + The value written to &rxcw is never used. + 2414. if ((hw->media_type == e1000_media_type_fiber) || + 2415. (hw->media_type == e1000_media_type_internal_serdes)) { + 2416. > rxcw = er32(RXCW); + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2403: error: DEAD_STORE + The value written to &signal is never used. + 2401. u32 rctl; + 2402. u32 icr; + 2403. > u32 signal = 0; + 2404. s32 ret_val; + 2405. u16 phy_data; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2419: error: DEAD_STORE + The value written to &signal is never used. + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + 2419. > signal = + 2420. (hw->mac_type > + 2421. e1000_82544) ? E1000_CTRL_SWDPIN1 : 0; + +drivers/iommu/amd_iommu_init.c:2545: error: DEAD_STORE + The value written to &ivrs_base is never used. + 2543. /* Don't leak any ACPI memory */ + 2544. acpi_put_table(ivrs_base); + 2545. > ivrs_base = NULL; + 2546. + 2547. return ret; + +drivers/iommu/amd_iommu_init.c:2412: error: DEAD_STORE + The value written to &ret is never used. + 2410. struct acpi_table_header *ivrs_base; + 2411. acpi_status status; + 2412. > int i, remap_cache_sz, ret = 0; + 2413. + 2414. if (!amd_iommu_detected) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2411: error: DEAD_STORE + The value written to &ret_val is never used. + 2409. static s32 e1000_hv_phy_workarounds_ich8lan(struct e1000_hw *hw) + 2410. { + 2411. > s32 ret_val = 0; + 2412. u16 phy_data; + 2413. + +drivers/gpu/drm/i915/intel_ddi.c:2429: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2417 could be null and is dereferenced at line 2429, column 2. + 2427. * enabling the port. + 2428. */ + 2429. > I915_WRITE(DDI_BUF_CTL(port), + 2430. dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE); + 2431. + +kernel/trace/trace.c:2419: error: DEAD_STORE + The value written to &size is never used. + 2417. { + 2418. struct trace_entry *entry; + 2419. > unsigned int size = 0; + 2420. + 2421. entry = ring_buffer_event_data(event); + +net/wireless/trace.h:2418: error: DEAD_STORE + The value written to &p is never used. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2434: error: DEAD_STORE + The value written to &p is never used. + 2432. ); + 2433. + 2434. > DECLARE_EVENT_CLASS(netdev_mac_evt, + 2435. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2436. TP_ARGS(netdev, mac), + +drivers/md/dm.c:2439: error: DEAD_STORE + The value written to &map is never used. + 2437. int dm_suspend(struct mapped_device *md, unsigned suspend_flags) + 2438. { + 2439. > struct dm_table *map = NULL; + 2440. int r = 0; + 2441. + +drivers/md/dm.c:2440: error: DEAD_STORE + The value written to &r is never used. + 2438. { + 2439. struct dm_table *map = NULL; + 2440. > int r = 0; + 2441. + 2442. retry: + +net/ipv4/tcp_input.c:2442: error: DEAD_STORE + The value written to &sndcnt is never used. + 2440. { + 2441. struct tcp_sock *tp = tcp_sk(sk); + 2442. > int sndcnt = 0; + 2443. int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp); + 2444. + +drivers/net/ethernet/intel/e1000/e1000_main.c:2461: error: DEAD_STORE + The value written to &txb2b is never used. + 2459. if (!netif_carrier_ok(netdev)) { + 2460. u32 ctrl; + 2461. > bool txb2b = true; + 2462. /* update snapshot of PHY registers on LSC */ + 2463. e1000_get_speed_and_duplex(hw, + +drivers/net/ethernet/intel/e1000/e1000_main.c:2483: error: DEAD_STORE + The value written to &txb2b is never used. + 2481. switch (adapter->link_speed) { + 2482. case SPEED_10: + 2483. > txb2b = false; + 2484. adapter->tx_timeout_factor = 16; + 2485. break; + +drivers/net/ethernet/intel/e1000/e1000_main.c:2487: error: DEAD_STORE + The value written to &txb2b is never used. + 2485. break; + 2486. case SPEED_100: + 2487. > txb2b = false; + 2488. /* maybe add some timeout factor ? */ + 2489. break; + +net/wireless/reg.c:2452: error: DEAD_STORE + The value written to &cfg80211_regd is never used. + 2450. const struct ieee80211_regdomain *wiphy1_regd = NULL; + 2451. const struct ieee80211_regdomain *wiphy2_regd = NULL; + 2452. > const struct ieee80211_regdomain *cfg80211_regd = NULL; + 2453. bool dfs_domain_same; + 2454. + +net/wireless/reg.c:2450: error: DEAD_STORE + The value written to &wiphy1_regd is never used. + 2448. bool reg_dfs_domain_same(struct wiphy *wiphy1, struct wiphy *wiphy2) + 2449. { + 2450. > const struct ieee80211_regdomain *wiphy1_regd = NULL; + 2451. const struct ieee80211_regdomain *wiphy2_regd = NULL; + 2452. const struct ieee80211_regdomain *cfg80211_regd = NULL; + +net/wireless/reg.c:2451: error: DEAD_STORE + The value written to &wiphy2_regd is never used. + 2449. { + 2450. const struct ieee80211_regdomain *wiphy1_regd = NULL; + 2451. > const struct ieee80211_regdomain *wiphy2_regd = NULL; + 2452. const struct ieee80211_regdomain *cfg80211_regd = NULL; + 2453. bool dfs_domain_same; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2464: error: DEAD_STORE + The value written to &exec2_list is never used. + 2462. struct drm_i915_gem_execbuffer2 exec2; + 2463. struct drm_i915_gem_exec_object *exec_list = NULL; + 2464. > struct drm_i915_gem_exec_object2 *exec2_list = NULL; + 2465. unsigned int i; + 2466. int err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2463: error: DEAD_STORE + The value written to &exec_list is never used. + 2461. struct drm_i915_gem_execbuffer *args = data; + 2462. struct drm_i915_gem_execbuffer2 exec2; + 2463. > struct drm_i915_gem_exec_object *exec_list = NULL; + 2464. struct drm_i915_gem_exec_object2 *exec2_list = NULL; + 2465. unsigned int i; + +net/wireless/trace.h:2459: error: DEAD_STORE + The value written to &p is never used. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +drivers/net/ethernet/intel/e100.c:2464: error: DEAD_STORE + The value written to &nic is never used. + 2462. static int e100_get_regs_len(struct net_device *netdev) + 2463. { + 2464. > struct nic *nic = netdev_priv(netdev); + 2465. return 1 + E100_PHY_REGS + sizeof(nic->mem->dump_buf); + 2466. } + +net/ipv4/igmp.c:2507: error: DEAD_STORE + The value written to &len is never used. + 2505. psl = rtnl_dereference(pmc->sflist); + 2506. if (!psl) { + 2507. > len = 0; + 2508. count = 0; + 2509. } else { + +drivers/iommu/amd_iommu.c:2484: error: DEAD_STORE + The value written to &npages is never used. + 2482. unsigned long attrs) + 2483. { + 2484. > int mapped_pages = 0, npages = 0, prot = 0, i; + 2485. struct protection_domain *domain; + 2486. struct dma_ops_domain *dma_dom; + +drivers/iommu/amd_iommu.c:2484: error: DEAD_STORE + The value written to &prot is never used. + 2482. unsigned long attrs) + 2483. { + 2484. > int mapped_pages = 0, npages = 0, prot = 0, i; + 2485. struct protection_domain *domain; + 2486. struct dma_ops_domain *dma_dom; + +net/wireless/trace.h:2483: error: DEAD_STORE + The value written to &p is never used. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +drivers/gpu/drm/drm_atomic_helper.c:2500: error: DEAD_STORE + The value written to &ret is never used. + 2498. struct drm_atomic_state *state; + 2499. struct drm_plane_state *plane_state; + 2500. > int ret = 0; + 2501. + 2502. state = drm_atomic_state_alloc(plane->dev); + +drivers/md/dm.c:2498: error: DEAD_STORE + The value written to &map is never used. + 2496. { + 2497. int r; + 2498. > struct dm_table *map = NULL; + 2499. + 2500. retry: + +security/selinux/hooks.c:2504: error: DEAD_STORE + The value written to &devnull is never used. + 2502. struct files_struct *files) + 2503. { + 2504. > struct file *file, *devnull = NULL; + 2505. struct tty_struct *tty; + 2506. int drop_tty = 0; + +drivers/hid/hid-sony.c:2660: error: DEAD_STORE + The value written to &ret is never used. + 2658. sony_init_output_report(sc, motion_send_output_report); + 2659. } else { + 2660. > ret = 0; + 2661. } + 2662. + +net/wireless/trace.h:2505: error: DEAD_STORE + The value written to &p is never used. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2523: error: DEAD_STORE + The value written to &p is never used. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +drivers/iommu/intel-iommu.c:2532: error: DEAD_STORE + The value written to &info is never used. + 2530. static struct dmar_domain *find_or_alloc_domain(struct device *dev, int gaw) + 2531. { + 2532. > struct device_domain_info *info = NULL; + 2533. struct dmar_domain *domain = NULL; + 2534. struct intel_iommu *iommu; + +drivers/iommu/intel-iommu.c:2543: error: DEAD_STORE + The value written to &req_id is never used. + 2541. return NULL; + 2542. + 2543. > req_id = ((u16)bus << 8) | devfn; + 2544. + 2545. if (dev_is_pci(dev)) { + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2534: error: DEAD_STORE + The value written to &ret_val is never used. + 2532. s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable) + 2533. { + 2534. > s32 ret_val = 0; + 2535. u16 phy_reg, data; + 2536. u32 mac_reg; + +drivers/md/dm.c:2539: error: DEAD_STORE + The value written to &map is never used. + 2537. static void __dm_internal_suspend(struct mapped_device *md, unsigned suspend_flags) + 2538. { + 2539. > struct dm_table *map = NULL; + 2540. + 2541. lockdep_assert_held(&md->suspend_lock); + +drivers/gpu/drm/drm_dp_mst_topology.c:2546: error: DEAD_STORE + The value written to &edid is never used. + 2544. struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port) + 2545. { + 2546. > struct edid *edid = NULL; + 2547. + 2548. /* we need to search for the port in the mgr in case its gone */ + +net/core/neighbour.c:2550: error: DEAD_STORE + The value written to &bucket is never used. + 2548. struct neigh_hash_table *nht = state->nht; + 2549. struct neighbour *n = NULL; + 2550. > int bucket = state->bucket; + 2551. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + +drivers/gpu/drm/drm_atomic_helper.c:2551: error: DEAD_STORE + The value written to &ret is never used. + 2549. struct drm_atomic_state *state; + 2550. struct drm_plane_state *plane_state; + 2551. > int ret = 0; + 2552. + 2553. state = drm_atomic_state_alloc(plane->dev); + +net/wireless/trace.h:2546: error: DEAD_STORE + The value written to &p is never used. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm), + 2548. TP_ARGS(wdev, freq, sig_mbm), + +drivers/gpu/drm/i915/i915_debugfs.c:2556: error: DEAD_STORE + The value written to &i is never used. + 2554. struct drm_i915_gem_object *obj = NULL; + 2555. u32 *log; + 2556. > int i = 0; + 2557. + 2558. if (dump_load_err) + +kernel/events/core.c:2562: error: DEAD_STORE + The value written to &ret is never used. + 2560. .restart = restart, + 2561. }; + 2562. > int ret = 0; + 2563. + 2564. do { + +drivers/iommu/amd_iommu.c:2568: error: DEAD_STORE + The value written to &npages is never used. + 2566. struct dma_ops_domain *dma_dom; + 2567. unsigned long startaddr; + 2568. > int npages = 2; + 2569. + 2570. domain = get_domain(dev); + +drivers/net/ethernet/intel/e1000e/netdev.c:2569: error: DEAD_STORE + The value written to ¤t_itr is never used. + 2567. /* for non-gigabit speeds, just fix the interrupt rate at 4000 */ + 2568. if (adapter->link_speed != SPEED_1000) { + 2569. > current_itr = 0; + 2570. new_itr = 4000; + 2571. goto set_itr_now; + +net/wireless/trace.h:2563: error: DEAD_STORE + The value written to &p is never used. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/ipv4/route.c:2575: error: DEAD_STORE + The value written to &expires is never used. + 2573. struct rtmsg *r; + 2574. struct nlmsghdr *nlh; + 2575. > unsigned long expires = 0; + 2576. u32 error; + 2577. u32 metrics[RTAX_MAX]; + +drivers/gpu/drm/i915/i915_perf.c:2578: error: DEAD_STORE + The value written to &stream is never used. + 2576. { + 2577. struct i915_gem_context *specific_ctx = NULL; + 2578. > struct i915_perf_stream *stream = NULL; + 2579. unsigned long f_flags = 0; + 2580. bool privileged_op = true; + +net/ipv4/ipmr.c:2592: error: DEAD_STORE + The value written to &rtm is never used. + 2590. goto errout; + 2591. + 2592. > rtm = nlmsg_data(nlh); + 2593. + 2594. src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0; + +kernel/power/snapshot.c:2581: error: DEAD_STORE + The value written to &error is never used. + 2579. { + 2580. static struct chain_allocator ca; + 2581. > int error = 0; + 2582. + 2583. /* Check if we have already loaded the entire image */ + +net/wireless/trace.h:2580: error: DEAD_STORE + The value written to &p is never used. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +drivers/iommu/amd_iommu.c:2588: error: DEAD_STORE + The value written to &dma_mask is never used. + 2586. unsigned long attrs) + 2587. { + 2588. > u64 dma_mask = dev->coherent_dma_mask; + 2589. struct protection_domain *domain; + 2590. struct dma_ops_domain *dma_dom; + +net/wireless/trace.h:2599: error: DEAD_STORE + The value written to &p is never used. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/unix/af_unix.c:2618: error: DEAD_STORE + The value written to &amount is never used. + 2616. { + 2617. struct sock *sk = sock->sk; + 2618. > long amount = 0; + 2619. int err; + 2620. + +drivers/md/md.c:2621: error: DEAD_STORE + The value written to &err is never used. + 2619. { + 2620. struct mddev *mddev = rdev->mddev; + 2621. > int err = 0; + 2622. bool add_journal = test_bit(Journal, &rdev->flags); + 2623. + +drivers/net/ethernet/intel/e100.c:2631: error: DEAD_STORE + The value written to &err is never used. + 2629. + 2630. /* save speed, duplex & autoneg settings */ + 2631. > err = mii_ethtool_gset(&nic->mii, &cmd); + 2632. + 2633. if (netif_running(netdev)) + +drivers/net/ethernet/intel/e100.c:2640: error: DEAD_STORE + The value written to &err is never used. + 2638. + 2639. /* restore speed, duplex & autoneg settings */ + 2640. > err = mii_ethtool_sset(&nic->mii, &cmd); + 2641. + 2642. if (netif_running(netdev)) + +net/packet/af_packet.c:2633: error: DEAD_STORE + The value written to &status is never used. + 2631. void *data; + 2632. int len_sum = 0; + 2633. > int status = TP_STATUS_AVAILABLE; + 2634. int hlen, tlen, copylen = 0; + 2635. + +net/wireless/trace.h:2620: error: DEAD_STORE + The value written to &p is never used. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +drivers/base/core.c:2625: error: DEAD_STORE + The value written to &old_device_name is never used. + 2623. { + 2624. struct kobject *kobj = &dev->kobj; + 2625. > char *old_device_name = NULL; + 2626. int error; + 2627. + +net/sunrpc/clnt.c:2673: error: NULL_DEREFERENCE + pointer `xprt` last assigned on line 2643 could be null and is dereferenced at line 2673, column 2. + 2671. xprt_put(xprt); + 2672. xprt_switch_put(xps); + 2673. > pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n", + 2674. status, xprt->address_strings[RPC_DISPLAY_ADDR]); + 2675. return status; + +net/wireless/trace.h:2635: error: DEAD_STORE + The value written to &p is never used. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +drivers/gpu/drm/i915/i915_debugfs.c:2647: error: DEAD_STORE + The value written to &psrperf is never used. + 2645. { + 2646. struct drm_i915_private *dev_priv = node_to_i915(m->private); + 2647. > u32 psrperf = 0; + 2648. u32 stat[3]; + 2649. enum pipe pipe; + +drivers/net/ethernet/intel/e1000/e1000_main.c:2657: error: DEAD_STORE + The value written to ¤t_itr is never used. + 2655. /* for non-gigabit speeds, just fix the interrupt rate at 4000 */ + 2656. if (unlikely(adapter->link_speed != SPEED_1000)) { + 2657. > current_itr = 0; + 2658. new_itr = 4000; + 2659. goto set_itr_now; + +net/core/neighbour.c:2652: error: DEAD_STORE + The value written to &bucket is never used. + 2650. struct neigh_table *tbl = state->tbl; + 2651. struct pneigh_entry *pn = NULL; + 2652. > int bucket = state->bucket; + 2653. + 2654. state->flags |= NEIGH_SEQ_IS_PNEIGH; + +drivers/tty/tty_io.c:2652: error: DEAD_STORE + The value written to &retval is never used. + 2650. struct tty_struct *tty = file_tty(file); + 2651. struct tty_ldisc *ld; + 2652. > int retval = -ENOIOCTLCMD; + 2653. + 2654. if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl")) + +net/wireless/trace.h:2651: error: DEAD_STORE + The value written to &p is never used. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +block/blk-core.c:2668: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 2668, column 31. + 2666. { + 2667. struct request *rq; + 2668. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 2669. + 2670. WARN_ON_ONCE(q->mq_ops); + +net/wireless/trace.h:2667: error: DEAD_STORE + The value written to &p is never used. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +drivers/gpu/drm/i915/intel_display.c:2676: error: DEAD_STORE + The value written to &obj is never used. + 2674. struct drm_i915_private *dev_priv = to_i915(dev); + 2675. struct i915_ggtt *ggtt = &dev_priv->ggtt; + 2676. > struct drm_i915_gem_object *obj = NULL; + 2677. struct drm_mode_fb_cmd2 mode_cmd = { 0 }; + 2678. struct drm_framebuffer *fb = &plane_config->fb->base; + +kernel/cgroup/cgroup.c:2685: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2684 could be null and is dereferenced at line 2685, column 7. + 2683. percpu_up_write(&cgroup_threadgroup_rwsem); + 2684. for_each_subsys(ss, ssid) + 2685. > if (ss->post_attach) + 2686. ss->post_attach(); + 2687. } + +drivers/ata/libata-eh.c:2838: error: DEAD_STORE + The value written to &failed_link is never used. + 2836. rc = ata_do_reset(link, reset, classes, deadline, true); + 2837. if (rc && rc != -EAGAIN) { + 2838. > failed_link = link; + 2839. goto fail; + 2840. } + +drivers/ata/libata-eh.c:2858: error: DEAD_STORE + The value written to &failed_link is never used. + 2856. break; + 2857. default: + 2858. > failed_link = slave; + 2859. rc = tmp; + 2860. goto fail; + +drivers/ata/libata-eh.c:2872: error: DEAD_STORE + The value written to &failed_link is never used. + 2870. ata_link_err(link, + 2871. "follow-up softreset required but no softreset available\n"); + 2872. > failed_link = link; + 2873. rc = -EINVAL; + 2874. goto fail; + +drivers/ata/libata-eh.c:2880: error: DEAD_STORE + The value written to &failed_link is never used. + 2878. rc = ata_do_reset(link, reset, classes, deadline, true); + 2879. if (rc) { + 2880. > failed_link = link; + 2881. goto fail; + 2882. } + +drivers/ata/libata-eh.c:2987: error: DEAD_STORE + The value written to &failed_link is never used. + 2985. "link online but %d devices misclassified, retrying\n", + 2986. nr_unknown); + 2987. > failed_link = link; + 2988. rc = -EAGAIN; + 2989. goto fail; + +net/ipv4/route.c:2690: error: DEAD_STORE + The value written to &dst is never used. + 2688. struct rtable *rt = NULL; + 2689. struct flowi4 fl4; + 2690. > __be32 dst = 0; + 2691. __be32 src = 0; + 2692. u32 iif; + +net/ipv4/route.c:2688: error: DEAD_STORE + The value written to &rt is never used. + 2686. struct nlattr *tb[RTA_MAX+1]; + 2687. struct fib_result res = {}; + 2688. > struct rtable *rt = NULL; + 2689. struct flowi4 fl4; + 2690. __be32 dst = 0; + +net/ipv4/route.c:2691: error: DEAD_STORE + The value written to &src is never used. + 2689. struct flowi4 fl4; + 2690. __be32 dst = 0; + 2691. > __be32 src = 0; + 2692. u32 iif; + 2693. int err; + +drivers/scsi/sd.c:2685: error: DEAD_STORE + The value written to &len is never used. + 2683. sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer) + 2684. { + 2685. > int len = 0, res; + 2686. struct scsi_device *sdp = sdkp->device; + 2687. + +net/wireless/trace.h:2682: error: DEAD_STORE + The value written to &p is never used. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +drivers/gpu/drm/drm_atomic_helper.c:2688: error: DEAD_STORE + The value written to &ret is never used. + 2686. struct drm_atomic_state *state; + 2687. struct drm_crtc *crtc = set->crtc; + 2688. > int ret = 0; + 2689. + 2690. state = drm_atomic_state_alloc(crtc->dev); + +kernel/cgroup/cgroup.c:2695: error: DEAD_STORE + The value written to &ssid is never used. + 2693. int ssid; + 2694. + 2695. > do_each_subsys_mask(ss, ssid, ss_mask) { + 2696. if (printed) + 2697. seq_putc(seq, ' '); + +net/core/filter.c:2697: error: DEAD_STORE + The value written to &err is never used. + 2695. struct net_device *fwd = NULL; + 2696. u32 index = ri->ifindex; + 2697. > int err = 0; + 2698. + 2699. ri->ifindex = 0; + +net/wireless/trace.h:2697: error: DEAD_STORE + The value written to &p is never used. + 2695. ); + 2696. + 2697. > DECLARE_EVENT_CLASS(cfg80211_rx_evt, + 2698. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2699. TP_ARGS(netdev, addr), + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2700: error: DEAD_STORE + The value written to &ret_val is never used. + 2698. static s32 e1000_lv_phy_workarounds_ich8lan(struct e1000_hw *hw) + 2699. { + 2700. > s32 ret_val = 0; + 2701. + 2702. if (hw->mac.type != e1000_pch2lan) + +net/ipv4/tcp_output.c:2713: error: NULL_DEREFERENCE + pointer `next_skb` last assigned on line 2709 could be null and is dereferenced at line 2713, column 18. + 2711. + 2712. skb_size = skb->len; + 2713. > next_skb_size = next_skb->len; + 2714. + 2715. BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1); + +sound/pci/hda/hda_codec.c:2712: error: DEAD_STORE + The value written to &end_time is never used. + 2710. unsigned int power_state) + 2711. { + 2712. > unsigned long end_time = jiffies + msecs_to_jiffies(500); + 2713. unsigned int state, actual_state; + 2714. + +drivers/net/ethernet/intel/e100.c:2732: error: DEAD_STORE + The value written to &i is never used. + 2730. data[i++] = nic->rx_tco_frames; + 2731. data[i++] = nic->rx_short_frame_errors; + 2732. > data[i++] = nic->rx_over_length_errors; + 2733. } + 2734. + +net/wireless/trace.h:2721: error: DEAD_STORE + The value written to &p is never used. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/ipv6/addrconf.c:2730: error: DEAD_STORE + The value written to &err is never used. + 2728. struct in6_ifreq ireq; + 2729. struct net_device *dev; + 2730. > int err = -EINVAL; + 2731. + 2732. rtnl_lock(); + +drivers/gpu/drm/i915/i915_debugfs.c:2736: error: DEAD_STORE + The value written to &intel_dp is never used. + 2734. struct intel_connector *connector; + 2735. struct drm_connector_list_iter conn_iter; + 2736. > struct intel_dp *intel_dp = NULL; + 2737. int ret; + 2738. u8 crc[6]; + +net/core/filter.c:2737: error: DEAD_STORE + The value written to &err is never used. + 2735. u32 index = ri->ifindex; + 2736. struct net_device *fwd; + 2737. > int err = 0; + 2738. + 2739. if (ri->map) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2734: error: DEAD_STORE + The value written to &ret_val is never used. + 2732. static s32 e1000_k1_workaround_lv(struct e1000_hw *hw) + 2733. { + 2734. > s32 ret_val = 0; + 2735. u16 status_reg = 0; + 2736. + +drivers/scsi/scsi_lib.c:2772: error: DEAD_STORE + The value written to &idx is never used. + 2770. } + 2771. + 2772. > envp[idx++] = NULL; + 2773. + 2774. kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); + +net/wireless/trace.h:2739: error: DEAD_STORE + The value written to &p is never used. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +drivers/iommu/amd_iommu.c:2745: error: DEAD_STORE + The value written to &err is never used. + 2743. int __init amd_iommu_init_api(void) + 2744. { + 2745. > int ret, err = 0; + 2746. + 2747. ret = iova_cache_get(); + +kernel/sched/fair.c:2753: error: DEAD_STORE + The value written to &res is never used. + 2751. cfs_rq->runnable_weight -= se->runnable_weight; + 2752. + 2753. > sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + +kernel/sched/fair.c:2754: error: DEAD_STORE + The value written to &res is never used. + 2752. + 2753. sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. > sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + 2756. } + +kernel/workqueue.c:2757: error: DEAD_STORE + The value written to &flush_cnt is never used. + 2755. void drain_workqueue(struct workqueue_struct *wq) + 2756. { + 2757. > unsigned int flush_cnt = 0; + 2758. struct pool_workqueue *pwq; + 2759. + +drivers/iommu/intel-iommu.c:2759: error: DEAD_STORE + The value written to &ret is never used. + 2757. static int __init si_domain_init(int hw) + 2758. { + 2759. > int nid, ret = 0; + 2760. + 2761. si_domain = alloc_domain(DOMAIN_FLAG_STATIC_IDENTITY); + +net/wireless/trace.h:2760: error: DEAD_STORE + The value written to &p is never used. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2764: error: DEAD_STORE + The value written to &data is never used. + 2762. { + 2763. u32 ctrl; + 2764. > u16 data = 0; + 2765. u8 i; + 2766. + +kernel/sched/fair.c:2768: error: DEAD_STORE + The value written to &res is never used. + 2766. dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) + 2767. { + 2768. > sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + +kernel/sched/fair.c:2769: error: DEAD_STORE + The value written to &res is never used. + 2767. { + 2768. sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. > sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + 2771. #else + +net/ipv6/mcast.c:2780: error: DEAD_STORE + The value written to &im is never used. + 2778. { + 2779. struct ip6_sf_list *psf = NULL; + 2780. > struct ifmcaddr6 *im = NULL; + 2781. struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq); + 2782. struct net *net = seq_file_net(seq); + +net/wireless/trace.h:2782: error: DEAD_STORE + The value written to &p is never used. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +drivers/net/ethernet/intel/e100.c:2798: error: DEAD_STORE + The value written to &err is never used. + 2796. { + 2797. struct nic *nic = netdev_priv(netdev); + 2798. > int err = 0; + 2799. + 2800. netif_carrier_off(netdev); + +net/wireless/trace.h:2803: error: DEAD_STORE + The value written to &p is never used. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2821: error: DEAD_STORE + The value written to &p is never used. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +drivers/cdrom/cdrom.c:2838: error: DEAD_STORE + The value written to &ret is never used. + 2836. track_information ti; + 2837. __u32 last_track; + 2838. > int ret = -1, ti_size; + 2839. + 2840. if (!CDROM_CAN(CDC_GENERIC_PACKET)) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2834: error: DEAD_STORE + The value written to &ret_val is never used. + 2832. static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw) + 2833. { + 2834. > s32 ret_val = 0; + 2835. u16 reg; + 2836. + +lib/vsprintf.c:2855: error: DEAD_STORE + The value written to &fmt is never used. + 2853. */ + 2854. if (isspace(*fmt)) { + 2855. > fmt = skip_spaces(++fmt); + 2856. str = skip_spaces(str); + 2857. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2844: error: DEAD_STORE + The value written to &mdic is never used. + 2842. { + 2843. u32 i; + 2844. > u32 mdic = 0; + 2845. const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1; + 2846. + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &p is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &ret is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +drivers/input/mouse/alps.c:2895: error: DEAD_STORE + The value written to &protocol is never used. + 2893. protocol = &alps_v8_protocol_data; + 2894. } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0xc8) { + 2895. > protocol = &alps_v9_protocol_data; + 2896. psmouse_warn(psmouse, + 2897. "Unsupported ALPS V9 touchpad: E7=%3ph, EC=%3ph\n", + +net/ipv4/igmp.c:2855: error: DEAD_STORE + The value written to &im is never used. + 2853. struct net *net = seq_file_net(seq); + 2854. struct ip_sf_list *psf = NULL; + 2855. > struct ip_mc_list *im = NULL; + 2856. struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); + 2857. + +net/wireless/reg.c:2860: error: DEAD_STORE + The value written to &request is never used. + 2858. char alpha2[2]; + 2859. enum environment_cap env = ENVIRON_ANY; + 2860. > struct regulatory_request *request = NULL, *lr; + 2861. + 2862. /* IE len must be evenly divisible by 2 */ + +drivers/pci/probe.c:2869: error: DEAD_STORE + The value written to &available_buses is never used. + 2867. struct pci_bus *parent = dev->bus; + 2868. int busnr, start = parent->busn_res.start; + 2869. > unsigned int available_buses = 0; + 2870. int end = parent->busn_res.end; + 2871. + +net/core/rtnetlink.c:2874: error: DEAD_STORE + The value written to &dev is never used. + 2872. char ifname[IFNAMSIZ]; + 2873. struct nlattr *tb[IFLA_MAX+1]; + 2874. > struct net_device *dev = NULL; + 2875. struct sk_buff *nskb; + 2876. int netnsid = -1; + +net/ipv4/ipmr.c:2875: error: DEAD_STORE + The value written to &nlh is never used. + 2873. { + 2874. struct net *net = sock_net(skb->sk); + 2875. > struct nlmsghdr *nlh = NULL; + 2876. unsigned int t = 0, s_t; + 2877. unsigned int e = 0, s_e; + +drivers/gpu/drm/i915/i915_gem.c:2884: error: DEAD_STORE + The value written to &request is never used. + 2882. i915_gem_reset_prepare_engine(struct intel_engine_cs *engine) + 2883. { + 2884. > struct drm_i915_gem_request *request = NULL; + 2885. + 2886. /* + +net/wireless/trace.h:2884: error: DEAD_STORE + The value written to &p is never used. + 2882. ); + 2883. + 2884. > DECLARE_EVENT_CLASS(wiphy_id_evt, + 2885. TP_PROTO(struct wiphy *wiphy, u64 id), + 2886. TP_ARGS(wiphy, id), + +drivers/video/fbdev/core/fbcon.c:2890: error: DEAD_STORE + The value written to &vc is never used. + 2888. static void fbcon_suspended(struct fb_info *info) + 2889. { + 2890. > struct vc_data *vc = NULL; + 2891. struct fbcon_ops *ops = info->fbcon_par; + 2892. + +kernel/cgroup/cgroup.c:2912: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2907 could be null and is dereferenced at line 2912, column 39. + 2910. WARN_ON_ONCE(css && percpu_ref_is_dying(&css->refcnt)); + 2911. + 2912. > if (!(cgroup_ss_mask(dsct) & (1 << ss->id))) + 2913. continue; + 2914. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2904: error: DEAD_STORE + The value written to &ret_val is never used. + 2902. static s32 e1000_phy_hw_reset_ich8lan(struct e1000_hw *hw) + 2903. { + 2904. > s32 ret_val = 0; + 2905. + 2906. /* Gate automatic PHY configuration by hardware on non-managed 82579 */ + +kernel/trace/trace.c:2911: error: DEAD_STORE + The value written to &len is never used. + 2909. unsigned long flags; + 2910. char *tbuffer; + 2911. > int len = 0, size, pc; + 2912. + 2913. if (unlikely(tracing_selftest_running || tracing_disabled)) + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &p is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &ret is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +drivers/tty/serial/8250/8250_port.c:2920: error: DEAD_STORE + The value written to &i is never used. + 2918. if (bytes < conf_type->rxtrig_bytes[i]) + 2919. /* Use the nearest lower value */ + 2920. > return (--i) << UART_FCR_R_TRIG_SHIFT; + 2921. } + 2922. + +net/netfilter/nf_conntrack_netlink.c:2920: error: NULL_DEREFERENCE + pointer `m_help` last assigned on line 2918 could be null and is dereferenced at line 2920, column 16. + 2918. m_help = nfct_help(exp->master); + 2919. + 2920. > return strcmp(m_help->helper->name, name) == 0; + 2921. } + 2922. + +net/unix/af_unix.c:2920: error: DEAD_STORE + The value written to &rc is never used. + 2918. static int __init af_unix_init(void) + 2919. { + 2920. > int rc = -1; + 2921. + 2922. BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb)); + +drivers/net/ethernet/nvidia/forcedeth.c:2926: error: DEAD_STORE + The value written to &vlanflags is never used. + 2924. struct fe_priv *np = netdev_priv(dev); + 2925. u32 flags; + 2926. > u32 vlanflags = 0; + 2927. int rx_work = 0; + 2928. struct sk_buff *skb; + +net/ipv6/route.c:2938: error: DEAD_STORE + The value written to &nrt is never used. + 2936. { + 2937. struct netevent_redirect netevent; + 2938. > struct rt6_info *rt, *nrt = NULL; + 2939. struct ndisc_options ndopts; + 2940. struct inet6_dev *in6_dev; + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &p is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &ret is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +block/blk-mq.c:2968: error: NULL_DEREFERENCE + pointer `rq` last assigned on line 2955 could be null and is dereferenced by call to `__blk_mq_poll()` at line 2968, column 9. + 2966. } + 2967. + 2968. > return __blk_mq_poll(hctx, rq); + 2969. } + 2970. + +kernel/cgroup/cgroup.c:2966: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2953 could be null and is dereferenced at line 2966, column 9. + 2964. } else if (!css_visible(css)) { + 2965. css_clear_dir(css); + 2966. > if (ss->css_reset) + 2967. ss->css_reset(css); + 2968. } + +kernel/trace/trace.c:2967: error: DEAD_STORE + The value written to &len is never used. + 2965. struct trace_event_call *call = &event_print; + 2966. struct ring_buffer_event *event; + 2967. > int len = 0, size, pc; + 2968. struct print_entry *entry; + 2969. unsigned long flags; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2966: error: DEAD_STORE + The value written to &ret_val is never used. + 2964. struct e1000_phy_info *phy = &hw->phy; + 2965. u32 phy_ctrl; + 2966. > s32 ret_val = 0; + 2967. u16 data; + 2968. + +drivers/tty/vt/vt.c:2972: error: DEAD_STORE + The value written to &currcons is never used. + 2970. const char *display_desc = NULL; + 2971. struct vc_data *vc; + 2972. > unsigned int currcons = 0, i; + 2973. + 2974. console_lock(); + +drivers/gpu/drm/drm_dp_mst_topology.c:3016: error: DEAD_STORE + The value written to &ret is never used. + 3014. int ret; + 3015. + 3016. > ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + +drivers/gpu/drm/drm_dp_mst_topology.c:3018: error: DEAD_STORE + The value written to &ret is never used. + 3016. ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. > ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + +drivers/gpu/drm/drm_dp_mst_topology.c:3020: error: DEAD_STORE + The value written to &ret is never used. + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. > ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + 3021. seq_printf(m, "mst ctrl: %*ph\n", 1, buf); + 3022. + +drivers/gpu/drm/drm_dp_mst_topology.c:3024: error: DEAD_STORE + The value written to &ret is never used. + 3022. + 3023. /* dump the standard OUI branch header */ + 3024. > ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE); + 3025. seq_printf(m, "branch oui: %*phN devid: ", 3, buf); + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + +drivers/gpu/drm/i915/i915_debugfs.c:2976: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 2974 could be null and is dereferenced at line 2976, column 36. + 2974. struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base); + 2975. + 2976. > seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]); + 2977. seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio)); + 2978. if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) + +net/wireless/trace.h:2970: error: DEAD_STORE + The value written to &p is never used. + 2968. ); + 2969. + 2970. > DECLARE_EVENT_CLASS(cfg80211_bss_evt, + 2971. TP_PROTO(struct cfg80211_bss *pub), + 2972. TP_ARGS(pub), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2982: error: DEAD_STORE + The value written to &mdic is never used. + 2980. { + 2981. u32 i; + 2982. > u32 mdic = 0; + 2983. const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1; + 2984. + +net/wireless/trace.h:2989: error: DEAD_STORE + The value written to &p is never used. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: DEAD_STORE + The value written to &p is never used. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +block/cfq-iosched.c:3007: error: DEAD_STORE + The value written to &rq is never used. + 3005. static struct request *cfq_check_fifo(struct cfq_queue *cfqq) + 3006. { + 3007. > struct request *rq = NULL; + 3008. + 3009. if (cfq_cfqq_fifo_expire(cfqq)) + +net/wireless/trace.h:3013: error: DEAD_STORE + The value written to &p is never used. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +kernel/sysctl.c:3086: error: DEAD_STORE + The value written to &first is never used. + 3084. + 3085. bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1); + 3086. > first = 0; + 3087. proc_skip_char(&p, &left, '\n'); + 3088. } + +drivers/net/ethernet/intel/e1000e/phy.c:3048: error: DEAD_STORE + The value written to &ret_val is never used. + 3046. s32 e1000_link_stall_workaround_hv(struct e1000_hw *hw) + 3047. { + 3048. > s32 ret_val = 0; + 3049. u16 data; + 3050. + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &p is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &ret is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +drivers/net/ethernet/intel/e1000e/netdev.c:3057: error: DEAD_STORE + The value written to &pages is never used. + 3055. struct e1000_hw *hw = &adapter->hw; + 3056. u32 rctl, rfctl; + 3057. > u32 pages = 0; + 3058. + 3059. /* Workaround Si errata on PCHx - configure jumbo frame flow. + +drivers/scsi/scsi_lib.c:3057: error: DEAD_STORE + The value written to &err is never used. + 3055. struct request_queue *q = sdev->request_queue; + 3056. unsigned long flags; + 3057. > int err = 0; + 3058. + 3059. err = scsi_device_set_state(sdev, SDEV_BLOCK); + +drivers/gpu/drm/drm_atomic_helper.c:3080: error: DEAD_STORE + The value written to &ret is never used. + 3078. struct drm_plane_state *plane_state; + 3079. struct drm_crtc_state *crtc_state; + 3080. > int ret = 0; + 3081. + 3082. crtc_state = drm_atomic_get_crtc_state(state, crtc); + +net/socket.c:3077: error: DEAD_STORE + The value written to &r is never used. + 3075. { + 3076. int ret; + 3077. > void *r = NULL; + 3078. struct in6_rtmsg r6; + 3079. struct rtentry r4; + +net/wireless/trace.h:3077: error: DEAD_STORE + The value written to &p is never used. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3092: error: DEAD_STORE + The value written to &p is never used. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/netfilter/nf_conntrack_netlink.c:3113: error: DEAD_STORE + The value written to &h is never used. + 3111. { + 3112. struct nf_conntrack_tuple tuple, mask, master_tuple; + 3113. > struct nf_conntrack_tuple_hash *h = NULL; + 3114. struct nf_conntrack_helper *helper = NULL; + 3115. struct nf_conntrack_expect *exp; + +drivers/clk/clk.c:3114: error: DEAD_STORE + The value written to &cn is never used. + 3112. int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb) + 3113. { + 3114. > struct clk_notifier *cn = NULL; + 3115. int ret = -EINVAL; + 3116. + +drivers/clk/clk.c:3115: error: DEAD_STORE + The value written to &ret is never used. + 3113. { + 3114. struct clk_notifier *cn = NULL; + 3115. > int ret = -EINVAL; + 3116. + 3117. if (!clk || !nb) + +net/wireless/trace.h:3115: error: DEAD_STORE + The value written to &p is never used. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +drivers/gpu/drm/drm_atomic_helper.c:3134: error: DEAD_STORE + The value written to &ret is never used. + 3132. struct drm_plane *plane = crtc->primary; + 3133. struct drm_atomic_state *state; + 3134. > int ret = 0; + 3135. + 3136. state = drm_atomic_state_alloc(plane->dev); + +drivers/usb/core/hub.c:3131: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3130 could be null and is dereferenced at line 3131, column 30. + 3129. { + 3130. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3131. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3132. int port1 = udev->portnum; + 3133. int status; + +net/wireless/reg.c:3141: error: DEAD_STORE + The value written to &freq_range is never used. + 3139. unsigned int i; + 3140. const struct ieee80211_reg_rule *reg_rule = NULL; + 3141. > const struct ieee80211_freq_range *freq_range = NULL; + 3142. const struct ieee80211_power_rule *power_rule = NULL; + 3143. char bw[32], cac_time[32]; + +net/wireless/reg.c:3142: error: DEAD_STORE + The value written to &power_rule is never used. + 3140. const struct ieee80211_reg_rule *reg_rule = NULL; + 3141. const struct ieee80211_freq_range *freq_range = NULL; + 3142. > const struct ieee80211_power_rule *power_rule = NULL; + 3143. char bw[32], cac_time[32]; + 3144. + +net/wireless/reg.c:3140: error: DEAD_STORE + The value written to ®_rule is never used. + 3138. { + 3139. unsigned int i; + 3140. > const struct ieee80211_reg_rule *reg_rule = NULL; + 3141. const struct ieee80211_freq_range *freq_range = NULL; + 3142. const struct ieee80211_power_rule *power_rule = NULL; + +net/wireless/trace.h:3138: error: DEAD_STORE + The value written to &p is never used. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +security/selinux/ss/services.c:3147: error: DEAD_STORE + The value written to &rc is never used. + 3145. struct user_datum *userdatum; + 3146. struct selinux_audit_rule **rule = (struct selinux_audit_rule **)vrule; + 3147. > int rc = 0; + 3148. + 3149. *rule = NULL; + +drivers/ata/libata-eh.c:3153: error: DEAD_STORE + The value written to &rc is never used. + 3151. unsigned int new_mask = 0; + 3152. unsigned long flags; + 3153. > int rc = 0; + 3154. + 3155. DPRINTK("ENTER\n"); + +security/selinux/hooks.c:3163: error: DEAD_STORE + The value written to &rc is never used. + 3161. struct common_audit_data ad; + 3162. u32 newsid, sid = current_sid(); + 3163. > int rc = 0; + 3164. + 3165. if (strcmp(name, XATTR_NAME_SELINUX)) { + +net/wireless/trace.h:3158: error: DEAD_STORE + The value written to &p is never used. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +drivers/gpu/drm/drm_atomic_helper.c:3179: error: DEAD_STORE + The value written to &ret is never used. + 3177. struct drm_atomic_state *state; + 3178. struct drm_crtc_state *crtc_state; + 3179. > int ret = 0; + 3180. + 3181. state = drm_atomic_state_alloc(plane->dev); + +net/ipv4/tcp_output.c:3178: error: DEAD_STORE + The value written to &md5 is never used. + 3176. struct inet_request_sock *ireq = inet_rsk(req); + 3177. const struct tcp_sock *tp = tcp_sk(sk); + 3178. > struct tcp_md5sig_key *md5 = NULL; + 3179. struct tcp_out_options opts; + 3180. struct sk_buff *skb; + +kernel/cgroup/cgroup.c:3177: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 3176 could be null and is dereferenced at line 3177, column 28. + 3175. { + 3176. struct cgroup *parent = cgroup_parent(cgrp); + 3177. > struct cgroup *dom_cgrp = parent->dom_cgrp; + 3178. int ret; + 3179. + +net/core/rtnetlink.c:3238: error: NULL_DEREFERENCE + pointer `br_dev` last assigned on line 3237 could be null and is dereferenced at line 3238, column 38. + 3236. (dev->priv_flags & IFF_BRIDGE_PORT)) { + 3237. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + 3238. > const struct net_device_ops *ops = br_dev->netdev_ops; + 3239. + 3240. err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3234: error: DEAD_STORE + The value written to &ret_val is never used. + 3232. struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan; + 3233. u32 act_offset; + 3234. > s32 ret_val = 0; + 3235. u32 bank = 0; + 3236. u32 dword = 0; + +net/wireless/reg.c:3255: error: DEAD_STORE + The value written to &intersected_rd is never used. + 3253. struct regulatory_request *user_request) + 3254. { + 3255. > const struct ieee80211_regdomain *intersected_rd = NULL; + 3256. + 3257. if (!regdom_changes(rd->alpha2)) + +net/wireless/reg.c:3277: error: DEAD_STORE + The value written to &rd is never used. + 3275. + 3276. kfree(rd); + 3277. > rd = NULL; + 3278. reset_regdomains(false, intersected_rd); + 3279. + +drivers/gpu/drm/i915/i915_gem.c:3289: error: DEAD_STORE + The value written to &timeout__ is never used. + 3287. * new request is submitted. + 3288. */ + 3289. > wait_for(intel_engines_are_idle(dev_priv), 10); + 3290. if (READ_ONCE(dev_priv->gt.active_requests)) + 3291. return; + +drivers/gpu/drm/i915/i915_gem.c:3314: error: DEAD_STORE + The value written to &timeout__ is never used. + 3312. goto out_unlock; + 3313. + 3314. > if (wait_for(intel_engines_are_idle(dev_priv), 10)) + 3315. DRM_ERROR("Timeout waiting for engines to idle\n"); + 3316. + +net/socket.c:3300: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3288 could be null and is dereferenced at line 3300, column 2. + 3298. } + 3299. + 3300. > (*newsock)->ops = sock->ops; + 3301. __module_get((*newsock)->ops->owner); + 3302. + +net/wireless/reg.c:3287: error: DEAD_STORE + The value written to &intersected_rd is never used. + 3285. { + 3286. const struct ieee80211_regdomain *regd; + 3287. > const struct ieee80211_regdomain *intersected_rd = NULL; + 3288. const struct ieee80211_regdomain *tmp; + 3289. struct wiphy *request_wiphy; + +net/wireless/reg.c:3334: error: DEAD_STORE + The value written to &rd is never used. + 3332. rcu_free_regdom(tmp); + 3333. + 3334. > rd = NULL; + 3335. + 3336. reset_regdomains(false, intersected_rd); + +net/core/rtnetlink.c:3302: error: DEAD_STORE + The value written to &err is never used. + 3300. struct nlattr *tb[NDA_MAX+1]; + 3301. struct net_device *dev; + 3302. > int err = -EINVAL; + 3303. __u8 *addr; + 3304. u16 vid; + +drivers/tty/vt/vt.c:3299: error: DEAD_STORE + The value written to &csw is never used. + 3297. static int vt_bind(struct con_driver *con) + 3298. { + 3299. > const struct consw *defcsw = NULL, *csw = NULL; + 3300. int i, more = 1, first = -1, last = -1, deflt = 0; + 3301. + +drivers/net/ethernet/nvidia/forcedeth.c:3317: error: DEAD_STORE + The value written to &newdup is never used. + 3315. int adv_lpa, adv_pause, lpa_pause; + 3316. int newls = np->linkspeed; + 3317. > int newdup = np->duplex; + 3318. int mii_status; + 3319. u32 bmcr; + +drivers/net/ethernet/nvidia/forcedeth.c:3316: error: DEAD_STORE + The value written to &newls is never used. + 3314. int lpa = 0; + 3315. int adv_lpa, adv_pause, lpa_pause; + 3316. > int newls = np->linkspeed; + 3317. int newdup = np->duplex; + 3318. int mii_status; + +drivers/net/ethernet/nvidia/forcedeth.c:3320: error: DEAD_STORE + The value written to &retval is never used. + 3318. int mii_status; + 3319. u32 bmcr; + 3320. > int retval = 0; + 3321. u32 control_1000, status_1000, phyreg, pause_flags, txreg; + 3322. u32 txrxFlags = 0; + +drivers/net/ethernet/intel/e1000/e1000_main.c:3322: error: DEAD_STORE + The value written to &i is never used. + 3320. u32 regs[NUM_REGS]; + 3321. u32 *regs_buff = regs; + 3322. > int i = 0; + 3323. + 3324. static const char * const reg_name[] = { + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3327: error: DEAD_STORE + The value written to &ret_val is never used. + 3325. struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan; + 3326. u32 act_offset; + 3327. > s32 ret_val = 0; + 3328. u32 bank = 0; + 3329. u16 i, word; + +drivers/tty/vt/vt.c:3349: error: DEAD_STORE + The value written to &csw is never used. + 3347. static int vt_unbind(struct con_driver *con) + 3348. { + 3349. > const struct consw *csw = NULL; + 3350. int i, more = 1, first = -1, last = -1, deflt = 0; + 3351. int ret; + +kernel/events/core.c:3365: error: DEAD_STORE + The value written to &ctx is never used. + 3363. static int perf_rotate_context(struct perf_cpu_context *cpuctx) + 3364. { + 3365. > struct perf_event_context *ctx = NULL; + 3366. int rotate = 0; + 3367. + +kernel/cgroup/cgroup.c:3372: error: DEAD_STORE + The value written to &ret is never used. + 3370. { + 3371. struct cgroup __maybe_unused *cgrp = seq_css(seq)->cgroup; + 3372. > int ret = 0; + 3373. + 3374. cgroup_stat_show_cputime(seq); + +net/ipv4/tcp_output.c:3385: error: DEAD_STORE + The value written to &err is never used. + 3383. struct tcp_sock *tp = tcp_sk(sk); + 3384. struct tcp_fastopen_request *fo = tp->fastopen_req; + 3385. > int space, err = 0; + 3386. struct sk_buff *syn_data; + 3387. + +net/ipv4/tcp_input.c:3404: error: DEAD_STORE + The value written to &half is never used. + 3402. if (now != challenge_timestamp) { + 3403. u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit; + 3404. > u32 half = (ack_limit + 1) >> 1; + 3405. + 3406. challenge_timestamp = now; + +kernel/trace/trace.c:3404: error: DEAD_STORE + The value written to &name is never used. + 3402. unsigned long entries; + 3403. unsigned long total; + 3404. > const char *name = "preemption"; + 3405. + 3406. name = type->name; + +drivers/gpu/drm/drm_edid.c:3402: error: DEAD_STORE + The value written to &hdmi_3d_len is never used. + 3400. { + 3401. int modes = 0, offset = 0, i, multi_present = 0, multi_len; + 3402. > u8 vic_len, hdmi_3d_len = 0; + 3403. u16 mask; + 3404. u16 structure_all; + +drivers/gpu/drm/drm_edid.c:3483: error: DEAD_STORE + The value written to &newmode is never used. + 3481. for (i = 0; i < (hdmi_3d_len - multi_len); i++) { + 3482. int vic_index; + 3483. > struct drm_display_mode *newmode = NULL; + 3484. unsigned int newflag = 0; + 3485. bool detail_present; + +drivers/usb/core/hub.c:3400: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3399 could be null and is dereferenced at line 3400, column 30. + 3398. { + 3399. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3400. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3401. int port1 = udev->portnum; + 3402. int status; + +net/core/rtnetlink.c:3437: error: DEAD_STORE + The value written to &brport_idx is never used. + 3435. struct net *net = sock_net(skb->sk); + 3436. struct hlist_head *head; + 3437. > int brport_idx = 0; + 3438. int br_idx = 0; + 3439. int h, s_h; + +net/core/rtnetlink.c:3441: error: DEAD_STORE + The value written to &err is never used. + 3439. int h, s_h; + 3440. int idx = 0, s_idx; + 3441. > int err = 0; + 3442. int fidx = 0; + 3443. + +drivers/iommu/intel-iommu.c:3460: error: DEAD_STORE + The value written to &iova_pfn is never used. + 3458. unsigned long nrpages, uint64_t dma_mask) + 3459. { + 3460. > unsigned long iova_pfn = 0; + 3461. + 3462. /* Restrict dma_mask to the width that the iommu can handle */ + +drivers/gpu/drm/i915/i915_gem.c:3470: error: DEAD_STORE + The value written to &timeout__ is never used. + 3468. static int wait_for_engines(struct drm_i915_private *i915) + 3469. { + 3470. > if (wait_for(intel_engines_are_idle(i915), 50)) { + 3471. DRM_ERROR("Failed to idle engines, declaring wedged!\n"); + 3472. i915_gem_set_wedged(i915); + +kernel/sched/fair.c:3496: error: DEAD_STORE + The value written to &res is never used. + 3494. + 3495. /* Update parent cfs_rq utilization */ + 3496. > add_positive(&cfs_rq->avg.util_avg, delta); + 3497. cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX; + 3498. } + +kernel/trace/ring_buffer.c:3486: error: DEAD_STORE + The value written to &reader is never used. + 3484. rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer) + 3485. { + 3486. > struct buffer_page *reader = NULL; + 3487. unsigned long overwrite; + 3488. unsigned long flags; + +drivers/gpu/drm/i915/i915_debugfs.c:3491: error: DEAD_STORE + The value written to &vrefresh is never used. + 3489. struct drm_i915_private *dev_priv = to_i915(dev); + 3490. struct i915_drrs *drrs = &dev_priv->drrs; + 3491. > int vrefresh = 0; + 3492. struct drm_connector *connector; + 3493. struct drm_connector_list_iter conn_iter; + +drivers/pci/quirks.c:3501: error: DEAD_STORE + The value written to &sibling is never used. + 3499. static void quirk_apple_wait_for_thunderbolt(struct pci_dev *dev) + 3500. { + 3501. > struct pci_dev *sibling = NULL; + 3502. struct pci_dev *nhi = NULL; + 3503. + +kernel/sched/fair.c:3551: error: DEAD_STORE + The value written to &res is never used. + 3549. se->avg.load_sum = runnable_sum; + 3550. se->avg.load_avg = load_avg; + 3551. > add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3552. add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3553. + +kernel/sched/fair.c:3552: error: DEAD_STORE + The value written to &res is never used. + 3550. se->avg.load_avg = load_avg; + 3551. add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3552. > add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3553. + 3554. runnable_load_sum = (s64)se_runnable(se) * runnable_sum; + +kernel/sched/fair.c:3563: error: DEAD_STORE + The value written to &res is never used. + 3561. + 3562. if (se->on_rq) { + 3563. > add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3564. add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3565. } + +kernel/sched/fair.c:3564: error: DEAD_STORE + The value written to &res is never used. + 3562. if (se->on_rq) { + 3563. add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3564. > add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3565. } + 3566. } + +security/selinux/hooks.c:3507: error: DEAD_STORE + The value written to &error is never used. + 3505. { + 3506. const struct cred *cred = current_cred(); + 3507. > int error = 0; + 3508. + 3509. switch (cmd) { + +drivers/usb/core/hub.c:3596: error: DEAD_STORE + The value written to &status is never used. + 3594. /* Enable hub to send remote wakeup for all ports. */ + 3595. for (port1 = 1; port1 <= hdev->maxchild; port1++) { + 3596. > status = set_port_feature(hdev, + 3597. port1 | + 3598. USB_PORT_FEAT_REMOTE_WAKE_CONNECT | + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3570: error: DEAD_STORE + The value written to &flash_data is never used. + 3568. union ich8_hws_flash_ctrl hsflctl; + 3569. u32 flash_linear_addr; + 3570. > u32 flash_data = 0; + 3571. s32 ret_val = -E1000_ERR_NVM; + 3572. u8 count = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3571: error: DEAD_STORE + The value written to &ret_val is never used. + 3569. u32 flash_linear_addr; + 3570. u32 flash_data = 0; + 3571. > s32 ret_val = -E1000_ERR_NVM; + 3572. u8 count = 0; + 3573. + +drivers/video/fbdev/core/fbcon.c:3582: error: DEAD_STORE + The value written to &pending is never used. + 3580. + 3581. for (i = 0; i < FB_MAX; i++) { + 3582. > int pending = 0; + 3583. + 3584. mapped = 0; + +drivers/video/fbdev/core/fbcon.c:3591: error: DEAD_STORE + The value written to &pending is never used. + 3589. + 3590. if (info->queue.func) + 3591. > pending = cancel_work_sync(&info->queue); + 3592. DPRINTK("fbcon: %s pending work\n", (pending ? "canceled" : + 3593. "no")); + +drivers/gpu/drm/i915/i915_debugfs.c:3600: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 3599 could be null and is dereferenced at line 3600, column 8. + 3598. + 3599. intel_dig_port = enc_to_dig_port(&intel_encoder->base); + 3600. > if (!intel_dig_port->dp.can_mst) + 3601. continue; + 3602. + +net/wireless/reg.c:3587: error: DEAD_STORE + The value written to ®d is never used. + 3585. bool regulatory_pre_cac_allowed(struct wiphy *wiphy) + 3586. { + 3587. > const struct ieee80211_regdomain *regd = NULL; + 3588. const struct ieee80211_regdomain *wiphy_regd = NULL; + 3589. bool pre_cac_allowed = false; + +net/wireless/reg.c:3588: error: DEAD_STORE + The value written to &wiphy_regd is never used. + 3586. { + 3587. const struct ieee80211_regdomain *regd = NULL; + 3588. > const struct ieee80211_regdomain *wiphy_regd = NULL; + 3589. bool pre_cac_allowed = false; + 3590. + +sound/core/pcm_native.c:3604: error: DEAD_STORE + The value written to &oparams is never used. + 3602. { + 3603. struct snd_pcm_hw_params *params; + 3604. > struct snd_pcm_hw_params_old *oparams = NULL; + 3605. int err; + 3606. + +drivers/gpu/drm/i915/i915_debugfs.c:3657: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3648 could be null and is dereferenced at line 3657, column 5. + 3655. */ + 3656. if (val == 1) + 3657. > intel_dp->compliance.test_active = 1; + 3658. else + 3659. intel_dp->compliance.test_active = 0; + +drivers/gpu/drm/i915/i915_debugfs.c:3659: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3648 could be null and is dereferenced at line 3659, column 5. + 3657. intel_dp->compliance.test_active = 1; + 3658. else + 3659. > intel_dp->compliance.test_active = 0; + 3660. } + 3661. } + +sound/core/pcm_native.c:3639: error: DEAD_STORE + The value written to &oparams is never used. + 3637. { + 3638. struct snd_pcm_hw_params *params; + 3639. > struct snd_pcm_hw_params_old *oparams = NULL; + 3640. int err; + 3641. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3646: error: DEAD_STORE + The value written to &ret_val is never used. + 3644. union ich8_hws_flash_ctrl hsflctl; + 3645. u32 flash_linear_addr; + 3646. > s32 ret_val = -E1000_ERR_NVM; + 3647. u8 count = 0; + 3648. + +kernel/sched/fair.c:3676: error: DEAD_STORE + The value written to &res is never used. + 3674. + 3675. r = removed_load; + 3676. > sub_positive(&sa->load_avg, r); + 3677. sub_positive(&sa->load_sum, r * divider); + 3678. + +kernel/sched/fair.c:3677: error: DEAD_STORE + The value written to &res is never used. + 3675. r = removed_load; + 3676. sub_positive(&sa->load_avg, r); + 3677. > sub_positive(&sa->load_sum, r * divider); + 3678. + 3679. r = removed_util; + +kernel/sched/fair.c:3680: error: DEAD_STORE + The value written to &res is never used. + 3678. + 3679. r = removed_util; + 3680. > sub_positive(&sa->util_avg, r); + 3681. sub_positive(&sa->util_sum, r * divider); + 3682. + +kernel/sched/fair.c:3681: error: DEAD_STORE + The value written to &res is never used. + 3679. r = removed_util; + 3680. sub_positive(&sa->util_avg, r); + 3681. > sub_positive(&sa->util_sum, r * divider); + 3682. + 3683. add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum); + +drivers/gpu/drm/i915/i915_debugfs.c:3692: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3691 could be null and is dereferenced at line 3692, column 8. + 3690. if (encoder && connector->status == connector_status_connected) { + 3691. intel_dp = enc_to_intel_dp(&encoder->base); + 3692. > if (intel_dp->compliance.test_active) + 3693. seq_puts(m, "1"); + 3694. else + +drivers/gpu/drm/drm_atomic_helper.c:3691: error: DEAD_STORE + The value written to &blob is never used. + 3689. struct drm_atomic_state *state; + 3690. struct drm_crtc_state *crtc_state; + 3691. > struct drm_property_blob *blob = NULL; + 3692. struct drm_color_lut *blob_data; + 3693. int i, ret = 0; + +drivers/gpu/drm/drm_atomic_helper.c:3693: error: DEAD_STORE + The value written to &ret is never used. + 3691. struct drm_property_blob *blob = NULL; + 3692. struct drm_color_lut *blob_data; + 3693. > int i, ret = 0; + 3694. bool replaced; + 3695. + +drivers/ata/libata-scsi.c:3691: error: DEAD_STORE + The value written to &fp is never used. + 3689. struct scsi_cmnd *scmd = qc->scsicmd; + 3690. const u8 *cdb = scmd->cmnd; + 3691. > u16 sect, fp = (u16)-1; + 3692. u8 sa, options, bp = 0xff; + 3693. u64 block; + +drivers/ata/libata-core.c:3726: error: DEAD_STORE + The value written to &nodev_deadline is never used. + 3724. + 3725. if (time_after(nodev_deadline, deadline)) + 3726. > nodev_deadline = deadline; + 3727. + 3728. while (1) { + +drivers/ata/libata-core.c:3729: error: DEAD_STORE + The value written to &now is never used. + 3727. + 3728. while (1) { + 3729. > unsigned long now = jiffies; + 3730. int ready, tmp; + 3731. + +drivers/ata/libata-core.c:3766: error: DEAD_STORE + The value written to &warned is never used. + 3764. "link is slow to respond, please be patient " + 3765. "(ready=%d)\n", tmp); + 3766. > warned = 1; + 3767. } + 3768. + +drivers/pci/quirks.c:3736: error: DEAD_STORE + The value written to &timeout is never used. + 3734. iowrite32(val, mmio_base + PCH_PP_CONTROL); + 3735. + 3736. > timeout = jiffies + msecs_to_jiffies(IGD_OPERATION_TIMEOUT); + 3737. do { + 3738. val = ioread32(mmio_base + PCH_PP_STATUS); + +net/core/rtnetlink.c:3724: error: DEAD_STORE + The value written to &err is never used. + 3722. struct net *net = dev_net(dev); + 3723. struct sk_buff *skb; + 3724. > int err = -EOPNOTSUPP; + 3725. + 3726. if (!dev->netdev_ops->ndo_bridge_getlink) + +drivers/gpu/drm/i915/i915_debugfs.c:3743: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3742 could be null and is dereferenced at line 3743, column 8. + 3741. if (encoder && connector->status == connector_status_connected) { + 3742. intel_dp = enc_to_intel_dp(&encoder->base); + 3743. > if (intel_dp->compliance.test_type == + 3744. DP_TEST_LINK_EDID_READ) + 3745. seq_printf(m, "%lx", + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3823: error: DEAD_STORE + The value written to &act_offset is never used. + 3821. + 3822. /* Convert offset to bytes. */ + 3823. > act_offset = (i + new_bank_offset) << 1; + 3824. + 3825. usleep_range(100, 200); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3869: error: DEAD_STORE + The value written to &act_offset is never used. + 3867. * to 1's. We can write 1's to 0's without an erase + 3868. */ + 3869. > act_offset = (old_bank_offset + E1000_ICH_NVM_SIG_WORD) * 2 + 1; + 3870. + 3871. /* offset in words but we read dword */ + +kernel/sched/fair.c:3759: error: DEAD_STORE + The value written to &res is never used. + 3757. { + 3758. dequeue_load_avg(cfs_rq, se); + 3759. > sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3760. sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3761. + +kernel/sched/fair.c:3760: error: DEAD_STORE + The value written to &res is never used. + 3758. dequeue_load_avg(cfs_rq, se); + 3759. sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3760. > sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3761. + 3762. add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum); + +net/ipv6/route.c:3830: error: DEAD_STORE + The value written to &err_nh is never used. + 3828. info->skip_notify = 1; + 3829. + 3830. > err_nh = NULL; + 3831. list_for_each_entry(nh, &rt6_nh_list, next) { + 3832. rt_last = nh->rt6_info; + +net/ipv6/route.c:3811: error: DEAD_STORE + The value written to &rt is never used. + 3809. if (IS_ERR(rt)) { + 3810. err = PTR_ERR(rt); + 3811. > rt = NULL; + 3812. goto cleanup; + 3813. } + +kernel/events/core.c:3770: error: DEAD_STORE + The value written to &clone_ctx is never used. + 3768. struct perf_event *event) + 3769. { + 3770. > struct perf_event_context *ctx, *clone_ctx = NULL; + 3771. struct perf_cpu_context *cpuctx; + 3772. void *task_ctx_data = NULL; + +drivers/ata/libata-scsi.c:3778: error: DEAD_STORE + The value written to &fp is never used. + 3776. u64 block; + 3777. u32 n_block; + 3778. > u16 fp = (u16)-1; + 3779. + 3780. if (unlikely(scmd->cmd_len < 16)) { + +drivers/gpu/drm/i915/i915_debugfs.c:3801: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3800 could be null and is dereferenced at line 3801, column 27. + 3799. if (encoder && connector->status == connector_status_connected) { + 3800. intel_dp = enc_to_intel_dp(&encoder->base); + 3801. > seq_printf(m, "%02lx", intel_dp->compliance.test_type); + 3802. } else + 3803. seq_puts(m, "0"); + +drivers/ata/libata-core.c:3828: error: DEAD_STORE + The value written to &deadline is never used. + 3826. t = ata_deadline(jiffies, params[2]); + 3827. if (time_before(t, deadline)) + 3828. > deadline = t; + 3829. + 3830. if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) + +drivers/ata/libata-core.c:3834: error: DEAD_STORE + The value written to &last is never used. + 3832. cur &= 0xf; + 3833. + 3834. > last = cur; + 3835. last_jiffies = jiffies; + 3836. + +drivers/ata/libata-core.c:3835: error: DEAD_STORE + The value written to &last_jiffies is never used. + 3833. + 3834. last = cur; + 3835. > last_jiffies = jiffies; + 3836. + 3837. while (1) { + +drivers/net/ethernet/intel/e1000/e1000_main.c:3828: error: DEAD_STORE + The value written to &tx_clean_complete is never used. + 3826. struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, + 3827. napi); + 3828. > int tx_clean_complete = 0, work_done = 0; + 3829. + 3830. tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]); + +drivers/net/ethernet/intel/e1000e/netdev.c:3829: error: DEAD_STORE + The value written to &tx_desc is never used. + 3827. struct e1000_hw *hw = &adapter->hw; + 3828. struct e1000_ring *tx_ring = adapter->tx_ring; + 3829. > struct e1000_tx_desc *tx_desc = NULL; + 3830. u32 tdt, tctl, txd_lower = E1000_TXD_CMD_IFCS; + 3831. u16 size = 512; + +kernel/workqueue.c:3838: error: DEAD_STORE + The value written to &old_pwq is never used. + 3836. int node = cpu_to_node(cpu); + 3837. int cpu_off = online ? -1 : cpu; + 3838. > struct pool_workqueue *old_pwq = NULL, *pwq; + 3839. struct workqueue_attrs *target_attrs; + 3840. cpumask_t *cpumask; + +net/packet/af_packet.c:3874: error: DEAD_STORE + The value written to &val is never used. + 3872. break; + 3873. case PACKET_AUXDATA: + 3874. > val = po->auxdata; + 3875. break; + 3876. case PACKET_ORIGDEV: + +net/packet/af_packet.c:3877: error: DEAD_STORE + The value written to &val is never used. + 3875. break; + 3876. case PACKET_ORIGDEV: + 3877. > val = po->origdev; + 3878. break; + 3879. case PACKET_VNET_HDR: + +net/packet/af_packet.c:3880: error: DEAD_STORE + The value written to &val is never used. + 3878. break; + 3879. case PACKET_VNET_HDR: + 3880. > val = po->has_vnet_hdr; + 3881. break; + 3882. case PACKET_VERSION: + +net/packet/af_packet.c:3883: error: DEAD_STORE + The value written to &val is never used. + 3881. break; + 3882. case PACKET_VERSION: + 3883. > val = po->tp_version; + 3884. break; + 3885. case PACKET_HDRLEN: + +net/packet/af_packet.c:3894: error: DEAD_STORE + The value written to &val is never used. + 3892. switch (val) { + 3893. case TPACKET_V1: + 3894. > val = sizeof(struct tpacket_hdr); + 3895. break; + 3896. case TPACKET_V2: + +net/packet/af_packet.c:3897: error: DEAD_STORE + The value written to &val is never used. + 3895. break; + 3896. case TPACKET_V2: + 3897. > val = sizeof(struct tpacket2_hdr); + 3898. break; + 3899. case TPACKET_V3: + +net/packet/af_packet.c:3900: error: DEAD_STORE + The value written to &val is never used. + 3898. break; + 3899. case TPACKET_V3: + 3900. > val = sizeof(struct tpacket3_hdr); + 3901. break; + 3902. default: + +net/packet/af_packet.c:3907: error: DEAD_STORE + The value written to &val is never used. + 3905. break; + 3906. case PACKET_RESERVE: + 3907. > val = po->tp_reserve; + 3908. break; + 3909. case PACKET_LOSS: + +net/packet/af_packet.c:3910: error: DEAD_STORE + The value written to &val is never used. + 3908. break; + 3909. case PACKET_LOSS: + 3910. > val = po->tp_loss; + 3911. break; + 3912. case PACKET_TIMESTAMP: + +net/packet/af_packet.c:3913: error: DEAD_STORE + The value written to &val is never used. + 3911. break; + 3912. case PACKET_TIMESTAMP: + 3913. > val = po->tp_tstamp; + 3914. break; + 3915. case PACKET_FANOUT: + +net/packet/af_packet.c:3916: error: DEAD_STORE + The value written to &val is never used. + 3914. break; + 3915. case PACKET_FANOUT: + 3916. > val = (po->fanout ? + 3917. ((u32)po->fanout->id | + 3918. ((u32)po->fanout->type << 16) | + +net/packet/af_packet.c:3932: error: DEAD_STORE + The value written to &val is never used. + 3930. break; + 3931. case PACKET_TX_HAS_OFF: + 3932. > val = po->tp_tx_has_off; + 3933. break; + 3934. case PACKET_QDISC_BYPASS: + +net/packet/af_packet.c:3935: error: DEAD_STORE + The value written to &val is never used. + 3933. break; + 3934. case PACKET_QDISC_BYPASS: + 3935. > val = packet_use_direct_xmit(po); + 3936. break; + 3937. default: + +drivers/net/ethernet/intel/e1000/e1000_hw.c:3842: error: DEAD_STORE + The value written to &retry_count is never used. + 3840. static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw) + 3841. { + 3842. > u16 retry_count = 0; + 3843. u8 spi_stat_reg; + 3844. + +drivers/net/ethernet/intel/e1000/e1000_main.c:3856: error: DEAD_STORE + The value written to &hw is never used. + 3854. struct e1000_tx_ring *tx_ring) + 3855. { + 3856. > struct e1000_hw *hw = &adapter->hw; + 3857. struct net_device *netdev = adapter->netdev; + 3858. struct e1000_tx_desc *tx_desc, *eop_desc; + +drivers/gpu/drm/i915/intel_dp.c:3884: error: DEAD_STORE + The value written to &count is never used. + 3882. u8 buf; + 3883. int ret = 0; + 3884. > int count = 0; + 3885. int attempts = 10; + 3886. + +net/ipv6/route.c:3897: error: DEAD_STORE + The value written to &err is never used. + 3895. int remaining; + 3896. int attrlen; + 3897. > int err = 1, last_err = 0; + 3898. + 3899. remaining = cfg->fc_mp_len; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:3896: error: DEAD_STORE + The value written to &i is never used. + 3894. { + 3895. struct e1000_eeprom_info *eeprom = &hw->eeprom; + 3896. > u32 i = 0; + 3897. + 3898. if (hw->mac_type == e1000_ce4100) { + +kernel/rcu/tree.c:3913: error: DEAD_STORE + The value written to &nbits is never used. + 3911. rnp->expmaskinitnext |= mask; + 3912. oldmask ^= rnp->expmaskinitnext; + 3913. > nbits = bitmap_weight(&oldmask, BITS_PER_LONG); + 3914. /* Allow lockless access for expedited grace periods. */ + 3915. smp_store_release(&rsp->ncpus, rsp->ncpus + nbits); /* ^^^ */ + +drivers/gpu/drm/i915/intel_pm.c:3990: error: DEAD_STORE + The value written to &height is never used. + 3988. struct intel_plane_state *intel_pstate = to_intel_plane_state(pstate); + 3989. uint32_t data_rate; + 3990. > uint32_t width = 0, height = 0; + 3991. struct drm_framebuffer *fb; + 3992. u32 format; + +drivers/gpu/drm/i915/intel_pm.c:3990: error: DEAD_STORE + The value written to &width is never used. + 3988. struct intel_plane_state *intel_pstate = to_intel_plane_state(pstate); + 3989. uint32_t data_rate; + 3990. > uint32_t width = 0, height = 0; + 3991. struct drm_framebuffer *fb; + 3992. u32 format; + +drivers/gpu/drm/i915/intel_dp.c:4014: error: DEAD_STORE + The value written to &status is never used. + 4012. static uint8_t intel_dp_autotest_link_training(struct intel_dp *intel_dp) + 4013. { + 4014. > int status = 0; + 4015. int test_link_rate; + 4016. uint8_t test_lane_count, test_link_bw; + +drivers/iommu/intel-iommu.c:4016: error: DEAD_STORE + The value written to &iommu is never used. + 4014. { + 4015. struct dmar_drhd_unit *drhd; + 4016. > struct intel_iommu *iommu = NULL; + 4017. + 4018. for_each_active_iommu(iommu, drhd) + +drivers/gpu/drm/i915/i915_gem.c:4038: error: DEAD_STORE + The value written to &recent_enough is never used. + 4036. struct drm_i915_private *dev_priv = to_i915(dev); + 4037. struct drm_i915_file_private *file_priv = file->driver_priv; + 4038. > unsigned long recent_enough = jiffies - DRM_I915_THROTTLE_JIFFIES; + 4039. struct drm_i915_gem_request *request, *target = NULL; + 4040. long ret; + +drivers/gpu/drm/i915/intel_dp.c:4054: error: DEAD_STORE + The value written to &status is never used. + 4052. uint8_t test_misc; + 4053. __be16 h_width, v_height; + 4054. > int status = 0; + 4055. + 4056. /* Read the TEST_PATTERN (DP CTS 3.1.5) */ + +drivers/tty/vt/vt.c:4060: error: DEAD_STORE + The value written to &rc is never used. + 4058. { + 4059. struct console_font font; + 4060. > int rc = -EINVAL; + 4061. int c; + 4062. + +drivers/iommu/intel-iommu.c:4063: error: DEAD_STORE + The value written to &iommu is never used. + 4061. { + 4062. struct dmar_drhd_unit *drhd; + 4063. > struct intel_iommu *iommu = NULL; + 4064. unsigned long flag; + 4065. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4069: error: DEAD_STORE + The value written to &status is never used. + 4067. { + 4068. struct e1000_eeprom_info *eeprom = &hw->eeprom; + 4069. > s32 status = 0; + 4070. + 4071. if (hw->mac_type == e1000_ce4100) { + +drivers/gpu/drm/i915/intel_pm.c:4109: error: DEAD_STORE + The value written to &src_h is never used. + 4107. if (fb->format->format == DRM_FORMAT_NV12 && !y) { + 4108. src_w /= 2; + 4109. > src_h /= 2; + 4110. } + 4111. + +drivers/iommu/intel-iommu.c:4103: error: DEAD_STORE + The value written to &iommu is never used. + 4101. { + 4102. struct dmar_drhd_unit *drhd; + 4103. > struct intel_iommu *iommu = NULL; + 4104. unsigned long flag; + 4105. + +net/ipv6/addrconf.c:4106: error: DEAD_STORE + The value written to &ifa is never used. + 4104. struct if6_iter_state *state = seq->private; + 4105. struct net *net = seq_file_net(seq); + 4106. > struct inet6_ifaddr *ifa = NULL; + 4107. int p = 0; + 4108. + +drivers/ata/libata-eh.c:4111: error: DEAD_STORE + The value written to &rc is never used. + 4109. { + 4110. unsigned long flags; + 4111. > int rc = 0; + 4112. struct ata_device *dev; + 4113. + +drivers/tty/vt/vt.c:4114: error: DEAD_STORE + The value written to &rc is never used. + 4112. { + 4113. struct console_font font; + 4114. > int rc = -EINVAL; + 4115. int size; + 4116. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:4164: error: DEAD_STORE + The value written to &flash_data is never used. + 4162. union ich8_hws_flash_ctrl hsflctl; + 4163. u32 flash_linear_addr; + 4164. > u32 flash_data = 0; + 4165. s32 ret_val; + 4166. u8 count = 0; + +kernel/sched/fair.c:4188: error: NULL_DEREFERENCE + pointer `se` last assigned on line 4187 could be null and is dereferenced at line 4188, column 27. + 4186. + 4187. se = __pick_first_entity(cfs_rq); + 4188. > delta = curr->vruntime - se->vruntime; + 4189. + 4190. if (delta < 0) + +drivers/gpu/drm/i915/intel_pm.c:4240: error: DEAD_STORE + The value written to &y_plane_blocks is never used. + 4238. for_each_plane_id_on_crtc(intel_crtc, plane_id) { + 4239. unsigned int data_rate, y_data_rate; + 4240. > uint16_t plane_blocks, y_plane_blocks = 0; + 4241. + 4242. if (plane_id == PLANE_CURSOR) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4184: error: DEAD_STORE + The value written to &i is never used. + 4182. u32 eecd; + 4183. u16 words_written = 0; + 4184. > u16 i = 0; + 4185. + 4186. /* Send the write enable command to the EEPROM (3-bit opcode plus + +net/packet/af_packet.c:4208: error: DEAD_STORE + The value written to &err is never used. + 4206. struct sk_buff_head *rb_queue; + 4207. __be16 num; + 4208. > int err = -EINVAL; + 4209. /* Added to avoid minimal code churn */ + 4210. struct tpacket_req *req = &req_u->req; + +drivers/gpu/drm/i915/intel_dp.c:4210: error: DEAD_STORE + The value written to &ret is never used. + 4208. if (intel_dp->is_mst) { + 4209. u8 esi[DP_DPRX_ESI_LEN] = { 0 }; + 4210. > int ret = 0; + 4211. int retry; + 4212. bool handled; + +net/core/rtnetlink.c:4210: error: DEAD_STORE + The value written to &dev is never used. + 4208. { + 4209. struct net *net = sock_net(skb->sk); + 4210. > struct net_device *dev = NULL; + 4211. int idxattr = 0, prividx = 0; + 4212. struct if_stats_msg *ifsm; + +net/core/rtnetlink.c:4259: error: DEAD_STORE + The value written to &filter_mask is never used. + 4257. struct hlist_head *head; + 4258. struct net_device *dev; + 4259. > u32 filter_mask = 0; + 4260. int idx = 0; + 4261. + +net/core/filter.c:4266: error: DEAD_STORE + The value written to &insn is never used. + 4264. struct bpf_prog *prog, u32 *target_size) + 4265. { + 4266. > struct bpf_insn *insn = insn_buf; + 4267. + 4268. switch (si->off) { + +net/core/filter.c:4270: error: NULL_DEREFERENCE + pointer `insn` last assigned on line 4270 could be null and is dereferenced at line 4270, column 13. + 4268. switch (si->off) { + 4269. case offsetof(struct __sk_buff, ifindex): + 4270. > *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, dev), + 4271. si->dst_reg, si->src_reg, + 4272. offsetof(struct sk_buff, dev)); + +drivers/net/ethernet/marvell/sky2.c:4282: error: DEAD_STORE + The value written to &start is never used. + 4280. static int sky2_vpd_wait(const struct sky2_hw *hw, int cap, u16 busy) + 4281. { + 4282. > unsigned long start = jiffies; + 4283. + 4284. while ( (sky2_pci_read16(hw, cap + PCI_VPD_ADDR) & PCI_VPD_ADDR_F) == busy) { + +drivers/iommu/intel-iommu.c:4291: error: DEAD_STORE + The value written to &ret is never used. + 4289. static int intel_iommu_add(struct dmar_drhd_unit *dmaru) + 4290. { + 4291. > int sp, ret = 0; + 4292. struct intel_iommu *iommu = dmaru->iommu; + 4293. + +drivers/ata/libata-scsi.c:4308: error: DEAD_STORE + The value written to &xlat_func is never used. + 4306. goto bad_cdb_len; + 4307. + 4308. > xlat_func = NULL; + 4309. if (likely((scsi_op != ATA_16) || !atapi_passthru16)) { + 4310. /* relay SCSI command to ATAPI device */ + +kernel/cgroup/cgroup.c:4320: error: NULL_DEREFERENCE + pointer `com_cgrp` last assigned on line 4321 could be null and is dereferenced by call to `cgroup_is_descendant()` at line 4320, column 10. + 4318. + 4319. /* find the common ancestor */ + 4320. > while (!cgroup_is_descendant(dst_cgrp, com_cgrp)) + 4321. com_cgrp = cgroup_parent(com_cgrp); + 4322. + +net/wireless/nl80211.c:4313: error: DEAD_STORE + The value written to &i is never used. + 4311. { + 4312. void *attr; + 4313. > int i = 0; + 4314. + 4315. if (!mask) + +kernel/trace/trace.c:4322: error: DEAD_STORE + The value written to &opts is never used. + 4320. struct tracer *trace = tr->current_trace; + 4321. struct tracer_flags *tracer_flags = trace->flags; + 4322. > struct tracer_opt *opts = NULL; + 4323. int i; + 4324. + +drivers/net/ethernet/broadcom/tg3.c:4321: error: DEAD_STORE + The value written to &err is never used. + 4319. static int tg3_phy_autoneg_cfg(struct tg3 *tp, u32 advertise, u32 flowctrl) + 4320. { + 4321. > int err = 0; + 4322. u32 val, new_adv; + 4323. + +drivers/net/ethernet/intel/e1000e/netdev.c:4374: error: DEAD_STORE + The value written to &temp is never used. + 4372. temp = time_delta; + 4373. /* VMWare users have seen incvalue of zero, don't div / 0 */ + 4374. > rem = incvalue ? do_div(temp, incvalue) : (time_delta != 0); + 4375. + 4376. systim = systim_next; + +drivers/gpu/drm/i915/i915_gem.c:4442: error: NULL_DEREFERENCE + pointer `obj->base.filp` last assigned on line 4431 could be null and is dereferenced at line 4442, column 12. + 4440. } + 4441. + 4442. > mapping = obj->base.filp->f_mapping; + 4443. mapping_set_gfp_mask(mapping, mask); + 4444. GEM_BUG_ON(!(mapping_gfp_mask(mapping) & __GFP_RECLAIM)); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4438: error: DEAD_STORE + The value written to &vfta_value is never used. + 4436. { + 4437. u32 offset; + 4438. > u32 vfta_value = 0; + 4439. u32 vfta_offset = 0; + 4440. u32 vfta_bit_in_reg = 0; + +drivers/md/md.c:4478: error: DEAD_STORE + The value written to &namelen is never used. + 4476. mddev->metadata_type[namelen] = 0; + 4477. if (namelen && mddev->metadata_type[namelen-1] == '\n') + 4478. > mddev->metadata_type[--namelen] = 0; + 4479. mddev->persistent = 0; + 4480. mddev->external = 1; + +drivers/iommu/intel-iommu.c:4455: error: DEAD_STORE + The value written to &ret is never used. + 4453. int dmar_iommu_notify_scope_dev(struct dmar_pci_notify_info *info) + 4454. { + 4455. > int ret = 0; + 4456. struct dmar_rmrr_unit *rmrru; + 4457. struct dmar_atsr_unit *atsru; + +security/selinux/hooks.c:4534: error: DEAD_STORE + The value written to &addr4 is never used. + 4532. struct common_audit_data ad; + 4533. struct lsm_network_audit net = {0,}; + 4534. > struct sockaddr_in *addr4 = NULL; + 4535. struct sockaddr_in6 *addr6 = NULL; + 4536. unsigned short snum; + +security/selinux/hooks.c:4535: error: DEAD_STORE + The value written to &addr6 is never used. + 4533. struct lsm_network_audit net = {0,}; + 4534. struct sockaddr_in *addr4 = NULL; + 4535. > struct sockaddr_in6 *addr6 = NULL; + 4536. unsigned short snum; + 4537. u32 sid, perm; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4531: error: DEAD_STORE + The value written to &ret_val is never used. + 4529. { + 4530. u32 ledctl; + 4531. > s32 ret_val = E1000_SUCCESS; + 4532. + 4533. switch (hw->mac_type) { + +net/ipv6/addrconf.c:4548: error: DEAD_STORE + The value written to &preferred_lft is never used. + 4546. struct inet6_ifaddr *ifa; + 4547. struct net_device *dev; + 4548. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4549. u32 ifa_flags; + 4550. int err; + +net/ipv6/addrconf.c:4548: error: DEAD_STORE + The value written to &valid_lft is never used. + 4546. struct inet6_ifaddr *ifa; + 4547. struct net_device *dev; + 4548. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4549. u32 ifa_flags; + 4550. int err; + +net/wireless/nl80211.c:4581: error: DEAD_STORE + The value written to &mac_addr is never used. + 4579. struct station_info sinfo; + 4580. struct sk_buff *msg; + 4581. > u8 *mac_addr = NULL; + 4582. int err; + 4583. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4581: error: DEAD_STORE + The value written to &ret_val is never used. + 4579. s32 e1000_cleanup_led(struct e1000_hw *hw) + 4580. { + 4581. > s32 ret_val = E1000_SUCCESS; + 4582. + 4583. switch (hw->mac_type) { + +kernel/workqueue.c:4637: error: DEAD_STORE + The value written to &worker_flags is never used. + 4635. WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND)); + 4636. worker_flags |= WORKER_REBOUND; + 4637. > worker_flags &= ~WORKER_UNBOUND; + 4638. WRITE_ONCE(worker->flags, worker_flags); + 4639. } + +drivers/gpu/drm/i915/intel_display.c:4595: error: DEAD_STORE + The value written to &temp is never used. + 4593. u32 temp; + 4594. + 4595. > temp = I915_READ(dslreg); + 4596. udelay(500); + 4597. if (wait_for(I915_READ(dslreg) != temp, 5)) { + +drivers/gpu/drm/i915/intel_display.c:4597: error: DEAD_STORE + The value written to &timeout__ is never used. + 4595. temp = I915_READ(dslreg); + 4596. udelay(500); + 4597. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4598. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4599. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4598: error: DEAD_STORE + The value written to &timeout__ is never used. + 4596. udelay(500); + 4597. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4598. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4599. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4600. } + +drivers/iommu/intel-iommu.c:4635: error: DEAD_STORE + The value written to &iommu is never used. + 4633. static void intel_disable_iommus(void) + 4634. { + 4635. > struct intel_iommu *iommu = NULL; + 4636. struct dmar_drhd_unit *drhd; + 4637. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4705: error: DEAD_STORE + The value written to &temp is never used. + 4703. volatile u32 temp; + 4704. + 4705. > temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4706: error: DEAD_STORE + The value written to &temp is never used. + 4704. + 4705. temp = er32(CRCERRS); + 4706. > temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4707: error: DEAD_STORE + The value written to &temp is never used. + 4705. temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. > temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4708: error: DEAD_STORE + The value written to &temp is never used. + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. > temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4709: error: DEAD_STORE + The value written to &temp is never used. + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. > temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4710: error: DEAD_STORE + The value written to &temp is never used. + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. > temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4711: error: DEAD_STORE + The value written to &temp is never used. + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. > temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4712: error: DEAD_STORE + The value written to &temp is never used. + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. > temp = er32(COLC); + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4713: error: DEAD_STORE + The value written to &temp is never used. + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. > temp = er32(DC); + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4714: error: DEAD_STORE + The value written to &temp is never used. + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + 4714. > temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4715: error: DEAD_STORE + The value written to &temp is never used. + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + 4715. > temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4716: error: DEAD_STORE + The value written to &temp is never used. + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. > temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4717: error: DEAD_STORE + The value written to &temp is never used. + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. > temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4718: error: DEAD_STORE + The value written to &temp is never used. + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. > temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4719: error: DEAD_STORE + The value written to &temp is never used. + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. > temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + 4721. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4720: error: DEAD_STORE + The value written to &temp is never used. + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. > temp = er32(FCRUC); + 4721. + 4722. temp = er32(PRC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4722: error: DEAD_STORE + The value written to &temp is never used. + 4720. temp = er32(FCRUC); + 4721. + 4722. > temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4723: error: DEAD_STORE + The value written to &temp is never used. + 4721. + 4722. temp = er32(PRC64); + 4723. > temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4724: error: DEAD_STORE + The value written to &temp is never used. + 4722. temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. > temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4725: error: DEAD_STORE + The value written to &temp is never used. + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. > temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4726: error: DEAD_STORE + The value written to &temp is never used. + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. > temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + 4728. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4727: error: DEAD_STORE + The value written to &temp is never used. + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. > temp = er32(PRC1522); + 4728. + 4729. temp = er32(GPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4729: error: DEAD_STORE + The value written to &temp is never used. + 4727. temp = er32(PRC1522); + 4728. + 4729. > temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4730: error: DEAD_STORE + The value written to &temp is never used. + 4728. + 4729. temp = er32(GPRC); + 4730. > temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4731: error: DEAD_STORE + The value written to &temp is never used. + 4729. temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. > temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4732: error: DEAD_STORE + The value written to &temp is never used. + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. > temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4733: error: DEAD_STORE + The value written to &temp is never used. + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. > temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4734: error: DEAD_STORE + The value written to &temp is never used. + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. > temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4735: error: DEAD_STORE + The value written to &temp is never used. + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. > temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4736: error: DEAD_STORE + The value written to &temp is never used. + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. > temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4737: error: DEAD_STORE + The value written to &temp is never used. + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. > temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4738: error: DEAD_STORE + The value written to &temp is never used. + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. > temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4739: error: DEAD_STORE + The value written to &temp is never used. + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. > temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4740: error: DEAD_STORE + The value written to &temp is never used. + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. > temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4741: error: DEAD_STORE + The value written to &temp is never used. + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. > temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4742: error: DEAD_STORE + The value written to &temp is never used. + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. > temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4743: error: DEAD_STORE + The value written to &temp is never used. + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. > temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4744: error: DEAD_STORE + The value written to &temp is never used. + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. > temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4745: error: DEAD_STORE + The value written to &temp is never used. + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. > temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. temp = er32(TPT); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4746: error: DEAD_STORE + The value written to &temp is never used. + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. > temp = er32(TPR); + 4747. temp = er32(TPT); + 4748. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4747: error: DEAD_STORE + The value written to &temp is never used. + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. > temp = er32(TPT); + 4748. + 4749. temp = er32(PTC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4749: error: DEAD_STORE + The value written to &temp is never used. + 4747. temp = er32(TPT); + 4748. + 4749. > temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4750: error: DEAD_STORE + The value written to &temp is never used. + 4748. + 4749. temp = er32(PTC64); + 4750. > temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4751: error: DEAD_STORE + The value written to &temp is never used. + 4749. temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. > temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4752: error: DEAD_STORE + The value written to &temp is never used. + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. > temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4753: error: DEAD_STORE + The value written to &temp is never used. + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. > temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + 4755. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4754: error: DEAD_STORE + The value written to &temp is never used. + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. > temp = er32(PTC1522); + 4755. + 4756. temp = er32(MPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4756: error: DEAD_STORE + The value written to &temp is never used. + 4754. temp = er32(PTC1522); + 4755. + 4756. > temp = er32(MPTC); + 4757. temp = er32(BPTC); + 4758. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4757: error: DEAD_STORE + The value written to &temp is never used. + 4755. + 4756. temp = er32(MPTC); + 4757. > temp = er32(BPTC); + 4758. + 4759. if (hw->mac_type < e1000_82543) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4762: error: DEAD_STORE + The value written to &temp is never used. + 4760. return; + 4761. + 4762. > temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4763: error: DEAD_STORE + The value written to &temp is never used. + 4761. + 4762. temp = er32(ALGNERRC); + 4763. > temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4764: error: DEAD_STORE + The value written to &temp is never used. + 4762. temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. > temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4765: error: DEAD_STORE + The value written to &temp is never used. + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. > temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4766: error: DEAD_STORE + The value written to &temp is never used. + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. > temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + 4768. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4767: error: DEAD_STORE + The value written to &temp is never used. + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. > temp = er32(TSCTFC); + 4768. + 4769. if (hw->mac_type <= e1000_82544) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4772: error: DEAD_STORE + The value written to &temp is never used. + 4770. return; + 4771. + 4772. > temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4773: error: DEAD_STORE + The value written to &temp is never used. + 4771. + 4772. temp = er32(MGTPRC); + 4773. > temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + 4775. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4774: error: DEAD_STORE + The value written to &temp is never used. + 4772. temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. > temp = er32(MGTPTC); + 4775. } + 4776. + +drivers/pci/quirks.c:4781: error: DEAD_STORE + The value written to &i is never used. + 4779. pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &cap[i++]); + 4780. pcie_capability_read_word(pdev, PCI_EXP_LNKCTL2, &cap[i++]); + 4781. > pcie_capability_read_word(pdev, PCI_EXP_SLTCTL2, &cap[i++]); + 4782. hlist_add_head(&state->next, &pdev->saved_cap_space); + 4783. } + +security/selinux/hooks.c:4724: error: DEAD_STORE + The value written to &err is never used. + 4722. u16 family) + 4723. { + 4724. > int err = 0; + 4725. struct sk_security_struct *sksec = sk->sk_security; + 4726. u32 sk_sid = sksec->sid; + +security/selinux/hooks.c:4826: error: DEAD_STORE + The value written to &err is never used. + 4824. int __user *optlen, unsigned len) + 4825. { + 4826. > int err = 0; + 4827. char *scontext; + 4828. u32 scontext_len; + +net/ipv6/addrconf.c:4909: error: DEAD_STORE + The value written to &addr is never used. + 4907. struct ifaddrmsg *ifm; + 4908. struct nlattr *tb[IFA_MAX+1]; + 4909. > struct in6_addr *addr = NULL, *peer; + 4910. struct net_device *dev = NULL; + 4911. struct inet6_ifaddr *ifa; + +drivers/gpu/drm/i915/intel_dp.c:4947: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 4944 could be null and is dereferenced by call to `intel_dp_mst_encoder_cleanup()` at line 4947, column 2. + 4945. struct intel_dp *intel_dp = &intel_dig_port->dp; + 4946. + 4947. > intel_dp_mst_encoder_cleanup(intel_dig_port); + 4948. if (intel_dp_is_edp(intel_dp)) { + 4949. cancel_delayed_work_sync(&intel_dp->panel_vdd_work); + +drivers/md/md.c:4977: error: DEAD_STORE + The value written to &backwards is never used. + 4975. reshape_direction_store(struct mddev *mddev, const char *buf, size_t len) + 4976. { + 4977. > int backwards = 0; + 4978. int err; + 4979. + +drivers/gpu/drm/i915/intel_dp.c:5030: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5026 could be null and is dereferenced at line 5030, column 18. + 5028. + 5029. if (!HAS_DDI(dev_priv)) + 5030. > intel_dp->DP = I915_READ(intel_dp->output_reg); + 5031. + 5032. if (lspcon->active) + +drivers/gpu/drm/i915/intel_dp.c:5035: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5026 could be null and is dereferenced at line 5035, column 2. + 5033. lspcon_resume(lspcon); + 5034. + 5035. > intel_dp->reset_link_params = true; + 5036. + 5037. pps_lock(intel_dp); + +net/wireless/nl80211.c:5043: error: DEAD_STORE + The value written to &mac_addr is never used. + 5041. struct net_device *dev = info->user_ptr[1]; + 5042. struct station_parameters params; + 5043. > u8 *mac_addr = NULL; + 5044. u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) | + 5045. BIT(NL80211_STA_FLAG_ASSOCIATED); + +drivers/gpu/drm/drm_edid.c:5071: error: DEAD_STORE + The value written to &displayid is never used. + 5069. struct edid *edid) + 5070. { + 5071. > void *displayid = NULL; + 5072. int ret; + 5073. connector->has_tile = false; + +drivers/iommu/intel-iommu.c:5075: error: DEAD_STORE + The value written to &freelist is never used. + 5073. { + 5074. struct dmar_domain *dmar_domain = to_dmar_domain(domain); + 5075. > struct page *freelist = NULL; + 5076. struct intel_iommu *iommu; + 5077. unsigned long start_pfn, last_pfn; + +drivers/iommu/intel-iommu.c:5096: error: DEAD_STORE + The value written to &iommu is never used. + 5094. + 5095. for_each_domain_iommu(iommu_id, dmar_domain) { + 5096. > iommu = g_iommus[iommu_id]; + 5097. + 5098. iommu_flush_iotlb_psi(g_iommus[iommu_id], dmar_domain, + +drivers/net/ethernet/intel/e1000/e1000_main.c:5090: error: DEAD_STORE + The value written to &retval is never used. + 5088. u32 wufc = adapter->wol; + 5089. #ifdef CONFIG_PM + 5090. > int retval = 0; + 5091. #endif + 5092. + +drivers/ata/libata-core.c:5105: error: NULL_DEREFERENCE + pointer `qc` last assigned on line 5104 could be null and is dereferenced at line 5105, column 2. + 5103. + 5104. qc = __ata_qc_from_tag(ap, tag); + 5105. > qc->tag = tag; + 5106. qc->scsicmd = NULL; + 5107. qc->ap = ap; + +security/selinux/hooks.c:5103: error: DEAD_STORE + The value written to &err is never used. + 5101. static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb) + 5102. { + 5103. > int err = 0; + 5104. u32 perm; + 5105. struct nlmsghdr *nlh; + +kernel/cgroup/cgroup.c:5115: error: DEAD_STORE + The value written to &ret is never used. + 5113. { + 5114. struct cgroup *cgrp; + 5115. > int ret = 0; + 5116. + 5117. cgrp = cgroup_kn_lock_live(kn, false); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:5143: error: DEAD_STORE + The value written to &ret_val is never used. + 5141. * stability + 5142. */ + 5143. > ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); + 5144. if (!link) + 5145. return 0; + +kernel/sched/core.c:5175: error: DEAD_STORE + The value written to &free is never used. + 5173. void sched_show_task(struct task_struct *p) + 5174. { + 5175. > unsigned long free = 0; + 5176. int ppid; + 5177. + +drivers/gpu/drm/i915/intel_dp.c:5191: error: DEAD_STORE + The value written to &pp_ctl is never used. + 5189. struct intel_dp *intel_dp, struct edp_power_seq *seq) + 5190. { + 5191. > u32 pp_on, pp_off, pp_div = 0, pp_ctl = 0; + 5192. struct pps_registers regs; + 5193. + +kernel/cgroup/cgroup.c:5209: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5208 could be null and is dereferenced at line 5209, column 3. + 5207. + 5208. for_each_subsys(ss, i) { + 5209. > WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id, + 5210. "invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p id:name=%d:%s\n", + 5211. i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free, + +kernel/trace/trace.c:5256: error: DEAD_STORE + The value written to &ret is never used. + 5254. unsigned long size, int cpu_id) + 5255. { + 5256. > int ret = size; + 5257. + 5258. mutex_lock(&trace_types_lock); + +net/core/skbuff.c:5265: error: DEAD_STORE + The value written to &insp is never used. + 5263. struct sk_buff *list = shinfo->frag_list; + 5264. struct sk_buff *clone = NULL; + 5265. > struct sk_buff *insp = NULL; + 5266. + 5267. do { + +net/ipv4/tcp_input.c:5389: error: DEAD_STORE + The value written to &eaten is never used. + 5387. } + 5388. } else { + 5389. > int eaten = 0; + 5390. bool fragstolen = false; + 5391. + +drivers/net/ethernet/nvidia/forcedeth.c:5512: error: DEAD_STORE + The value written to &miistat is never used. + 5510. { + 5511. u32 miistat; + 5512. > miistat = readl(base + NvRegMIIStatus); + 5513. writel(NVREG_MIISTAT_MASK_ALL, base + NvRegMIIStatus); + 5514. } + +net/wireless/nl80211.c:5403: error: DEAD_STORE + The value written to &dst is never used. + 5401. struct mpath_info pinfo; + 5402. struct sk_buff *msg; + 5403. > u8 *dst = NULL; + 5404. u8 next_hop[ETH_ALEN]; + 5405. + +net/wireless/nl80211.c:5440: error: DEAD_STORE + The value written to &dst is never used. + 5438. struct cfg80211_registered_device *rdev = info->user_ptr[0]; + 5439. struct net_device *dev = info->user_ptr[1]; + 5440. > u8 *dst = NULL; + 5441. u8 *next_hop = NULL; + 5442. + +net/wireless/nl80211.c:5441: error: DEAD_STORE + The value written to &next_hop is never used. + 5439. struct net_device *dev = info->user_ptr[1]; + 5440. u8 *dst = NULL; + 5441. > u8 *next_hop = NULL; + 5442. + 5443. if (!info->attrs[NL80211_ATTR_MAC]) + +drivers/usb/core/hub.c:5459: error: DEAD_STORE + The value written to &ret is never used. + 5457. struct usb_device_descriptor descriptor = udev->descriptor; + 5458. struct usb_host_bos *bos; + 5459. > int i, j, ret = 0; + 5460. int port1 = udev->portnum; + 5461. + +drivers/gpu/drm/i915/intel_dp.c:5458: error: DEAD_STORE + The value written to &dig_port is never used. + 5456. { + 5457. struct intel_encoder *encoder; + 5458. > struct intel_digital_port *dig_port = NULL; + 5459. struct intel_dp *intel_dp = dev_priv->drrs.dp; + 5460. struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc); + +drivers/gpu/drm/i915/intel_dp.c:5460: error: DEAD_STORE + The value written to &intel_crtc is never used. + 5458. struct intel_digital_port *dig_port = NULL; + 5459. struct intel_dp *intel_dp = dev_priv->drrs.dp; + 5460. > struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc); + 5461. enum drrs_refresh_rate_type index = DRRS_HIGH_RR; + 5462. + +net/wireless/nl80211.c:5465: error: DEAD_STORE + The value written to &dst is never used. + 5463. struct cfg80211_registered_device *rdev = info->user_ptr[0]; + 5464. struct net_device *dev = info->user_ptr[1]; + 5465. > u8 *dst = NULL; + 5466. u8 *next_hop = NULL; + 5467. + +net/wireless/nl80211.c:5466: error: DEAD_STORE + The value written to &next_hop is never used. + 5464. struct net_device *dev = info->user_ptr[1]; + 5465. u8 *dst = NULL; + 5466. > u8 *next_hop = NULL; + 5467. + 5468. if (!info->attrs[NL80211_ATTR_MAC]) + +kernel/cgroup/cgroup.c:5473: error: DEAD_STORE + The value written to &i is never used. + 5471. int i, j, ret; + 5472. + 5473. > do_each_subsys_mask(ss, i, have_canfork_callback) { + 5474. ret = ss->can_fork(child); + 5475. if (ret) + +drivers/net/ethernet/broadcom/tg3.c:5504: error: DEAD_STORE + The value written to &expected_sg_dig_ctrl is never used. + 5502. + 5503. serdes_cfg = 0; + 5504. > expected_sg_dig_ctrl = 0; + 5505. workaround = 0; + 5506. port_a = 1; + +kernel/cgroup/cgroup.c:5505: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5504 could be null and is dereferenced at line 5505, column 7. + 5503. + 5504. for_each_subsys(ss, i) + 5505. > if (ss->cancel_fork) + 5506. ss->cancel_fork(child); + 5507. } + +net/wireless/nl80211.c:5508: error: DEAD_STORE + The value written to &dst is never used. + 5506. struct mpath_info pinfo; + 5507. struct sk_buff *msg; + 5508. > u8 *dst = NULL; + 5509. u8 mpp[ETH_ALEN]; + 5510. + +kernel/cgroup/cgroup.c:5563: error: DEAD_STORE + The value written to &i is never used. + 5561. * and addition to css_set. + 5562. */ + 5563. > do_each_subsys_mask(ss, i, have_fork_callback) { + 5564. ss->fork(child); + 5565. } while_each_subsys_mask(); + +kernel/cgroup/cgroup.c:5609: error: DEAD_STORE + The value written to &i is never used. + 5607. + 5608. /* see cgroup_post_fork() for details */ + 5609. > do_each_subsys_mask(ss, i, have_exit_callback) { + 5610. ss->exit(tsk); + 5611. } while_each_subsys_mask(); + +drivers/net/ethernet/realtek/r8169.c:5599: error: DEAD_STORE + The value written to &tmp is never used. + 5597. u32 mc_filter[2]; /* Multicast hash filter */ + 5598. int rx_mode; + 5599. > u32 tmp = 0; + 5600. + 5601. if (dev->flags & IFF_PROMISC) { + +drivers/gpu/drm/i915/intel_pm.c:5635: error: DEAD_STORE + The value written to &timeout__ is never used. + 5633. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5634. + 5635. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5636. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5637. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +kernel/cgroup/cgroup.c:5620: error: DEAD_STORE + The value written to &ssid is never used. + 5618. int ssid; + 5619. + 5620. > do_each_subsys_mask(ss, ssid, have_free_callback) { + 5621. ss->free(task); + 5622. } while_each_subsys_mask(); + +drivers/usb/core/hub.c:5647: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5632 could be null and is dereferenced at line 5647, column 13. + 5645. } + 5646. + 5647. > port_dev = hub->ports[udev->portnum - 1]; + 5648. + 5649. /* + +drivers/net/ethernet/intel/e1000e/netdev.c:5644: error: DEAD_STORE + The value written to &tx_desc is never used. + 5642. { + 5643. struct e1000_adapter *adapter = tx_ring->adapter; + 5644. > struct e1000_tx_desc *tx_desc = NULL; + 5645. struct e1000_buffer *buffer_info; + 5646. u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS; + +net/core/dev.c:5672: error: DEAD_STORE + The value written to &time_limit is never used. + 5670. { + 5671. struct softnet_data *sd = this_cpu_ptr(&softnet_data); + 5672. > unsigned long time_limit = jiffies + + 5673. usecs_to_jiffies(netdev_budget_usecs); + 5674. int budget = netdev_budget; + +net/wireless/nl80211.c:5673: error: DEAD_STORE + The value written to &data is never used. + 5671. static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info) + 5672. { + 5673. > char *data = NULL; + 5674. bool is_indoor; + 5675. enum nl80211_user_reg_hint_type user_reg_hint_type; + +drivers/net/ethernet/broadcom/tg3.c:5748: error: DEAD_STORE + The value written to ¤t_link_up is never used. + 5746. udelay(40); + 5747. + 5748. > current_link_up = false; + 5749. tp->link_config.rmt_adv = 0; + 5750. mac_status = tr32(MAC_STATUS); + +net/ipv6/addrconf.c:5751: error: DEAD_STORE + The value written to &ret is never used. + 5749. loff_t *ppos) + 5750. { + 5751. > int ret = 0; + 5752. int new_val; + 5753. struct inet6_dev *idev = (struct inet6_dev *)ctl->extra1; + +drivers/usb/core/hub.c:5768: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5764 could be null and is dereferenced at line 5768, column 9. + 5766. if (port1 < 1 || port1 > hdev->maxchild) + 5767. return NULL; + 5768. > return hub->ports[port1 - 1]->child; + 5769. } + 5770. EXPORT_SYMBOL_GPL(usb_hub_find_child); + +drivers/gpu/drm/i915/intel_dp.c:5786: error: DEAD_STORE + The value written to &downclock_mode is never used. + 5784. struct drm_device *dev = connector->dev; + 5785. struct drm_i915_private *dev_priv = to_i915(dev); + 5786. > struct drm_display_mode *downclock_mode = NULL; + 5787. + 5788. INIT_DELAYED_WORK(&dev_priv->drrs.work, intel_edp_drrs_downclock_work); + +kernel/sched/core.c:5845: error: DEAD_STORE + The value written to &ptr is never used. + 5843. + 5844. root_task_group.cfs_rq = (struct cfs_rq **)ptr; + 5845. > ptr += nr_cpu_ids * sizeof(void **); + 5846. + 5847. #endif /* CONFIG_FAIR_GROUP_SCHED */ + +security/selinux/hooks.c:5873: error: DEAD_STORE + The value written to &av is never used. + 5871. static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag) + 5872. { + 5873. > u32 av = 0; + 5874. + 5875. av = 0; + +kernel/cgroup/cgroup.c:5903: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5902 could be null and is dereferenced at line 5903, column 33. + 5901. + 5902. for_each_subsys(ss, ssid) + 5903. > ret += show_delegatable_files(ss->dfl_cftypes, buf + ret, + 5904. PAGE_SIZE - ret, + 5905. cgroup_subsys_name[ssid]); + +kernel/trace/trace.c:5947: error: DEAD_STORE + The value written to &r is never used. + 5945. int cpu = tracing_get_cpu(inode); + 5946. char buf[64]; + 5947. > int r = 0; + 5948. ssize_t ret; + 5949. + +security/selinux/hooks.c:6040: error: DEAD_STORE + The value written to &error is never used. + 6038. + 6039. /* Only allow single threaded processes to change context */ + 6040. > error = -EPERM; + 6041. if (!current_is_single_threaded()) { + 6042. error = security_bounded_transition(tsec->sid, sid); + +security/selinux/hooks.c:6124: error: DEAD_STORE + The value written to &len is never used. + 6122. static int selinux_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen) + 6123. { + 6124. > int len = 0; + 6125. len = selinux_inode_getsecurity(inode, XATTR_SELINUX_SUFFIX, + 6126. ctx, true); + +drivers/net/ethernet/broadcom/tg3.c:6180: error: DEAD_STORE + The value written to &correction is never used. + 6178. struct tg3 *tp = container_of(ptp, struct tg3, ptp_info); + 6179. bool neg_adj = false; + 6180. > u32 correction = 0; + 6181. + 6182. if (ppb < 0) { + +drivers/md/md.c:6208: error: DEAD_STORE + The value written to &file is never used. + 6206. static int get_bitmap_file(struct mddev *mddev, void __user * arg) + 6207. { + 6208. > mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */ + 6209. char *ptr; + 6210. int err; + +net/core/dev.c:6328: error: DEAD_STORE + The value written to &ret is never used. + 6326. .upper_info = upper_info, + 6327. }; + 6328. > int ret = 0; + 6329. + 6330. ASSERT_RTNL(); + +kernel/sched/core.c:6326: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6324 could be null and is dereferenced by call to `sched_offline_group()` at line 6326, column 2. + 6324. struct task_group *tg = css_tg(css); + 6325. + 6326. > sched_offline_group(tg); + 6327. } + 6328. + +drivers/net/ethernet/intel/e1000e/netdev.c:6429: error: DEAD_STORE + The value written to &retval is never used. + 6427. lpi_ctrl |= I82579_LPI_CTRL_1000_ENABLE; + 6428. + 6429. > retval = e1e_wphy_locked(hw, I82579_LPI_CTRL, + 6430. lpi_ctrl); + 6431. } + +net/wireless/nl80211.c:6350: error: DEAD_STORE + The value written to ®dom is never used. + 6348. struct netlink_callback *cb) + 6349. { + 6350. > const struct ieee80211_regdomain *regdom = NULL; + 6351. struct cfg80211_registered_device *rdev; + 6352. int err, reg_idx, start = cb->args[2]; + +kernel/sched/core.c:6412: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6410 could be null and is dereferenced at line 6412, column 15. + 6410. struct task_group *tg = css_tg(css); + 6411. + 6412. > return (u64) scale_load_down(tg->shares); + 6413. } + 6414. + +net/core/dev.c:6560: error: DEAD_STORE + The value written to &lower is never used. + 6558. int dev_get_nest_level(struct net_device *dev) + 6559. { + 6560. > struct net_device *lower = NULL; + 6561. struct list_head *iter; + 6562. int max_nest = -1; + +drivers/ata/libata-core.c:6685: error: DEAD_STORE + The value written to &tmp is never used. + 6683. int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits) + 6684. { + 6685. > unsigned long tmp = 0; + 6686. + 6687. switch (bits->width) { + +drivers/ata/libata-core.c:6747: error: DEAD_STORE + The value written to &rc is never used. + 6745. { + 6746. struct ata_host *host = pci_get_drvdata(pdev); + 6747. > int rc = 0; + 6748. + 6749. rc = ata_host_suspend(host, mesg); + +kernel/sched/core.c:6753: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6752 could be null and is dereferenced at line 6753, column 15. + 6751. { + 6752. struct task_group *tg = css_tg(css); + 6753. > u64 weight = scale_load_down(tg->shares); + 6754. + 6755. return DIV_ROUND_CLOSEST_ULL(weight * CGROUP_WEIGHT_DFL, 1024); + +kernel/events/core.c:6847: error: DEAD_STORE + The value written to &flags is never used. + 6845. int maj = 0, min = 0; + 6846. u64 ino = 0, gen = 0; + 6847. > u32 prot = 0, flags = 0; + 6848. unsigned int size; + 6849. char tmp[16]; + +drivers/ata/libata-core.c:7084: error: DEAD_STORE + The value written to &deadline is never used. + 7082. * eat away the timeout. + 7083. */ + 7084. > deadline = ata_deadline(jiffies, timeout); + 7085. + 7086. while ((tmp & mask) == val && time_before(jiffies, deadline)) { + +drivers/ata/libata-core.c:7108: error: DEAD_STORE + The value written to &lpm_timeout is never used. + 7106. bool sata_lpm_ignore_phy_events(struct ata_link *link) + 7107. { + 7108. > unsigned long lpm_timeout = link->last_lpm_change + + 7109. msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY); + 7110. + +kernel/events/core.c:7359: error: DEAD_STORE + The value written to &ret is never used. + 7357. { + 7358. int events = atomic_read(&event->event_limit); + 7359. > int ret = 0; + 7360. + 7361. /* + +drivers/gpu/drm/i915/intel_display.c:7425: error: DEAD_STORE + The value written to &offset is never used. + 7423. if (INTEL_GEN(dev_priv) >= 4) { + 7424. if (plane_config->tiling) + 7425. > offset = I915_READ(DSPTILEOFF(plane)); + 7426. else + 7427. offset = I915_READ(DSPLINOFF(plane)); + +drivers/gpu/drm/i915/intel_display.c:7427: error: DEAD_STORE + The value written to &offset is never used. + 7425. offset = I915_READ(DSPTILEOFF(plane)); + 7426. else + 7427. > offset = I915_READ(DSPLINOFF(plane)); + 7428. base = I915_READ(DSPSURF(plane)) & 0xfffff000; + 7429. } else { + +net/wireless/nl80211.c:7460: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7448 could be null and is dereferenced at line 7460, column 11. + 7458. */ + 7459. if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) { + 7460. > while (!sched_scan_req->reqid) + 7461. sched_scan_req->reqid = rdev->wiphy.cookie_counter++; + 7462. } + +net/wireless/nl80211.c:7464: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7448 could be null and is dereferenced by call to `rdev_sched_scan_start()` at line 7464, column 8. + 7462. } + 7463. + 7464. > err = rdev_sched_scan_start(rdev, dev, sched_scan_req); + 7465. if (err) + 7466. goto out_free; + +drivers/gpu/drm/i915/intel_display.c:7610: error: DEAD_STORE + The value written to &can_ssc is never used. + 7608. bool has_panel = false; + 7609. bool has_ck505 = false; + 7610. > bool can_ssc = false; + 7611. bool using_ssc_source = false; + 7612. + +drivers/gpu/drm/i915/intel_display.c:7609: error: DEAD_STORE + The value written to &has_ck505 is never used. + 7607. bool has_cpu_edp = false; + 7608. bool has_panel = false; + 7609. > bool has_ck505 = false; + 7610. bool can_ssc = false; + 7611. bool using_ssc_source = false; + +drivers/md/md.c:7713: error: DEAD_STORE + The value written to &l is never used. + 7711. } + 7712. spin_unlock(&all_mddevs_lock); + 7713. > if (!l--) + 7714. return (void*)2;/* tail */ + 7715. return NULL; + +drivers/gpu/drm/i915/intel_display.c:7776: error: DEAD_STORE + The value written to &timeout__ is never used. + 7774. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7775. + 7776. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7777. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7778. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7784: error: DEAD_STORE + The value written to &timeout__ is never used. + 7782. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7783. + 7784. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7785. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7786. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/net/ethernet/broadcom/tg3.c:7792: error: DEAD_STORE + The value written to &new_addr is never used. + 7790. struct tg3 *tp = tnapi->tp; + 7791. struct sk_buff *new_skb, *skb = *pskb; + 7792. > dma_addr_t new_addr = 0; + 7793. int ret = 0; + 7794. + +net/core/dev.c:7870: error: DEAD_STORE + The value written to &rebroadcast_time is never used. + 7868. linkwatch_forget_dev(dev); + 7869. + 7870. > rebroadcast_time = warning_time = jiffies; + 7871. refcnt = netdev_refcnt_read(dev); + 7872. + +net/core/dev.c:7908: error: DEAD_STORE + The value written to &warning_time is never used. + 7906. pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n", + 7907. dev->name, refcnt); + 7908. > warning_time = jiffies; + 7909. } + 7910. } + +drivers/net/ethernet/broadcom/tg3.c:8145: error: DEAD_STORE + The value written to &i is never used. + 8143. + 8144. dma_error: + 8145. > tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, --i); + 8146. tnapi->tx_buffers[tnapi->tx_prod].skb = NULL; + 8147. drop: + +kernel/events/core.c:8243: error: DEAD_STORE + The value written to &mm is never used. + 8241. struct task_struct *task = READ_ONCE(event->ctx->task); + 8242. struct perf_addr_filter *filter; + 8243. > struct mm_struct *mm = NULL; + 8244. unsigned int count = 0; + 8245. unsigned long flags; + +net/wireless/nl80211.c:8262: error: DEAD_STORE + The value written to &ssid_len is never used. + 8260. struct cfg80211_assoc_request req = {}; + 8261. const u8 *bssid, *ssid; + 8262. > int err, ssid_len = 0; + 8263. + 8264. if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) + +kernel/trace/trace.c:8300: error: DEAD_STORE + The value written to &ret is never used. + 8298. { + 8299. char *kbuf, *buf, *tmp; + 8300. > int ret = 0; + 8301. size_t done = 0; + 8302. size_t size; + +net/core/dev.c:8396: error: DEAD_STORE + The value written to &err is never used. + 8394. + 8395. /* And unlink it from device chain */ + 8396. > err = -ENODEV; + 8397. unlist_netdevice(dev); + 8398. + +drivers/gpu/drm/i915/intel_display.c:8385: error: DEAD_STORE + The value written to &ps_ctrl is never used. + 8383. struct drm_i915_private *dev_priv = to_i915(dev); + 8384. struct intel_crtc_scaler_state *scaler_state = &pipe_config->scaler_state; + 8385. > uint32_t ps_ctrl = 0; + 8386. int id = -1; + 8387. int i; + +drivers/gpu/drm/i915/intel_display.c:8471: error: DEAD_STORE + The value written to &offset is never used. + 8469. plane_config->base = base; + 8470. + 8471. > offset = I915_READ(PLANE_OFFSET(pipe, 0)); + 8472. + 8473. val = I915_READ(PLANE_SIZE(pipe, 0)); + +net/core/dev.c:8469: error: DEAD_STORE + The value written to &remsd is never used. + 8467. struct sk_buff *skb; + 8468. unsigned int cpu; + 8469. > struct softnet_data *sd, *oldsd, *remsd = NULL; + 8470. + 8471. local_irq_disable(); + +drivers/gpu/drm/i915/intel_display.c:8561: error: DEAD_STORE + The value written to &offset is never used. + 8559. base = I915_READ(DSPSURF(pipe)) & 0xfffff000; + 8560. if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) { + 8561. > offset = I915_READ(DSPOFFSET(pipe)); + 8562. } else { + 8563. if (plane_config->tiling) + +drivers/gpu/drm/i915/intel_display.c:8564: error: DEAD_STORE + The value written to &offset is never used. + 8562. } else { + 8563. if (plane_config->tiling) + 8564. > offset = I915_READ(DSPTILEOFF(pipe)); + 8565. else + 8566. offset = I915_READ(DSPLINOFF(pipe)); + +drivers/gpu/drm/i915/intel_display.c:8566: error: DEAD_STORE + The value written to &offset is never used. + 8564. offset = I915_READ(DSPTILEOFF(pipe)); + 8565. else + 8566. > offset = I915_READ(DSPLINOFF(pipe)); + 8567. } + 8568. plane_config->base = base; + +drivers/gpu/drm/i915/intel_display.c:8764: error: DEAD_STORE + The value written to &timeout__ is never used. + 8762. I915_WRITE(LCPLL_CTL, val); + 8763. + 8764. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8765. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8766. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8783: error: DEAD_STORE + The value written to &timeout__ is never used. + 8781. ndelay(100); + 8782. + 8783. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8784. 1)) + 8785. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +kernel/sched/fair.c:8763: error: DEAD_STORE + The value written to &curr_cost is never used. + 8761. struct sched_domain *sd; + 8762. int pulled_task = 0; + 8763. > u64 curr_cost = 0; + 8764. + 8765. /* + +kernel/sched/fair.c:8759: error: DEAD_STORE + The value written to &next_balance is never used. + 8757. static int idle_balance(struct rq *this_rq, struct rq_flags *rf) + 8758. { + 8759. > unsigned long next_balance = jiffies + HZ; + 8760. int this_cpu = this_rq->cpu; + 8761. struct sched_domain *sd; + +kernel/sched/fair.c:8762: error: DEAD_STORE + The value written to &pulled_task is never used. + 8760. int this_cpu = this_rq->cpu; + 8761. struct sched_domain *sd; + 8762. > int pulled_task = 0; + 8763. u64 curr_cost = 0; + 8764. + +drivers/gpu/drm/i915/intel_display.c:8840: error: DEAD_STORE + The value written to &timeout__ is never used. + 8838. I915_WRITE(LCPLL_CTL, val); + 8839. + 8840. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8841. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8842. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/md/md.c:9103: error: DEAD_STORE + The value written to &ret is never used. + 9101. if (rdev2->raid_disk == -1 && role != 0xffff) { + 9102. rdev2->saved_raid_disk = role; + 9103. > ret = remove_and_add_spares(mddev, rdev2); + 9104. pr_info("Activated spare: %s\n", + 9105. bdevname(rdev2->bdev,b)); + +kernel/sched/fair.c:9112: error: DEAD_STORE + The value written to &continue_balancing is never used. + 9110. static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle) + 9111. { + 9112. > int continue_balancing = 1; + 9113. int cpu = rq->cpu; + 9114. unsigned long interval; + +drivers/gpu/drm/i915/intel_display.c:9248: error: NULL_DEREFERENCE + pointer `obj` last assigned on line 9244 could be null and is dereferenced at line 9248, column 10. + 9246. + 9247. if (INTEL_INFO(dev_priv)->cursor_needs_physical) + 9248. > base = obj->phys_handle->busaddr; + 9249. else + 9250. base = intel_plane_ggtt_offset(plane_state); + +kernel/sched/fair.c:9294: error: DEAD_STORE + The value written to &kick is never used. + 9292. struct sched_domain *sd; + 9293. int nr_busy, i, cpu = rq->cpu; + 9294. > bool kick = false; + 9295. + 9296. if (unlikely(rq->idle_balance)) + +kernel/sched/fair.c:9290: error: DEAD_STORE + The value written to &now is never used. + 9288. static inline bool nohz_kick_needed(struct rq *rq) + 9289. { + 9290. > unsigned long now = jiffies; + 9291. struct sched_domain_shared *sds; + 9292. struct sched_domain *sd; + +drivers/gpu/drm/i915/intel_pm.c:9327: error: DEAD_STORE + The value written to &timeout__ is never used. + 9325. goto out; + 9326. } + 9327. > ret = _wait_for(COND, timeout_base_ms * 1000, 10); + 9328. if (!ret) + 9329. goto out; + +kernel/events/core.c:9495: error: DEAD_STORE + The value written to &pmu is never used. + 9493. perf_event__state_init(event); + 9494. + 9495. > pmu = NULL; + 9496. + 9497. hwc = &event->hw; + +drivers/gpu/drm/i915/intel_pm.c:9460: error: DEAD_STORE + The value written to &loop is never used. + 9458. _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH)); + 9459. upper = I915_READ_FW(reg); + 9460. > } while (upper != tmp && --loop); + 9461. + 9462. /* Everywhere else we always use VLV_COUNTER_CONTROL with the + +drivers/gpu/drm/i915/intel_display.c:9992: error: DEAD_STORE + The value written to &restore_state is never used. + 9990. if (restore_state) { + 9991. drm_atomic_state_put(restore_state); + 9992. > restore_state = NULL; + 9993. } + 9994. + +drivers/gpu/drm/i915/intel_display.c:9988: error: DEAD_STORE + The value written to &state is never used. + 9986. if (state) { + 9987. drm_atomic_state_put(state); + 9988. > state = NULL; + 9989. } + 9990. if (restore_state) { + +kernel/events/core.c:10518: error: DEAD_STORE + The value written to &clone_ctx is never used. + 10516. static void perf_event_exit_task_context(struct task_struct *child, int ctxn) + 10517. { + 10518. > struct perf_event_context *child_ctx, *clone_ctx = NULL; + 10519. struct perf_event *child_event, *next; + 10520. + +drivers/net/ethernet/broadcom/tg3.c:10770: error: DEAD_STORE + The value written to &off is never used. + 10768. + 10769. tg3_ape_scratchpad_read(tp, (u32 *) ocir, off, len); + 10770. > off += len; + 10771. + 10772. if (ocir->signature != TG3_OCIR_SIG_MAGIC || + +net/wireless/nl80211.c:11284: error: DEAD_STORE + The value written to &err is never used. + 11282. struct sk_buff *msg = NULL; + 11283. void *hdr = NULL; + 11284. > int err = 0; + 11285. + 11286. if (wdev->iftype != NL80211_IFTYPE_NAN) + +drivers/gpu/drm/i915/intel_display.c:11920: error: DEAD_STORE + The value written to &ret is never used. + 11918. struct drm_crtc *crtc; + 11919. struct drm_crtc_state *old_crtc_state, *new_crtc_state; + 11920. > int ret = 0, i; + 11921. + 11922. if (!check_digital_port_conflicts(state)) { + +drivers/net/ethernet/broadcom/tg3.c:12186: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 12185 could be null and is dereferenced by call to `phy_ethtool_ksettings_set()` at line 12186, column 10. + 12184. return -EAGAIN; + 12185. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 12186. > return phy_ethtool_ksettings_set(phydev, cmd); + 12187. } + 12188. + +drivers/gpu/drm/i915/intel_display.c:12487: error: DEAD_STORE + The value written to &ret is never used. + 12485. struct intel_atomic_state *intel_state = to_intel_atomic_state(state); + 12486. struct drm_i915_private *dev_priv = to_i915(dev); + 12487. > int ret = 0; + 12488. + 12489. drm_atomic_state_get(state); + +drivers/net/ethernet/broadcom/tg3.c:12855: error: DEAD_STORE + The value written to &err is never used. + 12853. u32 csum, magic, len; + 12854. __be32 *buf; + 12855. > int i, j, k, err = 0, size; + 12856. + 12857. if (tg3_flag(tp, NO_NVRAM)) + +drivers/gpu/drm/i915/intel_display.c:13167: error: DEAD_STORE + The value written to &primary is never used. + 13165. intel_primary_plane_create(struct drm_i915_private *dev_priv, enum pipe pipe) + 13166. { + 13167. > struct intel_plane *primary = NULL; + 13168. struct intel_plane_state *state = NULL; + 13169. const uint32_t *intel_primary_formats; + +drivers/gpu/drm/i915/intel_display.c:13304: error: DEAD_STORE + The value written to &cursor is never used. + 13302. enum pipe pipe) + 13303. { + 13304. > struct intel_plane *cursor = NULL; + 13305. struct intel_plane_state *state = NULL; + 13306. int ret; + +drivers/gpu/drm/i915/intel_display.c:13402: error: DEAD_STORE + The value written to &crtc_state is never used. + 13400. { + 13401. struct intel_crtc *intel_crtc; + 13402. > struct intel_crtc_state *crtc_state = NULL; + 13403. struct intel_plane *primary = NULL; + 13404. struct intel_plane *cursor = NULL; + +drivers/gpu/drm/i915/intel_display.c:13404: error: DEAD_STORE + The value written to &cursor is never used. + 13402. struct intel_crtc_state *crtc_state = NULL; + 13403. struct intel_plane *primary = NULL; + 13404. > struct intel_plane *cursor = NULL; + 13405. int sprite, ret; + 13406. + +drivers/gpu/drm/i915/intel_display.c:13403: error: DEAD_STORE + The value written to &primary is never used. + 13401. struct intel_crtc *intel_crtc; + 13402. struct intel_crtc_state *crtc_state = NULL; + 13403. > struct intel_plane *primary = NULL; + 13404. struct intel_plane *cursor = NULL; + 13405. int sprite, ret; + +drivers/gpu/drm/i915/intel_display.c:13606: error: DEAD_STORE + The value written to &dpd_is_edp is never used. + 13604. { + 13605. struct intel_encoder *encoder; + 13606. > bool dpd_is_edp = false; + 13607. + 13608. intel_pps_init(dev_priv); + +drivers/net/ethernet/broadcom/tg3.c:15583: error: DEAD_STORE + The value written to &i is never used. + 15581. unsigned int block_end, rosize, len; + 15582. u32 vpdlen; + 15583. > int j, i = 0; + 15584. + 15585. vpd_data = (u8 *)tg3_vpd_readblock(tp, &vpdlen); + +Summary of the reports + + DEAD_STORE: 2009 + NULL_DEREFERENCE: 184 + QUANDARY_TAINT_ERROR: 8 + RESOURCE_LEAK: 7 + MEMORY_LEAK: 2 \ No newline at end of file diff --git a/infer/results/v415/infer0131/defconfig/inferconfig b/infer/results/v415/infer0131/defconfig/inferconfig new file mode 100644 index 0000000..c603e2d --- /dev/null +++ b/infer/results/v415/infer0131/defconfig/inferconfig @@ -0,0 +1 @@ +{"skip-analysis-in-path": ["linux/arch/x86/entry/vdso", "linux/arch/x86/kernel", "linux/arch/x86/mm", "linux/arch/x86/boot", "linux/drivers/acpi", "linux/fs", "linux/kernel/bpf", "linux/mm", "linux/net/mac80211"]} diff --git a/infer/results/v415/infer0150/defconfig/bugs.txt b/infer/results/v415/infer0150/defconfig/bugs.txt new file mode 100644 index 0000000..7482984 --- /dev/null +++ b/infer/results/v415/infer0150/defconfig/bugs.txt @@ -0,0 +1,45840 @@ +Found 5729 issues + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +drivers/scsi/scsi_debugfs.c:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. struct scsi_cmnd *cmd = container_of(scsi_req(rq), typeof(*cmd), req); + 10. int msecs = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc); + 11. > const u8 *const cdb = READ_ONCE(cmd->cmnd); + 12. char buf[80] = "(?)"; + 13. + +include/linux/netfilter_ingress.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. return false; + 14. #endif + 15. > return rcu_access_pointer(skb->dev->nf_hooks_ingress); + 16. } + 17. + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/sock.h:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(sock_rcvqueue_full, + 12. + 13. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/sock.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(sock_rcvqueue_full, + 12. + 13. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/sock.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(sock_rcvqueue_full, + 12. + 13. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +arch/x86/include/asm/current.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. static __always_inline struct task_struct *get_current(void) + 14. { + 15. > return this_cpu_read_stable(current_task); + 16. } + 17. + +block/blk-lib.c:19: error: NULL_DEREFERENCE + pointer `new` last assigned on line 16 could be null and is dereferenced by call to `bio_chain()` at line 19, column 3. + 17. + 18. if (bio) { + 19. > bio_chain(bio, new); + 20. submit_bio(bio); + 21. } + +block/ioctl.c:146: error: UNINITIALIZED_VALUE + The value read from p.length was never initialized. + 144. disk_part_iter_exit(&piter); + 145. part_nr_sects_write(part, (sector_t)length); + 146. > i_size_write(bdevp->bd_inode, p.length); + 147. mutex_unlock(&bdevp->bd_mutex); + 148. mutex_unlock(&bdev->bd_mutex); + +block/ioctl.c:33: error: UNINITIALIZED_VALUE + The value read from p.pno was never initialized. + 31. if (bdev != bdev->bd_contains) + 32. return -EINVAL; + 33. > partno = p.pno; + 34. if (partno <= 0) + 35. return -EINVAL; + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +net/ipv4/tcp_fastopen.c:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. + 18. rcu_read_lock(); + 19. > ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx); + 20. if (ctxt) { + 21. rcu_read_unlock(); + +tools/include/asm-generic/bitops/fls.h:36: error: DEAD_STORE + The value written to &x (type int) is never used. + 34. } + 35. if (!(x & 0x80000000u)) { + 36. > x <<= 1; + 37. r -= 1; + 38. } + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +block/blk-merge.c:50: error: DEAD_STORE + The value written to &tmp (type unsigned long) is never used. + 48. + 49. tmp = bio->bi_iter.bi_sector + split_sectors - alignment; + 50. > tmp = sector_div(tmp, granularity); + 51. + 52. if (split_sectors > tmp) + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +kernel/sched/stats.c:46: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 44. /* domain-specific stats */ + 45. rcu_read_lock(); + 46. > for_each_domain(cpu, sd) { + 47. enum cpu_idle_type itype; + 48. + +net/core/net-procfs.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. + 23. h = &net->dev_name_head[get_bucket(*pos)]; + 24. > hlist_for_each_entry_rcu(dev, h, name_hlist) { + 25. if (++count == offset) + 26. return dev; + +tools/lib/subcmd/help.c:20: error: NULL_DEREFERENCE + pointer `ent` last assigned on line 18 could be null and is dereferenced at line 20, column 2. + 18. struct cmdname *ent = malloc(sizeof(*ent) + len + 1); + 19. + 20. > ent->len = len; + 21. memcpy(ent->name, name, len); + 22. ent->name[len] = 0; + +arch/x86/include/asm/irq_regs.h:19: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 17. static inline struct pt_regs *get_irq_regs(void) + 18. { + 19. > return this_cpu_read(irq_regs); + 20. } + 21. + +arch/x86/include/asm/irq_regs.h:19: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 17. static inline struct pt_regs *get_irq_regs(void) + 18. { + 19. > return this_cpu_read(irq_regs); + 20. } + 21. + +drivers/input/input-compat.c:30: error: UNINITIALIZED_VALUE + The value read from compat_event.code was never initialized. + 28. event->time.tv_usec = compat_event.time.tv_usec; + 29. event->type = compat_event.type; + 30. > event->code = compat_event.code; + 31. event->value = compat_event.value; + 32. + +drivers/input/input-compat.c:29: error: UNINITIALIZED_VALUE + The value read from compat_event.type was never initialized. + 27. event->time.tv_sec = compat_event.time.tv_sec; + 28. event->time.tv_usec = compat_event.time.tv_usec; + 29. > event->type = compat_event.type; + 30. event->code = compat_event.code; + 31. event->value = compat_event.value; + +drivers/input/input-compat.c:31: error: UNINITIALIZED_VALUE + The value read from compat_event.value was never initialized. + 29. event->type = compat_event.type; + 30. event->code = compat_event.code; + 31. > event->value = compat_event.value; + 32. + 33. } else { + +lib/list_sort.c:27: error: MEMORY_LEAK + `tail->next` is not reachable after line 27, column 4. + 25. /* if equal, take 'a' -- important for sort stability */ + 26. if ((*cmp)(priv, a, b) <= 0) { + 27. > tail->next = a; + 28. a = a->next; + 29. } else { + +lib/list_sort.c:30: error: MEMORY_LEAK + `tail->next` is not reachable after line 30, column 4. + 28. a = a->next; + 29. } else { + 30. > tail->next = b; + 31. b = b->next; + 32. } + +lib/list_sort.c:35: error: MEMORY_LEAK + `tail->next` is not reachable after line 35, column 2. + 33. tail = tail->next; + 34. } + 35. > tail->next = a?:b; + 36. return head.next; + 37. } + +lib/list_sort.c:36: error: UNINITIALIZED_VALUE + The value read from head.next was never initialized. + 34. } + 35. tail->next = a?:b; + 36. > return head.next; + 37. } + 38. + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +lib/dynamic_queue_limits.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. bool all_prev_completed; + 23. + 24. > num_queued = READ_ONCE(dql->num_queued); + 25. + 26. /* Can't complete more than what's in queue */ + +include/linux/netfilter_ingress.h:21: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 19. static inline int nf_hook_ingress(struct sk_buff *skb) + 20. { + 21. > struct nf_hook_entries *e = rcu_dereference(skb->dev->nf_hooks_ingress); + 22. struct nf_hook_state state; + 23. int ret; + +lib/is_single_threaded.c:34: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 32. ret = false; + 33. rcu_read_lock(); + 34. > for_each_process(p) { + 35. if (unlikely(p->flags & PF_KTHREAD)) + 36. continue; + +lib/is_single_threaded.c:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. continue; + 39. + 40. > for_each_thread(p, t) { + 41. if (unlikely(t->mm == mm)) + 42. goto found; + +sound/hda/trace.h:19: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +arch/x86/include/asm/atomic64_64.h:22: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 20. static inline long atomic64_read(const atomic64_t *v) + 21. { + 22. > return READ_ONCE((v)->counter); + 23. } + 24. + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +net/ipv4/tcp_ulp.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. struct tcp_ulp_ops *e; + 23. + 24. > list_for_each_entry_rcu(e, &tcp_ulp_list, list) { + 25. if (strcmp(e->name, name) == 0) + 26. return e; + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +block/noop-iosched.c:26: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 24. struct request *rq; + 25. + 26. > rq = list_first_entry_or_null(&nd->queue, struct request, queuelist); + 27. if (rq) { + 28. list_del_init(&rq->queuelist); + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +drivers/tty/tty_port.c:30: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 28. struct tty_ldisc *disc; + 29. + 30. > tty = READ_ONCE(port->itty); + 31. if (!tty) + 32. return 0; + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +lib/assoc_array.c:109: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr const *) is never used. + 107. shortcut = assoc_array_ptr_to_shortcut(parent); + 108. smp_read_barrier_depends(); + 109. > cursor = parent; + 110. parent = READ_ONCE(shortcut->back_pointer); + 111. slot = shortcut->parent_slot; + +lib/assoc_array.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. shortcut = assoc_array_ptr_to_shortcut(cursor); + 41. smp_read_barrier_depends(); + 42. > cursor = READ_ONCE(shortcut->next_node); + 43. } + 44. + +lib/assoc_array.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. has_meta = 0; + 57. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 58. > ptr = READ_ONCE(node->slots[slot]); + 59. has_meta |= (unsigned long)ptr; + 60. if (ptr && assoc_array_ptr_is_leaf(ptr)) { + +lib/assoc_array.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. + 91. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 92. > ptr = READ_ONCE(node->slots[slot]); + 93. if (assoc_array_ptr_is_meta(ptr)) { + 94. cursor = ptr; + +lib/assoc_array.c:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. finished_node: + 100. /* Move up to the parent (may need to skip back over a shortcut) */ + 101. > parent = READ_ONCE(node->back_pointer); + 102. slot = node->parent_slot; + 103. if (parent == stop) + +lib/assoc_array.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. smp_read_barrier_depends(); + 109. cursor = parent; + 110. > parent = READ_ONCE(shortcut->back_pointer); + 111. slot = shortcut->parent_slot; + 112. if (parent == stop) + +net/ipv4/tcp_cong.c:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. struct tcp_congestion_ops *e; + 26. + 27. > list_for_each_entry_rcu(e, &tcp_cong_list, list) { + 28. if (strcmp(e->name, name) == 0) + 29. return e; + +net/ipv6/ip6_offload.c:32: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 30. + 31. if (proto != NEXTHDR_HOP) { + 32. > ops = rcu_dereference(inet6_offloads[proto]); + 33. + 34. if (unlikely(!ops)) + +net/netfilter/nf_conntrack_extend.c:30: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 28. for (i = 0; i < NF_CT_EXT_NUM; i++) { + 29. rcu_read_lock(); + 30. > t = rcu_dereference(nf_ct_ext_types[i]); + 31. + 32. /* Here the nf_ct_ext_type might have been unregisterd. + +tools/include/tools/be_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val >> 8; + 26. > *p++ = val; + 27. } + 28. + +tools/include/tools/le_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val; + 26. > *p++ = val >> 8; + 27. } + 28. + +drivers/dma-buf/seqno-fence.c:28: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 26 could be null and is dereferenced at line 28, column 9. + 26. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 27. + 28. > return seqno_fence->ops->get_driver_name(fence); + 29. } + 30. + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +arch/x86/include/asm/atomic.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. static __always_inline int atomic_read(const atomic_t *v) + 26. { + 27. > return READ_ONCE((v)->counter); + 28. } + 29. + +arch/x86/include/asm/preempt.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. + 30. do { + 31. > old = raw_cpu_read_4(__preempt_count); + 32. new = (old & PREEMPT_NEED_RESCHED) | + 33. (pc & ~PREEMPT_NEED_RESCHED); + +security/selinux/ss/conditional.c:80: error: UNINITIALIZED_VALUE + The value read from s[_] was never initialized. + 78. } + 79. } + 80. > return s[0]; + 81. } + 82. + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/pci/proc.c:100: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 98. pci_user_read_config_byte(dev, pos, &val); + 99. __put_user(val, buf); + 100. > buf++; + 101. pos++; + 102. cnt--; + +drivers/pci/proc.c:102: error: DEAD_STORE + The value written to &cnt (type unsigned int) is never used. + 100. buf++; + 101. pos++; + 102. > cnt--; + 103. } + 104. + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +kernel/task_work.c:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. + 32. do { + 33. > head = READ_ONCE(task->task_works); + 34. if (unlikely(head == &work_exited)) + 35. return -ESRCH; + +kernel/time/tick-oneshot.c:29: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 27. int tick_program_event(ktime_t expires, int force) + 28. { + 29. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 30. + 31. if (unlikely(expires == KTIME_MAX)) { + +kernel/time/tick-oneshot.c:29: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 27. int tick_program_event(ktime_t expires, int force) + 28. { + 29. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 30. + 31. if (unlikely(expires == KTIME_MAX)) { + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +include/net/netfilter/nf_conntrack_timeout.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. struct ctnl_timeout *timeout; + 32. + 33. > timeout = rcu_dereference(t->timeout); + 34. if (timeout == NULL) + 35. return NULL; + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +lib/ratelimit.c:42: error: DEAD_STORE + The value written to &flags (type unsigned long) is never used. + 40. * the entity that is holding the lock already: + 41. */ + 42. > if (!raw_spin_trylock_irqsave(&rs->lock, flags)) + 43. return 0; + 44. + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +block/partitions/amiga.c:36: error: DEAD_STORE + The value written to &blksize (type int) is never used. + 34. struct PartitionBlock *pb; + 35. int start_sect, nr_sects, blk, part, res = 0; + 36. > int blksize = 1; /* Multiplier for disk block size */ + 37. int slot = 1; + 38. char b[BDEVNAME_SIZE]; + +block/partitions/amiga.c:123: error: UNINITIALIZED_VALUE + The value read from dostype[_] was never initialized. + 121. *dt = pb->pb_Environment[16]; + 122. if (dostype[3] < ' ') + 123. > snprintf(tmp, sizeof(tmp), " (%c%c%c^%c)", + 124. dostype[0], dostype[1], + 125. dostype[2], dostype[3] + '@' ); + +block/partitions/amiga.c:127: error: UNINITIALIZED_VALUE + The value read from dostype[_] was never initialized. + 125. dostype[2], dostype[3] + '@' ); + 126. else + 127. > snprintf(tmp, sizeof(tmp), " (%c%c%c%c)", + 128. dostype[0], dostype[1], + 129. dostype[2], dostype[3]); + +drivers/pci/setup-res.c:121: error: UNINITIALIZED_VALUE + The value read from cmd was never initialized. + 119. + 120. if (disable) + 121. > pci_write_config_word(dev, PCI_COMMAND, cmd); + 122. } + 123. + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +kernel/irq_work.c:40: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 38. for (;;) { + 39. nflags = flags | IRQ_WORK_FLAGS; + 40. > oflags = cmpxchg(&work->flags, flags, nflags); + 41. if (oflags == flags) + 42. break; + +net/core/fib_notifier.c:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. for_each_net(net) { + 37. rcu_read_lock(); + 38. > list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) { + 39. if (!try_module_get(ops->owner)) + 40. continue; + +tools/lib/subcmd/run-command.c:96: error: UNINITIALIZED_VALUE + The value read from fderr[_] was never initialized. + 94. dup_devnull(2); + 95. else if (need_err) { + 96. > dup2(fderr[1], 2); + 97. close_pair(fderr); + 98. } + +tools/lib/subcmd/run-command.c:161: error: UNINITIALIZED_VALUE + The value read from fderr[_] was never initialized. + 159. + 160. if (need_err) + 161. > close(fderr[1]); + 162. + 163. return 0; + +tools/lib/subcmd/run-command.c:86: error: UNINITIALIZED_VALUE + The value read from fdin[_] was never initialized. + 84. dup_devnull(0); + 85. else if (need_in) { + 86. > dup2(fdin[0], 0); + 87. close_pair(fdin); + 88. } else if (cmd->in) { + +tools/lib/subcmd/run-command.c:151: error: UNINITIALIZED_VALUE + The value read from fdin[_] was never initialized. + 149. + 150. if (need_in) + 151. > close(fdin[0]); + 152. else if (cmd->in) + 153. close(cmd->in); + +tools/lib/subcmd/run-command.c:105: error: UNINITIALIZED_VALUE + The value read from fdout[_] was never initialized. + 103. dup2(2, 1); + 104. else if (need_out) { + 105. > dup2(fdout[1], 1); + 106. close_pair(fdout); + 107. } else if (cmd->out > 1) { + +tools/lib/subcmd/run-command.c:156: error: UNINITIALIZED_VALUE + The value read from fdout[_] was never initialized. + 154. + 155. if (need_out) + 156. > close(fdout[1]); + 157. else if (cmd->out) + 158. close(cmd->out); + +kernel/locking/qrwlock.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. * without waiting in the queue. + 41. */ + 42. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 43. return; + 44. } + +kernel/locking/qrwlock.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. * section in the case that the lock is currently held for write. + 57. */ + 58. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 59. + 60. /* + +lib/zlib_inflate/inffast.c:38: error: UNINITIALIZED_VALUE + The value read from mm.us was never initialized. + 36. mm.b[0] = b[0]; + 37. mm.b[1] = b[1]; + 38. > return mm.us; + 39. } + 40. + +net/core/stream.c:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. + 38. rcu_read_lock(); + 39. > wq = rcu_dereference(sk->sk_wq); + 40. if (skwq_has_sleeper(wq)) + 41. wake_up_interruptible_poll(&wq->wait, POLLOUT | + +tools/objtool/warn.h:48: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 48, column 3. + 46. + 47. if (func) + 48. > sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. sprintf(str, "%s+0x%lx", name, name_off); + +tools/objtool/warn.h:50: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 50, column 3. + 48. sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. > sprintf(str, "%s+0x%lx", name, name_off); + 51. + 52. return str; + +drivers/dma-buf/seqno-fence.c:35: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 33 could be null and is dereferenced at line 35, column 9. + 33. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 34. + 35. > return seqno_fence->ops->get_timeline_name(fence); + 36. } + 37. + +drivers/edac/edac_pci.c:40: error: DEAD_STORE + The value written to &pci (type edac_pci_ctl_info*) is never used. + 38. edac_dbg(1, "\n"); + 39. + 40. > pci = edac_align_ptr(&p, sizeof(*pci), 1); + 41. pvt = edac_align_ptr(&p, 1, sz_pvt); + 42. size = ((unsigned long)pvt) + sz_pvt; + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +kernel/power/process.c:44: error: DEAD_STORE + The value written to &end_time (type unsigned long) is never used. + 42. start = ktime_get_boottime(); + 43. + 44. > end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs); + 45. + 46. if (!user_only) + +kernel/power/process.c:40: error: DEAD_STORE + The value written to &sleep_usecs (type int) is never used. + 38. unsigned int elapsed_msecs; + 39. bool wakeup = false; + 40. > int sleep_usecs = USEC_PER_MSEC; + 41. + 42. start = ktime_get_boottime(); + +kernel/power/process.c:81: error: DEAD_STORE + The value written to &sleep_usecs (type int) is never used. + 79. usleep_range(sleep_usecs / 2, sleep_usecs); + 80. if (sleep_usecs < 8 * USEC_PER_MSEC) + 81. > sleep_usecs *= 2; + 82. } + 83. + +kernel/power/process.c:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. todo = 0; + 51. read_lock(&tasklist_lock); + 52. > for_each_process_thread(g, p) { + 53. if (p == current || !freeze_task(p)) + 54. continue; + +kernel/power/process.c:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. if (!wakeup) { + 100. read_lock(&tasklist_lock); + 101. > for_each_process_thread(g, p) { + 102. if (p != current && !freezer_should_skip(p) + 103. && freezing(p) && !frozen(p)) + +kernel/tsacct.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. stats->ac_pid = task_pid_nr_ns(tsk, pid_ns); + 63. rcu_read_lock(); + 64. > tcred = __task_cred(tsk); + 65. stats->ac_uid = from_kuid_munged(user_ns, tcred->uid); + 66. stats->ac_gid = from_kgid_munged(user_ns, tcred->gid); + +kernel/tsacct.c:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. stats->ac_gid = from_kgid_munged(user_ns, tcred->gid); + 67. stats->ac_ppid = pid_alive(tsk) ? + 68. > task_tgid_nr_ns(rcu_dereference(tsk->real_parent), pid_ns) : 0; + 69. rcu_read_unlock(); + 70. + +net/ipv6/inet6_connection_sock.c:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. fl6->daddr = ireq->ir_v6_rmt_addr; + 44. rcu_read_lock(); + 45. > final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final); + 46. rcu_read_unlock(); + 47. fl6->saddr = ireq->ir_v6_loc_addr; + +sound/hda/trace.h:31: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +net/netfilter/nf_queue.c:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. { + 34. /* should never happen, we only have one queueing backend in kernel */ + 35. > WARN_ON(rcu_access_pointer(net->nf.queue_handler)); + 36. rcu_assign_pointer(net->nf.queue_handler, qh); + 37. } + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +include/linux/netfilter_ipv6.h:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. static inline const struct nf_ipv6_ops *nf_get_ipv6_ops(void) + 34. { + 35. > return rcu_dereference(nf_ipv6_ops); + 36. } + 37. + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/sock.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. ); + 32. + 33. > TRACE_EVENT(sock_exceed_buf_limit, + 34. + 35. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/sock.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. ); + 32. + 33. > TRACE_EVENT(sock_exceed_buf_limit, + 34. + 35. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/sock.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. ); + 32. + 33. > TRACE_EVENT(sock_exceed_buf_limit, + 34. + 35. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +kernel/compat.c:57: error: UNINITIALIZED_VALUE + The value read from tx32.calcnt was never initialized. + 55. txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + 57. > txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + 59. txc->stbcnt = tx32.stbcnt; + +kernel/compat.c:46: error: UNINITIALIZED_VALUE + The value read from tx32.constant was never initialized. + 44. txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + 46. > txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + 48. txc->tolerance = tx32.tolerance; + +kernel/compat.c:58: error: UNINITIALIZED_VALUE + The value read from tx32.errcnt was never initialized. + 56. txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + 58. > txc->errcnt = tx32.errcnt; + 59. txc->stbcnt = tx32.stbcnt; + 60. + +kernel/compat.c:44: error: UNINITIALIZED_VALUE + The value read from tx32.esterror was never initialized. + 42. txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + 44. > txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + 46. txc->constant = tx32.constant; + +kernel/compat.c:42: error: UNINITIALIZED_VALUE + The value read from tx32.freq was never initialized. + 40. txc->modes = tx32.modes; + 41. txc->offset = tx32.offset; + 42. > txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + +kernel/compat.c:56: error: UNINITIALIZED_VALUE + The value read from tx32.jitcnt was never initialized. + 54. txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + 56. > txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + +kernel/compat.c:53: error: UNINITIALIZED_VALUE + The value read from tx32.jitter was never initialized. + 51. txc->tick = tx32.tick; + 52. txc->ppsfreq = tx32.ppsfreq; + 53. > txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + +kernel/compat.c:43: error: UNINITIALIZED_VALUE + The value read from tx32.maxerror was never initialized. + 41. txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + 43. > txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + +kernel/compat.c:40: error: UNINITIALIZED_VALUE + The value read from tx32.modes was never initialized. + 38. return -EFAULT; + 39. + 40. > txc->modes = tx32.modes; + 41. txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + +kernel/compat.c:41: error: UNINITIALIZED_VALUE + The value read from tx32.offset was never initialized. + 39. + 40. txc->modes = tx32.modes; + 41. > txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + +kernel/compat.c:52: error: UNINITIALIZED_VALUE + The value read from tx32.ppsfreq was never initialized. + 50. txc->time.tv_usec = tx32.time.tv_usec; + 51. txc->tick = tx32.tick; + 52. > txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + +kernel/compat.c:47: error: UNINITIALIZED_VALUE + The value read from tx32.precision was never initialized. + 45. txc->status = tx32.status; + 46. txc->constant = tx32.constant; + 47. > txc->precision = tx32.precision; + 48. txc->tolerance = tx32.tolerance; + 49. txc->time.tv_sec = tx32.time.tv_sec; + +kernel/compat.c:54: error: UNINITIALIZED_VALUE + The value read from tx32.shift was never initialized. + 52. txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + 54. > txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + +kernel/compat.c:55: error: UNINITIALIZED_VALUE + The value read from tx32.stabil was never initialized. + 53. txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + 55. > txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + +kernel/compat.c:45: error: UNINITIALIZED_VALUE + The value read from tx32.status was never initialized. + 43. txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + 45. > txc->status = tx32.status; + 46. txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + +kernel/compat.c:59: error: UNINITIALIZED_VALUE + The value read from tx32.stbcnt was never initialized. + 57. txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + 59. > txc->stbcnt = tx32.stbcnt; + 60. + 61. return 0; + +kernel/compat.c:51: error: UNINITIALIZED_VALUE + The value read from tx32.tick was never initialized. + 49. txc->time.tv_sec = tx32.time.tv_sec; + 50. txc->time.tv_usec = tx32.time.tv_usec; + 51. > txc->tick = tx32.tick; + 52. txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + +kernel/compat.c:48: error: UNINITIALIZED_VALUE + The value read from tx32.tolerance was never initialized. + 46. txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + 48. > txc->tolerance = tx32.tolerance; + 49. txc->time.tv_sec = tx32.time.tv_sec; + 50. txc->time.tv_usec = tx32.time.tv_usec; + +security/integrity/iint.c:51: error: UNINITIALIZED_VALUE + The value read from iint was never initialized. + 49. return NULL; + 50. + 51. > return iint; + 52. } + 53. + +net/ipv6/ip6_icmp.c:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. + 38. rcu_read_lock(); + 39. > send = rcu_dereference(ip6_icmp_send); + 40. + 41. if (!send) + +block/ioprio.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. + 41. rcu_read_lock(); + 42. > tcred = __task_cred(task); + 43. if (!uid_eq(tcred->uid, cred->euid) && + 44. !uid_eq(tcred->uid, cred->uid) && !capable(CAP_SYS_NICE)) { + +drivers/base/module.c:64: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 62. + 63. /* Don't check return codes; these calls are idempotent */ + 64. > no_warn = sysfs_create_link(&drv->p->kobj, &mk->kobj, "module"); + 65. driver_name = make_driver_name(drv); + 66. if (driver_name) { + +drivers/base/module.c:68: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 66. if (driver_name) { + 67. module_create_drivers_dir(mk); + 68. > no_warn = sysfs_create_link(mk->drivers_dir, &drv->p->kobj, + 69. driver_name); + 70. kfree(driver_name); + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +init/calibrate.c:138: error: UNINITIALIZED_VALUE + The value read from measured_times[_] was never initialized. + 136. if ((measured_times[max] - estimate) < + 137. (estimate - measured_times[min])) { + 138. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 139. "min bogoMips estimate %d = %lu\n", + 140. min, measured_times[min]); + +init/calibrate.c:144: error: UNINITIALIZED_VALUE + The value read from measured_times[_] was never initialized. + 142. min = max; + 143. } else { + 144. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 145. "max bogoMips estimate %d = %lu\n", + 146. max, measured_times[max]); + +net/compat.c:58: error: UNINITIALIZED_VALUE + The value read from msg.msg_control was never initialized. + 56. kmsg->msg_namelen = sizeof(struct sockaddr_storage); + 57. + 58. > kmsg->msg_control = compat_ptr(msg.msg_control); + 59. kmsg->msg_controllen = msg.msg_controllen; + 60. + +net/compat.c:59: error: UNINITIALIZED_VALUE + The value read from msg.msg_controllen was never initialized. + 57. + 58. kmsg->msg_control = compat_ptr(msg.msg_control); + 59. > kmsg->msg_controllen = msg.msg_controllen; + 60. + 61. if (save_addr) + +net/compat.c:46: error: UNINITIALIZED_VALUE + The value read from msg.msg_flags was never initialized. + 44. return -EFAULT; + 45. + 46. > kmsg->msg_flags = msg.msg_flags; + 47. kmsg->msg_namelen = msg.msg_namelen; + 48. + +net/compat.c:83: error: UNINITIALIZED_VALUE + The value read from msg.msg_iov was never initialized. + 81. + 82. return compat_import_iovec(save_addr ? READ : WRITE, + 83. > compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + 85. } + +net/compat.c:82: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 80. kmsg->msg_iocb = NULL; + 81. + 82. > return compat_import_iovec(save_addr ? READ : WRITE, + 83. compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + +net/compat.c:62: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 60. + 61. if (save_addr) + 62. > *save_addr = compat_ptr(msg.msg_name); + 63. + 64. if (msg.msg_name && kmsg->msg_namelen) { + +net/compat.c:66: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 64. if (msg.msg_name && kmsg->msg_namelen) { + 65. if (!save_addr) { + 66. > err = move_addr_to_kernel(compat_ptr(msg.msg_name), + 67. kmsg->msg_namelen, + 68. kmsg->msg_name); + +net/compat.c:47: error: UNINITIALIZED_VALUE + The value read from msg.msg_namelen was never initialized. + 45. + 46. kmsg->msg_flags = msg.msg_flags; + 47. > kmsg->msg_namelen = msg.msg_namelen; + 48. + 49. if (!msg.msg_name) + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +lib/mpi/mpi-pow.c:56: error: DEAD_STORE + The value written to &esign (type int) is never used. + 54. msize = mod->nlimbs; + 55. size = 2 * msize; + 56. > esign = exp->sign; + 57. msign = mod->sign; + 58. + +drivers/dma-buf/seqno-fence.c:42: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 40 could be null and is dereferenced at line 42, column 9. + 40. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 41. + 42. > return seqno_fence->ops->enable_signaling(fence); + 43. } + 44. + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +ipc/compat.c:45: error: UNINITIALIZED_VALUE + The value read from v.gid was never initialized. + 43. return -EFAULT; + 44. to->uid = v.uid; + 45. > to->gid = v.gid; + 46. to->mode = v.mode; + 47. return 0; + +ipc/compat.c:46: error: UNINITIALIZED_VALUE + The value read from v.mode was never initialized. + 44. to->uid = v.uid; + 45. to->gid = v.gid; + 46. > to->mode = v.mode; + 47. return 0; + 48. } + +ipc/compat.c:44: error: UNINITIALIZED_VALUE + The value read from v.uid was never initialized. + 42. if (copy_from_user(&v, from, sizeof(v))) + 43. return -EFAULT; + 44. > to->uid = v.uid; + 45. to->gid = v.gid; + 46. to->mode = v.mode; + +kernel/sched/membarrier.c:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. * iteration. + 78. */ + 79. > if (cpu == raw_smp_processor_id()) + 80. continue; + 81. rcu_read_lock(); + +lib/llist.c:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. + 43. do { + 44. > new_last->next = first = READ_ONCE(head->first); + 45. } while (cmpxchg(&head->first, first, new_first) != first); + 46. + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +include/net/netns/generic.h:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. + 44. rcu_read_lock(); + 45. > ng = rcu_dereference(net->gen); + 46. ptr = ng->ptr[id]; + 47. rcu_read_unlock(); + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +kernel/irq/spurious.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. bool irq_wait_for_poll(struct irq_desc *desc) + 40. { + 41. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 42. "irq poll in progress on cpu %d for irq %d\n", + 43. smp_processor_id(), desc->irq_data.irq)) + +kernel/irq/spurious.c:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. bool irq_wait_for_poll(struct irq_desc *desc) + 40. { + 41. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 42. "irq poll in progress on cpu %d for irq %d\n", + 43. smp_processor_id(), desc->irq_data.irq)) + +kernel/smpboot.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. void __init idle_thread_set_boot_cpu(void) + 40. { + 41. > per_cpu(idle_threads, smp_processor_id()) = current; + 42. } + 43. + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/percpu-rwsem.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. * release in percpu_up_write(). + 63. */ + 64. > if (likely(!smp_load_acquire(&sem->readers_block))) + 65. return 1; + 66. + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +drivers/clk/clk-gate.c:46: error: DEAD_STORE + The value written to &flags (type unsigned long) is never used. + 44. struct clk_gate *gate = to_clk_gate(hw); + 45. int set = gate->flags & CLK_GATE_SET_TO_DISABLE ? 1 : 0; + 46. > unsigned long uninitialized_var(flags); + 47. u32 reg; + 48. + +net/netfilter/nf_conntrack_extend.c:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. + 62. rcu_read_lock(); + 63. > t = rcu_dereference(nf_ct_ext_types[id]); + 64. if (!t) { + 65. rcu_read_unlock(); + +sound/hda/trace.h:43: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +lib/genalloc.c:54: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 52. return -EBUSY; + 53. cpu_relax(); + 54. > } while ((nval = cmpxchg(addr, val, val | mask_to_set)) != val); + 55. + 56. return 0; + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +drivers/dma-buf/seqno-fence.c:49: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 47 could be null and is dereferenced at line 49, column 9. + 47. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 48. + 49. > return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence); + 50. } + 51. + +drivers/usb/core/otg_whitelist.h:47: error: DEAD_STORE + The value written to &id (type usb_device_id*) is never used. + 45. static int is_targeted(struct usb_device *dev) + 46. { + 47. > struct usb_device_id *id = whitelist_table; + 48. + 49. /* HNP test device is _never_ targeted (see OTG spec 6.6.6) */ + +kernel/time/tick-broadcast-hrtimer.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. if (bc_moved) { + 70. /* Bind the "device" to the cpu */ + 71. > bc->bound_on = smp_processor_id(); + 72. } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + +kernel/time/tick-broadcast-hrtimer.c:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. /* Bind the "device" to the cpu */ + 71. bc->bound_on = smp_processor_id(); + 72. > } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + 74. } + +kernel/time/tick-broadcast-hrtimer.c:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. if (bc_moved) { + 70. /* Bind the "device" to the cpu */ + 71. > bc->bound_on = smp_processor_id(); + 72. } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + +net/netfilter/nf_nat_core.c:48: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 46. __nf_nat_l3proto_find(u8 family) + 47. { + 48. > return rcu_dereference(nf_nat_l3protos[family]); + 49. } + 50. + +drivers/dma-buf/dma-fence-array.c:52: error: NULL_DEREFERENCE + pointer `array` last assigned on line 48 could be null and is dereferenced at line 52, column 18. + 50. unsigned i; + 51. + 52. > for (i = 0; i < array->num_fences; ++i) { + 53. cb[i].array = array; + 54. /* + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +lib/list_sort.c:58: error: MEMORY_LEAK + `tail->next` is not reachable after line 58, column 4. + 56. /* if equal, take 'a' -- important for sort stability */ + 57. if ((*cmp)(priv, a, b) <= 0) { + 58. > tail->next = a; + 59. a->prev = tail; + 60. a = a->next; + +lib/list_sort.c:62: error: MEMORY_LEAK + `tail->next` is not reachable after line 62, column 4. + 60. a = a->next; + 61. } else { + 62. > tail->next = b; + 63. b->prev = tail; + 64. b = b->next; + +net/sunrpc/sunrpc.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. int loopback = 0; + 50. rcu_read_lock(); + 51. > dst = rcu_dereference(sk->sk_dst_cache); + 52. if (dst && dst->dev && + 53. (dst->dev->features & NETIF_F_LOOPBACK)) + +drivers/usb/core/message.c:63: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 61. if (!wait_for_completion_timeout(&ctx.done, expire)) { + 62. usb_kill_urb(urb); + 63. > retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status); + 64. + 65. dev_dbg(&urb->dev->dev, + +drivers/usb/core/message.c:73: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 71. urb->transfer_buffer_length); + 72. } else + 73. > retval = ctx.status; + 74. out: + 75. if (actual_length) + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +kernel/power/user.c:79: error: DEAD_STORE + The value written to &nr_calls (type int) is never used. + 77. error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls); + 78. if (error) + 79. > __pm_notifier_call_chain(PM_POST_HIBERNATION, --nr_calls, NULL); + 80. } else { + 81. /* + +drivers/gpu/drm/i915/i915_ioc32.c:59: error: UNINITIALIZED_VALUE + The value read from req32.param was never initialized. + 57. request = compat_alloc_user_space(sizeof(*request)); + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. > || __put_user(req32.param, &request->param) + 60. || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + +drivers/gpu/drm/i915/i915_ioc32.c:60: error: UNINITIALIZED_VALUE + The value read from req32.value was never initialized. + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. || __put_user(req32.param, &request->param) + 60. > || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + 62. return -EFAULT; + +include/linux/idr.h:50: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 48. static inline unsigned int idr_get_cursor(const struct idr *idr) + 49. { + 50. > return READ_ONCE(idr->idr_next); + 51. } + 52. + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +net/ipv4/xfrm4_protocol.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. return 0; + 57. + 58. > for_each_protocol_rcu(*head, handler) + 59. if ((ret = handler->cb_handler(skb, err)) <= 0) + 60. return ret; + +net/ipv6/xfrm6_protocol.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. return 0; + 57. + 58. > for_each_protocol_rcu(*proto_handlers(protocol), handler) + 59. if ((ret = handler->cb_handler(skb, err)) <= 0) + 60. return ret; + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +block/blk-stat.c:67: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 65. + 66. rcu_read_lock(); + 67. > list_for_each_entry_rcu(cb, &q->stats->callbacks, list) { + 68. if (!blk_stat_is_active(cb)) + 69. continue; + +drivers/edac/edac_device.c:78: error: DEAD_STORE + The value written to &dev_ctl (type edac_device_ctl_info*) is never used. + 76. */ + 77. p = NULL; + 78. > dev_ctl = edac_align_ptr(&p, sizeof(*dev_ctl), 1); + 79. + 80. /* Calc the 'end' offset past end of ONE ctl_info structure + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +ipc/compat.c:57: error: UNINITIALIZED_VALUE + The value read from v.gid was never initialized. + 55. return -EFAULT; + 56. to->uid = v.uid; + 57. > to->gid = v.gid; + 58. to->mode = v.mode; + 59. return 0; + +ipc/compat.c:58: error: UNINITIALIZED_VALUE + The value read from v.mode was never initialized. + 56. to->uid = v.uid; + 57. to->gid = v.gid; + 58. > to->mode = v.mode; + 59. return 0; + 60. } + +ipc/compat.c:56: error: UNINITIALIZED_VALUE + The value read from v.uid was never initialized. + 54. if (copy_from_user(&v, from, sizeof(v))) + 55. return -EFAULT; + 56. > to->uid = v.uid; + 57. to->gid = v.gid; + 58. to->mode = v.mode; + +net/ipv6/ip6_input.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. const struct inet6_protocol *ipprot; + 63. + 64. > ipprot = rcu_dereference(inet6_protos[ipv6_hdr(skb)->nexthdr]); + 65. if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) + 66. edemux(skb); + +net/ipv6/ip6_input.c:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. + 64. ipprot = rcu_dereference(inet6_protos[ipv6_hdr(skb)->nexthdr]); + 65. > if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) + 66. edemux(skb); + 67. } + +net/sched/act_api.c:55: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 53. const struct tcf_chain *chain = a->goto_chain; + 54. + 55. > res->goto_tp = rcu_dereference_bh(chain->filter_chain); + 56. } + 57. + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +kernel/futex_compat.c:103: error: DEAD_STORE + The value written to &uentry (type unsigned int) is never used. + 101. if (rc) + 102. return; + 103. > uentry = next_uentry; + 104. entry = next_entry; + 105. pi = next_pi; + +net/core/fib_notifier.c:55: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 53. struct fib_notifier_ops *ops; + 54. + 55. > list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) { + 56. int err; + 57. + +net/ipv6/ping.c:118: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 116. fl6.flowi6_uid = sk->sk_uid; + 117. fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. > fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + 120. + +net/ipv6/ping.c:135: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 133. + 134. pfh.icmph.type = user_icmph.icmp6_type; + 135. > pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + 137. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv6/ping.c:117: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 115. fl6.flowi6_mark = sk->sk_mark; + 116. fl6.flowi6_uid = sk->sk_uid; + 117. > fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + +net/ipv6/ping.c:134: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 132. fl6.flowi6_oif = np->ucast_oif; + 133. + 134. > pfh.icmph.type = user_icmph.icmp6_type; + 135. pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + +net/netfilter/nf_nat_core.c:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. __nf_nat_l4proto_find(u8 family, u8 protonum) + 53. { + 54. > return rcu_dereference(nf_nat_l4protos[family][protonum]); + 55. } + 56. EXPORT_SYMBOL_GPL(__nf_nat_l4proto_find); + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. * counter for this CPU. + 78. */ + 79. > if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. cpu = smp_processor_id(); + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +arch/x86/pci/mmconfig-shared.c:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. + 56. /* keep list sorted by segment and starting bus number */ + 57. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) { + 58. if (cfg->segment > new->segment || + 59. (cfg->segment == new->segment && + +drivers/dma-buf/seqno-fence.c:56: error: NULL_DEREFERENCE + pointer `f` last assigned on line 54 could be null and is dereferenced at line 56, column 14. + 54. struct seqno_fence *f = to_seqno_fence(fence); + 55. + 56. > dma_buf_put(f->sync_buf); + 57. if (f->ops->release) + 58. f->ops->release(fence); + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +net/ipv4/tcp_cong.c:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. struct tcp_congestion_ops *e; + 56. + 57. > list_for_each_entry_rcu(e, &tcp_cong_list, list) { + 58. if (e->key == key) + 59. return e; + +net/ipv6/inet6_hashtables.c:63: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 61. struct sock *sk; + 62. const struct hlist_nulls_node *node; + 63. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 64. /* Optimize here for direct hit, only listening connections can + 65. * have wildcards anyways. + +net/ipv6/inet6_hashtables.c:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. + 72. begin: + 73. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 74. if (sk->sk_hash != hash) + 75. continue; + +drivers/gpu/drm/drm_lock.c:71: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 69. _DRM_LOCK_CONT : 0); + 70. } + 71. > prev = cmpxchg(lock, old, new); + 72. } while (prev != old); + 73. spin_unlock_bh(&lock_data->spinlock); + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +kernel/time/tick-oneshot.c:56: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 54. void tick_resume_oneshot(void) + 55. { + 56. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 57. + 58. clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT); + +kernel/time/tick-oneshot.c:56: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 54. void tick_resume_oneshot(void) + 55. { + 56. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 57. + 58. clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT); + +kernel/task_work.c:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. */ + 70. raw_spin_lock_irqsave(&task->pi_lock, flags); + 71. > while ((work = READ_ONCE(*pprev))) { + 72. if (work->func != func) + 73. pprev = &work->next; + +sound/hda/trace.h:55: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 53. ); + 54. + 55. > DECLARE_EVENT_CLASS(hdac_stream, + 56. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 57. + +lib/decompress_unlzo.c:82: error: DEAD_STORE + The value written to &level (type unsigned char) is never used. + 80. parse += 7; + 81. if (version >= 0x0940) + 82. > level = *parse++; + 83. if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) + 84. parse += 8; /* flags + filter info */ + +kernel/rcu/rcu_segcblist.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. static inline long rcu_segcblist_n_cbs(struct rcu_segcblist *rsclp) + 57. { + 58. > return READ_ONCE(rsclp->len); + 59. } + 60. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +kernel/time/tick-sched.c:88: error: DEAD_STORE + The value written to &ticks (type unsigned long) is never used. + 86. incr * ticks); + 87. } + 88. > do_timer(++ticks); + 89. + 90. /* Keep the tick_next_period variable up to date */ + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/connector/cn_proc.c:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. + 62. msg->seq = __this_cpu_inc_return(proc_event_counts) - 1; + 63. > ((struct proc_event *)msg->data)->cpu = smp_processor_id(); + 64. + 65. /* + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +lib/errseq.c:94: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 92. + 93. /* Try to swap the new value into place */ + 94. > cur = cmpxchg(eseq, old, new); + 95. + 96. /* + +lib/errseq.c:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. * previous error. + 70. */ + 71. > old = READ_ONCE(*eseq); + 72. + 73. if (WARN(unlikely(err == 0 || (unsigned int)-err > MAX_ERRNO), + +lib/errseq.c:106: error: UNINITIALIZED_VALUE + The value read from cur was never initialized. + 104. old = cur; + 105. } + 106. > return cur; + 107. } + 108. EXPORT_SYMBOL(errseq_set); + +net/ipv6/ip6_offload.c:95: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 93. udpfrag = proto == IPPROTO_UDP && !skb->encapsulation; + 94. + 95. > ops = rcu_dereference(inet6_offloads[proto]); + 96. if (likely(ops && ops->callbacks.gso_segment)) { + 97. skb_reset_transport_header(skb); + +drivers/cpuidle/cpuidle.c:61: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 59. int cpuidle_play_dead(void) + 60. { + 61. > struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices); + 62. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 63. int i; + +drivers/cpuidle/cpuidle.c:61: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 59. int cpuidle_play_dead(void) + 60. { + 61. > struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices); + 62. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 63. int i; + +lib/genalloc.c:69: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 67. return -EBUSY; + 68. cpu_relax(); + 69. > } while ((nval = cmpxchg(addr, val, val & ~mask_to_clear)) != val); + 70. + 71. return 0; + +arch/x86/pci/amd_bus.c:128: error: DEAD_STORE + The value written to &info (type pci_root_info*) is never used. + 126. link = (reg >> 8) & 0x03; + 127. + 128. > info = alloc_pci_root_info(min_bus, max_bus, node, link); + 129. } + 130. + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +drivers/tty/tty_audit.c:66: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 64. struct task_struct *tsk = current; + 65. pid_t pid = task_pid_nr(tsk); + 66. > uid_t uid = from_kuid(&init_user_ns, task_uid(tsk)); + 67. uid_t loginuid = from_kuid(&init_user_ns, audit_get_loginuid(tsk)); + 68. unsigned int sessionid = audit_get_sessionid(tsk); + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +net/netlabel/netlabel_addrlist.c:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. struct netlbl_af4list *iter; + 64. + 65. > list_for_each_entry_rcu(iter, head, list) + 66. if (iter->valid && (addr & iter->mask) == iter->addr) + 67. return iter; + +sound/core/pcm_lib.c:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. if (runtime->silence_size < runtime->boundary) { + 67. snd_pcm_sframes_t noise_dist, n; + 68. > snd_pcm_uframes_t appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 69. if (runtime->silence_start != appl_ptr) { + 70. n = appl_ptr - runtime->silence_start; + +block/badblocks.c:76: error: DEAD_STORE + The value written to §ors (type int) is never used. + 74. target += (1<shift) - 1; + 75. target >>= bb->shift; + 76. > sectors = target - s; + 77. } + 78. /* 'target' is now the first block after the bad range */ + +drivers/char/agp/compat_ioctl.c:75: error: UNINITIALIZED_VALUE + The value read from ureserve.pid was never initialized. + 73. return -EFAULT; + 74. + 75. > kreserve.pid = ureserve.pid; + 76. kreserve.seg_count = ureserve.seg_count; + 77. + +drivers/char/agp/compat_ioctl.c:76: error: UNINITIALIZED_VALUE + The value read from ureserve.seg_count was never initialized. + 74. + 75. kreserve.pid = ureserve.pid; + 76. > kreserve.seg_count = ureserve.seg_count; + 77. + 78. client = agp_find_client_by_pid(kreserve.pid); + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +sound/core/vmaster.c:70: error: DEAD_STORE + The value written to &err (type int) is never used. + 68. return -ENOMEM; + 69. uctl->id = slave->slave.id; + 70. > err = slave->slave.get(&slave->slave, uctl); + 71. for (ch = 0; ch < slave->info.count; ch++) + 72. slave->vals[ch] = uctl->value.integer.value[ch]; + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +block/blk-ioc.c:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. * will. Hint assignment itself can race safely. + 79. */ + 80. > if (rcu_access_pointer(ioc->icq_hint) == icq) + 81. rcu_assign_pointer(ioc->icq_hint, NULL); + 82. + +drivers/dma-buf/seqno-fence.c:68: error: NULL_DEREFERENCE + pointer `f` last assigned on line 66 could be null and is dereferenced at line 68, column 9. + 66. struct seqno_fence *f = to_seqno_fence(fence); + 67. + 68. > return f->ops->wait(fence, intr, timeout); + 69. } + 70. + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +block/ioprio.c:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. else + 110. pgrp = find_vpid(who); + 111. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 112. ret = set_task_ioprio(p, ioprio); + 113. if (ret) + +block/ioprio.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. break; + 128. + 129. > for_each_process_thread(g, p) { + 130. if (!uid_eq(task_uid(p), uid) || + 131. !task_pid_vnr(p)) + +block/ioprio.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. + 129. for_each_process_thread(g, p) { + 130. > if (!uid_eq(task_uid(p), uid) || + 131. !task_pid_vnr(p)) + 132. continue; + +drivers/char/agp/isoch.c:140: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 138. dev = cur->dev; + 139. + 140. > mcapndx = cur->capndx; + 141. + 142. pci_read_config_dword(dev, cur->capndx+AGPNISTAT, &mnistat); + +drivers/char/agp/isoch.c:253: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 251. dev = cur->dev; + 252. + 253. > mcapndx = cur->capndx; + 254. + 255. master[cdev].rq += (cdev == ndevs - 1) + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +kernel/time/tick-common.c:67: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 65. int tick_is_oneshot_available(void) + 66. { + 67. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 68. + 69. if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT)) + +kernel/time/tick-common.c:67: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 65. int tick_is_oneshot_available(void) + 66. { + 67. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 68. + 69. if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT)) + +kernel/trace/trace_events_trigger.c:75: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 73. return tt; + 74. + 75. > list_for_each_entry_rcu(data, &file->triggers, list) { + 76. if (data->paused) + 77. continue; + +kernel/trace/trace_events_trigger.c:82: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 80. continue; + 81. } + 82. > filter = rcu_dereference_sched(data->filter); + 83. if (filter && !filter_match_preds(filter, rec)) + 84. continue; + +lib/llist.c:75: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 73. old_entry = entry; + 74. next = READ_ONCE(entry->next); + 75. > entry = cmpxchg(&head->first, old_entry, next); + 76. if (entry == old_entry) + 77. break; + +lib/llist.c:69: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 67. struct llist_node *entry, *old_entry, *next; + 68. + 69. > entry = smp_load_acquire(&head->first); + 70. for (;;) { + 71. if (entry == NULL) + +lib/llist.c:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. return NULL; + 73. old_entry = entry; + 74. > next = READ_ONCE(entry->next); + 75. entry = cmpxchg(&head->first, old_entry, next); + 76. if (entry == old_entry) + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +lib/bug.c:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. + 71. rcu_read_lock_sched(); + 72. > list_for_each_entry_rcu(mod, &module_bug_list, bug_list) { + 73. unsigned i; + 74. + +net/ipv4/xfrm4_protocol.c:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. goto out; + 79. + 80. > for_each_protocol_rcu(*head, handler) + 81. if ((ret = handler->input_handler(skb, nexthdr, spi, encap_type)) != -EINVAL) + 82. return ret; + +net/ipv6/xfrm6_protocol.c:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 72. + 73. > for_each_protocol_rcu(esp6_handlers, handler) + 74. if ((ret = handler->handler(skb)) != -EINVAL) + 75. return ret; + +kernel/events/core.c:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. if (p) { + 73. /* -EAGAIN */ + 74. > if (task_cpu(p) != smp_processor_id()) + 75. return; + 76. + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +lib/earlycpio.c:140: error: UNINITIALIZED_VALUE + The value read from ch[_] was never initialized. + 138. + 139. cd.data = (void *)dptr; + 140. > cd.size = ch[C_FILESIZE]; + 141. return cd; /* Found it! */ + 142. } + +drivers/gpu/drm/i915/dvo_sil164.c:94: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 92. + 93. if (i2c_transfer(adapter, msgs, 2) == 2) { + 94. > *ch = in_buf[0]; + 95. return true; + 96. } + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +kernel/locking/rtmutex.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. * still set. + 132. */ + 133. > owner = READ_ONCE(*p); + 134. if (owner & RT_MUTEX_HAS_WAITERS) + 135. WRITE_ONCE(*p, owner & ~RT_MUTEX_HAS_WAITERS); + +net/core/sock_diag.c:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. + 82. rcu_read_lock(); + 83. > filter = rcu_dereference(sk->sk_filter); + 84. if (!filter) + 85. goto out; + +net/ipv6/datagram.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. + 86. rcu_read_lock(); + 87. > opt = flowlabel ? flowlabel->opt : rcu_dereference(np->opt); + 88. final_p = fl6_update_dst(&fl6, opt, &final); + 89. rcu_read_unlock(); + +net/ipv6/xfrm6_mode_transport.c:77: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 74 could be null and is dereferenced at line 77, column 8. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +net/ipv6/xfrm6_mode_transport.c:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +net/core/dev_ioctl.c:86: error: UNINITIALIZED_VALUE + The value read from ifc.ifc_len was never initialized. + 84. + 85. pos = ifc.ifc_buf; + 86. > len = ifc.ifc_len; + 87. + 88. /* + +crypto/sha256_generic.c:230: error: DEAD_STORE + The value written to &a (type unsigned int) is never used. + 228. + 229. /* clear any sensitive info... */ + 230. > a = b = c = d = e = f = g = h = t1 = t2 = 0; + 231. memzero_explicit(W, 64 * sizeof(u32)); + 232. } + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +kernel/locking/qrwlock.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. /* When no more readers or writers, set the locked flag */ + 85. do { + 86. > atomic_cond_read_acquire(&lock->cnts, VAL == _QW_WAITING); + 87. } while (atomic_cmpxchg_relaxed(&lock->cnts, _QW_WAITING, + 88. _QW_LOCKED) != _QW_WAITING); + +kernel/softirq.c:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. { + 73. /* Interrupts are disabled: no need to stop preemption */ + 74. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 75. + 76. if (tsk && tsk->state != TASK_RUNNING) + +kernel/softirq.c:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. { + 73. /* Interrupts are disabled: no need to stop preemption */ + 74. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 75. + 76. if (tsk && tsk->state != TASK_RUNNING) + +security/selinux/netif.c:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. struct sel_netif *netif; + 76. + 77. > list_for_each_entry_rcu(netif, &sel_netif_hash[idx], list) + 78. if (net_eq(netif->nsec.ns, ns) && + 79. netif->nsec.ifindex == ifindex) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +drivers/gpu/drm/i915/intel_uncore.c:76: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 74. const struct intel_uncore_forcewake_domain *d) + 75. { + 76. > if (wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & + 77. FORCEWAKE_KERNEL) == 0, + 78. FORCEWAKE_ACK_TIMEOUT_MS)) + +drivers/gpu/drm/i915/intel_uncore.c:76: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 74. const struct intel_uncore_forcewake_domain *d) + 75. { + 76. > if (wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & + 77. FORCEWAKE_KERNEL) == 0, + 78. FORCEWAKE_ACK_TIMEOUT_MS)) + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +arch/x86/platform/efi/efi_64.c:105: error: DEAD_STORE + The value written to &vaddr (type unsigned long) is never used. + 103. for (pgd = 0; pgd < n_pgds; pgd++) { + 104. addr_pgd = (unsigned long)(pgd * PGDIR_SIZE); + 105. > vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 106. pgd_efi = pgd_offset_k(addr_pgd); + 107. save_pgd[pgd] = *pgd_efi; + +arch/x86/platform/efi/efi_64.c:107: error: NULL_DEREFERENCE + pointer `save_pgd` last assigned on line 93 could be null and is dereferenced at line 107, column 3. + 105. vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 106. pgd_efi = pgd_offset_k(addr_pgd); + 107. > save_pgd[pgd] = *pgd_efi; + 108. + 109. p4d = p4d_alloc(&init_mm, pgd_efi, addr_pgd); + +drivers/gpu/drm/drm_info.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. rcu_read_lock(); /* locks pid_task()->comm */ + 97. task = pid_task(priv->pid, PIDTYPE_PID); + 98. > uid = task ? __task_cred(task)->euid : GLOBAL_ROOT_UID; + 99. seq_printf(m, "%20s %5d %3d %c %c %5d %10u\n", + 100. task ? task->comm : "", + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +kernel/notifier.c:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. struct notifier_block *nb, *next_nb; + 80. + 81. > nb = rcu_dereference_raw(*nl); + 82. + 83. while (nb && nr_to_call) { + +kernel/notifier.c:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. + 83. while (nb && nr_to_call) { + 84. > next_nb = rcu_dereference_raw(nb->next); + 85. + 86. #ifdef CONFIG_DEBUG_NOTIFIERS + +net/core/filter.c:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. + 96. rcu_read_lock(); + 97. > filter = rcu_dereference(sk->sk_filter); + 98. if (filter) { + 99. struct sock *save_sk = skb->sk; + +net/ipv6/ip6_flowlabel.c:78: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 76. struct ip6_flowlabel *fl; + 77. + 78. > for_each_fl_rcu(FL_HASH(label), fl) { + 79. if (fl->label == label && net_eq(fl->fl_net, net)) + 80. return fl; + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +tools/objtool/orc_dump.c:102: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 102, column 3. + 100. elf = elf_begin(fd, ELF_C_READ_MMAP, NULL); + 101. if (!elf) { + 102. > WARN_ELF("elf_begin"); + 103. return -1; + 104. } + +tools/objtool/orc_dump.c:107: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 107, column 3. + 105. + 106. if (elf_getshdrnum(elf, &nr_sections)) { + 107. > WARN_ELF("elf_getshdrnum"); + 108. return -1; + 109. } + +tools/objtool/orc_dump.c:112: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 112, column 3. + 110. + 111. if (elf_getshdrstrndx(elf, &shstrtab_idx)) { + 112. > WARN_ELF("elf_getshdrstrndx"); + 113. return -1; + 114. } + +tools/objtool/orc_dump.c:119: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 119, column 4. + 117. scn = elf_getscn(elf, i); + 118. if (!scn) { + 119. > WARN_ELF("elf_getscn"); + 120. return -1; + 121. } + +tools/objtool/orc_dump.c:124: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 124, column 4. + 122. + 123. if (!gelf_getshdr(scn, &sh)) { + 124. > WARN_ELF("gelf_getshdr"); + 125. return -1; + 126. } + +tools/objtool/orc_dump.c:130: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 130, column 4. + 128. name = elf_strptr(elf, shstrtab_idx, sh.sh_name); + 129. if (!name) { + 130. > WARN_ELF("elf_strptr"); + 131. return -1; + 132. } + +tools/objtool/orc_dump.c:136: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 136, column 4. + 134. data = elf_getdata(scn, NULL); + 135. if (!data) { + 136. > WARN_ELF("elf_getdata"); + 137. return -1; + 138. } + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +drivers/ptp/ptp_sysfs.c:101: error: UNINITIALIZED_VALUE + The value read from event.index was never initialized. + 99. goto out; + 100. + 101. > cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n", + 102. event.index, event.t.sec, event.t.nsec); + 103. out: + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +drivers/connector/cn_proc.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. ev->what = PROC_EVENT_FORK; + 91. rcu_read_lock(); + 92. > parent = rcu_dereference(task->real_parent); + 93. ev->event_data.fork.parent_pid = parent->pid; + 94. ev->event_data.fork.parent_tgid = parent->tgid; + +drivers/power/supply/power_supply_sysfs.c:122: error: UNINITIALIZED_VALUE + The value read from value.strval was never initialized. + 120. power_supply_scope_text[value.intval]); + 121. else if (off >= POWER_SUPPLY_PROP_MODEL_NAME) + 122. > return sprintf(buf, "%s\n", value.strval); + 123. + 124. return sprintf(buf, "%d\n", value.intval); + +include/net/netfilter/nf_conntrack_l3proto.h:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. if (unlikely(l3proto >= NFPROTO_NUMPROTO)) + 80. return &nf_conntrack_l3proto_generic; + 81. > return rcu_dereference(nf_ct_l3protos[l3proto]); + 82. } + 83. + +kernel/cgroup/stat.c:96: error: NULL_DEREFERENCE + pointer `pos` last assigned on line 92 could be null and is dereferenced by call to `cgroup_cpu_stat()` at line 96, column 11. + 94. /* walk down to the first leaf */ + 95. while (true) { + 96. > cstat = cgroup_cpu_stat(pos, cpu); + 97. if (cstat->updated_children == pos) + 98. break; + +net/wireless/scan.c:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. return; + 82. + 83. > ies = (void *)rcu_access_pointer(bss->pub.beacon_ies); + 84. if (ies && !bss->pub.hidden_beacon_bss) + 85. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. if (ies && !bss->pub.hidden_beacon_bss) + 85. kfree_rcu(ies, rcu_head); + 86. > ies = (void *)rcu_access_pointer(bss->pub.proberesp_ies); + 87. if (ies) + 88. kfree_rcu(ies, rcu_head); + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +drivers/pps/kapi.c:88: error: DEAD_STORE + The value written to &err (type int) is never used. + 86. pr_err("%s: unsupported default parameters\n", + 87. info->name); + 88. > err = -EINVAL; + 89. goto pps_register_source_exit; + 90. } + +drivers/pps/kapi.c:94: error: DEAD_STORE + The value written to &err (type int) is never used. + 92. pr_err("%s: unspecified time format\n", + 93. info->name); + 94. > err = -EINVAL; + 95. goto pps_register_source_exit; + 96. } + +drivers/pps/kapi.c:101: error: DEAD_STORE + The value written to &err (type int) is never used. + 99. pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL); + 100. if (pps == NULL) { + 101. > err = -ENOMEM; + 102. goto pps_register_source_exit; + 103. } + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +kernel/ptrace.c:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. { + 80. rcu_read_lock(); + 81. > __ptrace_link(child, new_parent, __task_cred(new_parent)); + 82. rcu_read_unlock(); + 83. } + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +net/netfilter/nf_log.c:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. if (pf == NFPROTO_UNSPEC) { + 89. for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { + 90. > if (rcu_access_pointer(loggers[i][logger->type])) { + 91. ret = -EEXIST; + 92. goto unlock; + +net/netfilter/nf_log.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. rcu_assign_pointer(loggers[i][logger->type], logger); + 97. } else { + 98. > if (rcu_access_pointer(loggers[pf][logger->type])) { + 99. ret = -EEXIST; + 100. goto unlock; + +net/xfrm/xfrm_input.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. + 85. rcu_read_lock(); + 86. > afinfo = rcu_dereference(xfrm_input_afinfo[family]); + 87. if (unlikely(!afinfo)) + 88. rcu_read_unlock(); + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:90: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 84 could be null and is dereferenced at line 90, column 6. + 88. + 89. /* Write the MSB and/or LSB */ + 90. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) { + 91. vals[0] = (level & 0xFF00) >> 8; + 92. vals[1] = (level & 0xFF); + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +net/core/net-sysfs.c:87: error: DEAD_STORE + The value written to &ret (type int) is never used. + 85. struct net *net = dev_net(netdev); + 86. unsigned long new; + 87. > int ret = -EINVAL; + 88. + 89. if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) + +drivers/dma-buf/dma-fence-array.c:86: error: NULL_DEREFERENCE + pointer `array` last assigned on line 83 could be null and is dereferenced at line 86, column 18. + 84. unsigned i; + 85. + 86. > for (i = 0; i < array->num_fences; ++i) + 87. dma_fence_put(array->fences[i]); + 88. + +security/selinux/ibpkey.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. + 86. idx = sel_ib_pkey_hashfn(pkey_num); + 87. > list_for_each_entry_rcu(pkey, &sel_ib_pkey_hash[idx].list, list) { + 88. if (pkey->psec.pkey == pkey_num && + 89. pkey->psec.subnet_prefix == subnet_prefix) + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +lib/sbitmap.c:111: error: UNINITIALIZED_VALUE + The value read from nr was never initialized. + 109. } + 110. + 111. > return nr; + 112. } + 113. + +net/ipv6/icmp.c:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline struct sock *icmpv6_sk(struct net *net) + 83. { + 84. > return net->ipv6.icmp_sk[smp_processor_id()]; + 85. } + 86. + +drivers/base/devtmpfs.c:119: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 117. kfree(tmp); + 118. + 119. > return req.err; + 120. } + 121. + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +lib/percpu_counter.c:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. + 87. preempt_disable(); + 88. > count = __this_cpu_read(*fbc->counters) + amount; + 89. if (count >= batch || count <= -batch) { + 90. unsigned long flags; + +net/core/fib_notifier.c:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. + 93. rcu_read_lock(); + 94. > for_each_net_rcu(net) { + 95. err = fib_net_dump(net, nb); + 96. if (err) + +net/ipv6/inet6_connection_sock.c:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. + 104. rcu_read_lock(); + 105. > final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final); + 106. rcu_read_unlock(); + 107. + +net/ipv6/xfrm6_protocol.c:88: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 86. struct xfrm6_protocol *handler; + 87. + 88. > for_each_protocol_rcu(esp6_handlers, handler) + 89. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 90. break; + +sound/core/hwdep.c:158: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 156. module_put(hw->card->module); + 157. snd_card_unref(hw->card); + 158. > return err; + 159. } + 160. + +drivers/i2c/algos/i2c-algo-bit.c:94: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 92. goto done; + 93. + 94. > start = jiffies; + 95. while (!getscl(adap)) { + 96. /* This hw knows how to read the clock line, so we wait + +drivers/usb/core/usb-acpi.c:100: error: DEAD_STORE + The value written to &status (type unsigned int) is never used. + 98. * no connectable, the port would be not used. + 99. */ + 100. > status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer); + 101. upc = buffer.pointer; + 102. if (!upc || (upc->type != ACPI_TYPE_PACKAGE) + +kernel/softirq.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. static bool ksoftirqd_running(void) + 85. { + 86. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 87. + 88. return tsk && (tsk->state == TASK_RUNNING); + +kernel/softirq.c:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. static bool ksoftirqd_running(void) + 85. { + 86. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 87. + 88. return tsk && (tsk->state == TASK_RUNNING); + +lib/idr.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. + 90. radix_tree_for_each_slot(slot, &idr->idr_rt, &iter, 0) { + 91. > int ret = fn(iter.index, rcu_dereference_raw(*slot), data); + 92. if (ret) + 93. return ret; + +net/netlabel/netlabel_addrlist.c:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. struct netlbl_af4list *iter; + 89. + 90. > list_for_each_entry_rcu(iter, head, list) + 91. if (iter->valid && iter->addr == addr && iter->mask == mask) + 92. return iter; + +net/netlabel/netlabel_addrlist.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. struct netlbl_af4list *n = __af4list_entry(s); + 89. while (i != h && !n->valid) { + 90. > i = rcu_dereference(list_next_rcu(i)); + 91. n = __af4list_entry(i); + 92. } + +sound/hda/hdac_controller.c:88: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 86. unsigned long timeout; + 87. + 88. > timeout = jiffies + msecs_to_jiffies(100); + 89. while ((snd_hdac_chip_readb(bus, RIRBCTL) & AZX_RBCTL_DMA_EN) + 90. && time_before(jiffies, timeout)) + +sound/hda/hdac_controller.c:93: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 91. udelay(10); + 92. + 93. > timeout = jiffies + msecs_to_jiffies(100); + 94. while ((snd_hdac_chip_readb(bus, CORBCTL) & AZX_CORBCTL_RUN) + 95. && time_before(jiffies, timeout)) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +block/genhd.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. struct hd_struct *__disk_get_part(struct gendisk *disk, int partno) + 86. { + 87. > struct disk_part_tbl *ptbl = rcu_dereference(disk->part_tbl); + 88. + 89. if (unlikely(partno < 0 || partno >= ptbl->len)) + +block/genhd.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. if (unlikely(partno < 0 || partno >= ptbl->len)) + 90. return NULL; + 91. > return rcu_dereference(ptbl->part[partno]); + 92. } + 93. + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +net/ipv4/tcp_ulp.c:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. *buf = '\0'; + 92. rcu_read_lock(); + 93. > list_for_each_entry_rcu(ulp_ops, &tcp_ulp_list, list) { + 94. offs += snprintf(buf + offs, maxlen - offs, + 95. "%s%s", + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/zlib_inflate/inffast.c:257: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 255. PUP(out) = PUP(from); + 256. if (len > 1) + 257. > PUP(out) = PUP(from); + 258. } + 259. } + +lib/zlib_inflate/inffast.c:304: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 302. } + 303. if (len & 1) + 304. > PUP(out) = PUP(from); + 305. } + 306. } + +net/core/fib_rules.c:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. + 92. rcu_read_lock(); + 93. > list_for_each_entry_rcu(ops, &net->rules_ops, list) { + 94. if (ops->family == family) { + 95. if (!try_module_get(ops->owner)) + +sound/hda/hdac_bus.c:115: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 113. trace_hda_get_response(bus, addr, *res); + 114. } + 115. > return err; + 116. } + 117. EXPORT_SYMBOL_GPL(snd_hdac_bus_exec_verb_unlocked); + +crypto/algapi.c:96: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 94. struct crypto_spawn *spawn, *n; + 95. + 96. > spawn = list_first_entry_or_null(stack, struct crypto_spawn, list); + 97. if (!spawn) + 98. return NULL; + +drivers/gpu/drm/drm_ioc32.c:103: error: UNINITIALIZED_VALUE + The value read from v32.date was never initialized. + 101. .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. > .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. .desc = compat_ptr(v32.desc), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.date_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:105: error: UNINITIALIZED_VALUE + The value read from v32.desc was never initialized. + 103. .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. > .desc = compat_ptr(v32.desc), + 106. }; + 107. err = drm_ioctl_kernel(file, drm_version, &v, + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.desc_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:101: error: UNINITIALIZED_VALUE + The value read from v32.name was never initialized. + 99. v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. > .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. .date = compat_ptr(v32.date), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.name_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/i915/intel_sprite.c:169: error: UNINITIALIZED_VALUE + The value read from scanline was never initialized. + 167. scanline = intel_get_crtc_scanline(crtc); + 168. + 169. > crtc->debug.scanline_start = scanline; + 170. crtc->debug.start_vbl_time = ktime_get(); + 171. crtc->debug.start_vbl_count = intel_crtc_get_vblank_counter(crtc); + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +security/keys/permission.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int key_validate(const struct key *key) + 90. { + 91. > unsigned long flags = READ_ONCE(key->flags); + 92. time64_t expiry = READ_ONCE(key->expiry); + 93. + +security/keys/permission.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. { + 91. unsigned long flags = READ_ONCE(key->flags); + 92. > time64_t expiry = READ_ONCE(key->expiry); + 93. + 94. if (flags & (1 << KEY_FLAG_INVALIDATED)) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/gpu/drm/i915/intel_uncore.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. const struct intel_uncore_forcewake_domain *d) + 93. { + 94. > if (wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & + 95. FORCEWAKE_KERNEL), + 96. FORCEWAKE_ACK_TIMEOUT_MS)) + +drivers/gpu/drm/i915/intel_uncore.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. const struct intel_uncore_forcewake_domain *d) + 93. { + 94. > if (wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & + 95. FORCEWAKE_KERNEL), + 96. FORCEWAKE_ACK_TIMEOUT_MS)) + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +kernel/exit.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. u64 utime, stime; + 97. + 98. > sighand = rcu_dereference_check(tsk->sighand, + 99. lockdep_tasklist_lock_is_held()); + 100. spin_lock(&sighand->siglock); + +kernel/locking/osq_lock.c:169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 167. * true. + 168. */ + 169. > if (smp_load_acquire(&node->locked)) + 170. return true; + 171. + +kernel/locking/osq_lock.c:178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 176. * case its step-C will write us a new @node->prev pointer. + 177. */ + 178. > prev = READ_ONCE(node->prev); + 179. } + 180. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +kernel/task_work.c:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. raw_spin_lock_irq(&task->pi_lock); + 101. do { + 102. > work = READ_ONCE(task->task_works); + 103. head = !work && (task->flags & PF_EXITING) ? + 104. &work_exited : NULL; + +net/ipv4/ip_options.c:178: error: UNINITIALIZED_VALUE + The value read from faddr was never initialized. + 176. } + 177. if (doffset > 3) { + 178. > dopt->faddr = faddr; + 179. dptr[0] = start[0]; + 180. dptr[1] = doffset+3; + +net/ipv4/tcp_minisocks.c:148: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 146. if (tmp_opt.saw_tstamp) { + 147. tcptw->tw_ts_recent_stamp = get_seconds(); + 148. > tcptw->tw_ts_recent = tmp_opt.rcv_tsval; + 149. } + 150. + +net/ipv4/tcp_minisocks.c:191: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 189. + 190. if (tmp_opt.saw_tstamp) { + 191. > tcptw->tw_ts_recent = tmp_opt.rcv_tsval; + 192. tcptw->tw_ts_recent_stamp = get_seconds(); + 193. } + +net/netfilter/nf_nat_sip.c:112: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 99 could be null and is dereferenced at line 112, column 13. + 110. ct->tuplehash[dir].tuple.dst.u.udp.port == port) { + 111. newaddr = ct->tuplehash[!dir].tuple.src.u3; + 112. > newport = ct_sip_info->forced_dport ? : + 113. ct->tuplehash[!dir].tuple.src.u.udp.port; + 114. } else + +drivers/gpu/drm/drm_hashtab.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. hashed_key = hash_long(key, ht->order); + 99. h_list = &ht->table[hashed_key]; + 100. > hlist_for_each_entry_rcu(entry, h_list, head) { + 101. if (entry->key == key) + 102. return &entry->head; + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +net/ipv4/xfrm4_protocol.c:99: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 97. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 98. + 99. > for_each_protocol_rcu(esp4_handlers, handler) + 100. if ((ret = handler->handler(skb)) != -EINVAL) + 101. return ret; + +drivers/gpu/drm/i915/dvo_tfp410.c:119: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 117. + 118. if (i2c_transfer(adapter, msgs, 2) == 2) { + 119. > *ch = in_buf[0]; + 120. return true; + 121. } + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/intel_dp_mst.c:103: error: NULL_DEREFERENCE + pointer `old_conn_state` last assigned on line 102 could be null and is dereferenced at line 103, column 13. + 101. + 102. old_conn_state = drm_atomic_get_old_connector_state(state, connector); + 103. > old_crtc = old_conn_state->crtc; + 104. if (!old_crtc) + 105. return ret; + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +net/ipv6/sit.c:104: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 102. int ifindex = dev ? dev->ifindex : 0; + 103. + 104. > for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) { + 105. if (local == t->parms.iph.saddr && + 106. remote == t->parms.iph.daddr && + +net/ipv6/sit.c:112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 110. return t; + 111. } + 112. > for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) { + 113. if (remote == t->parms.iph.daddr && + 114. (!dev || !t->parms.link || ifindex == t->parms.link || + +net/ipv6/sit.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. return t; + 118. } + 119. > for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) { + 120. if (local == t->parms.iph.saddr && + 121. (!dev || !t->parms.link || ifindex == t->parms.link || + +net/ipv6/sit.c:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. return t; + 125. } + 126. > t = rcu_dereference(sitn->tunnels_wc[0]); + 127. if (t && (t->dev->flags & IFF_UP)) + 128. return t; + +net/ipv6/xfrm6_protocol.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 99. + 100. > for_each_protocol_rcu(ah6_handlers, handler) + 101. if ((ret = handler->handler(skb)) != -EINVAL) + 102. return ret; + +drivers/tty/tty_jobctrl.c:105: error: MEMORY_LEAK + `tty->pgrp` is not reachable after line 105, column 2. + 103. put_pid(tty->session); + 104. put_pid(tty->pgrp); + 105. > tty->pgrp = get_pid(task_pgrp(current)); + 106. spin_unlock_irqrestore(&tty->ctrl_lock, flags); + 107. tty->session = get_pid(task_session(current)); + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +net/ipv4/tunnel4.c:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. goto drop; + 100. + 101. > for_each_tunnel_rcu(tunnel4_handlers, handler) + 102. if (!handler->handler(skb)) + 103. return 0; + +security/keys/request_key.c:99: error: DEAD_STORE + The value written to &cred (type cred const *) is never used. + 97. { + 98. static char const request_key[] = "/sbin/request-key"; + 99. > const struct cred *cred = current_cred(); + 100. key_serial_t prkey, sskey; + 101. struct key *key = cons->key, *authkey = cons->authkey, *keyring, + +security/keys/request_key.c:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. + 148. rcu_read_lock(); + 149. > session = rcu_dereference(cred->session_keyring); + 150. if (!session) + 151. session = cred->user->session_keyring; + +security/selinux/netport.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. + 99. idx = sel_netport_hashfn(pnum); + 100. > list_for_each_entry_rcu(port, &sel_netport_hash[idx].list, list) + 101. if (port->psec.port == pnum && port->psec.protocol == protocol) + 102. return port; + +drivers/gpu/drm/i915/i915_gem_batch_pool.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. * than replace the existing fence. + 132. */ + 133. > if (rcu_access_pointer(resv->fence)) { + 134. reservation_object_lock(resv, NULL); + 135. reservation_object_add_excl_fence(resv, NULL); + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c:114: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 112. + 113. /* rcu_read_lock()ed by nf_hook_thresh */ + 114. > helper = rcu_dereference(help->helper); + 115. if (!helper) + 116. return NF_ACCEPT; + +drivers/gpu/drm/i915/i915_gem_context.c:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. rcu_read_lock(); + 108. radix_tree_for_each_slot(slot, &ctx->handles_vma, &iter, 0) { + 109. > struct i915_vma *vma = rcu_dereference_raw(*slot); + 110. + 111. radix_tree_iter_delete(&ctx->handles_vma, &iter, slot); + +drivers/scsi/scsi_logging.c:115: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 113. if (!WARN_ON(off >= logbuf_len)) { + 114. va_start(args, fmt); + 115. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 116. va_end(args); + 117. } + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +net/ipv4/ip_tunnel.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. head = &itn->tunnels[hash]; + 107. + 108. > hlist_for_each_entry_rcu(t, head, hash_node) { + 109. if (local != t->parms.iph.saddr || + 110. remote != t->parms.iph.daddr || + +net/ipv4/ip_tunnel.c:123: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 121. } + 122. + 123. > hlist_for_each_entry_rcu(t, head, hash_node) { + 124. if (remote != t->parms.iph.daddr || + 125. t->parms.iph.saddr != 0 || + +net/ipv4/ip_tunnel.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. head = &itn->tunnels[hash]; + 140. + 141. > hlist_for_each_entry_rcu(t, head, hash_node) { + 142. if ((local != t->parms.iph.saddr || t->parms.iph.daddr != 0) && + 143. (local != t->parms.iph.daddr || !ipv4_is_multicast(local))) + +net/ipv4/ip_tunnel.c:161: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 159. goto skip_key_lookup; + 160. + 161. > hlist_for_each_entry_rcu(t, head, hash_node) { + 162. if (t->parms.i_key != key || + 163. t->parms.iph.saddr != 0 || + +net/ipv4/ip_tunnel.c:178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 176. return cand; + 177. + 178. > t = rcu_dereference(itn->collect_md_tun); + 179. if (t && t->dev->flags & IFF_UP) + 180. return t; + +net/ipv6/inet6_hashtables.c:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. score++; + 120. } + 121. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 122. score++; + 123. } + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +net/ipv4/inetpeer.c:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. int cmp; + 112. + 113. > next = rcu_dereference_raw(*pp); + 114. if (!next) + 115. break; + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +include/net/busy_poll.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. { + 101. #ifdef CONFIG_NET_RX_BUSY_POLL + 102. > unsigned long bp_usec = READ_ONCE(sk->sk_ll_usec); + 103. + 104. if (bp_usec) { + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. return NF_ACCEPT; + 118. /* rcu_read_lock()ed by nf_hook_thresh */ + 119. > helper = rcu_dereference(help->helper); + 120. if (!helper) + 121. return NF_ACCEPT; + +drivers/char/agp/frontend.c:112: error: DEAD_STORE + The value written to &num_segments (type int) is never used. + 110. pg_count = size / 4096; + 111. seg = *(client->segments); + 112. > num_segments = client->num_segments; + 113. + 114. for (i = 0; i < client->num_segments; i++) { + +drivers/md/dm-kcopyd.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. spin_lock_irq(&throttle_spinlock); + 109. + 110. > throttle = READ_ONCE(t->throttle); + 111. + 112. if (likely(throttle >= 100)) + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +net/netfilter/nf_conntrack_core.c:107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 105. * It pairs with the smp_store_release() in nf_conntrack_all_unlock() + 106. */ + 107. > if (likely(smp_load_acquire(&nf_conntrack_locks_all) == false)) + 108. return; + 109. + +net/netfilter/nf_queue.c:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. + 104. rcu_read_lock(); + 105. > qh = rcu_dereference(net->nf.queue_handler); + 106. if (qh) + 107. count = qh->nf_hook_drop(net); + +block/blk-mq.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 101. { + 102. > return __blk_mq_get_ctx(q, get_cpu()); + 103. } + 104. + +block/blk-mq.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 101. { + 102. > return __blk_mq_get_ctx(q, get_cpu()); + 103. } + 104. + +kernel/sched/cpuacct.c:104: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 102 could be null and is dereferenced at line 104, column 14. + 102. struct cpuacct *ca = css_ca(css); + 103. + 104. > free_percpu(ca->cpustat); + 105. free_percpu(ca->cpuusage); + 106. kfree(ca); + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +arch/x86/include/asm/mmu_context.h:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. + 107. /* READ_ONCE synchronizes with smp_store_release */ + 108. > ldt = READ_ONCE(mm->context.ldt); + 109. + 110. /* + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +net/ipv4/datagram.c:118: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 116. return; + 117. } + 118. > inet_opt = rcu_dereference(inet->inet_opt); + 119. if (inet_opt && inet_opt->opt.srr) + 120. daddr = inet_opt->opt.faddr; + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +net/core/sock_reuseport.c:107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 105. struct sock_reuseport *reuse; + 106. + 107. > if (!rcu_access_pointer(sk2->sk_reuseport_cb)) { + 108. int err = reuseport_alloc(sk2); + 109. + +net/ipv4/netfilter/nf_reject_ipv4.c:128: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 126. + 127. skb_reserve(nskb, LL_MAX_HEADER); + 128. > niph = nf_reject_iphdr_put(nskb, oldskb, IPPROTO_TCP, + 129. ip4_dst_hoplimit(skb_dst(nskb))); + 130. nf_reject_ip_tcphdr_put(nskb, oldskb, oth); + +net/ipv4/netfilter/nf_reject_ipv4.c:135: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 133. goto free_nskb; + 134. + 135. > niph = ip_hdr(nskb); + 136. + 137. /* "Never happens" */ + +net/netfilter/nfnetlink.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. return NULL; + 109. + 110. > return rcu_dereference(table[subsys_id].subsys); + 111. } + 112. + +net/netfilter/nfnetlink_log.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. + 109. head = &log->instance_table[instance_hashfn(group_num)]; + 110. > hlist_for_each_entry_rcu(inst, head, hlist) { + 111. if (inst->group_num == group_num) + 112. return inst; + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/gpu/drm/drm_lock.c:114: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 112. old = *lock; + 113. new = context | _DRM_LOCK_HELD; + 114. > prev = cmpxchg(lock, old, new); + 115. } while (prev != old); + 116. return 1; + +drivers/pci/vc.c:153: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 151. if (ctrl2 & PCI_VC_RES_CTRL_ENABLE) { + 152. ctrl2 &= ~PCI_VC_RES_CTRL_ENABLE; + 153. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 154. } + 155. + +drivers/pci/vc.c:158: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 156. /* Enable on both ends */ + 157. ctrl2 |= PCI_VC_RES_CTRL_ENABLE; + 158. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 159. enable: + 160. ctrl |= PCI_VC_RES_CTRL_ENABLE; + +drivers/pci/vc.c:166: error: UNINITIALIZED_VALUE + The value read from status_pos2 was never initialized. + 164. dev_err(&dev->dev, "VC%d negotiation stuck pending\n", id); + 165. + 166. > if (link && !pci_wait_for_pending(link, status_pos2, + 167. PCI_VC_RES_STATUS_NEGO)) + 168. dev_err(&link->dev, "VC%d negotiation stuck pending\n", id); + +drivers/pps/pps.c:227: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 225. /* Check for supported capabilities */ + 226. if ((bind_args.edge & ~pps->info.mode) != 0) { + 227. > dev_err(pps->dev, "unsupported capabilities (%x)\n", + 228. bind_args.edge); + 229. return -EINVAL; + +drivers/pps/pps.c:236: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 234. (bind_args.edge & ~PPS_CAPTUREBOTH) != 0 || + 235. bind_args.consumer != PPS_KC_HARDPPS) { + 236. > dev_err(pps->dev, "invalid kernel consumer bind" + 237. " parameters (%x)\n", bind_args.edge); + 238. return -EINVAL; + +drivers/pps/pps.c:141: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 139. return -EFAULT; + 140. if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) { + 141. > dev_dbg(pps->dev, "capture mode unspecified (%x)\n", + 142. params.mode); + 143. return -EINVAL; + +drivers/pps/pps.c:148: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 146. /* Check for supported capabilities */ + 147. if ((params.mode & ~pps->info.mode) != 0) { + 148. > dev_dbg(pps->dev, "unsupported capabilities (%x)\n", + 149. params.mode); + 150. return -EINVAL; + +drivers/pps/pps.c:161: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 159. if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + 160. /* section 3.3 of RFC 2783 interpreted */ + 161. > dev_dbg(pps->dev, "time format unspecified (%x)\n", + 162. params.mode); + 163. pps->params.mode |= PPS_TSFMT_TSPEC; + +include/linux/rbtree_latch.h:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. int (*comp)(void *key, struct latch_tree_node *node)) + 107. { + 108. > struct rb_node *node = rcu_dereference_raw(ltr->tree[idx].rb_node); + 109. struct latch_tree_node *ltn; + 110. int c; + +include/linux/rbtree_latch.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. + 116. if (c < 0) + 117. > node = rcu_dereference_raw(node->rb_left); + 118. else if (c > 0) + 119. node = rcu_dereference_raw(node->rb_right); + +include/linux/rbtree_latch.h:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. node = rcu_dereference_raw(node->rb_left); + 118. else if (c > 0) + 119. > node = rcu_dereference_raw(node->rb_right); + 120. else + 121. return ltn; + +lib/rhashtable.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. unsigned int i; + 109. + 110. > ntbl = rcu_dereference_raw(ntbl->table); + 111. if (!ntbl) + 112. return; + +drivers/pnp/support.c:126: error: DEAD_STORE + The value written to &len (type int) is never used. + 124. case IORESOURCE_IO: + 125. port = &option->u.port; + 126. > len += scnprintf(buf + len, sizeof(buf) - len, "io min %#llx " + 127. "max %#llx align %lld size %lld flags %#x", + 128. (unsigned long long) port->min, + +drivers/pnp/support.c:135: error: DEAD_STORE + The value written to &len (type int) is never used. + 133. case IORESOURCE_MEM: + 134. mem = &option->u.mem; + 135. > len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx " + 136. "max %#llx align %lld size %lld flags %#x", + 137. (unsigned long long) mem->min, + +drivers/pnp/support.c:158: error: DEAD_STORE + The value written to &len (type int) is never used. + 156. irq->flags); + 157. if (irq->flags & IORESOURCE_IRQ_OPTIONAL) + 158. > len += scnprintf(buf + len, sizeof(buf) - len, + 159. " (optional)"); + 160. break; + +drivers/pnp/support.c:174: error: DEAD_STORE + The value written to &len (type int) is never used. + 172. " %d", i); + 173. } + 174. > len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) " + 175. "flags %#x", dma->map, dma->flags); + 176. break; + +include/trace/events/tcp.h:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. ); + 104. + 105. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 106. + 107. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:105: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 103. ); + 104. + 105. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 106. + 107. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:105: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 103. ); + 104. + 105. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 106. + 107. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +kernel/cgroup/freezer.c:108: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 107 could be null and is dereferenced by call to `parent_freezer()` at line 108, column 27. + 106. { + 107. struct freezer *freezer = css_freezer(css); + 108. > struct freezer *parent = parent_freezer(freezer); + 109. + 110. mutex_lock(&freezer_mutex); + +net/core/sysctl_net_core.c:158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 156. for_each_possible_cpu(i) { + 157. sd = &per_cpu(softnet_data, i); + 158. > if (rcu_dereference(sd->flow_limit)) + 159. cpumask_set_cpu(i, mask); + 160. } + +drivers/tty/serial/serial_core.c:115: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 113. if (port) + 114. port->ops->stop_tx(port); + 115. > uart_port_unlock(port, flags); + 116. } + 117. + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +kernel/smp.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. static __always_inline void csd_lock_wait(call_single_data_t *csd) + 107. { + 108. > smp_cond_load_acquire(&csd->flags, !(VAL & CSD_FLAG_LOCK)); + 109. } + 110. + +kernel/smpboot.c:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. preempt_enable(); + 127. if (ht->park && td->status == HP_THREAD_ACTIVE) { + 128. > BUG_ON(td->cpu != smp_processor_id()); + 129. ht->park(td->cpu); + 130. td->status = HP_THREAD_PARKED; + +kernel/smpboot.c:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. } + 136. + 137. > BUG_ON(td->cpu != smp_processor_id()); + 138. + 139. /* Check for state change setup */ + +drivers/pci/pci-acpi.c:118: error: UNINITIALIZED_VALUE + The value read from mcfg_addr was never initialized. + 116. return 0; + 117. + 118. > return (phys_addr_t)mcfg_addr; + 119. } + 120. + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +kernel/locking/rtmutex_common.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock) + 108. { + 109. > unsigned long owner = (unsigned long) READ_ONCE(lock->owner); + 110. + 111. return (struct task_struct *) (owner & ~RT_MUTEX_HAS_WAITERS); + +include/linux/seqlock.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. + 112. repeat: + 113. > ret = READ_ONCE(s->sequence); + 114. if (unlikely(ret & 1)) { + 115. cpu_relax(); + +kernel/trace/trace_events_trigger.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct event_trigger_data *data; + 114. + 115. > list_for_each_entry_rcu(data, &file->triggers, list) { + 116. if (data->paused) + 117. continue; + +net/netfilter/nf_conntrack_irc.c:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. IPPROTO_TCP, NULL, &port); + 211. + 212. > nf_nat_irc = rcu_dereference(nf_nat_irc_hook); + 213. if (nf_nat_irc && ct->status & IPS_NAT_MASK) + 214. ret = nf_nat_irc(skb, ctinfo, protoff, + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +lib/hexdump.c:205: error: DEAD_STORE + The value written to &lx (type int) is never used. + 203. return lx; + 204. overflow2: + 205. > linebuf[lx++] = '\0'; + 206. overflow1: + 207. return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1; + +net/ipv4/xfrm4_protocol.c:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. struct xfrm4_protocol *handler; + 112. + 113. > for_each_protocol_rcu(esp4_handlers, handler) + 114. if (!handler->err_handler(skb, info)) + 115. break; + +net/xfrm/xfrm_policy.c:116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 114. return NULL; + 115. rcu_read_lock(); + 116. > afinfo = rcu_dereference(xfrm_policy_afinfo[family]); + 117. if (unlikely(!afinfo)) + 118. rcu_read_unlock(); + +lib/idr.c:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. + 119. *nextid = iter.index; + 120. > return rcu_dereference_raw(*slot); + 121. } + 122. EXPORT_SYMBOL(idr_get_next); + +net/ipv6/af_inet6.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. err = -ESOCKTNOSUPPORT; + 128. rcu_read_lock(); + 129. > list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) { + 130. + 131. err = 0; + +net/ipv6/xfrm6_protocol.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct xfrm6_protocol *handler; + 114. + 115. > for_each_protocol_rcu(ah6_handlers, handler) + 116. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 117. break; + +net/netlabel/netlabel_addrlist.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct netlbl_af6list *iter; + 114. + 115. > list_for_each_entry_rcu(iter, head, list) + 116. if (iter->valid && + 117. ipv6_masked_addr_cmp(&iter->addr, &iter->mask, addr) == 0) + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/pci/proc.c:173: error: DEAD_STORE + The value written to &buf (type char const *) is never used. + 171. __get_user(val, buf); + 172. pci_user_write_config_byte(dev, pos, val); + 173. > buf++; + 174. pos++; + 175. cnt--; + +drivers/pci/proc.c:175: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 173. buf++; + 174. pos++; + 175. > cnt--; + 176. } + 177. + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +kernel/time/tick-oneshot.c:117: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 115. + 116. local_irq_save(flags); + 117. > ret = __this_cpu_read(tick_cpu_device.mode) == TICKDEV_MODE_ONESHOT; + 118. local_irq_restore(flags); + 119. + +net/netfilter/nf_conntrack_standalone.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. st->bucket < st->htable_size; + 118. st->bucket++) { + 119. > n = rcu_dereference( + 120. hlist_nulls_first_rcu(&st->hash[st->bucket])); + 121. if (!is_a_nulls(n)) + +block/partition-generic.c:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. int cpu; + 119. + 120. > cpu = part_stat_lock(); + 121. part_round_stats(q, cpu, p); + 122. part_stat_unlock(); + +block/partition-generic.c:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. int cpu; + 119. + 120. > cpu = part_stat_lock(); + 121. part_round_stats(q, cpu, p); + 122. part_stat_unlock(); + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +net/ipv6/xfrm6_mode_tunnel.c:116: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 114 could be null and is dereferenced at line 116, column 6. + 114. struct xfrm_offload *xo = xfrm_offload(skb); + 115. + 116. > if (xo->flags & XFRM_GSO_SEGMENT) { + 117. skb->network_header = skb->network_header - x->props.header_len; + 118. skb->transport_header = skb->network_header + sizeof(struct ipv6hdr); + +net/sched/act_api.c:121: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 119. struct idr *idr = &idrinfo->action_idr; + 120. struct tc_action *p; + 121. > unsigned long id = 1; + 122. + 123. spin_lock_bh(&idrinfo->lock); + +arch/x86/include/asm/syscall.h:138: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 136. case 5: + 137. if (!n--) break; + 138. > *args++ = regs->bp; + 139. case 6: + 140. if (!n--) break; + +arch/x86/include/asm/syscall.h:165: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 163. case 5: + 164. if (!n--) break; + 165. > *args++ = regs->r9; + 166. case 6: + 167. if (!n--) break; + +arch/x86/include/asm/syscall.h:140: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 138. *args++ = regs->bp; + 139. case 6: + 140. > if (!n--) break; + 141. default: + 142. BUG(); + +arch/x86/include/asm/syscall.h:167: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 165. *args++ = regs->r9; + 166. case 6: + 167. > if (!n--) break; + 168. default: + 169. BUG(); + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +net/ipv4/tunnel4.c:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. goto drop; + 119. + 120. > for_each_tunnel_rcu(tunnel64_handlers, handler) + 121. if (!handler->handler(skb)) + 122. return 0; + +drivers/iommu/dmar.c:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. + 119. if (*devices && *cnt) { + 120. > for_each_active_dev_scope(*devices, *cnt, i, tmp_dev) + 121. put_device(tmp_dev); + 122. kfree(*devices); + +include/net/busy_poll.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. { + 116. #ifdef CONFIG_NET_RX_BUSY_POLL + 117. > unsigned int napi_id = READ_ONCE(sk->sk_napi_id); + 118. + 119. if (napi_id >= MIN_NAPI_ID) + +net/ipv4/tcp_fastopen.c:122: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 120. rcu_read_lock(); + 121. + 122. > ctx = rcu_dereference(inet_csk(sk)->icsk_accept_queue.fastopenq.ctx); + 123. if (!ctx) + 124. ctx = rcu_dereference(sock_net(sk)->ipv4.tcp_fastopen_ctx); + +net/ipv4/tcp_fastopen.c:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. ctx = rcu_dereference(inet_csk(sk)->icsk_accept_queue.fastopenq.ctx); + 123. if (!ctx) + 124. > ctx = rcu_dereference(sock_net(sk)->ipv4.tcp_fastopen_ctx); + 125. + 126. if (ctx) { + +net/netfilter/nf_queue.c:125: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 123. + 124. /* QUEUE == DROP if no one is waiting, to be safe. */ + 125. > qh = rcu_dereference(net->nf.queue_handler); + 126. if (!qh) { + 127. status = -ESRCH; + +security/selinux/netnode.c:131: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 129. } + 130. + 131. > list_for_each_entry_rcu(node, &sel_netnode_hash[idx].list, list) + 132. if (node->nsec.family == family) + 133. switch (family) { + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgtyp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +net/netfilter/nf_conntrack_helper.c:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. + 125. h = helper_hash(tuple); + 126. > hlist_for_each_entry_rcu(helper, &nf_ct_helper_hash[h], hnode) { + 127. if (nf_ct_tuple_src_mask_cmp(tuple, &helper->tuple, &mask)) + 128. return helper; + +net/netfilter/nf_conntrack_proto.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. return &nf_conntrack_l4proto_generic; + 120. + 121. > return rcu_dereference(nf_ct_protos[l3proto][l4proto]); + 122. } + 123. EXPORT_SYMBOL_GPL(__nf_ct_l4proto_find); + +drivers/md/dm.c:118: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 116. static int __dm_get_module_param_int(int *module_param, int min, int max) + 117. { + 118. > int param = READ_ONCE(*module_param); + 119. int modified_param = 0; + 120. bool modified = true; + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/tcp.h:116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 114. * active reset, skb should be NULL + 115. */ + 116. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 117. + 118. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. * active reset, skb should be NULL + 115. */ + 116. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 117. + 118. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. * active reset, skb should be NULL + 115. */ + 116. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 117. + 118. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +kernel/events/ring_buffer.c:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. event = event->parent; + 136. + 137. > rb = rcu_dereference(event->rb); + 138. if (unlikely(!rb)) + 139. goto out; + +kernel/events/ring_buffer.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. + 159. do { + 160. > tail = READ_ONCE(rb->user_page->data_tail); + 161. offset = head = local_read(&rb->head); + 162. if (!rb->overwrite) { + +arch/x86/pci/mmconfig-shared.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. struct pci_mmcfg_region *cfg; + 120. + 121. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) + 122. if (cfg->segment == segment && + 123. cfg->start_bus <= bus && bus <= cfg->end_bus) + +crypto/echainiv.c:131: error: DEAD_STORE + The value written to &alg (type aead_alg*) is never used. + 129. + 130. spawn = aead_instance_ctx(inst); + 131. > alg = crypto_spawn_aead_alg(spawn); + 132. + 133. err = -EINVAL; + +include/linux/ptrace.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. { + 119. if (unlikely(task->ptrace)) + 120. > return rcu_dereference(task->parent); + 121. return NULL; + 122. } + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +lib/errseq.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. errseq_t errseq_sample(errseq_t *eseq) + 118. { + 119. > errseq_t old = READ_ONCE(*eseq); + 120. errseq_t new = old; + 121. + +net/netfilter/nf_conntrack_expect.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. + 128. h = nf_ct_expect_dst_hash(net, tuple); + 129. > hlist_for_each_entry_rcu(i, &nf_ct_expect_hash[h], hnode) { + 130. if (nf_ct_exp_equal(tuple, i, zone, net)) + 131. return i; + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/gpu/drm/i915/intel_dsi.c:136: error: DEAD_STORE + The value written to &data (type unsigned char const *) is never used. + 134. + 135. header = packet.header; + 136. > data = packet.payload; + 137. + 138. if (msg->flags & MIPI_DSI_MSG_USE_LPM) { + +net/ipv4/xfrm4_protocol.c:125: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 123. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 124. + 125. > for_each_protocol_rcu(ah4_handlers, handler) + 126. if ((ret = handler->handler(skb)) != -EINVAL) + 127. return ret; + +net/ipv6/inet6_connection_sock.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. fl6.daddr = sk->sk_v6_daddr; + 138. + 139. > res = ip6_xmit(sk, skb, &fl6, sk->sk_mark, rcu_dereference(np->opt), + 140. np->tclass); + 141. rcu_read_unlock(); + +net/netlabel/netlabel_domainhash.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. for (iter = 0, val = 0, len = strlen(key); iter < len; iter++) + 128. val = (val << 4 | (val >> (8 * sizeof(u32) - 4))) ^ key[iter]; + 129. > return val & (netlbl_domhsh_rcu_deref(netlbl_domhsh)->size - 1); + 130. } + 131. + +drivers/gpu/drm/drm_lock.c:137: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 135. old = *lock; + 136. new = _DRM_LOCKING_CONTEXT(old); + 137. > prev = cmpxchg(lock, old, new); + 138. } while (prev != old); + 139. + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.chan was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.func was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:245: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 243. break; + 244. } + 245. > pin_index = pd.index; + 246. if (pin_index >= ops->n_pins) { + 247. err = -EINVAL; + +drivers/ptp/ptp_chardev.c:263: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 261. break; + 262. } + 263. > pin_index = pd.index; + 264. if (pin_index >= ops->n_pins) { + 265. err = -EINVAL; + +drivers/scsi/scsi_transport_spi.c:142: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 140. break; + 141. } + 142. > return result; + 143. } + 144. + +net/ipv4/fib_frontend.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. + 129. head = &net->ipv4.fib_table_hash[h]; + 130. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 131. if (tb->tb_id == id) + 132. return tb; + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +kernel/irq/spurious.c:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. goto out; + 127. + 128. > irq_poll_cpu = smp_processor_id(); + 129. + 130. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. goto out; + 127. + 128. > irq_poll_cpu = smp_processor_id(); + 129. + 130. for_each_irq_desc(i, desc) { + +net/ipv6/tcp_ipv6.c:199: error: UNINITIALIZED_VALUE + The value read from fl6.flowlabel was never initialized. + 197. + 198. sk->sk_v6_daddr = usin->sin6_addr; + 199. > np->flow_label = fl6.flowlabel; + 200. + 201. /* + +net/ipv6/xfrm6_policy.c:162: error: DEAD_STORE + The value written to &exthdr (type ipv6_opt_hdr*) is never used. + 160. offset += ipv6_optlen(exthdr); + 161. nexthdr = exthdr->nexthdr; + 162. > exthdr = (struct ipv6_opt_hdr *)(nh + offset); + 163. break; + 164. + +net/ipv6/xfrm6_protocol.c:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 126. + 127. > for_each_protocol_rcu(ipcomp6_handlers, handler) + 128. if ((ret = handler->handler(skb)) != -EINVAL) + 129. return ret; + +net/sunrpc/clnt.c:147: error: UNINITIALIZED_VALUE + The value read from dentry was never initialized. + 145. } + 146. dput(dir); + 147. > return dentry; + 148. } + 149. + +sound/core/info.c:130: error: DEAD_STORE + The value written to &offset (type long long) is never used. + 128. mutex_lock(&entry->access); + 129. if (entry->c.ops->llseek) { + 130. > offset = entry->c.ops->llseek(entry, + 131. data->file_private_data, + 132. file, offset, orig); + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +drivers/base/devtmpfs.c:148: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 146. + 147. kfree(tmp); + 148. > return req.err; + 149. } + 150. + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +kernel/rcu/rcu.h:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. static inline unsigned long rcu_seq_current(unsigned long *sp) + 123. { + 124. > return READ_ONCE(*sp); + 125. } + 126. + +drivers/scsi/scsi_logging.c:140: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 138. if (off < logbuf_len) { + 139. va_start(args, fmt); + 140. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 141. va_end(args); + 142. } + +kernel/compat.c:134: error: UNINITIALIZED_VALUE + The value read from ts.tv_nsec was never initialized. + 132. + 133. ts64->tv_sec = ts.tv_sec; + 134. > ts64->tv_nsec = ts.tv_nsec; + 135. + 136. return 0; + +kernel/compat.c:133: error: UNINITIALIZED_VALUE + The value read from ts.tv_sec was never initialized. + 131. return -EFAULT; + 132. + 133. > ts64->tv_sec = ts.tv_sec; + 134. ts64->tv_nsec = ts.tv_nsec; + 135. + +lib/rhashtable.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. unsigned int i; + 129. + 130. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 131. + 132. for (i = 0; i < len; i++) + +net/sched/cls_api.c:134: error: DEAD_STORE + The value written to &err (type int) is never used. + 132. return ERR_PTR(-ENOBUFS); + 133. + 134. > err = -ENOENT; + 135. tp->ops = tcf_proto_lookup_ops(kind); + 136. if (!tp->ops) { + +drivers/dma/virt-dma.h:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. static inline struct virt_dma_desc *vchan_next_desc(struct virt_dma_chan *vc) + 125. { + 126. > return list_first_entry_or_null(&vc->desc_issued, + 127. struct virt_dma_desc, node); + 128. } + +drivers/gpu/drm/i915/intel_huc.c:154: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 152. + 153. /* Wait for DMA to finish */ + 154. > ret = wait_for((I915_READ(DMA_CTRL) & START_DMA) == 0, 100); + 155. + 156. DRM_DEBUG_DRIVER("HuC DMA transfer wait over with ret %d\n", ret); + +drivers/input/ff-memless.c:127: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 125. { + 126. struct ml_effect_state *state; + 127. > unsigned long now = jiffies; + 128. unsigned long earliest = 0; + 129. unsigned long next_at; + +lib/idr.c:134: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 132. + 133. *nextid = iter.index; + 134. > return rcu_dereference_raw(*slot); + 135. } + 136. EXPORT_SYMBOL(idr_get_next_ext); + +lib/radix-tree.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. { + 128. unsigned int offset = (index >> parent->shift) & RADIX_TREE_MAP_MASK; + 129. > void __rcu **entry = rcu_dereference_raw(parent->slots[offset]); + 130. + 131. #ifdef CONFIG_RADIX_TREE_MULTIORDER + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +arch/x86/entry/vsyscall/vsyscall_64.c:216: error: UNINITIALIZED_VALUE + The value read from syscall_nr was never initialized. + 214. * here doesn't matter. + 215. */ + 216. > regs->orig_ax = syscall_nr; + 217. regs->ax = -ENOSYS; + 218. tmp = secure_computing(NULL); + +drivers/base/power/runtime.c:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. goto out; + 136. + 137. > autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); + 138. if (autosuspend_delay < 0) + 139. goto out; + +drivers/base/power/runtime.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. goto out; + 140. + 141. > last_busy = READ_ONCE(dev->power.last_busy); + 142. elapsed = jiffies - last_busy; + 143. if (elapsed < 0) + +drivers/tty/serial/serial_core.c:135: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 133. port = uart_port_lock(state, flags); + 134. __uart_start(tty); + 135. > uart_port_unlock(port, flags); + 136. } + 137. + +drivers/usb/storage/sierra_ms.c:197: error: DEAD_STORE + The value written to &result (type int) is never used. + 195. } + 196. complete: + 197. > result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); + 198. + 199. return 0; + +drivers/usb/storage/sierra_ms.c:134: error: DEAD_STORE + The value written to &retries (type int) is never used. + 132. struct Scsi_Host *sh; + 133. + 134. > retries = 3; + 135. result = 0; + 136. udev = us->pusb_dev; + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +net/ipv6/addrlabel.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. struct ip6addrlbl_entry *p; + 132. + 133. > hlist_for_each_entry_rcu(p, &net->ipv6.ip6addrlbl_table.head, list) { + 134. if (__ip6addrlbl_match(p, addr, type, ifindex)) + 135. return p; + +net/netfilter/nf_conntrack_standalone.c:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. struct ct_iter_state *st = seq->private; + 131. + 132. > head = rcu_dereference(hlist_nulls_next_rcu(head)); + 133. while (is_a_nulls(head)) { + 134. if (likely(get_nulls_value(head) == st->bucket)) { + +net/netfilter/nf_conntrack_standalone.c:138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 136. return NULL; + 137. } + 138. > head = rcu_dereference( + 139. hlist_nulls_first_rcu(&st->hash[st->bucket])); + 140. } + +drivers/gpu/drm/drm_ioc32.c:139: error: UNINITIALIZED_VALUE + The value read from uq32.unique was never initialized. + 137. uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. > .unique = compat_ptr(uq32.unique), + 140. }; + 141. + +drivers/gpu/drm/drm_ioc32.c:137: error: UNINITIALIZED_VALUE + The value read from uq32.unique_len was never initialized. + 135. if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32))) + 136. return -EFAULT; + 137. > uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. .unique = compat_ptr(uq32.unique), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +net/ipv4/inet_connection_sock.c:152: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 150. sk2->sk_state == TCP_LISTEN) && + 151. (!reuseport || !sk2->sk_reuseport || + 152. > rcu_access_pointer(sk->sk_reuseport_cb) || + 153. (sk2->sk_state != TCP_TIME_WAIT && + 154. !uid_eq(uid, sock_i_uid(sk2))))) { + +drivers/char/hw_random/via-rng.c:177: error: DEAD_STORE + The value written to &hi (type unsigned int) is never used. + 175. /* perhaps-unnecessary sanity check; remove after testing if + 176. unneeded */ + 177. > rdmsr(MSR_VIA_RNG, lo, hi); + 178. if ((lo & VIA_RNG_ENABLE) == 0) { + 179. pr_err(PFX "cannot enable VIA C3 RNG, aborting\n"); + +drivers/gpu/drm/i915/intel_guc_fw.c:173: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 171. * execlist mode if this happens.) + 172. */ + 173. > ret = wait_for(guc_ucode_response(dev_priv, &status), 100); + 174. + 175. DRM_DEBUG_DRIVER("DMA status 0x%x, GuC status 0x%x\n", + +drivers/gpu/drm/i915/intel_guc_fw.c:173: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 171. * execlist mode if this happens.) + 172. */ + 173. > ret = wait_for(guc_ucode_response(dev_priv, &status), 100); + 174. + 175. DRM_DEBUG_DRIVER("DMA status 0x%x, GuC status 0x%x\n", + +drivers/gpu/drm/i915/intel_guc_fw.c:175: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 173. ret = wait_for(guc_ucode_response(dev_priv, &status), 100); + 174. + 175. > DRM_DEBUG_DRIVER("DMA status 0x%x, GuC status 0x%x\n", + 176. I915_READ(DMA_CTRL), status); + 177. + +net/ipv6/udp.c:173: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 171. } + 172. + 173. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 174. score++; + 175. + +drivers/connector/cn_proc.c:147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 145. ev->event_data.id.process_tgid = task->tgid; + 146. rcu_read_lock(); + 147. > cred = __task_cred(task); + 148. if (which_id == PROC_EVENT_UID) { + 149. ev->event_data.id.r.ruid = from_kuid_munged(&init_user_ns, cred->uid); + +include/linux/percpu-refcount.h:143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 141. * READ_ONCE() is required when fetching it. + 142. */ + 143. > percpu_ptr = READ_ONCE(ref->percpu_count_ptr); + 144. + 145. /* paired with smp_store_release() in __percpu_ref_switch_to_percpu() */ + +include/linux/seqlock.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. static inline unsigned raw_read_seqcount(const seqcount_t *s) + 131. { + 132. > unsigned ret = READ_ONCE(s->sequence); + 133. smp_rmb(); + 134. return ret; + +kernel/cgroup/freezer.c:136: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 132 could be null and is dereferenced at line 136, column 6. + 134. mutex_lock(&freezer_mutex); + 135. + 136. > if (freezer->state & CGROUP_FREEZING) + 137. atomic_dec(&system_freezing_cnt); + 138. + +drivers/input/input.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. rcu_read_lock(); + 141. + 142. > handle = rcu_dereference(dev->grab); + 143. if (handle) { + 144. count = input_to_handler(handle, vals, count); + +drivers/input/input.c:146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 144. count = input_to_handler(handle, vals, count); + 145. } else { + 146. > list_for_each_entry_rcu(handle, &dev->h_list, d_node) + 147. if (handle->open) { + 148. count = input_to_handler(handle, vals, count); + +init/initramfs.c:137: error: NULL_DEREFERENCE + pointer `de` last assigned on line 133 could be null and is dereferenced at line 137, column 2. + 135. panic("can't allocate dir_entry buffer"); + 136. INIT_LIST_HEAD(&de->list); + 137. > de->name = kstrdup(name, GFP_KERNEL); + 138. de->mtime = mtime; + 139. list_add(&de->list, &dir_list); + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +net/core/gen_stats.c:149: error: UNINITIALIZED_VALUE + The value read from seq was never initialized. + 147. bstats->bytes = b->bytes; + 148. bstats->packets = b->packets; + 149. > } while (running && read_seqcount_retry(running, seq)); + 150. } + 151. EXPORT_SYMBOL(__gnet_stats_copy_basic); + +net/ipv6/netfilter/nf_reject_ipv6.c:187: error: DEAD_STORE + The value written to &ip6h (type ipv6hdr*) is never used. + 185. + 186. skb_reserve(nskb, hh_len + dst->header_len); + 187. > ip6h = nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP, + 188. ip6_dst_hoplimit(dst)); + 189. nf_reject_ip6_tcphdr_put(nskb, oldskb, otcph, otcplen); + +block/genhd.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. + 138. rcu_read_lock(); + 139. > ptbl = rcu_dereference(disk->part_tbl); + 140. + 141. piter->disk = disk; + +drivers/gpu/drm/i915/intel_lspcon.c:154: error: UNINITIALIZED_VALUE + The value read from adaptor_type was never initialized. + 152. + 153. if (adaptor_type != DRM_DP_DUAL_MODE_LSPCON) { + 154. > DRM_DEBUG_KMS("No LSPCON detected, found %s\n", + 155. drm_dp_get_dual_mode_type_name(adaptor_type)); + 156. return false; + +include/net/inet_sock.h:135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 133. static inline struct ip_options_rcu *ireq_opt_deref(const struct inet_request_sock *ireq) + 134. { + 135. > return rcu_dereference_check(ireq->ireq_opt, + 136. refcount_read(&ireq->req.rsk_refcnt) > 0); + 137. } + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +net/ipv4/af_inet.c:158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 156. + 157. kfree(rcu_dereference_protected(inet->inet_opt, 1)); + 158. > dst_release(rcu_dereference_check(sk->sk_dst_cache, 1)); + 159. dst_release(sk->sk_rx_dst); + 160. sk_refcnt_debug_dec(sk); + +net/ipv6/syncookies.c:232: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 230. fl6.flowi6_proto = IPPROTO_TCP; + 231. fl6.daddr = ireq->ir_v6_rmt_addr; + 232. > final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), &final); + 233. fl6.saddr = ireq->ir_v6_loc_addr; + 234. fl6.flowi6_oif = ireq->ir_iif; + +net/netfilter/nf_conntrack_helper.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. + 139. for (i = 0; i < nf_ct_helper_hsize; i++) { + 140. > hlist_for_each_entry_rcu(h, &nf_ct_helper_hash[i], hnode) { + 141. if (strcmp(h->name, name)) + 142. continue; + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +net/netlabel/netlabel_cipso_v4.c:137: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 135. struct netlbl_audit *audit_info) + 136. { + 137. > int ret_val = -EINVAL; + 138. struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + +drivers/gpu/drm/i915/dvo_ch7xxx.c:161: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 159. + 160. if (i2c_transfer(adapter, msgs, 2) == 2) { + 161. > *ch = in_buf[0]; + 162. return true; + 163. } + +drivers/tty/sysrq.c:147: error: NULL_DEREFERENCE + pointer `killer` last assigned on line 137 could be null and is dereferenced at line 147, column 2. + 145. panic_on_oops = 1; /* force panic */ + 146. wmb(); + 147. > *killer = 1; + 148. } + 149. static struct sysrq_key_op sysrq_crash_op = { + +net/ipv4/xfrm4_protocol.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. struct xfrm4_protocol *handler; + 138. + 139. > for_each_protocol_rcu(ah4_handlers, handler) + 140. if (!handler->err_handler(skb, info)) + 141. break; + +net/ipv6/mcast.c:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. + 148. rcu_read_lock(); + 149. > for_each_pmc_rcu(np, mc_lst) { + 150. if ((ifindex == 0 || mc_lst->ifindex == ifindex) && + 151. ipv6_addr_equal(&mc_lst->addr, addr)) { + +net/netlabel/netlabel_addrlist.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. struct netlbl_af6list *iter; + 140. + 141. > list_for_each_entry_rcu(iter, head, list) + 142. if (iter->valid && + 143. ipv6_addr_equal(&iter->addr, addr) && + +drivers/usb/core/devio.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. u64 lim; + 139. + 140. > lim = READ_ONCE(usbfs_memory_mb); + 141. lim <<= 20; + 142. + +arch/x86/entry/common.c:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. local_irq_disable(); + 173. + 174. > cached_flags = READ_ONCE(current_thread_info()->flags); + 175. + 176. if (!(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +drivers/md/dm.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. unsigned def, unsigned max) + 139. { + 140. > unsigned param = READ_ONCE(*module_param); + 141. unsigned modified_param = 0; + 142. + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +net/ipv6/xfrm6_protocol.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. struct xfrm6_protocol *handler; + 141. + 142. > for_each_protocol_rcu(ipcomp6_handlers, handler) + 143. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 144. break; + +net/netfilter/nf_conntrack_sip.c:174: error: UNINITIALIZED_VALUE + The value read from end was never initialized. + 172. + 173. if (endp) + 174. > *endp = end; + 175. return 1; + 176. } + +kernel/nsproxy.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. { + 140. struct nsproxy *old_ns = tsk->nsproxy; + 141. > struct user_namespace *user_ns = task_cred_xxx(tsk, user_ns); + 142. struct nsproxy *new_ns; + 143. + +block/blk-mq-sched.c:143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 141. struct request_queue *q = hctx->queue; + 142. LIST_HEAD(rq_list); + 143. > struct blk_mq_ctx *ctx = READ_ONCE(hctx->dispatch_from); + 144. + 145. do { + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +security/commoncap.c:147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 145. rcu_read_lock(); + 146. cred = current_cred(); + 147. > child_cred = __task_cred(child); + 148. if (mode & PTRACE_MODE_FSCREDS) + 149. caller_caps = &cred->cap_effective; + +kernel/smp.c:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. smp_call_func_t func, void *info) + 143. { + 144. > if (cpu == smp_processor_id()) { + 145. unsigned long flags; + 146. + +net/ipv6/ip6_offload.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. for (;;) { + 149. if (proto != NEXTHDR_HOP) { + 150. > *opps = rcu_dereference(inet6_offloads[proto]); + 151. if (unlikely(!(*opps))) + 152. break; + +net/ipv6/ipv6_sockglue.c:821: error: DEAD_STORE + The value written to &retv (type int) is never used. + 819. goto e_inval; + 820. + 821. > retv = -EINVAL; + 822. + 823. /* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */ + +net/ipv6/ipv6_sockglue.c:685: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 683. psin6 = (struct sockaddr_in6 *)&greq.gr_group; + 684. if (optname == MCAST_JOIN_GROUP) + 685. > retv = ipv6_sock_mc_join(sk, greq.gr_interface, + 686. &psin6->sin6_addr); + 687. else + +net/ipv6/ipv6_sockglue.c:688: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 686. &psin6->sin6_addr); + 687. else + 688. > retv = ipv6_sock_mc_drop(sk, greq.gr_interface, + 689. &psin6->sin6_addr); + 690. break; + +net/ipv6/ipv6_sockglue.c:721: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 719. + 720. psin6 = (struct sockaddr_in6 *)&greqs.gsr_group; + 721. > retv = ipv6_sock_mc_join(sk, greqs.gsr_interface, + 722. &psin6->sin6_addr); + 723. /* prior join w/ different source is ok */ + +net/ipv6/ipv6_sockglue.c:644: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 642. + 643. if (optname == IPV6_ADD_MEMBERSHIP) + 644. > retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + +net/ipv6/ipv6_sockglue.c:646: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 644. retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. > retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 647. break; + 648. } + +net/ipv6/ipv6_sockglue.c:662: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 660. + 661. if (optname == IPV6_JOIN_ANYCAST) + 662. > retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + +net/ipv6/ipv6_sockglue.c:664: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 662. retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. > retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 665. break; + 666. } + +net/ipv6/ipv6_sockglue.c:481: error: UNINITIALIZED_VALUE + The value read from pkt.ipi6_ifindex was never initialized. + 479. goto e_inval; + 480. + 481. > np->sticky_pktinfo.ipi6_ifindex = pkt.ipi6_ifindex; + 482. np->sticky_pktinfo.ipi6_addr = pkt.ipi6_addr; + 483. retv = 0; + +drivers/char/hpet.c:167: error: DEAD_STORE + The value written to &m (type unsigned long) is never used. + 165. + 166. t = devp->hd_ireqfreq; + 167. > m = read_counter(&devp->hd_timer->hpet_compare); + 168. mc = read_counter(&hpet->hpet_mc); + 169. /* The time for the next interrupt would logically be t + m, + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/rtc/rtc-dev.c:194: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 192. sizeof(unsigned long); + 193. } + 194. > return ret; + 195. } + 196. + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +drivers/gpu/drm/drm_modes.c:252: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 250. vsyncandback_porch = tmp1; + 251. /* 10. Find number of lines in back porch */ + 252. > vback_porch = vsyncandback_porch - vsync; + 253. drm_mode->vtotal = vdisplay_rnd + 2 * vmargin + + 254. vsyncandback_porch + CVT_MIN_V_PORCH; + +drivers/gpu/drm/drm_sysfs.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. enum drm_connector_status status; + 149. + 150. > status = READ_ONCE(connector->status); + 151. + 152. return snprintf(buf, PAGE_SIZE, "%s\n", + +crypto/seqiv.c:157: error: DEAD_STORE + The value written to &alg (type aead_alg*) is never used. + 155. + 156. spawn = aead_instance_ctx(inst); + 157. > alg = crypto_spawn_aead_alg(spawn); + 158. + 159. err = -EINVAL; + +drivers/gpu/drm/i915/i915_gem_shrinker.c:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. spin_lock(&dev_priv->mm.obj_lock); + 225. while (count < target && + 226. > (obj = list_first_entry_or_null(phase->list, + 227. typeof(*obj), + 228. mm.link))) { + +drivers/hid/hid-ntrig.c:162: error: DEAD_STORE + The value written to &ret (type int) is never used. + 160. + 161. if (ret == 8) { + 162. > ret = ntrig_version_string(&data[2], buf); + 163. + 164. hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n", + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +kernel/kprobes.c:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. retry: + 152. rcu_read_lock(); + 153. > list_for_each_entry_rcu(kip, &c->pages, list) { + 154. if (kip->nused < slots_per_page(c)) { + 155. int i; + +net/ipv4/xfrm4_protocol.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 150. + 151. > for_each_protocol_rcu(ipcomp4_handlers, handler) + 152. if ((ret = handler->handler(skb)) != -EINVAL) + 153. return ret; + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +include/linux/page-flags.h:147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 145. static inline struct page *compound_head(struct page *page) + 146. { + 147. > unsigned long head = READ_ONCE(page->compound_head); + 148. + 149. if (unlikely(head & 1)) + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/timer.h:145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 143. * @mode: the hrtimers mode + 144. */ + 145. > TRACE_EVENT(hrtimer_init, + 146. + 147. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +include/trace/events/timer.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. * @mode: the hrtimers mode + 144. */ + 145. > TRACE_EVENT(hrtimer_init, + 146. + 147. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +include/trace/events/timer.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. * @mode: the hrtimers mode + 144. */ + 145. > TRACE_EVENT(hrtimer_init, + 146. + 147. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +lib/assoc_array.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. void *iterator_data) + 149. { + 150. > struct assoc_array_ptr *root = READ_ONCE(array->root); + 151. + 152. if (!root) + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +kernel/irq/spurious.c:153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 151. if (atomic_inc_return(&irq_poll_active) != 1) + 152. goto out; + 153. > irq_poll_cpu = smp_processor_id(); + 154. + 155. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 151. if (atomic_inc_return(&irq_poll_active) != 1) + 152. goto out; + 153. > irq_poll_cpu = smp_processor_id(); + 154. + 155. for_each_irq_desc(i, desc) { + +kernel/time/posix-timers.c:152: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 150. struct k_itimer *timer; + 151. + 152. > hlist_for_each_entry_rcu(timer, head, t_hash) { + 153. if ((timer->it_signal == sig) && (timer->it_id == id)) + 154. return timer; + +arch/x86/platform/efi/efi_64.c:184: error: DEAD_STORE + The value written to &p4d (type p4d_t*) is never used. + 182. } + 183. + 184. > p4d = (p4d_t *)pgd_page_vaddr(*pgd); + 185. p4d_free(&init_mm, p4d); + 186. } + +lib/errseq.c:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. int errseq_check(errseq_t *eseq, errseq_t since) + 148. { + 149. > errseq_t cur = READ_ONCE(*eseq); + 150. + 151. if (likely(cur == since)) + +net/core/dst.c:151: error: DEAD_STORE + The value written to &dst (type dst_entry*) is never used. + 149. struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head); + 150. + 151. > dst = dst_destroy(dst); + 152. } + 153. + +net/core/net-procfs.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. + 155. rcu_read_lock(); + 156. > fl = rcu_dereference(sd->flow_limit); + 157. if (fl) + 158. flow_limit_count = fl->count; + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +drivers/gpu/drm/drm_framebuffer.c:177: error: NULL_DEREFERENCE + pointer `info` last assigned on line 165 could be null and is dereferenced at line 177, column 18. + 175. } + 176. + 177. > for (i = 0; i < info->num_planes; i++) { + 178. unsigned int width = fb_plane_width(r->width, info, i); + 179. unsigned int height = fb_plane_height(r->height, info, i); + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +net/ipv4/udp.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. inet_rcv_saddr_equal(sk, sk2, true)) { + 164. if (sk2->sk_reuseport && sk->sk_reuseport && + 165. > !rcu_access_pointer(sk->sk_reuseport_cb) && + 166. uid_eq(uid, sock_i_uid(sk2))) { + 167. if (!bitmap) + +net/sunrpc/auth_gss/gss_rpc_xdr.c:158: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 156. if (unlikely(p == NULL)) + 157. return -ENOSPC; + 158. > count = be32_to_cpup(p++); + 159. memset(&dummy, 0, sizeof(dummy)); + 160. for (i = 0; i < count; i++) { + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +kernel/sys.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. static bool set_one_prio_perm(struct task_struct *p) + 150. { + 151. > const struct cred *cred = current_cred(), *pcred = __task_cred(p); + 152. + 153. if (uid_eq(pcred->uid, cred->euid) || + +net/netlabel/netlabel_domainhash.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. if (domain != NULL) { + 158. bkt = netlbl_domhsh_hash(domain); + 159. > bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt]; + 160. list_for_each_entry_rcu(iter, bkt_list, list) + 161. if (iter->valid && + +net/netlabel/netlabel_domainhash.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. bkt = netlbl_domhsh_hash(domain); + 159. bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt]; + 160. > list_for_each_entry_rcu(iter, bkt_list, list) + 161. if (iter->valid && + 162. netlbl_family_match(iter->family, family) && + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +net/ipv4/udp_offload.c:171: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 169. case ENCAP_TYPE_IPPROTO: + 170. offloads = is_ipv6 ? inet6_offloads : inet_offloads; + 171. > ops = rcu_dereference(offloads[skb->inner_ipproto]); + 172. if (!ops || !ops->callbacks.gso_segment) + 173. goto out_unlock; + +net/netlabel/netlabel_addrlist.h:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. struct netlbl_af6list *n = __af6list_entry(s); + 156. while (i != h && !n->valid) { + 157. > i = rcu_dereference(list_next_rcu(i)); + 158. n = __af6list_entry(i); + 159. } + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +lib/rhashtable.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. int i; + 159. + 160. > ntbl = rcu_dereference(*prev); + 161. if (ntbl) + 162. return ntbl; + +net/ipv4/tunnel4.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. struct xfrm_tunnel *handler; + 155. + 156. > for_each_tunnel_rcu(tunnel4_handlers, handler) + 157. if (!handler->err_handler(skb, info)) + 158. break; + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/ksysfs.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. struct kobj_attribute *attr, char *buf) + 155. { + 156. > return sprintf(buf, "%d\n", READ_ONCE(rcu_expedited)); + 157. } + 158. static ssize_t rcu_expedited_store(struct kobject *kobj, + +net/sched/sch_mq.c:157: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 155 could be null and is dereferenced at line 157, column 9. + 155. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 156. + 157. > return dev_queue->qdisc_sleeping; + 158. } + 159. + +net/ipv4/ip_input.c:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. struct net *net = dev_net(dev); + 161. + 162. > for (ra = rcu_dereference(ip_ra_chain); ra; ra = rcu_dereference(ra->next)) { + 163. struct sock *sk = ra->sk; + 164. + +net/ipv4/ip_input.c:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. struct net *net = dev_net(dev); + 161. + 162. > for (ra = rcu_dereference(ip_ra_chain); ra; ra = rcu_dereference(ra->next)) { + 163. struct sock *sk = ra->sk; + 164. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:166: error: DEAD_STORE + The value written to &ret_val (type unsigned int) is never used. + 164. * at the end of this routine. + 165. */ + 166. > ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data); + 167. + 168. /* Disabled the PHY transmitter */ + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +lib/decompress_bunzip2.c:271: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 269. } + 270. /* Find largest and smallest lengths in this group */ + 271. > minLen = maxLen = length[0]; + 272. + 273. for (i = 1; i < symCount; i++) { + +lib/decompress_bunzip2.c:275: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 273. for (i = 1; i < symCount; i++) { + 274. if (length[i] > maxLen) + 275. > maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. minLen = length[i]; + +lib/decompress_bunzip2.c:277: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 275. maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. > minLen = length[i]; + 278. } + 279. + +net/ipv4/inet_fragment.c:167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 165. local_bh_disable(); + 166. + 167. > for (i = READ_ONCE(f->next_bucket); budget; --budget) { + 168. evicted += inet_evict_bucket(f, &f->hash[i]); + 169. i = (i + 1) & (INETFRAGS_HASHSZ - 1); + +drivers/gpu/drm/drm_sysfs.c:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. int dpms; + 162. + 163. > dpms = READ_ONCE(connector->dpms); + 164. + 165. return snprintf(buf, PAGE_SIZE, "%s\n", + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +kernel/events/callchain.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. return NULL; + 164. + 165. > entries = rcu_dereference(callchain_cpus_entries); + 166. if (!entries) + 167. return NULL; + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +net/ipv4/tcp_cong.c:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. + 162. rcu_read_lock(); + 163. > ca = rcu_dereference(net->ipv4.tcp_congestion_control); + 164. if (unlikely(!try_module_get(ca->owner))) + 165. ca = &tcp_reno; + +arch/x86/ia32/sys_ia32.c:166: error: UNINITIALIZED_VALUE + The value read from a.addr was never initialized. + 164. return -EINVAL; + 165. + 166. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 167. a.offset>>PAGE_SHIFT); + 168. } + +arch/x86/ia32/sys_ia32.c:166: error: UNINITIALIZED_VALUE + The value read from a.fd was never initialized. + 164. return -EINVAL; + 165. + 166. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 167. a.offset>>PAGE_SHIFT); + 168. } + +arch/x86/ia32/sys_ia32.c:166: error: UNINITIALIZED_VALUE + The value read from a.flags was never initialized. + 164. return -EINVAL; + 165. + 166. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 167. a.offset>>PAGE_SHIFT); + 168. } + +arch/x86/ia32/sys_ia32.c:166: error: UNINITIALIZED_VALUE + The value read from a.len was never initialized. + 164. return -EINVAL; + 165. + 166. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 167. a.offset>>PAGE_SHIFT); + 168. } + +arch/x86/ia32/sys_ia32.c:166: error: UNINITIALIZED_VALUE + The value read from a.prot was never initialized. + 164. return -EINVAL; + 165. + 166. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 167. a.offset>>PAGE_SHIFT); + 168. } + +drivers/gpu/drm/i915/intel_uncore.c:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. * thread to wake up. + 161. */ + 162. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 163. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 164. DRM_ERROR("GT thread status wait timed out\n"); + +drivers/gpu/drm/i915/intel_uncore.c:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. * thread to wake up. + 161. */ + 162. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 163. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 164. DRM_ERROR("GT thread status wait timed out\n"); + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +kernel/printk/printk.c:186: error: UNINITIALIZED_VALUE + The value read from old was never initialized. + 184. + 185. /* ... and restore old setting. */ + 186. > devkmsg_log = old; + 187. strncpy(devkmsg_log_str, old_str, DEVKMSG_STR_MAX_SIZE); + 188. + +kernel/time/timekeeping.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. static inline u64 tk_clock_read(struct tk_read_base *tkr) + 158. { + 159. > struct clocksource *clock = READ_ONCE(tkr->clock); + 160. + 161. return clock->read(clock); + +lib/ioremap.c:168: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 166. BUG_ON(addr >= end); + 167. + 168. > start = addr; + 169. phys_addr -= addr; + 170. pgd = pgd_offset_k(addr); + +include/linux/cpuidle.h:159: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 157. extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev); + 158. static inline struct cpuidle_device *cpuidle_get_device(void) + 159. > {return __this_cpu_read(cpuidle_devices); } + 160. #else + 161. static inline void disable_cpuidle(void) { } + +include/linux/cpuidle.h:159: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 157. extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev); + 158. static inline struct cpuidle_device *cpuidle_get_device(void) + 159. > {return __this_cpu_read(cpuidle_devices); } + 160. #else + 161. static inline void disable_cpuidle(void) { } + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +kernel/softirq.c:177: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 175. preempt_count_sub(cnt - 1); + 176. + 177. > if (unlikely(!in_interrupt() && local_softirq_pending())) { + 178. /* + 179. * Run softirq if any pending. And do it in its own stack + +drivers/dma-buf/dma-buf.c:185: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 183. rcu_read_lock(); + 184. + 185. > fobj = rcu_dereference(resv->fence); + 186. if (fobj) + 187. shared_count = fobj->shared_count; + +drivers/dma-buf/dma-buf.c:190: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 188. else + 189. shared_count = 0; + 190. > fence_excl = rcu_dereference(resv->fence_excl); + 191. if (read_seqcount_retry(&resv->seq, seq)) { + 192. rcu_read_unlock(); + +drivers/dma-buf/dma-buf.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. + 246. for (i = 0; i < shared_count; ++i) { + 247. > struct dma_fence *fence = rcu_dereference(fobj->shared[i]); + 248. + 249. if (!dma_fence_get_rcu(fence)) { + +net/netfilter/nf_log.c:179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 177. } + 178. + 179. > if (rcu_access_pointer(loggers[pf][type]) == NULL) + 180. request_module("nf-logger-%u-%u", pf, type); + 181. + +net/netfilter/nf_log.c:183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 181. + 182. rcu_read_lock(); + 183. > logger = rcu_dereference(loggers[pf][type]); + 184. if (logger == NULL) + 185. goto out; + +tools/lib/subcmd/exec-cmd.c:169: error: NULL_DEREFERENCE + pointer `nargv` last assigned on line 167 could be null and is dereferenced at line 169, column 2. + 167. nargv = malloc(sizeof(*nargv) * (argc + 2)); + 168. + 169. > nargv[0] = subcmd_config.exec_name; + 170. for (argc = 0; argv[argc]; argc++) + 171. nargv[argc + 1] = argv[argc]; + +net/ipv4/xfrm4_protocol.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. struct xfrm4_protocol *handler; + 164. + 165. > for_each_protocol_rcu(ipcomp4_handlers, handler) + 166. if (!handler->err_handler(skb, info)) + 167. break; + +arch/x86/lib/msr-smp.c:174: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 172. *h = rv.reg.h; + 173. + 174. > return err ? err : rv.err; + 175. } + 176. EXPORT_SYMBOL(rdmsr_safe_on_cpu); + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +net/ipv4/tunnel4.c:166: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 164. struct xfrm_tunnel *handler; + 165. + 166. > for_each_tunnel_rcu(tunnel64_handlers, handler) + 167. if (!handler->err_handler(skb, info)) + 168. break; + +net/netlabel/netlabel_addrlist.c:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. * address mask such that the entry with the widest mask (smallest + 174. * numerical value) appears first in the list */ + 175. > list_for_each_entry_rcu(iter, head, list) + 176. if (iter->valid && + 177. ntohl(entry->mask) > ntohl(iter->mask)) { + +drivers/net/ethernet/intel/e1000e/netdev.c:189: error: UNINITIALIZED_VALUE + The value read from regs[_] was never initialized. + 187. + 188. snprintf(rname, 16, "%s%s", reginfo->name, "[0-1]"); + 189. > pr_info("%-15s %08x %08x\n", rname, regs[0], regs[1]); + 190. } + 191. + +drivers/input/ff-memless.c:168: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 166. { + 167. struct ff_effect *effect = state->effect; + 168. > unsigned long now = jiffies; + 169. int time_from_level; + 170. int time_of_envelope; + +init/initramfs.c:175: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 173. parsed[i] = simple_strtoul(buf, NULL, 16); + 174. } + 175. > ino = parsed[0]; + 176. mode = parsed[1]; + 177. uid = parsed[2]; + +init/initramfs.c:176: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 174. } + 175. ino = parsed[0]; + 176. > mode = parsed[1]; + 177. uid = parsed[2]; + 178. gid = parsed[3]; + +init/initramfs.c:177: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 175. ino = parsed[0]; + 176. mode = parsed[1]; + 177. > uid = parsed[2]; + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + +init/initramfs.c:178: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 176. mode = parsed[1]; + 177. uid = parsed[2]; + 178. > gid = parsed[3]; + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + +init/initramfs.c:179: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 177. uid = parsed[2]; + 178. gid = parsed[3]; + 179. > nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + +init/initramfs.c:180: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + 180. > mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. major = parsed[7]; + +init/initramfs.c:181: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. > body_len = parsed[6]; + 182. major = parsed[7]; + 183. minor = parsed[8]; + +init/initramfs.c:182: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. > major = parsed[7]; + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + +init/initramfs.c:183: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 181. body_len = parsed[6]; + 182. major = parsed[7]; + 183. > minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. name_len = parsed[11]; + +init/initramfs.c:185: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. > name_len = parsed[11]; + 186. } + 187. + +net/ipv6/ip6_offload.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. rcu_read_lock(); + 193. proto = iph->nexthdr; + 194. > ops = rcu_dereference(inet6_offloads[proto]); + 195. if (!ops || !ops->callbacks.gro_receive) { + 196. __pskb_pull(skb, skb_gro_offset(skb)); + +net/ipv6/ip6_offload.c:203: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 201. __skb_push(skb, skb_gro_offset(skb)); + 202. + 203. > ops = rcu_dereference(inet6_offloads[proto]); + 204. if (!ops || !ops->callbacks.gro_receive) + 205. goto out_unlock; + +arch/x86/lib/delay.c:175: error: DEAD_STORE + The value written to &xloops (type unsigned long) is never used. + 173. :"1" (xloops), "0" (lpj * (HZ / 4))); + 174. + 175. > __delay(++xloops); + 176. } + 177. EXPORT_SYMBOL(__const_udelay); + +arch/x86/lib/delay.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. inline void __const_udelay(unsigned long xloops) + 166. { + 167. > unsigned long lpj = this_cpu_read(cpu_info.loops_per_jiffy) ? : loops_per_jiffy; + 168. int d0; + 169. + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +net/core/rtnetlink.c:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. msgindex = rtm_msgindex(msgtype); + 174. + 175. > tab = rcu_dereference_raw(rtnl_msg_handlers[protocol]); + 176. if (tab == NULL) { + 177. tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL); + +block/genhd.c:177: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 175. /* get part_tbl */ + 176. rcu_read_lock(); + 177. > ptbl = rcu_dereference(piter->disk->part_tbl); + 178. + 179. /* determine iteration parameters */ + +block/genhd.c:196: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 194. struct hd_struct *part; + 195. + 196. > part = rcu_dereference(ptbl->part[piter->idx]); + 197. if (!part) + 198. continue; + +kernel/sched/cpuacct.c:174: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 169 could be null and is dereferenced by call to `cpuacct_cpuusage_read()` at line 174, column 20. + 172. + 173. for_each_possible_cpu(i) + 174. > totalcpuusage += cpuacct_cpuusage_read(ca, i, index); + 175. + 176. return totalcpuusage; + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +drivers/gpu/drm/drm_ioc32.c:179: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 177. return -EFAULT; + 178. + 179. > map.offset = m32.offset; + 180. err = drm_ioctl_kernel(file, drm_legacy_getmap_ioctl, &map, DRM_UNLOCKED); + 181. if (err) + +drivers/gpu/drm/drm_ioc32.c:187: error: UNINITIALIZED_VALUE + The value read from map.flags was never initialized. + 185. m32.size = map.size; + 186. m32.type = map.type; + 187. > m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. m32.mtrr = map.mtrr; + +drivers/gpu/drm/drm_ioc32.c:189: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. > m32.mtrr = map.mtrr; + 190. if (copy_to_user(argp, &m32, sizeof(m32))) + 191. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:185: error: UNINITIALIZED_VALUE + The value read from map.size was never initialized. + 183. + 184. m32.offset = map.offset; + 185. > m32.size = map.size; + 186. m32.type = map.type; + 187. m32.flags = map.flags; + +drivers/gpu/drm/drm_ioc32.c:186: error: UNINITIALIZED_VALUE + The value read from map.type was never initialized. + 184. m32.offset = map.offset; + 185. m32.size = map.size; + 186. > m32.type = map.type; + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +net/sched/act_api.c:176: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 174. struct idr *idr = &idrinfo->action_idr; + 175. struct tc_action *p; + 176. > unsigned long id = 1; + 177. + 178. nest = nla_nest_start(skb, 0); + +drivers/gpu/drm/drm_sysfs.c:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. bool enabled; + 175. + 176. > enabled = READ_ONCE(connector->encoder); + 177. + 178. return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n"); + +include/trace/events/tcp.h:169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 167. ); + 168. + 169. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 170. + 171. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:169: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 167. ); + 168. + 169. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 170. + 171. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:169: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 167. ); + 168. + 169. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 170. + 171. TP_PROTO(const struct sock *sk), + +net/ipv4/devinet.c:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. struct in_ifaddr *ifa; + 173. + 174. > hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) + 175. if (ifa->ifa_local == addr && + 176. net_eq(dev_net(ifa->ifa_dev->dev), net)) + +net/sched/sch_mq.c:176: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 172 could be null and is dereferenced at line 176, column 18. + 174. tcm->tcm_parent = TC_H_ROOT; + 175. tcm->tcm_handle |= TC_H_MIN(cl); + 176. > tcm->tcm_info = dev_queue->qdisc_sleeping->handle; + 177. return 0; + 178. } + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +kernel/ksysfs.c:173: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 171. struct kobj_attribute *attr, char *buf) + 172. { + 173. > return sprintf(buf, "%d\n", READ_ONCE(rcu_normal)); + 174. } + 175. static ssize_t rcu_normal_store(struct kobject *kobj, + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +drivers/tty/tty_jobctrl.c:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. { + 173. struct task_struct *p; + 174. > do_each_pid_task(session, PIDTYPE_SID, p) { + 175. proc_clear_tty(p); + 176. } while_each_pid_task(session, PIDTYPE_SID, p); + +include/linux/ptrace.h:183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 181. + 182. rcu_read_lock(); + 183. > ns = task_active_pid_ns(rcu_dereference(current->parent)); + 184. if (ns) + 185. message = pid_nr_ns(pid, ns); + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +lib/asn1_decoder.c:400: error: UNINITIALIZED_VALUE + The value read from cons_datalen_stack[_] was never initialized. + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. > datalen = cons_datalen_stack[csp]; + 401. pr_debug("- end cons t=%zu dp=%zu l=%zu/%zu\n", + 402. tdp, dp, len, datalen); + +lib/asn1_decoder.c:397: error: UNINITIALIZED_VALUE + The value read from cons_dp_stack[_] was never initialized. + 395. goto cons_stack_underflow; + 396. csp--; + 397. > tdp = cons_dp_stack[csp]; + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + +lib/asn1_decoder.c:398: error: UNINITIALIZED_VALUE + The value read from cons_hdrlen_stack[_] was never initialized. + 396. csp--; + 397. tdp = cons_dp_stack[csp]; + 398. > hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. datalen = cons_datalen_stack[csp]; + +lib/asn1_decoder.c:463: error: UNINITIALIZED_VALUE + The value read from jump_stack[_] was never initialized. + 461. if (unlikely(jsp <= 0)) + 462. goto jump_stack_underflow; + 463. > pc = jump_stack[--jsp]; + 464. flags |= FLAG_MATCHED | FLAG_LAST_MATCHED; + 465. goto next_op; + +net/ipv4/inet_hashtables.c:196: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 194. score += 4; + 195. } + 196. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 197. score++; + 198. } + +net/sched/sch_generic.c:185: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 183. + 184. if (likely(skb)) { + 185. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 186. if (!netif_xmit_frozen_or_stopped(txq)) + 187. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +net/sched/sch_generic.c:185: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 183. + 184. if (likely(skb)) { + 185. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 186. if (!netif_xmit_frozen_or_stopped(txq)) + 187. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +drivers/ata/libata-scsi.c:197: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 195. + 196. link = dev->link; + 197. > now = jiffies; + 198. if (ap->pflags & ATA_PFLAG_EH_IN_PROGRESS && + 199. link->eh_context.unloaded_mask & (1 << dev->devno) && + +drivers/char/agp/compat_ioctl.c:181: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 179. return -EFAULT; + 180. + 181. > memory = agp_find_mem_by_key(bind_info.key); + 182. + 183. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:186: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 184. return -EINVAL; + 185. + 186. > return agp_bind_memory(memory, bind_info.pg_start); + 187. } + 188. + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +kernel/time/clocksource.c:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. /* Check the deviation from the watchdog clocksource. */ + 225. if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) { + 226. > pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n", + 227. smp_processor_id(), cs->name); + 228. pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n", + +kernel/time/clocksource.c:280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 278. * to each other. + 279. */ + 280. > next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); + 281. if (next_cpu >= nr_cpu_ids) + 282. next_cpu = cpumask_first(cpu_online_mask); + +kernel/time/clocksource.c:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. /* Check the deviation from the watchdog clocksource. */ + 225. if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) { + 226. > pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n", + 227. smp_processor_id(), cs->name); + 228. pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n", + +kernel/time/clocksource.c:280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 278. * to each other. + 279. */ + 280. > next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); + 281. if (next_cpu >= nr_cpu_ids) + 282. next_cpu = cpumask_first(cpu_online_mask); + +lib/errseq.c:184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 182. * to take the lock that protects the "since" value. + 183. */ + 184. > old = READ_ONCE(*eseq); + 185. if (old != *since) { + 186. /* + +arch/x86/include/asm/atomic64_64.h:177: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 175. static inline long atomic64_cmpxchg(atomic64_t *v, long old, long new) + 176. { + 177. > return cmpxchg(&v->counter, old, new); + 178. } + 179. + +block/ioprio.c:199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 197. else + 198. pgrp = find_vpid(who); + 199. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 200. tmpio = get_task_ioprio(p); + 201. if (tmpio < 0) + +block/ioprio.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. break; + 218. + 219. > for_each_process_thread(g, p) { + 220. if (!uid_eq(task_uid(p), user->uid) || + 221. !task_pid_vnr(p)) + +block/ioprio.c:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. + 219. for_each_process_thread(g, p) { + 220. > if (!uid_eq(task_uid(p), user->uid) || + 221. !task_pid_vnr(p)) + 222. continue; + +drivers/md/md-bitmap.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. rdev_dec_pending(rdev, mddev); + 197. } + 198. > list_for_each_entry_continue_rcu(rdev, &mddev->disks, same_set) { + 199. if (rdev->raid_disk >= 0 && + 200. !test_bit(Faulty, &rdev->flags)) { + +drivers/pci/probe.c:249: error: UNINITIALIZED_VALUE + The value read from orig_cmd was never initialized. + 247. + 248. if (!dev->mmio_always_on && (orig_cmd & PCI_COMMAND_DECODE_ENABLE)) + 249. > pci_write_config_word(dev, PCI_COMMAND, orig_cmd); + 250. + 251. if (!sz64) + +include/trace/events/timer.h:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. * @hrtimer: pointer to struct hrtimer + 174. */ + 175. > TRACE_EVENT(hrtimer_start, + 176. + 177. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:175: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 173. * @hrtimer: pointer to struct hrtimer + 174. */ + 175. > TRACE_EVENT(hrtimer_start, + 176. + 177. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:175: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 173. * @hrtimer: pointer to struct hrtimer + 174. */ + 175. > TRACE_EVENT(hrtimer_start, + 176. + 177. TP_PROTO(struct hrtimer *hrtimer), + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +include/trace/events/tcp.h:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. ); + 175. + 176. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 177. + 178. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:176: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 174. ); + 175. + 176. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 177. + 178. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:176: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 174. ); + 175. + 176. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 177. + 178. TP_PROTO(const struct sock *sk), + +net/sunrpc/xprtmultipath.c:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. if (xpi->xpi_ops != NULL) + 180. return xpi->xpi_ops; + 181. > return rcu_dereference(xpi->xpi_xpswitch)->xps_iter_ops; + 182. } + 183. + +security/commoncap.c:182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 180. + 181. rcu_read_lock(); + 182. > cred = __task_cred(parent); + 183. child_cred = current_cred(); + 184. if (cred->user_ns == child_cred->user_ns && + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +security/keys/proc.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. /* come up with a suitable timeout value */ + 222. > expiry = READ_ONCE(key->expiry); + 223. if (expiry == 0) { + 224. memcpy(xbuf, "perm", 5); + +security/keys/proc.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. ((FLAGS & (1 << FLAG)) ? LETTER : '-') + 246. + 247. > flags = READ_ONCE(key->flags); + 248. seq_printf(m, "%08x %c%c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ", + 249. key->serial, + +arch/x86/lib/msr-smp.c:190: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 188. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 189. + 190. > return err ? err : rv.err; + 191. } + 192. EXPORT_SYMBOL(wrmsr_safe_on_cpu); + +drivers/firmware/dmi-id.c:206: error: DEAD_STORE + The value written to &i (type int) is never used. + 204. ADD_DMI_ATTR(chassis_serial, DMI_CHASSIS_SERIAL); + 205. ADD_DMI_ATTR(chassis_asset_tag, DMI_CHASSIS_ASSET_TAG); + 206. > sys_dmi_attributes[i++] = &sys_dmi_modalias_attr.attr; + 207. } + 208. + +drivers/gpu/drm/i915/intel_hdmi.c:189: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 183 could be null and is dereferenced at line 189, column 37. + 187. return false; + 188. + 189. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->port)) + 190. return false; + 191. + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +net/sunrpc/auth_gss/auth_gss.c:186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 184. + 185. rcu_read_lock(); + 186. > ctx = rcu_dereference(gss_cred->gc_ctx); + 187. if (ctx) + 188. gss_get_ctx(ctx); + +net/ipv6/udp.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. result = NULL; + 191. badness = -1; + 192. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 193. score = compute_score(sk, net, saddr, sport, + 194. daddr, hnum, dif, sdif, exact_dif); + +net/sched/sch_mq.c:185: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 183 could be null and is dereferenced at line 185, column 8. + 183. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 184. + 185. > sch = dev_queue->qdisc_sleeping; + 186. if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || + 187. gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +lib/assoc_array.c:197: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 195. pr_devel("-->%s()\n", __func__); + 196. + 197. > cursor = READ_ONCE(array->root); + 198. if (!cursor) + 199. return assoc_array_walk_tree_empty; + +lib/assoc_array.c:223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 221. slot = segments >> (level & ASSOC_ARRAY_KEY_CHUNK_MASK); + 222. slot &= ASSOC_ARRAY_FAN_MASK; + 223. > ptr = READ_ONCE(node->slots[slot]); + 224. + 225. pr_devel("consider slot %x [ix=%d type=%lu]\n", + +lib/assoc_array.c:297: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 295. + 296. /* The shortcut matches the leaf's index to this point. */ + 297. > cursor = READ_ONCE(shortcut->next_node); + 298. if (((level ^ sc_level) & ~ASSOC_ARRAY_KEY_CHUNK_MASK) != 0) { + 299. level = sc_level; + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/intel_dp_mst.c:223: error: DEAD_STORE + The value written to &ret (type int) is never used. + 221. I915_WRITE(DP_TP_STATUS(port), temp); + 222. + 223. > ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); + 224. } + 225. + +include/linux/netfilter.h:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. + 197. rcu_read_lock(); + 198. > hook_head = rcu_dereference(net->nf.hooks[pf][hook]); + 199. if (hook_head) { + 200. struct nf_hook_state state; + +include/linux/seqlock.h:184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 182. static inline unsigned raw_seqcount_begin(const seqcount_t *s) + 183. { + 184. > unsigned ret = READ_ONCE(s->sequence); + 185. smp_rmb(); + 186. return ret & ~1; + +arch/x86/entry/common.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. lockdep_sys_exit(); + 191. + 192. > cached_flags = READ_ONCE(ti->flags); + 193. + 194. if (unlikely(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +drivers/gpu/drm/i915/intel_breadcrumbs.c:199: error: DEAD_STORE + The value written to &first (type intel_wait*) is never used. + 197. + 198. spin_lock(&b->irq_lock); + 199. > first = fetch_and_zero(&b->irq_wait); + 200. __intel_engine_disarm_breadcrumbs(engine); + 201. spin_unlock(&b->irq_lock); + +drivers/gpu/drm/i915/intel_uncore.c:195: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 193. + 194. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 195. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 196. GT_FIFO_NUM_RESERVED_ENTRIES, + 197. GT_FIFO_TIMEOUT_MS)) { + +drivers/gpu/drm/i915/intel_uncore.c:195: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 193. + 194. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 195. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 196. GT_FIFO_NUM_RESERVED_ENTRIES, + 197. GT_FIFO_TIMEOUT_MS)) { + +include/trace/events/tcp.h:183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 181. ); + 182. + 183. > TRACE_EVENT(tcp_set_state, + 184. + 185. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +include/trace/events/tcp.h:183: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 181. ); + 182. + 183. > TRACE_EVENT(tcp_set_state, + 184. + 185. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +include/trace/events/tcp.h:183: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 181. ); + 182. + 183. > TRACE_EVENT(tcp_set_state, + 184. + 185. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +kernel/exit.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. * can't be modifying its own credentials. But shut RCU-lockdep up */ + 191. rcu_read_lock(); + 192. > atomic_dec(&__task_cred(p)->user->processes); + 193. rcu_read_unlock(); + 194. + +net/ipv4/udp.c:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. inet_rcv_saddr_equal(sk, sk2, true)) { + 201. if (sk2->sk_reuseport && sk->sk_reuseport && + 202. > !rcu_access_pointer(sk->sk_reuseport_cb) && + 203. uid_eq(uid, sock_i_uid(sk2))) { + 204. res = 0; + +net/netlabel/netlabel_domainhash.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. return entry; + 192. if (family == AF_INET || family == AF_UNSPEC) { + 193. > entry = netlbl_domhsh_rcu_deref(netlbl_domhsh_def_ipv4); + 194. if (entry != NULL && entry->valid) + 195. return entry; + +net/netlabel/netlabel_domainhash.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. } + 197. if (family == AF_INET6 || family == AF_UNSPEC) { + 198. > entry = netlbl_domhsh_rcu_deref(netlbl_domhsh_def_ipv6); + 199. if (entry != NULL && entry->valid) + 200. return entry; + +net/netlink/genetlink.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. netlink_table_grab(); + 233. rcu_read_lock(); + 234. > for_each_net_rcu(net) { + 235. err = __netlink_change_ngroups(net->genl_sock, + 236. mc_groups_longs * BITS_PER_LONG); + +arch/x86/include/asm/atomic.h:187: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 185. static __always_inline int atomic_cmpxchg(atomic_t *v, int old, int new) + 186. { + 187. > return cmpxchg(&v->counter, old, new); + 188. } + 189. + +net/ipv6/inet6_hashtables.c:196: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 194. struct net *net = sock_net(sk); + 195. const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 196. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 197. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + 198. inet->inet_dport); + +net/ipv6/inet6_hashtables.c:195: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 193. const int dif = sk->sk_bound_dev_if; + 194. struct net *net = sock_net(sk); + 195. > const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 196. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 197. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +kernel/seccomp.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. u32 ret = SECCOMP_RET_ALLOW; + 191. /* Make sure cross-thread synced filter points somewhere sane. */ + 192. > struct seccomp_filter *f = + 193. READ_ONCE(current->seccomp.filter); + 194. + +net/netfilter/nf_conntrack_netlink.c:197: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 195. return 0; + 196. + 197. > helper = rcu_dereference(help->helper); + 198. if (!helper) + 199. goto out; + +scripts/mod/file2alias.c:196: error: DEAD_STORE + The value written to &bcdDevice_lo (type unsigned short) is never used. + 194. DEF_FIELD(symval, usb_device_id, idVendor); + 195. DEF_FIELD(symval, usb_device_id, idProduct); + 196. > DEF_FIELD(symval, usb_device_id, bcdDevice_lo); + 197. DEF_FIELD(symval, usb_device_id, bDeviceClass); + 198. DEF_FIELD(symval, usb_device_id, bDeviceSubClass); + +drivers/video/fbdev/core/fbcvt.c:192: error: DEAD_STORE + The value written to &aspect (type unsigned int) is never used. + 190. u32 xres = cvt->xres; + 191. u32 yres = cvt->yres; + 192. > u32 aspect = -1; + 193. + 194. if (xres == (yres * 4)/3 && !((yres * 4) % 3)) + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +kernel/cred.c:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. + 194. do { + 195. > cred = __task_cred((task)); + 196. BUG_ON(!cred); + 197. } while (!atomic_inc_not_zero(&((struct cred *)cred)->usage)); + +net/netfilter/nf_nat_core.c:200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 198. const struct nf_conn *ct; + 199. + 200. > hlist_for_each_entry_rcu(ct, &nf_nat_bysource[h], nat_bysource) { + 201. if (same_src(ct, tuple) && + 202. net_eq(net, nf_ct_net(ct)) && + +drivers/char/agp/compat_ioctl.c:198: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 196. return -EFAULT; + 197. + 198. > memory = agp_find_mem_by_key(unbind.key); + 199. + 200. if (memory == NULL) + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +kernel/power/process.c:210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 208. + 209. read_lock(&tasklist_lock); + 210. > for_each_process_thread(g, p) { + 211. /* No other threads should have PF_SUSPEND_TASK set */ + 212. WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK)); + +kernel/sys.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. else + 223. pgrp = task_pgrp(current); + 224. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 225. error = set_one_prio(p, niceval, error); + 226. } while_each_pid_thread(pgrp, PIDTYPE_PGID, p); + +kernel/sys.c:238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 236. goto out_unlock; /* No processes for this user */ + 237. } + 238. > do_each_thread(g, p) { + 239. if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) + 240. error = set_one_prio(p, niceval, error); + +kernel/sys.c:239: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 237. } + 238. do_each_thread(g, p) { + 239. > if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) + 240. error = set_one_prio(p, niceval, error); + 241. } while_each_thread(g, p); + +net/core/dev_ioctl.c:204: error: UNINITIALIZED_VALUE + The value read from cfg.rx_filter was never initialized. + 202. + 203. tx_type = cfg.tx_type; + 204. > rx_filter = cfg.rx_filter; + 205. + 206. switch (tx_type) { + +net/core/dev_ioctl.c:203: error: UNINITIALIZED_VALUE + The value read from cfg.tx_type was never initialized. + 201. return -EINVAL; + 202. + 203. > tx_type = cfg.tx_type; + 204. rx_filter = cfg.rx_filter; + 205. + +crypto/scompress.c:196: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 194. struct crypto_scomp *scomp = *tfm_ctx; + 195. void **ctx = acomp_request_ctx(req); + 196. > const int cpu = get_cpu(); + 197. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 198. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +crypto/scompress.c:196: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 194. struct crypto_scomp *scomp = *tfm_ctx; + 195. void **ctx = acomp_request_ctx(req); + 196. > const int cpu = get_cpu(); + 197. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 198. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +net/core/netpoll.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. { + 192. const struct net_device_ops *ops; + 193. > struct netpoll_info *ni = rcu_dereference_bh(dev->npinfo); + 194. + 195. /* Don't do any rx activity if the dev_lock mutex is held + +security/selinux/hooks.c:199: error: NULL_DEREFERENCE + pointer `tsec` last assigned on line 195 could be null and is dereferenced at line 199, column 15. + 197. panic("SELinux: Failed to initialize initial task.\n"); + 198. + 199. > tsec->osid = tsec->sid = SECINITSID_KERNEL; + 200. cred->security = tsec; + 201. } + +drivers/tty/tty_jobctrl.c:199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 197. read_lock(&tasklist_lock); + 198. if (tty->session) { + 199. > do_each_pid_task(tty->session, PIDTYPE_SID, p) { + 200. spin_lock_irq(&p->sighand->siglock); + 201. if (p->signal->tty == tty) { + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +net/ipv4/ip_input.c:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. raw = raw_local_deliver(skb, protocol); + 204. + 205. > ipprot = rcu_dereference(inet_protos[protocol]); + 206. if (ipprot) { + 207. int ret; + +net/wireless/reg.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. static struct regulatory_request *get_last_request(void) + 193. { + 194. > return rcu_dereference_rtnl(last_request); + 195. } + 196. + +arch/x86/lib/msr-smp.c:206: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 204. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 205. + 206. > return err ? err : rv.err; + 207. } + 208. EXPORT_SYMBOL(wrmsrl_safe_on_cpu); + +scripts/kconfig/menu.c:196: error: MEMORY_LEAK + memory dynamically allocated by call to `expr_alloc_symbol()` at line 196, column 28 is not reachable after line 196, column 2. + 194. void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep) + 195. { + 196. > menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep); + 197. } + 198. + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +kernel/ucount.c:204: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 202. int max; + 203. tns = iter->ns; + 204. > max = READ_ONCE(tns->ucount_max[type]); + 205. if (!atomic_inc_below(&iter->ucount[type], max)) + 206. goto fail; + +net/ipv6/proc.c:207: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 205. snmp_get_cpu_field_batch(buff, itemlist, pcpumib); + 206. for (i = 0; itemlist[i].name; i++) + 207. > seq_printf(seq, "%-32s\t%lu\n", + 208. itemlist[i].name, buff[i]); + 209. } else { + +net/netfilter/nf_log.c:208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 206. + 207. rcu_read_lock(); + 208. > logger = rcu_dereference(loggers[pf][type]); + 209. module_put(logger->me); + 210. rcu_read_unlock(); + +net/sunrpc/xprtmultipath.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. struct rpc_xprt *xprt_switch_find_first_entry(struct list_head *head) + 197. { + 198. > return list_first_or_null_rcu(head, struct rpc_xprt, xprt_switch); + 199. } + 200. + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +drivers/gpu/drm/drm_ioc32.c:210: error: UNINITIALIZED_VALUE + The value read from m32.flags was never initialized. + 208. map.size = m32.size; + 209. map.type = m32.type; + 210. > map.flags = m32.flags; + 211. + 212. err = drm_ioctl_kernel(file, drm_legacy_addmap_ioctl, &map, + +drivers/gpu/drm/drm_ioc32.c:207: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 205. return -EFAULT; + 206. + 207. > map.offset = m32.offset; + 208. map.size = m32.size; + 209. map.type = m32.type; + +drivers/gpu/drm/drm_ioc32.c:208: error: UNINITIALIZED_VALUE + The value read from m32.size was never initialized. + 206. + 207. map.offset = m32.offset; + 208. > map.size = m32.size; + 209. map.type = m32.type; + 210. map.flags = m32.flags; + +drivers/gpu/drm/drm_ioc32.c:209: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 207. map.offset = m32.offset; + 208. map.size = m32.size; + 209. > map.type = m32.type; + 210. map.flags = m32.flags; + 211. + +drivers/gpu/drm/drm_ioc32.c:221: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + 221. > pr_err_ratelimited("compat_drm_addmap truncated handle %p for type %d offset %x\n", + 222. map.handle, m32.type, m32.offset); + 223. + +drivers/gpu/drm/drm_ioc32.c:218: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 216. + 217. m32.offset = map.offset; + 218. > m32.mtrr = map.mtrr; + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + +kernel/sched/cpuacct.c:209: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 199 could be null and is dereferenced by call to `cpuacct_cpuusage_write()` at line 209, column 3. + 207. + 208. for_each_possible_cpu(cpu) + 209. > cpuacct_cpuusage_write(ca, cpu, 0); + 210. + 211. return 0; + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/kthread.c:219: error: NULL_DEREFERENCE + pointer `done` last assigned on line 211 could be null and is dereferenced by call to `complete()` at line 219, column 3. + 217. if (!self) { + 218. create->result = ERR_PTR(-ENOMEM); + 219. > complete(done); + 220. do_exit(-ENOMEM); + 221. } + +net/ipv6/seg6.c:215: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 213. + 214. rcu_read_lock(); + 215. > tun_src = rcu_dereference(seg6_pernet(net)->tun_src); + 216. + 217. if (nla_put(msg, SEG6_ATTR_DST, sizeof(struct in6_addr), tun_src)) + +drivers/gpu/drm/drm_drv.c:205: error: NULL_DEREFERENCE + pointer `slot` last assigned on line 204 could be null and is dereferenced at line 205, column 10. + 203. + 204. slot = drm_minor_get_slot(dev, type); + 205. > minor = *slot; + 206. if (!minor) + 207. return; + +kernel/power/user.c:373: error: UNINITIALIZED_VALUE + The value read from swap_area.dev was never initialized. + 371. * so we need to recode them + 372. */ + 373. > swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. offset = swap_area.offset; + +kernel/power/user.c:375: error: UNINITIALIZED_VALUE + The value read from swap_area.offset was never initialized. + 373. swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. > offset = swap_area.offset; + 376. data->swap = swap_type_of(swdev, offset, NULL); + 377. if (data->swap < 0) + +net/netlabel/netlabel_addrlist.c:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. * address mask such that the entry with the widest mask (smallest + 212. * numerical value) appears first in the list */ + 213. > list_for_each_entry_rcu(iter, head, list) + 214. if (iter->valid && + 215. ipv6_addr_cmp(&entry->mask, &iter->mask) > 0) { + +block/ioctl.c:218: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 216. return -EFAULT; + 217. + 218. > start = range[0]; + 219. len = range[1]; + 220. + +block/ioctl.c:219: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 217. + 218. start = range[0]; + 219. > len = range[1]; + 220. + 221. if (start & 511) + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +net/netlabel/netlabel_unlabeled.c:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. static u32 netlbl_unlhsh_hash(int ifindex) + 201. { + 202. > return ifindex & (netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->size - 1); + 203. } + 204. + +drivers/char/hpet.c:254: error: UNINITIALIZED_VALUE + The value read from gsi was never initialized. + 252. v |= irq << Tn_INT_ROUTE_CNF_SHIFT; + 253. writel(v, &timer->hpet_config); + 254. > devp->hd_hdwirq = gsi; + 255. spin_unlock_irq(&hpet_lock); + 256. } + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +kernel/sched/loadavg.c:208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 206. * If we're still before the pending sample window, we're done. + 207. */ + 208. > this_rq->calc_load_update = READ_ONCE(calc_load_update); + 209. if (time_before(jiffies, this_rq->calc_load_update)) + 210. return; + +net/sunrpc/xprtmultipath.c:204: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 202. struct rpc_xprt *xprt_iter_first_entry(struct rpc_xprt_iter *xpi) + 203. { + 204. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 205. + 206. if (xps == NULL) + +crypto/rsa.c:218: error: DEAD_STORE + The value written to &ret (type int) is never used. + 216. } + 217. + 218. > ret = -ENOMEM; + 219. s = mpi_read_raw_from_sgl(req->src, req->src_len); + 220. if (!s) { + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/tty/tty_audit.c:209: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 207. dev_t dev; + 208. + 209. > audit_tty = READ_ONCE(current->signal->audit_tty); + 210. if (~audit_tty & AUDIT_TTY_ENABLE) + 211. return; + +security/selinux/avc.c:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. slots_used++; + 216. chain_len = 0; + 217. > hlist_for_each_entry_rcu(node, head, list) + 218. chain_len++; + 219. if (chain_len > max_chain_len) + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +kernel/cgroup/freezer.c:221: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 220 could be null and is dereferenced at line 221, column 6. + 219. + 220. freezer = task_freezer(task); + 221. > if (freezer->state & CGROUP_FREEZING) + 222. freeze_task(task); + 223. + +drivers/input/mouse/synaptics.c:216: error: UNINITIALIZED_VALUE + The value read from resp.be_val was never initialized. + 214. return error; + 215. + 216. > *val = be32_to_cpu(resp.be_val); + 217. return 0; + 218. } + +kernel/fork.c:213: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 211. struct vm_struct *s; + 212. + 213. > s = this_cpu_xchg(cached_stacks[i], NULL); + 214. + 215. if (!s) + +kernel/fork.c:213: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 211. struct vm_struct *s; + 212. + 213. > s = this_cpu_xchg(cached_stacks[i], NULL); + 214. + 215. if (!s) + +drivers/gpu/drm/i915/i915_guc_submission.c:220: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 218. * to go to zero after updating db_status before we call the GuC to + 219. * release the doorbell */ + 220. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 221. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 222. + +drivers/gpu/drm/i915/i915_guc_submission.c:220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 218. * to go to zero after updating db_status before we call the GuC to + 219. * release the doorbell */ + 220. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 221. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 222. + +drivers/gpu/drm/i915/i915_guc_submission.c:220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 218. * to go to zero after updating db_status before we call the GuC to + 219. * release the doorbell */ + 220. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 221. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 222. + +drivers/gpu/drm/i915/i915_guc_submission.c:220: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 218. * to go to zero after updating db_status before we call the GuC to + 219. * release the doorbell */ + 220. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 221. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 222. + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/rcu/srcutree.c:211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 209. WARN_ON_ONCE(rcu_scheduler_active == RCU_SCHEDULER_INIT); + 210. /* The smp_load_acquire() pairs with the smp_store_release(). */ + 211. > if (!rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq_needed))) /*^^^*/ + 212. return; /* Already initialized. */ + 213. raw_spin_lock_irqsave_rcu_node(sp, flags); + +net/sunrpc/stats.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. + 218. rcu_read_lock(); + 219. > xprt = rcu_dereference(clnt->cl_xprt); + 220. if (xprt) + 221. xprt->ops->print_stats(xprt, seq); + +security/commoncap.c:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. /* Derived from kernel/capability.c:sys_capget. */ + 211. rcu_read_lock(); + 212. > cred = __task_cred(target); + 213. *effective = cred->cap_effective; + 214. *inheritable = cred->cap_inheritable; + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +kernel/audit_tree.c:214: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 212. struct audit_chunk *p; + 213. + 214. > list_for_each_entry_rcu(p, list, hash) { + 215. if (chunk_to_key(p) == key) { + 216. atomic_long_inc(&p->refs); + +lib/bug.c:214: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 212. + 213. rcu_read_lock_sched(); + 214. > list_for_each_entry_rcu(mod, &module_bug_list, bug_list) + 215. clear_once_table(mod->bug_table, + 216. mod->bug_table + mod->num_bugs); + +net/core/dst.c:220: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 218. + 219. new = (unsigned long) p; + 220. > prev = cmpxchg(&dst->_metrics, old, new); + 221. + 222. if (prev != old) { + +net/netfilter/nf_queue.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. pf = entry->state.pf; + 221. + 222. > hooks = rcu_dereference(net->nf.hooks[pf][entry->state.hook]); + 223. + 224. nf_queue_entry_release_refs(entry); + +include/trace/events/timer.h:209: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 207. * Allows to determine the timer latency. + 208. */ + 209. > TRACE_EVENT(hrtimer_expire_entry, + 210. + 211. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +include/trace/events/timer.h:209: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 207. * Allows to determine the timer latency. + 208. */ + 209. > TRACE_EVENT(hrtimer_expire_entry, + 210. + 211. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +include/trace/events/timer.h:209: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 207. * Allows to determine the timer latency. + 208. */ + 209. > TRACE_EVENT(hrtimer_expire_entry, + 210. + 211. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +kernel/rcu/tree.c:211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 209. unsigned long rcu_rnp_online_cpus(struct rcu_node *rnp) + 210. { + 211. > return READ_ONCE(rnp->qsmaskinitnext); + 212. } + 213. + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +arch/x86/lib/msr-smp.c:221: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 219. *q = rv.reg.q; + 220. + 221. > return err ? err : rv.err; + 222. } + 223. EXPORT_SYMBOL(rdmsrl_safe_on_cpu); + +crypto/algboss.c:213: error: DEAD_STORE + The value written to &type (type unsigned int) is never used. + 211. { + 212. struct crypto_test_param *param = data; + 213. > u32 type = param->type; + 214. int err = 0; + 215. + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +net/ipv4/inet_hashtables.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. u32 phash = 0; + 223. + 224. > sk_for_each_rcu(sk, &ilb->head) { + 225. score = compute_score(sk, net, hnum, daddr, + 226. dif, sdif, exact_dif); + +net/ipv4/tcp_metrics.c:218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 216. int depth = 0; + 217. + 218. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 219. tm = rcu_dereference(tm->tcpm_next)) { + 220. if (addr_same(&tm->tcpm_saddr, saddr) && + +net/ipv4/tcp_metrics.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. + 218. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 219. > tm = rcu_dereference(tm->tcpm_next)) { + 220. if (addr_same(&tm->tcpm_saddr, saddr) && + 221. addr_same(&tm->tcpm_daddr, daddr) && + +net/sunrpc/xprtmultipath.c:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. struct rpc_xprt *pos; + 216. + 217. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 218. if (cur == pos) + 219. return pos; + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +net/core/net-procfs.c:218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 216. int t; + 217. + 218. > list_for_each_entry_rcu(pt, &ptype_all, list) { + 219. if (i == pos) + 220. return pt; + +net/core/net-procfs.c:225: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 223. + 224. for (t = 0; t < PTYPE_HASH_SIZE; t++) { + 225. > list_for_each_entry_rcu(pt, &ptype_base[t], list) { + 226. if (i == pos) + 227. return pt; + +net/wireless/radiotap.c:304: error: UNINITIALIZED_VALUE + The value read from size was never initialized. + 302. iterator->this_arg_index = iterator->_arg_index; + 303. iterator->this_arg = iterator->_arg; + 304. > iterator->this_arg_size = size; + 305. + 306. /* internally move on the size of this arg */ + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +net/core/sock_reuseport.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. + 223. rcu_read_lock(); + 224. > reuse = rcu_dereference(sk->sk_reuseport_cb); + 225. + 226. /* if memory allocation failed or add call is not yet complete */ + +net/core/sock_reuseport.c:230: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 228. goto out; + 229. + 230. > prog = rcu_dereference(reuse->prog); + 231. socks = READ_ONCE(reuse->num_socks); + 232. if (likely(socks)) { + +net/core/sock_reuseport.c:231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 229. + 230. prog = rcu_dereference(reuse->prog); + 231. > socks = READ_ONCE(reuse->num_socks); + 232. if (likely(socks)) { + 233. /* paired with smp_wmb() in reuseport_add_sock() */ + +drivers/tty/tty_buffer.c:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. * no pending memory accesses to the freed buffer + 225. */ + 226. > while ((next = smp_load_acquire(&buf->head->next)) != NULL) { + 227. tty_buffer_free(port, buf->head); + 228. buf->head = next; + +drivers/video/fbdev/core/fbcvt.c:261: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 259. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. > cnt -= read; + 262. offset += read; + 263. } + +drivers/video/fbdev/core/fbcvt.c:262: error: DEAD_STORE + The value written to &offset (type int) is never used. + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. cnt -= read; + 262. > offset += read; + 263. } + 264. } + +include/linux/inetdevice.h:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. static inline struct in_device *__in_dev_get_rcu(const struct net_device *dev) + 215. { + 216. > return rcu_dereference(dev->ip_ptr); + 217. } + 218. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +lib/genalloc.c:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. + 219. rcu_read_lock(); + 220. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 221. if (addr >= chunk->start_addr && addr <= chunk->end_addr) { + 222. paddr = chunk->phys_addr + (addr - chunk->start_addr); + +net/netfilter/nf_log.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. rcu_read_lock(); + 228. if (loginfo != NULL) + 229. > logger = rcu_dereference(loggers[pf][loginfo->type]); + 230. else + 231. logger = rcu_dereference(net->nf.nf_loggers[pf]); + +net/netfilter/nf_log.c:231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 229. logger = rcu_dereference(loggers[pf][loginfo->type]); + 230. else + 231. > logger = rcu_dereference(net->nf.nf_loggers[pf]); + 232. + 233. if (logger) { + +drivers/ata/libata-sff.c:223: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 221. status = ata_sff_busy_wait(ap, ATA_BUSY, 300); + 222. timer_start = jiffies; + 223. > timeout = ata_deadline(timer_start, tmout_pat); + 224. while (status != 0xff && (status & ATA_BUSY) && + 225. time_before(jiffies, timeout)) { + +drivers/ata/libata-sff.c:235: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 233. status); + 234. + 235. > timeout = ata_deadline(timer_start, tmout); + 236. while (status != 0xff && (status & ATA_BUSY) && + 237. time_before(jiffies, timeout)) { + +kernel/audit.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. rcu_read_lock(); + 222. > ac = rcu_dereference(auditd_conn); + 223. rc = (ac && ac->pid == task_tgid(task) ? 1 : 0); + 224. rcu_read_unlock(); + +kernel/time/timer.c:222: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 220. + 221. /* Avoid the loop, if nothing to update */ + 222. > if (this_cpu_read(timer_bases[BASE_STD].migration_enabled) == on) + 223. return; + 224. + +net/ipv6/proc.c:226: error: UNINITIALIZED_VALUE + The value read from buff64[_] was never initialized. + 224. snmp_get_cpu_field64_batch(buff64, itemlist, mib, syncpoff); + 225. for (i = 0; itemlist[i].name; i++) + 226. > seq_printf(seq, "%-32s\t%llu\n", itemlist[i].name, buff64[i]); + 227. } + 228. + +net/netlabel/netlabel_unlabeled.c:223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 221. + 222. bkt = netlbl_unlhsh_hash(ifindex); + 223. > bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]; + 224. list_for_each_entry_rcu(iter, bkt_list, list) + 225. if (iter->valid && iter->ifindex == ifindex) + +net/netlabel/netlabel_unlabeled.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. bkt = netlbl_unlhsh_hash(ifindex); + 223. bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]; + 224. > list_for_each_entry_rcu(iter, bkt_list, list) + 225. if (iter->valid && iter->ifindex == ifindex) + 226. return iter; + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +net/wireless/trace.h:217: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +security/selinux/hooks.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. rcu_read_lock(); + 222. > sid = cred_sid(__task_cred(task)); + 223. rcu_read_unlock(); + 224. return sid; + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +drivers/pci/pcie/aspm.c:268: error: DEAD_STORE + The value written to &start_jiffies (type unsigned long) is never used. + 266. + 267. /* Wait for link training end. Break out after waiting for timeout */ + 268. > start_jiffies = jiffies; + 269. for (;;) { + 270. pcie_capability_read_word(parent, PCI_EXP_LNKSTA, ®16); + +drivers/pci/pcie/aspm.c:283: error: UNINITIALIZED_VALUE + The value read from child_reg[_] was never initialized. + 281. dev_err(&parent->dev, "ASPM: Could not configure common clock\n"); + 282. list_for_each_entry(child, &linkbus->devices, bus_list) + 283. > pcie_capability_write_word(child, PCI_EXP_LNKCTL, + 284. child_reg[PCI_FUNC(child->devfn)]); + 285. pcie_capability_write_word(parent, PCI_EXP_LNKCTL, parent_reg); + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +drivers/scsi/scsi_logging.c:249: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 247. if (cmd->cmd_len > 16) { + 248. /* Print opcode in one line and use separate lines for CDB */ + 249. > off += scnprintf(logbuf + off, logbuf_len - off, "\n"); + 250. dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf); + 251. scsi_log_release_buffer(logbuf); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +include/net/ip6_fib.h:227: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 225. + 226. rcu_read_lock(); + 227. > fn = rcu_dereference(rt->rt6i_node); + 228. + 229. if (fn) { + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +net/ipv6/udp.c:266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 264. result = NULL; + 265. badness = -1; + 266. > sk_for_each_rcu(sk, &hslot->head) { + 267. score = compute_score(sk, net, saddr, sport, daddr, hnum, dif, + 268. sdif, exact_dif); + +sound/core/hwdep.c:236: error: UNINITIALIZED_VALUE + The value read from info.image was never initialized. + 234. if (hw->dsp_loaded & (1 << info.index)) + 235. return -EBUSY; + 236. > if (!access_ok(VERIFY_READ, info.image, info.length)) + 237. return -EFAULT; + 238. err = hw->ops.dsp_load(hw, &info); + +sound/core/hwdep.c:236: error: UNINITIALIZED_VALUE + The value read from info.length was never initialized. + 234. if (hw->dsp_loaded & (1 << info.index)) + 235. return -EBUSY; + 236. > if (!access_ok(VERIFY_READ, info.image, info.length)) + 237. return -EFAULT; + 238. err = hw->ops.dsp_load(hw, &info); + +drivers/iommu/dmar.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. } + 263. + 264. > for_each_dev_scope(devices, devices_cnt, i, tmp) + 265. if (tmp == NULL) { + 266. devices[i].bus = info->dev->bus->number; + +net/xfrm/xfrm_state.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. typemap = afinfo->type_map; + 233. + 234. > type = READ_ONCE(typemap[proto]); + 235. if (unlikely(type && !try_module_get(type->owner))) + 236. type = NULL; + +security/selinux/ss/conditional.c:238: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 236. goto err; + 237. + 238. > booldatum->value = le32_to_cpu(buf[0]); + 239. booldatum->state = le32_to_cpu(buf[1]); + 240. + +security/selinux/ss/conditional.c:239: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 237. + 238. booldatum->value = le32_to_cpu(buf[0]); + 239. > booldatum->state = le32_to_cpu(buf[1]); + 240. + 241. rc = -EINVAL; + +security/selinux/ss/conditional.c:245: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 243. goto err; + 244. + 245. > len = le32_to_cpu(buf[2]); + 246. if (((len == 0) || (len == (u32)-1))) + 247. goto err; + +drivers/tty/vt/vt_ioctl.c:240: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 238. op->width = 8; + 239. op->height = cfdarg.charheight; + 240. > op->charcount = cfdarg.charcount; + 241. op->data = cfdarg.chardata; + 242. return con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:248: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 246. op->width = 8; + 247. op->height = cfdarg.charheight; + 248. > op->charcount = cfdarg.charcount; + 249. op->data = cfdarg.chardata; + 250. i = con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:241: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 239. op->height = cfdarg.charheight; + 240. op->charcount = cfdarg.charcount; + 241. > op->data = cfdarg.chardata; + 242. return con_font_op(vc_cons[fg_console].d, op); + 243. case GIO_FONTX: { + +drivers/tty/vt/vt_ioctl.c:249: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 247. op->height = cfdarg.charheight; + 248. op->charcount = cfdarg.charcount; + 249. > op->data = cfdarg.chardata; + 250. i = con_font_op(vc_cons[fg_console].d, op); + 251. if (i) + +drivers/tty/vt/vt_ioctl.c:239: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 237. op->flags = KD_FONT_FLAG_OLD; + 238. op->width = 8; + 239. > op->height = cfdarg.charheight; + 240. op->charcount = cfdarg.charcount; + 241. op->data = cfdarg.chardata; + +drivers/tty/vt/vt_ioctl.c:247: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 245. op->flags = KD_FONT_FLAG_OLD; + 246. op->width = 8; + 247. > op->height = cfdarg.charheight; + 248. op->charcount = cfdarg.charcount; + 249. op->data = cfdarg.chardata; + +net/core/netpoll.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. might_sleep(); + 228. idx = srcu_read_lock(&netpoll_srcu); + 229. > ni = srcu_dereference(dev->npinfo, &netpoll_srcu); + 230. if (ni) + 231. down(&ni->dev_lock); + +net/ipv4/ip_tunnel.c:236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 234. struct hlist_head *head = ip_bucket(itn, parms); + 235. + 236. > hlist_for_each_entry_rcu(t, head, hash_node) { + 237. if (local == t->parms.iph.saddr && + 238. remote == t->parms.iph.daddr && + +net/ipv6/ip6_input.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. resubmit_final: + 246. raw = raw6_local_deliver(skb, nexthdr); + 247. > ipprot = rcu_dereference(inet6_protos[nexthdr]); + 248. if (ipprot) { + 249. int ret; + +net/sunrpc/xprtmultipath.c:227: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 225. struct rpc_xprt *xprt_iter_current_entry(struct rpc_xprt_iter *xpi) + 226. { + 227. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 228. struct list_head *head; + 229. + +block/blk-lib.c:244: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 243 could be null and is dereferenced at line 244, column 3. + 242. while (nr_sects) { + 243. bio = next_bio(bio, 0, gfp_mask); + 244. > bio->bi_iter.bi_sector = sector; + 245. bio_set_dev(bio, bdev); + 246. bio->bi_opf = REQ_OP_WRITE_ZEROES; + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +arch/x86/events/intel/bts.c:232: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 229 could be null and is dereferenced at line 232, column 7. + 230. u64 config = 0; + 231. + 232. > if (!buf->snapshot) + 233. config |= ARCH_PERFMON_EVENTSEL_INT; + 234. if (!event->attr.exclude_kernel) + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/gpu/drm/i915/intel_dp_mst.c:246: error: DEAD_STORE + The value written to &ret (type int) is never used. + 244. DRM_ERROR("Timed out waiting for ACT sent\n"); + 245. + 246. > ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 247. + 248. ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + +drivers/gpu/drm/i915/intel_dp_mst.c:248: error: DEAD_STORE + The value written to &ret (type int) is never used. + 246. ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 247. + 248. > ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + 249. if (pipe_config->has_audio) + 250. intel_audio_codec_enable(encoder, pipe_config, conn_state); + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = table->private; + 264. > cpu = smp_processor_id(); + 265. /* + 266. * Ensure we load private-> members after we've fetched the base + +net/ipv4/netfilter/ip_tables.c:281: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 279. */ + 280. if (static_key_false(&xt_tee_enabled)) + 281. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 282. + 283. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = table->private; + 264. > cpu = smp_processor_id(); + 265. /* + 266. * Ensure we load private-> members after we've fetched the base + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:233: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 230 could be null and is dereferenced at line 233, column 6. + 231. struct intel_panel *panel = &connector->panel; + 232. + 233. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) + 234. panel->backlight.max = 0xFFFF; + 235. else + +kernel/power/process.c:237: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 235. + 236. read_lock(&tasklist_lock); + 237. > for_each_process_thread(g, p) { + 238. if (p->flags & (PF_KTHREAD | PF_WQ_WORKER)) + 239. __thaw_task(p); + +net/ipv4/tcp_metrics.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. hash = hash_32(hash, tcp_metrics_hash_log); + 259. + 260. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 261. tm = rcu_dereference(tm->tcpm_next)) { + 262. if (addr_same(&tm->tcpm_saddr, &saddr) && + +net/ipv4/tcp_metrics.c:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. + 260. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 261. > tm = rcu_dereference(tm->tcpm_next)) { + 262. if (addr_same(&tm->tcpm_saddr, &saddr) && + 263. addr_same(&tm->tcpm_daddr, &daddr) && + +include/linux/reservation.h:235: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 233. struct dma_fence *fence; + 234. + 235. > if (!rcu_access_pointer(obj->fence_excl)) + 236. return NULL; + 237. + +include/trace/events/tcp.h:230: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 228. ); + 229. + 230. > TRACE_EVENT(tcp_retransmit_synack, + 231. + 232. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +include/trace/events/tcp.h:230: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 228. ); + 229. + 230. > TRACE_EVENT(tcp_retransmit_synack, + 231. + 232. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +include/trace/events/tcp.h:230: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 228. ); + 229. + 230. > TRACE_EVENT(tcp_retransmit_synack, + 231. + 232. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +kernel/rcu/tree.c:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. { + 232. RCU_LOCKDEP_WARN(preemptible(), "rcu_sched_qs() invoked with preemption enabled!!!"); + 233. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + +kernel/rcu/tree.c:236: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + 236. > __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + 239. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 240. return; + 241. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.exp, false); + +kernel/rcu/tree.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. > trace_rcu_grace_period(TPS("rcu_sched"), + 236. __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + +net/netfilter/nf_conntrack_helper.c:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. * we cannot reallocate the helper extension area. + 272. */ + 273. > struct nf_conntrack_helper *tmp = rcu_dereference(help->helper); + 274. + 275. if (tmp && tmp->help != helper->help) { + +drivers/video/backlight/backlight.c:234: error: DEAD_STORE + The value written to &rc (type int) is never used. + 232. struct device_attribute *attr, char *buf) + 233. { + 234. > int rc = -ENXIO; + 235. struct backlight_device *bd = to_backlight_device(dev); + 236. + +sound/hda/hdac_controller.c:239: error: DEAD_STORE + The value written to &loopcounter (type unsigned long) is never used. + 237. timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. > for (loopcounter = 0;; loopcounter++) { + 240. spin_lock_irq(&bus->reg_lock); + 241. if (!bus->rirb.cmds[addr]) { + +sound/hda/hdac_controller.c:237: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 235. unsigned long loopcounter; + 236. + 237. > timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. for (loopcounter = 0;; loopcounter++) { + +drivers/gpu/drm/i915/intel_uncore.c:296: error: UNINITIALIZED_VALUE + The value read from irqflags was never initialized. + 294. assert_forcewakes_inactive(dev_priv); + 295. + 296. > spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags); + 297. } + 298. + +scripts/kconfig/menu.c:264: error: NULL_DEREFERENCE + pointer `sym2` last assigned on line 259 could be null and is dereferenced at line 264, column 13. + 262. "config symbol '%s' uses %s, but is " + 263. "not boolean or tristate", sym->name, use); + 264. > else if (sym2->type != S_UNKNOWN && + 265. sym2->type != S_BOOLEAN && + 266. sym2->type != S_TRISTATE) + +block/ioctl.c:246: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 244. return -EFAULT; + 245. + 246. > start = range[0]; + 247. len = range[1]; + 248. end = start + len - 1; + +block/ioctl.c:247: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 245. + 246. start = range[0]; + 247. > len = range[1]; + 248. end = start + len - 1; + 249. + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +kernel/exit.c:245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 243. */ + 244. retry: + 245. > task = rcu_dereference(*ptask); + 246. if (!task) + 247. return NULL; + +net/core/gen_estimator.c:235: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 233. bool gen_estimator_active(struct net_rate_estimator __rcu **rate_est) + 234. { + 235. > return !!rcu_access_pointer(*rate_est); + 236. } + 237. EXPORT_SYMBOL(gen_estimator_active); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +kernel/audit.c:241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 239. + 240. rcu_read_lock(); + 241. > ac = rcu_dereference(auditd_conn); + 242. if (!ac || !ac->pid) + 243. pid = 0; + +security/selinux/ss/mls.c:366: error: DEAD_STORE + The value written to &p (type char*) is never used. + 364. goto out; + 365. } + 366. > *scontext = ++p; + 367. rc = 0; + 368. out: + +drivers/gpu/drm/i915/intel_hdmi.c:248: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 240 could be null and is dereferenced at line 248, column 37. + 246. return false; + 247. + 248. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->port)) + 249. return false; + 250. + +drivers/video/fbdev/core/bitblit.c:252: error: DEAD_STORE + The value written to &mode (type int) is never used. + 250. if (softback_lines) { + 251. if (y + softback_lines >= vc->vc_rows) { + 252. > mode = CM_ERASE; + 253. ops->cursor_flash = 0; + 254. return; + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +kernel/trace/trace_events.c:242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 240. struct trace_pid_list *pid_list; + 241. + 242. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 243. if (!pid_list) + 244. return false; + +net/core/netpoll.c:240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 238. struct netpoll_info *ni; + 239. rcu_read_lock(); + 240. > ni = rcu_dereference(dev->npinfo); + 241. if (ni) + 242. up(&ni->dev_lock); + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +drivers/firmware/efi/esrt.c:305: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_count was never initialized. + 303. */ + 304. if (tmpesrt.fw_resource_count > 128) { + 305. > pr_err("ESRT says fw_resource_count has very large value %d.\n", + 306. tmpesrt.fw_resource_count); + 307. goto err_memunmap; + +drivers/firmware/efi/esrt.c:286: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_version was never initialized. + 284. entry_size = sizeof (*v1_entries); + 285. } else { + 286. > pr_err("Unsupported ESRT version %lld.\n", + 287. tmpesrt.fw_resource_version); + 288. return; + +lib/sbitmap.c:246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 244. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. > unsigned long word = READ_ONCE(sb->map[i].word); + 247. unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + +lib/sbitmap.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. unsigned long word = READ_ONCE(sb->map[i].word); + 247. > unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + 249. while (word_bits > 0) { + +net/core/dst.c:243: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 241. + 242. new = ((unsigned long) &dst_default_metrics) | DST_METRICS_READ_ONLY; + 243. > prev = cmpxchg(&dst->_metrics, old, new); + 244. if (prev == old) + 245. kfree(__DST_METRICS_PTR(old)); + +net/sunrpc/xprtmultipath.c:248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 246. + 247. head = &xps->xps_xprt_list; + 248. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 249. if (rpc_cmp_addr_port(sap, (struct sockaddr *)&pos->addr)) { + 250. pr_info("RPC: addr %s already in xprt switch\n", + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +net/core/gen_estimator.c:246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 244. + 245. rcu_read_lock(); + 246. > est = rcu_dereference(*rate_est); + 247. if (!est) { + 248. rcu_read_unlock(); + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +kernel/kexec.c:265: error: UNINITIALIZED_VALUE + The value read from in.buf was never initialized. + 263. return -EFAULT; + 264. + 265. > out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + +kernel/kexec.c:266: error: UNINITIALIZED_VALUE + The value read from in.bufsz was never initialized. + 264. + 265. out.buf = compat_ptr(in.buf); + 266. > out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. out.memsz = in.memsz; + +kernel/kexec.c:267: error: UNINITIALIZED_VALUE + The value read from in.mem was never initialized. + 265. out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. > out.mem = in.mem; + 268. out.memsz = in.memsz; + 269. + +kernel/kexec.c:268: error: UNINITIALIZED_VALUE + The value read from in.memsz was never initialized. + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. > out.memsz = in.memsz; + 269. + 270. result = copy_to_user(&ksegments[i], &out, sizeof(out)); + +lib/random32.c:250: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 248. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. > state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + +lib/random32.c:251: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. state->s1 = __seed(seeds[0], 2U); + 251. > state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + +lib/random32.c:252: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 250. state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. > state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + 254. + +lib/random32.c:253: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. > state->s4 = __seed(seeds[3], 128U); + 254. + 255. prandom_warmup(state); + +net/ipv6/ip6_flowlabel.c:249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 247. + 248. rcu_read_lock_bh(); + 249. > for_each_sk_fl_rcu(np, sfl) { + 250. struct ip6_flowlabel *fl = sfl->fl; + 251. if (fl->label == label) { + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +net/sunrpc/auth_gss/gss_rpc_xdr.c:253: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 251. if (unlikely(p == NULL)) + 252. return -ENOSPC; + 253. > count = be32_to_cpup(p++); + 254. if (!count) + 255. return 0; + +kernel/softirq.c:244: error: DEAD_STORE + The value written to &end (type unsigned long) is never used. + 242. asmlinkage __visible void __softirq_entry __do_softirq(void) + 243. { + 244. > unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. int max_restart = MAX_SOFTIRQ_RESTART; + +kernel/softirq.c:246: error: DEAD_STORE + The value written to &max_restart (type int) is never used. + 244. unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. > int max_restart = MAX_SOFTIRQ_RESTART; + 247. struct softirq_action *h; + 248. bool in_hardirq; + +kernel/softirq.c:303: error: DEAD_STORE + The value written to &max_restart (type int) is never used. + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + 303. > --max_restart) + 304. goto restart; + 305. + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/md/dm-stripe.c:255: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 253. sector = *result; + 254. if (sc->chunk_size_shift < 0) + 255. > *result -= sector_div(sector, sc->chunk_size); + 256. else + 257. *result = sector & ~(sector_t)(sc->chunk_size - 1); + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +init/main.c:253: error: DEAD_STORE + The value written to &val (type char*) is never used. + 251. val[-2] = '='; + 252. memmove(val-1, val, strlen(val)+1); + 253. > val--; + 254. } else + 255. BUG(); + +net/netfilter/nf_log.c:256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 254. + 255. rcu_read_lock(); + 256. > logger = rcu_dereference(net->nf.nf_loggers[pf]); + 257. if (logger) { + 258. va_start(args, fmt); + +arch/x86/events/intel/uncore.c:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. box = container_of(hrtimer, struct intel_uncore_box, hrtimer); + 252. > if (!box->n_active || box->cpu != smp_processor_id()) + 253. return HRTIMER_NORESTART; + 254. /* + +include/linux/dma-fence.h:250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 248. struct dma_fence *fence; + 249. + 250. > fence = rcu_dereference(*fencep); + 251. if (!fence) + 252. return NULL; + +include/linux/dma-fence.h:271: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 269. * the right fence, as below. + 270. */ + 271. > if (fence == rcu_access_pointer(*fencep)) + 272. return rcu_pointer_handoff(fence); + 273. + +kernel/cgroup/freezer.c:253: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 246 could be null and is dereferenced at line 253, column 8. + 251. lockdep_assert_held(&freezer_mutex); + 252. + 253. > if (!(freezer->state & CGROUP_FREEZING) || + 254. (freezer->state & CGROUP_FROZEN)) + 255. return; + +net/packet/af_packet.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. local_bh_disable(); + 263. + 264. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 265. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 266. ret = netdev_start_xmit(skb, dev, txq, false); + +net/packet/af_packet.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. local_bh_disable(); + 263. + 264. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 265. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 266. ret = netdev_start_xmit(skb, dev, txq, false); + +lib/rhashtable.c:252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 250. do { + 251. new_tbl = tbl; + 252. > tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 253. } while (tbl); + 254. + +net/ipv4/af_inet.c:265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 263. err = -ESOCKTNOSUPPORT; + 264. rcu_read_lock(); + 265. > list_for_each_entry_rcu(answer, &inetsw[sock->type], list) { + 266. + 267. err = 0; + +arch/x86/entry/common.c:248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 246. { + 247. struct thread_info *ti = current_thread_info(); + 248. > u32 cached_flags = READ_ONCE(ti->flags); + 249. + 250. CT_WARN_ON(ct_state() != CONTEXT_KERNEL); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:254: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 249 could be null and is dereferenced at line 254, column 6. + 252. * the panel can support backlight control over the aux channel + 253. */ + 254. > if (intel_dp->edp_dpcd[1] & DP_EDP_TCON_BACKLIGHT_ADJUSTMENT_CAP && + 255. (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP) && + 256. !(intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_PWM_PIN_CAP)) { + +kernel/profile.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. + 250. mutex_lock(&profile_flip_mutex); + 251. > j = per_cpu(cpu_profile_flip, get_cpu()); + 252. put_cpu(); + 253. on_each_cpu(__profile_flip_buffers, NULL, 1); + +kernel/rcu/tree.c:249: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 247. { + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. > if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + +kernel/rcu/tree.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. > __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + 253. __this_cpu_write(rcu_bh_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. > trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + +net/ipv4/inet_connection_sock.c:255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 253. if (!sk->sk_reuseport) + 254. return 0; + 255. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 256. return 0; + 257. if (!uid_eq(tb->fastuid, uid)) + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +kernel/fork.c:255: error: UNINITIALIZED_VALUE + The value read from pco_ret__ was never initialized. + 253. + 254. for (i = 0; i < NR_CACHED_STACKS; i++) { + 255. > if (this_cpu_cmpxchg(cached_stacks[i], + 256. NULL, tsk->stack_vm_area) != NULL) + 257. continue; + +kernel/kprobes.c:256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 254. mutex_lock(&c->mutex); + 255. rcu_read_lock(); + 256. > list_for_each_entry_rcu(kip, &c->pages, list) { + 257. idx = ((long)slot - (long)kip->insns) / + 258. (c->insn_size * sizeof(kprobe_opcode_t)); + +kernel/kprobes.c:277: error: UNINITIALIZED_VALUE + The value read from idx was never initialized. + 275. collect_garbage_slots(c); + 276. } else { + 277. > collect_one_slot(kip, idx); + 278. } + 279. } + +lib/iomap.c:250: error: DEAD_STORE + The value written to &port (type unsigned long) is never used. + 248. void pci_iounmap(struct pci_dev *dev, void __iomem * addr) + 249. { + 250. > IO_COND(addr, /* nothing */, iounmap(addr)); + 251. } + 252. EXPORT_SYMBOL(pci_iounmap); + +net/ipv4/tcp_cong.c:254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 252. + 253. rcu_read_lock(); + 254. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) { + 255. offs += snprintf(buf + offs, maxlen - offs, + 256. "%s%s", + +sound/core/pcm_native.c:268: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 266. + 267. if (trace_hw_mask_param_enabled()) + 268. > old_mask = *m; + 269. + 270. changed = snd_mask_refine(m, constrs_mask(constrs, k)); + +kernel/events/core.c:252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 250. { + 251. struct perf_event_context *ctx = event->ctx; + 252. > struct task_struct *task = READ_ONCE(ctx->task); /* verified in event_function */ + 253. struct event_function_struct efs = { + 254. .event = event, + +drivers/gpu/drm/i915/intel_guc_log.c:280: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.read_ptr was never initialized. + 278. sizeof(struct guc_log_buffer_state)); + 279. buffer_size = guc_get_log_buffer_size(type); + 280. > read_offset = log_buf_state_local.read_ptr; + 281. write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + +drivers/gpu/drm/i915/intel_guc_log.c:281: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.sampled_write_ptr was never initialized. + 279. buffer_size = guc_get_log_buffer_size(type); + 280. read_offset = log_buf_state_local.read_ptr; + 281. > write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + 283. + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +drivers/base/power/main.c:265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 263. * walking. + 264. */ + 265. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 266. if (READ_ONCE(link->status) != DL_STATE_DORMANT) + 267. dpm_wait(link->supplier, async); + +net/ipv6/netfilter/ip6_tables.c:291: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 289. */ + 290. smp_read_barrier_depends(); + 291. > cpu = smp_processor_id(); + 292. table_base = private->entries; + 293. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +net/ipv6/netfilter/ip6_tables.c:303: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 301. */ + 302. if (static_key_false(&xt_tee_enabled)) + 303. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 304. + 305. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv6/netfilter/ip6_tables.c:291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 289. */ + 290. smp_read_barrier_depends(); + 291. > cpu = smp_processor_id(); + 292. table_base = private->entries; + 293. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +drivers/gpu/drm/drm_ioc32.c:263: error: UNINITIALIZED_VALUE + The value read from c32.idx was never initialized. + 261. return -EFAULT; + 262. + 263. > client.idx = c32.idx; + 264. + 265. err = drm_ioctl_kernel(file, drm_getclient, &client, DRM_UNLOCKED); + +drivers/gpu/drm/drm_ioc32.c:270: error: UNINITIALIZED_VALUE + The value read from client.auth was never initialized. + 268. + 269. c32.idx = client.idx; + 270. > c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + +drivers/gpu/drm/drm_ioc32.c:274: error: UNINITIALIZED_VALUE + The value read from client.iocs was never initialized. + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. > c32.iocs = client.iocs; + 275. + 276. if (copy_to_user(argp, &c32, sizeof(c32))) + +drivers/gpu/drm/drm_ioc32.c:273: error: UNINITIALIZED_VALUE + The value read from client.magic was never initialized. + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. > c32.magic = client.magic; + 274. c32.iocs = client.iocs; + 275. + +drivers/gpu/drm/drm_ioc32.c:271: error: UNINITIALIZED_VALUE + The value read from client.pid was never initialized. + 269. c32.idx = client.idx; + 270. c32.auth = client.auth; + 271. > c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + +drivers/gpu/drm/drm_ioc32.c:272: error: UNINITIALIZED_VALUE + The value read from client.uid was never initialized. + 270. c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. > c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. c32.iocs = client.iocs; + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +kernel/sched/core.c:257: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 255. struct rq_flags rf; + 256. + 257. > WARN_ON_ONCE(cpu_of(rq) != smp_processor_id()); + 258. + 259. rq_lock(rq, &rf); + +net/core/fib_rules.c:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. rcu_read_lock(); + 260. + 261. > list_for_each_entry_rcu(rule, &ops->rules_list, list) { + 262. jumped: + 263. if (!fib_rule_match(rule, ops, fl, flags, arg)) + +net/core/fib_rules.c:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. struct fib_rule *target; + 268. + 269. > target = rcu_dereference(rule->ctarget); + 270. if (target == NULL) { + 271. continue; + +block/genhd.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. int i; + 259. + 260. > ptbl = rcu_dereference(disk->part_tbl); + 261. + 262. part = rcu_dereference(ptbl->last_lookup); + +block/genhd.c:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. ptbl = rcu_dereference(disk->part_tbl); + 261. + 262. > part = rcu_dereference(ptbl->last_lookup); + 263. if (part && sector_in_part(part, sector)) + 264. return part; + +block/genhd.c:267: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 265. + 266. for (i = 1; i < ptbl->len; i++) { + 267. > part = rcu_dereference(ptbl->part[i]); + 268. + 269. if (part && sector_in_part(part, sector)) { + +drivers/cpufreq/acpi-cpufreq.c:258: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 256. u32 val, dummy; + 257. + 258. > rdmsr(MSR_IA32_PERF_CTL, val, dummy); + 259. return val; + 260. } + +drivers/gpu/drm/i915/i915_debugfs.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. int ret; + 263. + 264. > total = READ_ONCE(dev_priv->mm.object_count); + 265. objects = kvmalloc_array(total, sizeof(*objects), GFP_KERNEL); + 266. if (!objects) + +drivers/pcmcia/ds.c:282: error: UNINITIALIZED_VALUE + The value read from cis_config.base was never initialized. + 280. &cis_config); + 281. if (!ret) { + 282. > p_dev->config_base = cis_config.base; + 283. p_dev->config_regs = cis_config.rmask[0]; + 284. dev_dbg(dev, "base %x, regs %x", p_dev->config_base, + +security/keys/request_key.c:272: error: NULL_DEREFERENCE + pointer `cred` last assigned on line 257 could be null and is dereferenced at line 272, column 11. + 270. /* use a default keyring; falling through the cases until we + 271. * find one that we actually have */ + 272. > switch (cred->jit_keyring) { + 273. case KEY_REQKEY_DEFL_DEFAULT: + 274. case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: + +security/keys/request_key.c:303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 301. rcu_read_lock(); + 302. dest_keyring = key_get( + 303. > rcu_dereference(cred->session_keyring)); + 304. rcu_read_unlock(); + 305. + +include/trace/events/timer.h:255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 253. * determine the runtime of the callback function. + 254. */ + 255. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 256. + 257. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:255: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 253. * determine the runtime of the callback function. + 254. */ + 255. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 256. + 257. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:255: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 253. * determine the runtime of the callback function. + 254. */ + 255. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 256. + 257. TP_PROTO(struct hrtimer *hrtimer), + +net/wireless/trace.h:255: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +arch/x86/include/asm/tlbflush.h:261: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 259. + 260. local_irq_save(flags); + 261. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 262. if ((cr4 | mask) != cr4) + 263. __cr4_set(cr4 | mask); + +arch/x86/include/asm/tlbflush.h:261: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 259. + 260. local_irq_save(flags); + 261. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 262. if ((cr4 | mask) != cr4) + 263. __cr4_set(cr4 | mask); + +net/ipv4/inet_timewait_sock.c:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. rcu_read_lock(); + 268. restart: + 269. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 270. if (sk->sk_state != TCP_TIME_WAIT) + 271. continue; + +lib/idr.c:290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 288. } + 289. new = iter.index * IDA_BITMAP_BITS; + 290. > bitmap = rcu_dereference_raw(*slot); + 291. if (radix_tree_exception(bitmap)) { + 292. unsigned long tmp = (unsigned long)bitmap; + +lib/idr.c:300: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 298. return 0; + 299. } + 300. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 301. if (!bitmap) + 302. return -EAGAIN; + +lib/idr.c:333: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 331. return 0; + 332. } + 333. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 334. if (!bitmap) + 335. return -EAGAIN; + +lib/idr.c:300: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 298. return 0; + 299. } + 300. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 301. if (!bitmap) + 302. return -EAGAIN; + +lib/idr.c:333: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 331. return 0; + 332. } + 333. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 334. if (!bitmap) + 335. return -EAGAIN; + +lib/rhashtable.c:292: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 290. + 291. spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING); + 292. > head = rht_dereference_bucket(new_tbl->buckets[new_hash], + 293. new_tbl, new_hash); + 294. + +lib/rhashtable.c:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht); + 261. struct bucket_table *new_tbl = rhashtable_last_table(ht, + 262. > rht_dereference_rcu(old_tbl->future_tbl, ht)); + 263. struct rhash_head __rcu **pprev = rht_bucket_var(old_tbl, old_hash); + 264. int err = -EAGAIN; + +lib/rhashtable.c:300: error: UNINITIALIZED_VALUE + The value read from next was never initialized. + 298. spin_unlock(new_bucket_lock); + 299. + 300. > rcu_assign_pointer(*pprev, next); + 301. + 302. out: + +net/ipv4/sysctl_net_ipv4.c:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. + 273. rcu_read_lock(); + 274. > ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx); + 275. if (ctxt) + 276. memcpy(user_key, ctxt->key, TCP_FASTOPEN_KEY_LENGTH); + +net/ipv4/sysctl_net_ipv4.c:281: error: UNINITIALIZED_VALUE + The value read from user_key[_] was never initialized. + 279. rcu_read_unlock(); + 280. + 281. > snprintf(tbl.data, tbl.maxlen, "%08x-%08x-%08x-%08x", + 282. user_key[0], user_key[1], user_key[2], user_key[3]); + 283. ret = proc_dostring(&tbl, write, buffer, lenp, ppos); + +net/ipv4/sysctl_net_ipv4.c:296: error: UNINITIALIZED_VALUE + The value read from user_key[_] was never initialized. + 294. + 295. bad_key: + 296. > pr_debug("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n", + 297. user_key[0], user_key[1], user_key[2], user_key[3], + 298. (char *)tbl.data, ret); + +net/sunrpc/xprtmultipath.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. struct rpc_xprt *pos, *prev = NULL; + 263. + 264. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 265. if (cur == prev) + 266. return pos; + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +kernel/sys.c:290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 288. else + 289. pgrp = task_pgrp(current); + 290. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 291. niceval = nice_to_rlimit(task_nice(p)); + 292. if (niceval > retval) + +kernel/sys.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. goto out_unlock; /* No processes for this user */ + 305. } + 306. > do_each_thread(g, p) { + 307. if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) { + 308. niceval = nice_to_rlimit(task_nice(p)); + +kernel/sys.c:307: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 305. } + 306. do_each_thread(g, p) { + 307. > if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) { + 308. niceval = nice_to_rlimit(task_nice(p)); + 309. if (niceval > retval) + +drivers/gpu/drm/i915/intel_opregion.c:328: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 326. /* Poll for the result. */ + 327. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 328. > if (wait_for(C, dslp)) { + 329. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 330. return -ETIMEDOUT; + +drivers/tty/serial/serial_core.c:283: error: NULL_DEREFERENCE + pointer `uport` last assigned on line 264 could be null and is dereferenced by call to `uart_port_dtr_rts()` at line 283, column 4. + 281. + 282. if (!tty || C_HUPCL(tty)) + 283. > uart_port_dtr_rts(uport, 0); + 284. + 285. uart_port_shutdown(port); + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +net/netlink/genetlink.c:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. netlink_table_grab(); + 268. rcu_read_lock(); + 269. > for_each_net_rcu(net) { + 270. for (i = 0; i < family->n_mcgrps; i++) + 271. __netlink_clear_multicast_users( + +net/sched/sch_api.c:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. return root; + 272. + 273. > hash_for_each_possible_rcu(qdisc_dev(root)->qdisc_hash, q, hash, handle) { + 274. if (q->handle == handle) + 275. return q; + +drivers/tty/vt/vt_ioctl.c:274: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 272. if (!perm) + 273. return -EPERM; + 274. > return con_set_unimap(vc, tmp.entry_ct, tmp.entries); + 275. case GIO_UNIMAP: + 276. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:278: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 276. if (!perm && fg_console != vc->vc_num) + 277. return -EPERM; + 278. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries); + 279. } + 280. return 0; + +net/ipv4/tcp_cong.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. + 267. rcu_read_lock(); + 268. > ca = rcu_dereference(net->ipv4.tcp_congestion_control); + 269. strncpy(name, ca->name, TCP_CA_NAME_MAX); + 270. rcu_read_unlock(); + +net/ipv6/ip6_flowlabel.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. struct ipv6_fl_socklist *sfl; + 267. + 268. > if (!rcu_access_pointer(np->ipv6_fl_list)) + 269. return; + 270. + +drivers/base/power/runtime.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. struct device_link *link; + 267. + 268. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) { + 269. int retval; + 270. + +sound/core/pcm_lib.c:408: error: DEAD_STORE + The value written to &hw_base (type unsigned long) is never used. + 406. /* move new_hw_ptr according jiffies not pos variable */ + 407. new_hw_ptr = old_hw_ptr; + 408. > hw_base = delta; + 409. /* use loop to avoid checks for delta overflows */ + 410. /* the delta value is small or zero in most cases */ + +kernel/irq/matrix.c:277: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 275. cm->available--; + 276. m->global_available--; + 277. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 278. } + 279. + +kernel/irq/matrix.c:277: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 275. cm->available--; + 276. m->global_available--; + 277. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 278. } + 279. + +kernel/power/swap.c:273: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 272 could be null and is dereferenced at line 273, column 2. + 271. + 272. bio = bio_alloc(__GFP_RECLAIM | __GFP_HIGH, 1); + 273. > bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >> 9); + 274. bio_set_dev(bio, hib_resume_bdev); + 275. bio_set_op_attrs(bio, op, op_flags); + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +drivers/gpu/drm/i915/intel_i2c.c:283: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 281. + 282. status |= GMBUS_SATOER; + 283. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:285: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 283. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 286. + 287. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_i2c.c:283: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 281. + 282. status |= GMBUS_SATOER; + 283. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:283: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 281. + 282. status |= GMBUS_SATOER; + 283. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:283: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 281. + 282. status |= GMBUS_SATOER; + 283. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:285: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 283. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 284. if (ret) + 285. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 286. + 287. I915_WRITE_FW(GMBUS4, 0); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/timer.h:266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 264. * @hrtimer: pointer to struct hrtimer + 265. */ + 266. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 267. + 268. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 264. * @hrtimer: pointer to struct hrtimer + 265. */ + 266. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 267. + 268. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 264. * @hrtimer: pointer to struct hrtimer + 265. */ + 266. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 267. + 268. TP_PROTO(struct hrtimer *hrtimer), + +kernel/sched/wait_bit.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. __sched int bit_wait_timeout(struct wait_bit_key *word, int mode) + 267. { + 268. > unsigned long now = READ_ONCE(jiffies); + 269. if (time_after_eq(now, word->timeout)) + 270. return -EAGAIN; + +kernel/seccomp.c:276: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 274. /* Validate all threads being eligible for synchronization. */ + 275. caller = current; + 276. > for_each_thread(caller, thread) { + 277. pid_t failed; + 278. + +scripts/sortextable.c:313: error: DEAD_STORE + The value written to &custom_sort (type _fn_(*)) is never used. + 311. case EM_386: + 312. case EM_X86_64: + 313. > custom_sort = x86_sort_relative_table; + 314. break; + 315. + +scripts/sortextable.c:321: error: DEAD_STORE + The value written to &custom_sort (type _fn_(*)) is never used. + 319. case EM_PPC: + 320. case EM_PPC64: + 321. > custom_sort = sort_relative_table; + 322. break; + 323. case EM_ARCOMPACT: + +arch/x86/include/asm/tlbflush.h:273: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 271. + 272. local_irq_save(flags); + 273. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 274. if ((cr4 & ~mask) != cr4) + 275. __cr4_set(cr4 & ~mask); + +arch/x86/include/asm/tlbflush.h:273: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 271. + 272. local_irq_save(flags); + 273. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 274. if ((cr4 & ~mask) != cr4) + 275. __cr4_set(cr4 & ~mask); + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +kernel/time/posix-cpu-timers.c:284: error: UNINITIALIZED_VALUE + The value read from rtn was never initialized. + 282. + 283. if (!err) + 284. > *tp = ns_to_timespec64(rtn); + 285. + 286. return err; + +drivers/gpu/drm/drm_crtc_helper.c:281: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 279. bool saved_enabled; + 280. struct drm_encoder *encoder; + 281. > bool ret = true; + 282. + 283. drm_warn_on_modeset_not_all_locked(dev); + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/net/ethernet/intel/e1000e/ethtool.c:321: error: DEAD_STORE + The value written to &advertising (type unsigned int) is never used. + 319. hw->phy.autoneg_advertised = advertising | + 320. ADVERTISED_TP | ADVERTISED_Autoneg; + 321. > advertising = hw->phy.autoneg_advertised; + 322. if (adapter->fc_autoneg) + 323. hw->fc.requested_mode = e1000_fc_default; + +kernel/profile.c:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. + 273. mutex_lock(&profile_flip_mutex); + 274. > i = per_cpu(cpu_profile_flip, get_cpu()); + 275. put_cpu(); + 276. on_each_cpu(__profile_flip_buffers, NULL, 1); + +net/wireless/trace.h:269: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +scripts/basic/fixdep.c:297: error: MEMORY_LEAK + memory dynamically allocated by call to `malloc()` at line 290, column 8 is not reachable after line 297, column 3. + 295. } + 296. if (read(fd, map, st.st_size) != st.st_size) { + 297. > perror("fixdep: read"); + 298. close(fd); + 299. return; + +drivers/net/ethernet/intel/e1000/e1000_param.c:283: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 281. struct e1000_tx_ring *tx_ring = adapter->tx_ring; + 282. int i; + 283. > e1000_mac_type mac_type = adapter->hw.mac_type; + 284. + 285. opt = (struct e1000_option) { + +drivers/net/ethernet/intel/e1000/e1000_param.c:311: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 309. struct e1000_rx_ring *rx_ring = adapter->rx_ring; + 310. int i; + 311. > e1000_mac_type mac_type = adapter->hw.mac_type; + 312. + 313. opt = (struct e1000_option) { + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +drivers/cpufreq/acpi-cpufreq.c:275: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 273. u32 val, dummy; + 274. + 275. > rdmsr(MSR_AMD_PERF_CTL, val, dummy); + 276. return val; + 277. } + +drivers/dma-buf/reservation.c:327: error: DEAD_STORE + The value written to &new (type dma_fence*) is never used. + 325. } + 326. + 327. > new = dma_fence_get_rcu_safe(&src->fence_excl); + 328. rcu_read_unlock(); + 329. + +drivers/dma-buf/reservation.c:280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 278. + 279. rcu_read_lock(); + 280. > src_list = rcu_dereference(src->fence); + 281. + 282. retry: + +drivers/dma-buf/reservation.c:294: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 292. + 293. rcu_read_lock(); + 294. > src_list = rcu_dereference(src->fence); + 295. if (!src_list || src_list->shared_count > shared_count) { + 296. kfree(dst_list); + +drivers/dma-buf/reservation.c:305: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 303. struct dma_fence *fence; + 304. + 305. > fence = rcu_dereference(src_list->shared[i]); + 306. if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, + 307. &fence->flags)) + +drivers/dma-buf/reservation.c:312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 310. if (!dma_fence_get_rcu(fence)) { + 311. kfree(dst_list); + 312. > src_list = rcu_dereference(src->fence); + 313. goto retry; + 314. } + +kernel/ptrace.c:311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 309. caller_gid = cred->gid; + 310. } + 311. > tcred = __task_cred(task); + 312. if (uid_eq(caller_uid, tcred->euid) && + 313. uid_eq(caller_uid, tcred->suid) && + +include/net/neighbour.h:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. struct net_device *dev) + 280. { + 281. > struct neigh_hash_table *nht = rcu_dereference_bh(tbl->nht); + 282. struct neighbour *n; + 283. u32 hash_val; + +include/net/neighbour.h:286: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 284. + 285. hash_val = hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift); + 286. > for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 287. n != NULL; + 288. n = rcu_dereference_bh(n->next)) { + +include/net/neighbour.h:288: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 286. for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 287. n != NULL; + 288. > n = rcu_dereference_bh(n->next)) { + 289. if (n->dev == dev && key_eq(n, pkey)) + 290. return n; + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +net/ipv4/inet_hashtables.c:278: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 276. const int dif, const int sdif) + 277. { + 278. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 279. const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 280. struct sock *sk; + +net/ipv4/inet_hashtables.c:279: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 277. { + 278. INET_ADDR_COOKIE(acookie, saddr, daddr); + 279. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 280. struct sock *sk; + 281. const struct hlist_nulls_node *node; + +net/ipv4/inet_hashtables.c:290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 288. + 289. begin: + 290. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 291. if (sk->sk_hash != hash) + 292. continue; + +net/sunrpc/xprtmultipath.c:285: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 283. if (pos == NULL) + 284. break; + 285. > cur = cmpxchg_relaxed(cursor, old, pos); + 286. if (cur == old) + 287. break; + +net/sunrpc/xprtmultipath.c:279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 277. struct rpc_xprt *cur, *pos, *old; + 278. + 279. > cur = READ_ONCE(*cursor); + 280. for (;;) { + 281. old = cur; + +net/sunrpc/xprtmultipath.c:289: error: UNINITIALIZED_VALUE + The value read from pos was never initialized. + 287. break; + 288. } + 289. > return pos; + 290. } + 291. + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +drivers/cpufreq/cpufreq_governor.c:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. */ + 297. smp_rmb(); + 298. > lst = READ_ONCE(policy_dbs->last_sample_time); + 299. delta_ns = time - lst; + 300. if ((s64)delta_ns < policy_dbs->sample_delay_ns) + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +net/ipv4/tcp_cong.c:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. *buf = '\0'; + 280. rcu_read_lock(); + 281. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) { + 282. if (!(ca->flags & TCP_CONG_NON_RESTRICTED)) + 283. continue; + +drivers/ata/libata-scsi.c:299: error: UNINITIALIZED_VALUE + The value read from ncq_prio_enable was never initialized. + 297. spin_unlock_irq(ap->lock); + 298. + 299. > return rc ? rc : snprintf(buf, 20, "%u\n", ncq_prio_enable); + 300. } + 301. + +drivers/gpu/drm/drm_fb_helper.c:277: error: DEAD_STORE + The value written to &helper (type drm_fb_helper*) is never used. + 275. int drm_fb_helper_debug_enter(struct fb_info *info) + 276. { + 277. > struct drm_fb_helper *helper = info->par; + 278. const struct drm_crtc_helper_funcs *funcs; + 279. int i; + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +net/ipv6/calipso.c:278: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 276. const struct netlbl_lsm_secattr *secattr) + 277. { + 278. > int ret_val = -EPERM; + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + +drivers/gpu/drm/i915/i915_gem_request.h:279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 277. i915_gem_request_global_seqno(const struct drm_i915_gem_request *request) + 278. { + 279. > return READ_ONCE(request->global_seqno); + 280. } + 281. + +block/blk-lib.c:293: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 291 could be null and is dereferenced at line 293, column 3. + 291. bio = next_bio(bio, __blkdev_sectors_to_bio_pages(nr_sects), + 292. gfp_mask); + 293. > bio->bi_iter.bi_sector = sector; + 294. bio_set_dev(bio, bdev); + 295. bio_set_op_attrs(bio, REQ_OP_WRITE, 0); + +drivers/base/power/main.c:294: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 292. * unregistration). + 293. */ + 294. > list_for_each_entry_rcu(link, &dev->links.consumers, s_node) + 295. if (READ_ONCE(link->status) != DL_STATE_DORMANT) + 296. dpm_wait(link->consumer, async); + +drivers/iommu/dmar.c:287: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 285. return 0; + 286. + 287. > for_each_active_dev_scope(devices, count, index, tmp) + 288. if (tmp == &info->dev->dev) { + 289. RCU_INIT_POINTER(devices[index].dev, NULL); + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +kernel/sched/wait_bit.c:280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 278. __sched int bit_wait_io_timeout(struct wait_bit_key *word, int mode) + 279. { + 280. > unsigned long now = READ_ONCE(jiffies); + 281. if (time_after_eq(now, word->timeout)) + 282. return -EAGAIN; + +scripts/kconfig/symbol.c:290: error: NULL_DEREFERENCE + pointer `def_sym` last assigned on line 289 could be null and is dereferenced at line 290, column 7. + 288. continue; + 289. def_sym = prop_get_symbol(prop); + 290. > if (def_sym->visible != no) + 291. return def_sym; + 292. } + +sound/hda/hdac_regmap.c:348: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 346. out: + 347. codec_pm_unlock(codec, pm_lock); + 348. > return err; + 349. } + 350. + +drivers/video/fbdev/core/fbmem.c:286: error: DEAD_STORE + The value written to &fg (type unsigned char) is never used. + 284. const u8 *src = logo->data; + 285. u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0; + 286. > u8 fg = 1, d; + 287. + 288. switch (fb_get_color_depth(&info->var, &info->fix)) { + +include/linux/seqlock.h:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. static inline int raw_read_seqcount_latch(seqcount_t *s) + 280. { + 281. > int seq = READ_ONCE(s->sequence); + 282. /* Pairs with the first smp_wmb() in raw_write_seqcount_latch() */ + 283. smp_read_barrier_depends(); + +include/trace/events/timer.h:280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 278. * @expires: the itimers expiry time + 279. */ + 280. > TRACE_EVENT(itimer_state, + 281. + 282. TP_PROTO(int which, const struct itimerval *const value, + +include/trace/events/timer.h:280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 278. * @expires: the itimers expiry time + 279. */ + 280. > TRACE_EVENT(itimer_state, + 281. + 282. TP_PROTO(int which, const struct itimerval *const value, + +include/trace/events/timer.h:280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 278. * @expires: the itimers expiry time + 279. */ + 280. > TRACE_EVENT(itimer_state, + 281. + 282. TP_PROTO(int which, const struct itimerval *const value, + +kernel/sched/cpuacct.c:301: error: UNINITIALIZED_VALUE + The value read from val[_] was never initialized. + 299. seq_printf(sf, "%s %lld\n", + 300. cpuacct_stat_desc[stat], + 301. > (long long)nsec_to_clock_t(val[stat])); + 302. } + 303. + +net/netlink/af_netlink.c:288: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 286. return; + 287. + 288. > list_for_each_entry_rcu(tmp, &netlink_tap_all, list) { + 289. ret = __netlink_deliver_tap_skb(skb, tmp->dev); + 290. if (unlikely(ret)) + +kernel/rcu/tree.c:283: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 281. bool rcu_irq_enter_disabled(void) + 282. { + 283. > return this_cpu_read(disable_rcu_irq_enter); + 284. } + 285. + +kernel/rcu/tree.c:283: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 281. bool rcu_irq_enter_disabled(void) + 282. { + 283. > return this_cpu_read(disable_rcu_irq_enter); + 284. } + 285. + +net/packet/af_packet.c:286: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 284. + 285. rcu_read_lock(); + 286. > dev = rcu_dereference(po->cached_dev); + 287. if (likely(dev)) + 288. dev_hold(dev); + +net/wireless/trace.h:281: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 279. ); + 280. + 281. > DECLARE_EVENT_CLASS(wiphy_only_evt, + 282. TP_PROTO(struct wiphy *wiphy), + 283. TP_ARGS(wiphy), + +drivers/cpuidle/governors/menu.c:294: error: NULL_DEREFERENCE + pointer `device` last assigned on line 286 could be null and is dereferenced by call to `dev_pm_qos_raw_read_value()` at line 294, column 23. + 292. unsigned int expected_interval; + 293. unsigned long nr_iowaiters, cpu_load; + 294. > int resume_latency = dev_pm_qos_raw_read_value(device); + 295. + 296. if (data->needs_update) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +net/ipv6/sit.c:289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 287. struct ip_tunnel_prl_entry *prl; + 288. + 289. > for_each_prl_rcu(t->prl) + 290. if (prl->addr == addr) + 291. break; + +sound/core/pcm_native.c:304: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 302. + 303. if (trace_hw_interval_param_enabled()) + 304. > old_interval = *i; + 305. + 306. changed = snd_interval_refine(i, constrs_interval(constrs, k)); + +security/selinux/ss/services.c:456: error: UNINITIALIZED_VALUE + The value read from s[_] was never initialized. + 454. + 455. BUG_ON(sp != 0); + 456. > return s[0]; + 457. } + 458. + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +kernel/kprobes.c:294: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 292. + 293. rcu_read_lock(); + 294. > list_for_each_entry_rcu(kip, &c->pages, list) { + 295. if (addr >= (unsigned long)kip->insns && + 296. addr < (unsigned long)kip->insns + PAGE_SIZE) { + +net/netfilter/nf_conntrack_helper.c:292: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 290. struct nf_conn_help *help = nfct_help(ct); + 291. + 292. > if (help && rcu_dereference_raw(help->helper) == me) { + 293. nf_conntrack_event(IPCT_HELPER, ct); + 294. RCU_INIT_POINTER(help->helper, NULL); + +drivers/base/power/runtime.c:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. struct device_link *link; + 292. + 293. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 294. if (link->rpm_active && + 295. READ_ONCE(link->status) != DL_STATE_SUPPLIER_UNBIND) { + +lib/genalloc.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. nbits = (size + (1UL << order) - 1) >> order; + 305. rcu_read_lock(); + 306. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 307. if (size > atomic_long_read(&chunk->avail)) + 308. continue; + +arch/x86/events/amd/core.c:319: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 317. if (new == -1 || hwc->idx == idx) + 318. /* assign free slot, prefer hwc->idx */ + 319. > old = cmpxchg(nb->owners + idx, NULL, event); + 320. else if (nb->owners[idx] == event) + 321. /* event already present */ + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +kernel/exit.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. * see comment in rcuwait_wait_event() regarding ->exit_state. + 314. */ + 315. > task = rcu_dereference(w->task); + 316. if (task) + 317. wake_up_process(task); + +net/ipv4/tcp_cong.c:313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 311. + 312. /* pass 2 clear old values */ + 313. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) + 314. ca->flags &= ~TCP_CONG_NON_RESTRICTED; + 315. + +net/sunrpc/xprtmultipath.c:296: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 294. xprt_switch_find_xprt_t find_next) + 295. { + 296. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 297. + 298. if (xps == NULL) + +include/linux/netfilter.h:295: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 293. static inline const struct nf_afinfo *nf_get_afinfo(unsigned short family) + 294. { + 295. > return rcu_dereference(nf_afinfo[family]); + 296. } + 297. + +net/netlabel/netlabel_calipso.c:295: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 293. static int netlbl_calipso_remove(struct sk_buff *skb, struct genl_info *info) + 294. { + 295. > int ret_val = -EINVAL; + 296. struct netlbl_domhsh_walk_arg cb_arg; + 297. struct netlbl_audit audit_info; + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +kernel/locking/qspinlock.c:460: error: UNINITIALIZED_VALUE + The value read from VAL was never initialized. + 458. goto locked; + 459. + 460. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 461. + 462. locked: + +kernel/locking/qspinlock.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. * implementations imply full barriers. + 361. */ + 362. > smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_MASK)); + 363. + 364. /* + +kernel/locking/qspinlock.c:423: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 421. + 422. pv_wait_node(node, prev); + 423. > arch_mcs_spin_lock_contended(&node->locked); + 424. + 425. /* + +kernel/locking/qspinlock.c:431: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 429. * to reduce latency in the upcoming MCS unlock operation. + 430. */ + 431. > next = READ_ONCE(node->next); + 432. if (next) + 433. prefetchw(next); + +kernel/locking/qspinlock.c:460: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 458. goto locked; + 459. + 460. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 461. + 462. locked: + +kernel/locking/qspinlock.c:495: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 493. */ + 494. if (!next) { + 495. > while (!(next = READ_ONCE(node->next))) + 496. cpu_relax(); + 497. } + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +net/sched/sch_generic.c:311: error: DEAD_STORE + The value written to &trans_start (type unsigned long) is never used. + 309. + 310. txq = netdev_get_tx_queue(dev, i); + 311. > trans_start = txq->trans_start; + 312. if (netif_xmit_stopped(txq) && + 313. time_after(jiffies, (trans_start + + +arch/x86/platform/efi/efi.c:342: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 340. efi_systab.tables = data ? (unsigned long)data->tables : + 341. systab64->tables; + 342. > tmp |= data ? data->tables : systab64->tables; + 343. + 344. early_memunmap(systab64, sizeof(*systab64)); + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/intel_lpe_audio.c:302: error: DEAD_STORE + The value written to &desc (type irq_desc*) is never used. + 300. return; + 301. + 302. > desc = irq_to_desc(dev_priv->lpe_audio.irq); + 303. + 304. lpe_audio_platdev_destroy(dev_priv); + +usr/gen_init_cpio.c:303: error: DEAD_STORE + The value written to &file (type int) is never used. + 301. struct stat buf; + 302. long size; + 303. > int file = -1; + 304. int retval; + 305. int rc = -1; + +drivers/i2c/i2c-core-smbus.c:452: error: UNINITIALIZED_VALUE + The value read from msgbuf1[_] was never initialized. + 450. break; + 451. case I2C_SMBUS_BYTE_DATA: + 452. > data->byte = msgbuf1[0]; + 453. break; + 454. case I2C_SMBUS_WORD_DATA: + +drivers/i2c/i2c-core-smbus.c:460: error: UNINITIALIZED_VALUE + The value read from msgbuf1[_] was never initialized. + 458. case I2C_SMBUS_I2C_BLOCK_DATA: + 459. for (i = 0; i < data->block[0]; i++) + 460. > data->block[i+1] = msgbuf1[i]; + 461. break; + 462. case I2C_SMBUS_BLOCK_DATA: + +drivers/i2c/i2c-core-smbus.c:465: error: UNINITIALIZED_VALUE + The value read from msgbuf1[_] was never initialized. + 463. case I2C_SMBUS_BLOCK_PROC_CALL: + 464. for (i = 0; i < msgbuf1[0] + 1; i++) + 465. > data->block[i] = msgbuf1[i]; + 466. break; + 467. } + +drivers/md/dm-io.c:315: error: NULL_DEREFERENCE + pointer `q` last assigned on line 306 could be null and is dereferenced at line 315, column 29. + 313. */ + 314. if (op == REQ_OP_DISCARD) + 315. > special_cmd_max_sectors = q->limits.max_discard_sectors; + 316. else if (op == REQ_OP_WRITE_ZEROES) + 317. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + +drivers/md/dm-io.c:317: error: NULL_DEREFERENCE + pointer `q` last assigned on line 306 could be null and is dereferenced at line 317, column 29. + 315. special_cmd_max_sectors = q->limits.max_discard_sectors; + 316. else if (op == REQ_OP_WRITE_ZEROES) + 317. > special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 318. else if (op == REQ_OP_WRITE_SAME) + 319. special_cmd_max_sectors = q->limits.max_write_same_sectors; + +drivers/md/dm-io.c:319: error: NULL_DEREFERENCE + pointer `q` last assigned on line 306 could be null and is dereferenced at line 319, column 29. + 317. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 318. else if (op == REQ_OP_WRITE_SAME) + 319. > special_cmd_max_sectors = q->limits.max_write_same_sectors; + 320. if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES || + 321. op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) { + +kernel/capability.c:302: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 300. + 301. rcu_read_lock(); + 302. > ret = security_capable(__task_cred(t), ns, cap); + 303. rcu_read_unlock(); + 304. + +kernel/sched/cputime.c:325: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 323. times->sum_exec_runtime = sig->sum_sched_runtime; + 324. + 325. > for_each_thread(tsk, t) { + 326. task_cputime(t, &utime, &stime); + 327. times->utime += utime; + +net/ipv6/sit.c:329: error: DEAD_STORE + The value written to &ret (type int) is never used. + 327. kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC); + 328. if (!kp) { + 329. > ret = -ENOMEM; + 330. goto out; + 331. } + +net/ipv6/sit.c:335: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 333. + 334. c = 0; + 335. > for_each_prl_rcu(t->prl) { + 336. if (c >= cmax) + 337. break; + +drivers/char/hpet.c:335: error: UNINITIALIZED_VALUE + The value read from data was never initialized. + 333. } + 334. + 335. > retval = put_user(data, (unsigned long __user *)buf); + 336. if (!retval) + 337. retval = sizeof(unsigned long); + +drivers/iommu/dmar.c:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. struct acpi_dmar_hardware_unit *drhd; + 303. + 304. > for_each_drhd_unit(dmaru) { + 305. if (dmaru->include_all) + 306. continue; + +include/net/addrconf.h:300: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 298. static inline struct inet6_dev *__in6_dev_get(const struct net_device *dev) + 299. { + 300. > return rcu_dereference_rtnl(dev->ip6_ptr); + 301. } + 302. + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +arch/x86/events/intel/bts.c:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 303. struct bts_buffer *buf = NULL; + 304. > int state = READ_ONCE(bts->state); + 305. + 306. if (state == BTS_STATE_ACTIVE) + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +net/netfilter/nf_conntrack_helper.c:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. if (help) { + 307. rcu_read_lock(); + 308. > helper = rcu_dereference(help->helper); + 309. if (helper && helper->destroy) + 310. helper->destroy(ct); + +drivers/input/evdev.c:316: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 314. rcu_read_lock(); + 315. + 316. > client = rcu_dereference(evdev->grab); + 317. + 318. if (client) + +drivers/input/evdev.c:321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 319. evdev_pass_values(client, vals, count, ev_time); + 320. else + 321. > list_for_each_entry_rcu(client, &evdev->client_list, node) + 322. evdev_pass_values(client, vals, count, ev_time); + 323. + +include/net/ipv6.h:307: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 305. + 306. rcu_read_lock(); + 307. > opt = rcu_dereference(np->opt); + 308. if (opt) { + 309. if (!refcount_inc_not_zero(&opt->refcnt)) + +kernel/events/core.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. struct perf_event_context *ctx = event->ctx; + 305. struct perf_cpu_context *cpuctx = __get_cpu_context(ctx); + 306. > struct task_struct *task = READ_ONCE(ctx->task); + 307. struct perf_event_context *task_ctx = NULL; + 308. + +net/ipv4/sysctl_net_ipv4.c:312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 310. rcu_read_lock(); + 311. + 312. > ipprot = rcu_dereference(inet_protos[protocol]); + 313. if (ipprot) + 314. ipprot->early_demux = enabled ? ipprot->early_demux_handler : + +net/ipv4/sysctl_net_ipv4.c:318: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 316. + 317. #if IS_ENABLED(CONFIG_IPV6) + 318. > ip6prot = rcu_dereference(inet6_protos[protocol]); + 319. if (ip6prot) + 320. ip6prot->early_demux = enabled ? ip6prot->early_demux_handler : + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +kernel/notifier.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. * is, we re-check the list after having taken the lock anyway: + 314. */ + 315. > if (rcu_access_pointer(nh->head)) { + 316. down_read(&nh->rwsem); + 317. ret = notifier_call_chain(&nh->head, val, v, nr_to_call, + +scripts/kconfig/symbol.c:314: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 313 could be null and is dereferenced at line 314, column 2. + 312. flags = sym->flags; + 313. prop = sym_get_choice_prop(sym); + 314. > expr_list_for_each_sym(prop->expr, e, def_sym) { + 315. sym_calc_visibility(def_sym); + 316. if (def_sym->visible != no) + +kernel/pid.c:310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 308. if (pid) { + 309. struct hlist_node *first; + 310. > first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]), + 311. lockdep_tasklist_lock_is_held()); + 312. if (first) + +drivers/edac/edac_mc.c:345: error: DEAD_STORE + The value written to &mci (type mem_ctl_info*) is never used. + 343. * hardcode everything into a single struct. + 344. */ + 345. > mci = edac_align_ptr(&ptr, sizeof(*mci), 1); + 346. layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers); + 347. for (i = 0; i < n_layers; i++) { + +drivers/edac/edac_mc.c:431: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 429. for (i = 0; i < tot_dimms; i++) { + 430. chan = mci->csrows[row]->channels[chn]; + 431. > off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]); + 432. if (off < 0 || off >= tot_dimms) { + 433. edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n"); + +drivers/edac/edac_mc.c:452: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 450. len -= n; + 451. for (j = 0; j < n_layers; j++) { + 452. > n = snprintf(p, len, "%s#%u", + 453. edac_layer_name[layers[j].type], + 454. pos[j]); + +drivers/edac/edac_mc.c:457: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 455. p += n; + 456. len -= n; + 457. > dimm->location[j] = pos[j]; + 458. + 459. if (len <= 0) + +drivers/gpu/drm/drm_lock.c:316: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 314. do { + 315. old = *lock; + 316. > prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT); + 317. } while (prev != old); + 318. wake_up_interruptible(&lock_data->lock_queue); + +include/net/ip_fib.h:320: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 318. res->tclassid = 0; + 319. + 320. > tb = rcu_dereference_rtnl(net->ipv4.fib_main); + 321. if (tb) + 322. err = fib_table_lookup(tb, flp, res, flags); + +include/net/ip_fib.h:327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 325. goto out; + 326. + 327. > tb = rcu_dereference_rtnl(net->ipv4.fib_default); + 328. if (tb) + 329. err = fib_table_lookup(tb, flp, res, flags); + +kernel/printk/printk_safe.c:313: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 311. * the lock must be taken on another CPU and we could wait for it. + 312. */ + 313. > if ((this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) && + 314. raw_spin_is_locked(&logbuf_lock)) { + 315. this_cpu_or(printk_context, PRINTK_NMI_CONTEXT_MASK); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:316: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 314. if (unlikely(p == NULL)) + 315. return -ENOSPC; + 316. > p = xdr_decode_hyper(p, &status->major_status); + 317. + 318. /* status->mech */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:327: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 325. if (unlikely(p == NULL)) + 326. return -ENOSPC; + 327. > p = xdr_decode_hyper(p, &status->minor_status); + 328. + 329. /* status->major_status_string */ + +kernel/reboot.c:315: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 310 could be null and is dereferenced at line 315, column 18. + 313. + 314. /* We only trust the superuser with rebooting the system. */ + 315. > if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT)) + 316. return -EPERM; + 317. + +net/ipv6/mcast.c:311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 309. struct ipv6_pinfo *np = inet6_sk(sk); + 310. + 311. > if (!rcu_access_pointer(np->ipv6_mc_list)) + 312. return; + 313. rtnl_lock(); + +include/net/ip_tunnels.h:320: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 318. + 319. rcu_read_lock(); + 320. > ops = rcu_dereference(iptun_encaps[e->type]); + 321. if (likely(ops && ops->encap_hlen)) + 322. hlen = ops->encap_hlen(e); + +kernel/seccomp.c:317: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 315. /* Synchronize all threads. */ + 316. caller = current; + 317. > for_each_thread(caller, thread) { + 318. /* Skip current, since it needs no changes. */ + 319. if (thread == caller) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +include/net/sch_generic.h:311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 309. static inline struct Qdisc *qdisc_root(const struct Qdisc *qdisc) + 310. { + 311. > struct Qdisc *q = rcu_dereference_rtnl(qdisc->dev_queue->qdisc); + 312. + 313. return q; + +kernel/sched/loadavg.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. long delta, active, n; + 314. + 315. > sample_window = READ_ONCE(calc_load_update); + 316. if (!time_before(jiffies, sample_window + 10)) { + 317. /* + +net/packet/af_packet.c:312: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 310. static u16 __packet_pick_tx_queue(struct net_device *dev, struct sk_buff *skb) + 311. { + 312. > return (u16) raw_smp_processor_id() % dev->real_num_tx_queues; + 313. } + 314. + +drivers/gpu/drm/i915/i915_gem_request.c:331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 329. * noops - they are safe to be replayed on a reset. + 330. */ + 331. > tail = READ_ONCE(request->ring->tail); + 332. } else { + 333. tail = request->postfix; + +include/net/addrconf.h:316: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 314. + 315. rcu_read_lock(); + 316. > idev = rcu_dereference(dev->ip6_ptr); + 317. if (idev) + 318. refcount_inc(&idev->refcnt); + +net/ipv4/cipso_ipv4.c:314: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 312. const struct netlbl_lsm_secattr *secattr) + 313. { + 314. > int ret_val = -EPERM; + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + +net/ipv4/ip_input.c:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. int protocol = iph->protocol; + 332. + 333. > ipprot = rcu_dereference(inet_protos[protocol]); + 334. if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) { + 335. err = edemux(skb); + +net/ipv4/ip_input.c:334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 332. + 333. ipprot = rcu_dereference(inet_protos[protocol]); + 334. > if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) { + 335. err = edemux(skb); + 336. if (unlikely(err)) + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.agp_start was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.count was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.flags was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.high_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.low_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.size was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +net/wireless/trace.h:313: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 311. ); + 312. + 313. > DECLARE_EVENT_CLASS(wiphy_enabled_evt, + 314. TP_PROTO(struct wiphy *wiphy, bool enabled), + 315. TP_ARGS(wiphy, enabled), + +drivers/char/hw_random/core.c:318: error: DEAD_STORE + The value written to &err (type int) is never used. + 316. const char *buf, size_t len) + 317. { + 318. > int err = -ENODEV; + 319. struct hwrng *rng; + 320. + +drivers/gpu/drm/i915/intel_pm.c:330: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 328. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 329. + 330. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 331. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 332. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +net/netfilter/nf_conntrack_core.c:320: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 318. + 319. /* add this conntrack to the (per cpu) dying list */ + 320. > ct->cpu = smp_processor_id(); + 321. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 322. + +net/netfilter/nf_conntrack_core.c:320: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 318. + 319. /* add this conntrack to the (per cpu) dying list */ + 320. > ct->cpu = smp_processor_id(); + 321. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 322. + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +drivers/char/agp/isoch.c:336: error: DEAD_STORE + The value written to &arqsz (type unsigned int) is never used. + 334. return -ENODEV; + 335. + 336. > arqsz = (tstatus >> 13) & 0x7; + 337. + 338. /* + +include/trace/events/timer.h:317: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 315. * @now: current time, used to calculate the latency of itimer + 316. */ + 317. > TRACE_EVENT(itimer_expire, + 318. + 319. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +include/trace/events/timer.h:317: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 315. * @now: current time, used to calculate the latency of itimer + 316. */ + 317. > TRACE_EVENT(itimer_expire, + 318. + 319. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +include/trace/events/timer.h:317: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 315. * @now: current time, used to calculate the latency of itimer + 316. */ + 317. > TRACE_EVENT(itimer_expire, + 318. + 319. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +kernel/rcu/tree_exp.h:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. rnp = rdp->mynode; + 325. if (!(READ_ONCE(rnp->expmask) & rdp->grpmask) || + 326. > __this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 327. return; + 328. if (rcu_is_cpu_rrupt_from_idle()) { + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +lib/zlib_inflate/inflate.c:494: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 492. NEEDBITS(this.bits); + 493. DROPBITS(this.bits); + 494. > state->lens[state->have++] = this.val; + 495. } + 496. else { + +lib/zlib_inflate/inflate.c:580: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 578. } + 579. DROPBITS(this.bits); + 580. > state->length = (unsigned)this.val; + 581. if ((int)(this.op) == 0) { + 582. state->mode = LIT; + +lib/zlib_inflate/inflate.c:625: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 623. break; + 624. } + 625. > state->offset = (unsigned)this.val; + 626. state->extra = (unsigned)(this.op) & 15; + 627. state->mode = DISTEXT; + +net/core/netpoll.c:322: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 320. + 321. list_for_each_entry(napi, &dev->napi_list, dev_list) { + 322. > if (napi->poll_owner == smp_processor_id()) + 323. return 1; + 324. } + +net/ipv6/mcast.c:427: error: DEAD_STORE + The value written to &rv (type int) is never used. + 425. pmc->sflist = psl = newpsl; + 426. } + 427. > rv = 1; /* > 0 for insert logic below if sl_count is 0 */ + 428. for (i = 0; i < psl->sl_count; i++) { + 429. rv = !ipv6_addr_equal(&psl->sl_addr[i], source); + +net/ipv6/mcast.c:347: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 345. err = -EADDRNOTAVAIL; + 346. + 347. > for_each_pmc_rcu(inet6, pmc) { + 348. if (pgsr->gsr_interface && pmc->ifindex != pgsr->gsr_interface) + 349. continue; + +lib/assoc_array.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. */ + 339. for (slot = 0; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 340. > ptr = READ_ONCE(node->slots[slot]); + 341. if (ptr && assoc_array_ptr_is_leaf(ptr)) { + 342. /* We need a barrier between the read of the pointer + +net/compat.c:330: error: UNINITIALIZED_VALUE + The value read from f32.filter was never initialized. + 328. memset(&f, 0, sizeof(f)); + 329. f.len = f32.len; + 330. > f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + 332. return NULL; + +net/compat.c:329: error: UNINITIALIZED_VALUE + The value read from f32.len was never initialized. + 327. return NULL; + 328. memset(&f, 0, sizeof(f)); + 329. > f.len = f32.len; + 330. f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + +drivers/gpu/drm/i915/i915_gem.c:337: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 335. return ret; + 336. + 337. > while ((vma = list_first_entry_or_null(&obj->vma_list, + 338. struct i915_vma, + 339. obj_link))) { + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +sound/core/pcm_native.c:397: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 395. if (trace_hw_interval_param_enabled()) { + 396. if (hw_is_interval(r->var)) + 397. > old_interval = *hw_param_interval(params, r->var); + 398. } + 399. + +sound/core/pcm_native.c:393: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 391. if (trace_hw_mask_param_enabled()) { + 392. if (hw_is_mask(r->var)) + 393. > old_mask = *hw_param_mask(params, r->var); + 394. } + 395. if (trace_hw_interval_param_enabled()) { + +net/ipv4/inet_hashtables.c:332: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 330. struct net *net = sock_net(sk); + 331. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 332. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 333. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 334. unsigned int hash = inet_ehashfn(net, daddr, lport, + +net/ipv4/inet_hashtables.c:333: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 331. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 332. INET_ADDR_COOKIE(acookie, saddr, daddr); + 333. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 334. unsigned int hash = inet_ehashfn(net, daddr, lport, + 335. saddr, inet->inet_dport); + +net/ipv4/inet_hashtables.c:331: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 329. int dif = sk->sk_bound_dev_if; + 330. struct net *net = sock_net(sk); + 331. > int sdif = l3mdev_master_ifindex_by_index(net, dif); + 332. INET_ADDR_COOKIE(acookie, saddr, daddr); + 333. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + +net/wireless/scan.c:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 327. + 328. > list_for_each_entry_rcu(pos, &rdev->sched_scan_req_list, list) { + 329. if (pos->reqid == reqid) + 330. return pos; + +drivers/iommu/dmar.c:329: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 327. struct dmar_drhd_unit *dmaru; + 328. + 329. > for_each_drhd_unit(dmaru) + 330. if (dmar_remove_dev_scope(info, dmaru->segment, + 331. dmaru->devices, dmaru->devices_cnt)) + +net/netfilter/nf_log.c:327: error: DEAD_STORE + The value written to &net (type net*) is never used. + 325. static void *seq_start(struct seq_file *seq, loff_t *pos) + 326. { + 327. > struct net *net = seq_file_net(seq); + 328. + 329. mutex_lock(&nf_log_mutex); + +net/netlabel/netlabel_unlabeled.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. goto add_iface_failure; + 344. list_add_tail_rcu(&iface->list, + 345. > &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]); + 346. } else { + 347. INIT_LIST_HEAD(&iface->list); + +net/netlabel/netlabel_unlabeled.c:348: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 346. } else { + 347. INIT_LIST_HEAD(&iface->list); + 348. > if (netlbl_unlhsh_rcu_deref(netlbl_unlhsh_def) != NULL) + 349. goto add_iface_failure; + 350. rcu_assign_pointer(netlbl_unlhsh_def, iface); + +drivers/gpu/drm/drm_dp_mst_topology.c:373: error: DEAD_STORE + The value written to &crc4 (type unsigned char) is never used. + 371. if (msg->curchunk_idx >= msg->curchunk_len) { + 372. /* do CRC */ + 373. > crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1); + 374. /* copy chunk into bigger msg */ + 375. memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1); + +net/ipv6/ip6_fib.c:335: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 333. struct fib6_table *tb; + 334. + 335. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) + 336. fib_seq += tb->fib_seq; + 337. } + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +kernel/events/ring_buffer.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. */ + 383. if (!rb->aux_overwrite) { + 384. > aux_tail = READ_ONCE(rb->user_page->aux_tail); + 385. handle->wakeup = rb->aux_wakeup + rb->aux_watermark; + 386. if (aux_head - aux_tail < perf_aux_size(rb)) + +include/net/ip_tunnels.h:341: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 339. + 340. rcu_read_lock(); + 341. > ops = rcu_dereference(iptun_encaps[t->encap.type]); + 342. if (likely(ops && ops->build_header)) + 343. ret = ops->build_header(skb, &t->encap, protocol, fl4); + +ipc/msg.c:348: error: UNINITIALIZED_VALUE + The value read from tbuf_old.msg_lqbytes was never initialized. + 346. + 347. if (tbuf_old.msg_qbytes == 0) + 348. > out->msg_qbytes = tbuf_old.msg_lqbytes; + 349. else + 350. out->msg_qbytes = tbuf_old.msg_qbytes; + +ipc/msg.c:350: error: UNINITIALIZED_VALUE + The value read from tbuf_old.msg_qbytes was never initialized. + 348. out->msg_qbytes = tbuf_old.msg_lqbytes; + 349. else + 350. > out->msg_qbytes = tbuf_old.msg_qbytes; + 351. + 352. return 0; + +lib/rhashtable.c:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. + 335. /* Did somebody beat us to it? */ + 336. > if (rcu_access_pointer(old_tbl->future_tbl)) { + 337. spin_unlock_bh(old_tbl->locks); + 338. return -EEXIST; + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +drivers/gpu/drm/drm_dp_helper.c:340: error: UNINITIALIZED_VALUE + The value read from values[_] was never initialized. + 338. return err; + 339. + 340. > link->revision = values[0]; + 341. link->rate = drm_dp_bw_code_to_link_rate(values[1]); + 342. link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK; + +drivers/gpu/drm/drm_dp_helper.c:341: error: UNINITIALIZED_VALUE + The value read from values[_] was never initialized. + 339. + 340. link->revision = values[0]; + 341. > link->rate = drm_dp_bw_code_to_link_rate(values[1]); + 342. link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK; + 343. + +include/net/ip.h:332: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 330. int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst) + 331. { + 332. > u8 pmtudisc = READ_ONCE(inet_sk(sk)->pmtudisc); + 333. + 334. return pmtudisc == IP_PMTUDISC_DO || + +kernel/exit.c:334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 332. struct task_struct *p; + 333. + 334. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 335. if ((p == ignored_task) || + 336. (p->exit_state && thread_group_empty(p)) || + +net/core/netpoll.c:339: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 337. lockdep_assert_irqs_disabled(); + 338. + 339. > npinfo = rcu_dereference_bh(np->dev->npinfo); + 340. if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) { + 341. dev_kfree_skb_irq(skb); + +drivers/gpu/drm/i915/intel_runtime_pm.c:333: error: DEAD_STORE + The value written to &id (type int) is never used. + 331. struct i915_power_well *power_well) + 332. { + 333. > enum i915_power_well_id id = power_well->id; + 334. bool disabled; + 335. u32 reqs; + +drivers/gpu/drm/i915/intel_runtime_pm.c:346: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 344. * diagnostic message. + 345. */ + 346. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 347. HSW_PWR_WELL_CTL_STATE(id))) || + 348. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +net/netfilter/nf_conntrack_core.c:335: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 333. + 334. /* add this conntrack to the (per cpu) unconfirmed list */ + 335. > ct->cpu = smp_processor_id(); + 336. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 337. + +net/netfilter/nf_conntrack_core.c:335: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 333. + 334. /* add this conntrack to the (per cpu) unconfirmed list */ + 335. > ct->cpu = smp_processor_id(); + 336. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 337. + +drivers/dma-buf/sync_file.c:352: error: UNINITIALIZED_VALUE + The value read from data.fd2 was never initialized. + 350. } + 351. + 352. > fence2 = sync_file_fdget(data.fd2); + 353. if (!fence2) { + 354. err = -ENOENT; + +drivers/gpu/drm/i915/intel_guc_ct.c:343: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 341. */ + 342. #define done (READ_ONCE(desc->fence) == fence) + 343. > err = wait_for_us(done, 10); + 344. if (err) + 345. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:345: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 343. err = wait_for_us(done, 10); + 344. if (err) + 345. > err = wait_for(done, 10); + 346. #undef done + 347. + +drivers/gpu/drm/i915/intel_guc_ct.c:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. */ + 342. #define done (READ_ONCE(desc->fence) == fence) + 343. > err = wait_for_us(done, 10); + 344. if (err) + 345. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. */ + 342. #define done (READ_ONCE(desc->fence) == fence) + 343. > err = wait_for_us(done, 10); + 344. if (err) + 345. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:343: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 341. */ + 342. #define done (READ_ONCE(desc->fence) == fence) + 343. > err = wait_for_us(done, 10); + 344. if (err) + 345. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:345: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 343. err = wait_for_us(done, 10); + 344. if (err) + 345. > err = wait_for(done, 10); + 346. #undef done + 347. + +drivers/tty/vt/vt_ioctl.c:814: error: DEAD_STORE + The value written to &arg (type unsigned long) is never used. + 812. vt_disallocate_all(); + 813. else + 814. > ret = vt_disallocate(--arg); + 815. break; + 816. + +drivers/tty/vt/vt_ioctl.c:881: error: UNINITIALIZED_VALUE + The value read from v.v_clin was never initialized. + 879. vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. > vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_cols was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_rows was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:879: error: UNINITIALIZED_VALUE + The value read from v.v_vlin was never initialized. + 877. console_lock(); + 878. if (v.v_vlin) + 879. > vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. vc_cons[i].d->vc_font.height = v.v_clin; + +net/core/fib_rules.c:339: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 337. if (!ops) + 338. return -EAFNOSUPPORT; + 339. > list_for_each_entry_rcu(rule, &ops->rules_list, list) + 340. call_fib_rule_notifier(nb, net, FIB_EVENT_RULE_ADD, rule, + 341. family); + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +ipc/sem.c:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. + 366. /* pairs with smp_store_release() */ + 367. > if (!smp_load_acquire(&sma->use_global_lock)) { + 368. /* fast path successful! */ + 369. return sops->sem_num; + +arch/x86/events/intel/bts.c:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. { + 335. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 336. > int state = READ_ONCE(bts->state); + 337. + 338. /* + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &ret (type int) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +drivers/base/power/wakeup.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. + 339. srcuidx = srcu_read_lock(&wakeup_srcu); + 340. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 341. dev_pm_arm_wake_irq(ws->wakeirq); + 342. srcu_read_unlock(&wakeup_srcu, srcuidx); + +kernel/pid.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. if (type != PIDTYPE_PID) + 339. task = task->group_leader; + 340. > pid = get_pid(rcu_dereference(task->pids[type].pid)); + 341. rcu_read_unlock(); + 342. return pid; + +net/netfilter/nf_conntrack_helper.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. bool found = false; + 339. + 340. > list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) { + 341. if (!strcmp(cur->name, name)) { + 342. found = true; + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +include/linux/netfilter.h:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. + 342. rcu_read_lock(); + 343. > decodefn = rcu_dereference(nf_nat_decode_session_hook); + 344. if (decodefn) + 345. decodefn(skb, fl); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +kernel/kprobes.c:342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 340. + 341. head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)]; + 342. > hlist_for_each_entry_rcu(p, head, hlist) { + 343. if (p->addr == addr) + 344. return p; + +net/ipv6/calipso.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. struct calipso_doi *iter; + 339. + 340. > list_for_each_entry_rcu(iter, &calipso_doi_list, list) + 341. if (iter->doi == doi && refcount_read(&iter->refcount)) + 342. return iter; + +scripts/kconfig/symbol.c:352: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 351 could be null and is dereferenced by call to `prop_get_symbol()` at line 352, column 18. + 350. sym->flags &= ~SYMBOL_NEED_SET_CHOICE_VALUES; + 351. prop = sym_get_choice_prop(sym); + 352. > sym_calc_value(prop_get_symbol(prop)); + 353. } + 354. + +kernel/capability.c:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. + 342. rcu_read_lock(); + 343. > ret = security_capable_noaudit(__task_cred(t), ns, cap); + 344. rcu_read_unlock(); + 345. + +net/netfilter/nf_log.c:339: error: DEAD_STORE + The value written to &net (type net*) is never used. + 337. static void *seq_next(struct seq_file *s, void *v, loff_t *pos) + 338. { + 339. > struct net *net = seq_file_net(s); + 340. + 341. (*pos)++; + +drivers/input/ff-memless.c:354: error: DEAD_STORE + The value written to &effect (type ff_effect*) is never used. + 352. + 353. state = &ml->states[i]; + 354. > effect = state->effect; + 355. + 356. if (!test_bit(FF_EFFECT_STARTED, &state->flags)) + +sound/hda/hdmi_chmap.c:376: error: UNINITIALIZED_VALUE + The value read from non_pcm_mapping[_] was never initialized. + 374. + 375. for (i = 0; i < 8; i++) { + 376. > int slotsetup = non_pcm ? non_pcm_mapping[i] : hdmi_channel_mapping[ca][i]; + 377. int hdmi_slot = slotsetup & 0x0f; + 378. int channel = (slotsetup & 0xf0) >> 4; + +block/badblocks.c:356: error: DEAD_STORE + The value written to §ors (type int) is never used. + 354. s >>= bb->shift; + 355. target >>= bb->shift; + 356. > sectors = target - s; + 357. } + 358. + +security/keys/process_keys.c:396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 394. rcu_read_lock(); + 395. key_ref = keyring_search_aux( + 396. > make_key_ref(rcu_dereference(ctx->cred->session_keyring), 1), + 397. ctx); + 398. rcu_read_unlock(); + +block/blk-sysfs.c:343: error: DEAD_STORE + The value written to &ret (type long) is never used. + 341. queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) + 342. { + 343. > ssize_t ret = -EINVAL; + 344. #ifdef CONFIG_SMP + 345. unsigned long val; + +drivers/tty/sysrq.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. + 344. read_lock(&tasklist_lock); + 345. > for_each_process(p) { + 346. if (p->flags & PF_KTHREAD) + 347. continue; + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +drivers/gpu/drm/drm_ioc32.c:356: error: UNINITIALIZED_VALUE + The value read from b32.high_mark was never initialized. + 354. buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. > buf.high_mark = b32.high_mark; + 357. + 358. return drm_ioctl_kernel(file, drm_legacy_markbufs, &buf, + +drivers/gpu/drm/drm_ioc32.c:355: error: UNINITIALIZED_VALUE + The value read from b32.low_mark was never initialized. + 353. + 354. buf.size = b32.size; + 355. > buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + 357. + +drivers/gpu/drm/drm_ioc32.c:354: error: UNINITIALIZED_VALUE + The value read from b32.size was never initialized. + 352. return -EFAULT; + 353. + 354. > buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +net/sunrpc/xprtsock.c:380: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 378. err = 0; + 379. } + 380. > return err; + 381. } + 382. + +security/selinux/ss/ebitmap.c:360: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 358. goto out; + 359. + 360. > mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. count = le32_to_cpu(buf[2]); + +security/selinux/ss/ebitmap.c:361: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 359. + 360. mapunit = le32_to_cpu(buf[0]); + 361. > e->highbit = le32_to_cpu(buf[1]); + 362. count = le32_to_cpu(buf[2]); + 363. + +security/selinux/ss/ebitmap.c:362: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 360. mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. > count = le32_to_cpu(buf[2]); + 363. + 364. if (mapunit != BITS_PER_U64) { + +scripts/kallsyms.c:472: error: UNINITIALIZED_VALUE + The value read from best_idx[_] was never initialized. + 470. output_label("kallsyms_token_index"); + 471. for (i = 0; i < 256; i++) + 472. > printf("\t.short\t%d\n", best_idx[i]); + 473. printf("\n"); + 474. } + +net/xfrm/xfrm_policy.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. return &net->xfrm.policy_inexact[dir]; + 362. + 363. > return rcu_dereference_check(net->xfrm.policy_bydst[dir].table, + 364. lockdep_is_held(&net->xfrm.xfrm_policy_lock)) + hash; + 365. } + +arch/x86/include/asm/tlbflush.h:358: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 356. WARN_ON_ONCE(preemptible()); + 357. + 358. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 359. + 360. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +arch/x86/include/asm/tlbflush.h:358: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 356. WARN_ON_ONCE(preemptible()); + 357. + 358. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 359. + 360. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +block/blk-ioc.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. */ + 361. rcu_read_lock(); + 362. > icq = rcu_dereference(ioc->icq_hint); + 363. if (icq && icq->q == q) + 364. goto out; + +kernel/rcu/srcutree.c:360: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 358. for_each_possible_cpu(cpu) + 359. flush_delayed_work(&per_cpu_ptr(sp->sda, cpu)->work); + 360. > if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 361. WARN_ON(srcu_readers_active(sp))) { + 362. pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + +kernel/rcu/srcutree.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 361. WARN_ON(srcu_readers_active(sp))) { + 362. > pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + 363. return; /* Caller forgot to stop doing call_srcu()? */ + 364. } + +lib/sbitmap.c:355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 353. + 354. hint = this_cpu_read(*sbq->alloc_hint); + 355. > depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + 357. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +net/ipv4/tcp_minisocks.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. + 361. mss = tcp_mss_clamp(tp, dst_metric_advmss(dst)); + 362. > window_clamp = READ_ONCE(tp->window_clamp); + 363. /* Set this up on the first call only */ + 364. req->rsk_window_clamp = window_clamp ? : dst_metric(dst, RTAX_WINDOW); + +drivers/base/power/wakeup.c:356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 354. + 355. srcuidx = srcu_read_lock(&wakeup_srcu); + 356. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 357. dev_pm_disarm_wake_irq(ws->wakeirq); + 358. srcu_read_unlock(&wakeup_srcu, srcuidx); + +kernel/locking/rwsem-xadd.c:353: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 351. { + 352. struct task_struct *owner; + 353. > bool ret = true; + 354. + 355. if (need_resched()) + +kernel/locking/rwsem-xadd.c:359: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 357. + 358. rcu_read_lock(); + 359. > owner = READ_ONCE(sem->owner); + 360. if (!rwsem_owner_is_writer(owner)) { + 361. /* + +net/wireless/trace.h:350: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 348. ); + 349. + 350. > DECLARE_EVENT_CLASS(wiphy_wdev_evt, + 351. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 352. TP_ARGS(wiphy, wdev), + +scripts/asn1_compiler.c:361: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 361, column 3. + 359. token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token)); + 360. if (!tokens) { + 361. > perror(NULL); + 362. exit(1); + 363. } + +include/trace/events/rcu.h:351: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 349. * All but the type of RCU are extracted from the rcu_node structure. + 350. */ + 351. > TRACE_EVENT(rcu_quiescent_state_report, + 352. + 353. TP_PROTO(const char *rcuname, unsigned long gpnum, + +include/trace/events/rcu.h:351: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 349. * All but the type of RCU are extracted from the rcu_node structure. + 350. */ + 351. > TRACE_EVENT(rcu_quiescent_state_report, + 352. + 353. TP_PROTO(const char *rcuname, unsigned long gpnum, + +include/trace/events/rcu.h:351: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 349. * All but the type of RCU are extracted from the rcu_node structure. + 350. */ + 351. > TRACE_EVENT(rcu_quiescent_state_report, + 352. + 353. TP_PROTO(const char *rcuname, unsigned long gpnum, + +net/netfilter/nf_conntrack_helper.c:357: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 355. bool found = false; + 356. + 357. > list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) { + 358. if (cur->expectfn == symbol) { + 359. found = true; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:378: error: DEAD_STORE + The value written to &err (type int) is never used. + 376. opt.value.data = LUCID_VALUE; + 377. opt.value.len = sizeof(LUCID_VALUE); + 378. > err = gssx_enc_option(xdr, &opt); + 379. + 380. /* ..and user creds */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:371: error: NULL_DEREFERENCE + pointer `p` last assigned on line 370 could be null and is dereferenced at line 371, column 2. + 369. /* ctx->options */ + 370. p = xdr_reserve_space(xdr, 4); + 371. > *p = cpu_to_be32(2); + 372. + 373. /* we want a lucid_v1 context */ + +sound/hda/hdac_controller.c:360: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 358. snd_hdac_chip_updatel(bus, GCTL, AZX_GCTL_RESET, 0); + 359. + 360. > timeout = jiffies + msecs_to_jiffies(100); + 361. while ((snd_hdac_chip_readb(bus, GCTL) & AZX_GCTL_RESET) && + 362. time_before(jiffies, timeout)) + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +lib/idr.c:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. goto err; + 366. + 367. > bitmap = rcu_dereference_raw(*slot); + 368. if (radix_tree_exception(bitmap)) { + 369. btmp = (unsigned long *)slot; + +lib/idr.c:382: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 380. radix_tree_iter_tag_set(&ida->ida_rt, &iter, IDR_FREE); + 381. if (radix_tree_exception(bitmap)) { + 382. > if (rcu_dereference_raw(*slot) == + 383. (void *)RADIX_TREE_EXCEPTIONAL_ENTRY) + 384. radix_tree_iter_delete(&ida->ida_rt, &iter, slot); + +security/selinux/ss/conditional.c:368: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 366. return rc; + 367. + 368. > len = le32_to_cpu(buf[0]); + 369. if (len == 0) + 370. return 0; + +include/net/ip.h:366: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 364. return dst_mtu(dst); + 365. + 366. > return min(READ_ONCE(dst->dev->mtu), IP_MAX_MTU); + 367. } + 368. + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +kernel/sched/loadavg.c:361: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 359. long active, delta; + 360. + 361. > sample_window = READ_ONCE(calc_load_update); + 362. if (time_before(jiffies, sample_window + 10)) + 363. return; + +net/sched/act_api.c:362: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 360. struct tc_action *p; + 361. int ret; + 362. > unsigned long id = 1; + 363. + 364. idr_for_each_entry_ext(idr, p, id) { + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +include/linux/netfilter/x_tables.h:365: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 363. * called xt_write_recseq_begin(). + 364. */ + 365. > addend = (__this_cpu_read(xt_recseq.sequence) + 1) & 1; + 366. + 367. /* + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/sched/clock.c:371: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 369. scd = cpu_sdc(cpu); + 370. + 371. > if (cpu != smp_processor_id()) + 372. clock = sched_clock_remote(scd); + 373. else + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:394: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 392. + 393. /* ...and verify the command was successful. */ + 394. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 395. + 396. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +drivers/dma/dmaengine.c:361: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 359. struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type) + 360. { + 361. > return this_cpu_read(channel_table[tx_type]->chan); + 362. } + 363. EXPORT_SYMBOL(dma_find_channel); + +drivers/dma/dmaengine.c:361: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 359. struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type) + 360. { + 361. > return this_cpu_read(channel_table[tx_type]->chan); + 362. } + 363. EXPORT_SYMBOL(dma_find_channel); + +kernel/exit.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. struct task_struct *p; + 362. + 363. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 364. if (p->signal->flags & SIGNAL_STOP_STOPPED) + 365. return true; + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +include/linux/key.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. { + 362. /* Barrier versus mark_key_instantiated(). */ + 363. > return smp_load_acquire(&key->state); + 364. } + 365. + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +lib/assoc_array.c:426: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr*) is never used. + 424. shortcut = assoc_array_ptr_to_shortcut(parent); + 425. BUG_ON(shortcut->next_node != cursor); + 426. > cursor = parent; + 427. parent = shortcut->back_pointer; + 428. slot = shortcut->parent_slot; + +drivers/usb/core/message.c:450: error: DEAD_STORE + The value written to &i (type int) is never used. + 448. urb->transfer_buffer_length = len; + 449. } + 450. > io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; + 451. + 452. /* transaction state */ + +kernel/printk/printk_safe.c:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. { + 363. /* Use extra buffer in NMI when logbuf_lock is taken or in safe mode. */ + 364. > if (this_cpu_read(printk_context) & PRINTK_NMI_CONTEXT_MASK) + 365. return vprintk_nmi(fmt, args); + 366. + +kernel/printk/printk_safe.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Use extra buffer to prevent a recursion deadlock in safe mode. */ + 368. > if (this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) + 369. return vprintk_safe(fmt, args); + 370. + +kernel/printk/printk_safe.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. * But avoid calling console drivers that might have their own locks. + 374. */ + 375. > if (this_cpu_read(printk_context) & PRINTK_NMI_DEFERRED_CONTEXT_MASK) + 376. return vprintk_deferred(fmt, args); + 377. + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +kernel/time/timer.c:365: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 363. unsigned long round_jiffies(unsigned long j) + 364. { + 365. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 366. } + 367. EXPORT_SYMBOL_GPL(round_jiffies); + +kernel/time/timer.c:365: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 363. unsigned long round_jiffies(unsigned long j) + 364. { + 365. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 366. } + 367. EXPORT_SYMBOL_GPL(round_jiffies); + +drivers/dma-buf/reservation.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. seq = read_seqcount_begin(&obj->seq); + 383. + 384. > fence_excl = rcu_dereference(obj->fence_excl); + 385. if (fence_excl && !dma_fence_get_rcu(fence_excl)) + 386. goto unlock; + +drivers/dma-buf/reservation.c:388: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 386. goto unlock; + 387. + 388. > fobj = rcu_dereference(obj->fence); + 389. if (fobj) { + 390. struct dma_fence **nshared; + +drivers/dma-buf/reservation.c:410: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 408. + 409. for (i = 0; i < shared_count; ++i) { + 410. > shared[i] = rcu_dereference(fobj->shared[i]); + 411. if (!dma_fence_get_rcu(shared[i])) + 412. break; + +drivers/scsi/scsi_logging.c:375: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 373. return; + 374. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 375. > off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr); + 376. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + 377. scsi_log_release_buffer(logbuf); + +drivers/scsi/scsi_logging.c:383: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 381. return; + 382. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 383. > off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, + 384. sshdr->asc, sshdr->ascq); + 385. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +drivers/gpu/drm/drm_modes.c:459: error: DEAD_STORE + The value written to &hperiod (type unsigned int) is never used. + 457. vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. > hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + 460. + 461. /* 13. Find the actual Vertical field frequency: */ + +drivers/gpu/drm/drm_modes.c:452: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 450. vsync_plus_bp = (vsync_plus_bp + 500) / 1000; + 451. /* 9. Find the number of lines in V back porch alone: */ + 452. > vback_porch = vsync_plus_bp - V_SYNC_RQD; + 453. /* 10. Find the total number of lines in Vertical field period: */ + 454. vtotal_lines = vdisplay_rnd + top_margin + bottom_margin + + +drivers/gpu/drm/drm_modes.c:457: error: DEAD_STORE + The value written to &vfieldrate_est (type unsigned int) is never used. + 455. vsync_plus_bp + GTF_MIN_V_PORCH; + 456. /* 11. Estimate the Vertical field frequency: */ + 457. > vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + +drivers/gpu/drm/drm_modes.c:465: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 463. /* 14. Find the Vertical frame frequency: */ + 464. if (interlaced) + 465. > vframe_rate = vfield_rate / 2; + 466. else + 467. vframe_rate = vfield_rate; + +drivers/gpu/drm/drm_modes.c:467: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 465. vframe_rate = vfield_rate / 2; + 466. else + 467. > vframe_rate = vfield_rate; + 468. /* 15. Find number of pixels in left margin: */ + 469. if (margins) + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +arch/x86/include/asm/tlbflush.h:389: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 387. raw_local_irq_save(flags); + 388. + 389. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 390. /* toggle PGE */ + 391. native_write_cr4(cr4 ^ X86_CR4_PGE); + +arch/x86/include/asm/tlbflush.h:389: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 387. raw_local_irq_save(flags); + 388. + 389. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 390. /* toggle PGE */ + 391. native_write_cr4(cr4 ^ X86_CR4_PGE); + +drivers/md/dm-stripe.c:384: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 382. } + 383. buffer[i] = '\0'; + 384. > DMEMIT("1 %s", buffer); + 385. break; + 386. + +drivers/pcmcia/ti113x.h:417: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 415. dev_info(&socket->dev->dev, + 416. "TI: all-serial interrupts ok\n"); + 417. > mfunc_old = mfunc; + 418. goto out; + 419. } + +drivers/pcmcia/ti113x.h:462: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 460. pci_irq_status = yenta_probe_cb_irq(socket); + 461. if (pci_irq_status == 1) { + 462. > mfunc_old = mfunc; + 463. dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n"); + 464. } else { + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +net/netfilter/nf_conntrack_helper.c:385: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 383. + 384. /* rcu_read_lock()ed by nf_hook_thresh */ + 385. > helper = rcu_dereference(help->helper); + 386. + 387. nf_log_packet(nf_ct_net(ct), nf_ct_l3num(ct), 0, skb, NULL, NULL, NULL, + +net/xfrm/xfrm_policy.c:380: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 378. hash = __addr_hash(daddr, saddr, family, hmask, dbits, sbits); + 379. + 380. > return rcu_dereference_check(net->xfrm.policy_bydst[dir].table, + 381. lockdep_is_held(&net->xfrm.xfrm_policy_lock)) + hash; + 382. } + +drivers/dma/dmaengine.c:374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 372. + 373. rcu_read_lock(); + 374. > list_for_each_entry_rcu(device, &dma_device_list, global_node) { + 375. if (dma_has_cap(DMA_PRIVATE, device->cap_mask)) + 376. continue; + +kernel/signal.c:379: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 377. */ + 378. rcu_read_lock(); + 379. > user = get_uid(__task_cred(t)->user); + 380. atomic_inc(&user->sigpending); + 381. rcu_read_unlock(); + +include/net/ip.h:378: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 376. } + 377. + 378. > return min(READ_ONCE(skb_dst(skb)->dev->mtu), IP_MAX_MTU); + 379. } + 380. + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +kernel/sched/cpuacct.c:377: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 376 could be null and is dereferenced at line 377, column 3. + 375. rcu_read_lock(); + 376. for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca)) + 377. > this_cpu_ptr(ca->cpustat)->cpustat[index] += val; + 378. rcu_read_unlock(); + 379. } + +drivers/iommu/dmar.c:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. struct dmar_drhd_unit *dmaru; + 376. + 377. > list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list) + 378. if (dmaru->segment == drhd->segment && + 379. dmaru->reg_base_addr == drhd->address) + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +kernel/time/tick-common.c:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. void tick_handover_do_timer(void) + 373. { + 374. > if (tick_do_timer_cpu == smp_processor_id()) { + 375. int cpu = cpumask_first(cpu_online_mask); + 376. + +include/trace/events/timer.h:373: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 371. __print_symbolic(val, TICK_DEP_NAMES) + 372. + 373. > TRACE_EVENT(tick_stop, + 374. + 375. TP_PROTO(int success, int dependency), + +include/trace/events/timer.h:373: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 371. __print_symbolic(val, TICK_DEP_NAMES) + 372. + 373. > TRACE_EVENT(tick_stop, + 374. + 375. TP_PROTO(int success, int dependency), + +include/trace/events/timer.h:373: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 371. __print_symbolic(val, TICK_DEP_NAMES) + 372. + 373. > TRACE_EVENT(tick_stop, + 374. + 375. TP_PROTO(int success, int dependency), + +kernel/params.c:384: error: UNINITIALIZED_VALUE + The value read from v was never initialized. + 382. ret = param_set_bool(val, &boolkp); + 383. if (ret == 0) + 384. > *(int *)kp->arg = v; + 385. return ret; + 386. } + +net/ipv4/cipso_ipv4.c:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. struct cipso_v4_doi *iter; + 376. + 377. > list_for_each_entry_rcu(iter, &cipso_v4_doi_list, list) + 378. if (iter->doi == doi && refcount_read(&iter->refcount)) + 379. return iter; + +sound/hda/hdac_controller.c:379: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 377. snd_hdac_chip_updateb(bus, GCTL, 0, AZX_GCTL_RESET); + 378. + 379. > timeout = jiffies + msecs_to_jiffies(100); + 380. while (!snd_hdac_chip_readb(bus, GCTL) && time_before(jiffies, timeout)) + 381. usleep_range(500, 1000); + +drivers/tty/vt/vc_screen.c:536: error: DEAD_STORE + The value written to &con_buf0 (type char*) is never used. + 534. unsigned char c; + 535. + 536. > c = *con_buf0++; + 537. #ifdef __BIG_ENDIAN + 538. vcs_scr_writew(vc, (vcs_scr_readw(vc, org) & 0xff) | (c << 8), org); + +lib/genalloc.c:386: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 384. nbits = (size + (1UL << order) - 1) >> order; + 385. rcu_read_lock(); + 386. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 387. if (addr >= chunk->start_addr && addr <= chunk->end_addr) { + 388. BUG_ON(addr + size - 1 > chunk->end_addr); + +net/netfilter/nf_conntrack_ftp.c:523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 521. /* Now, NAT might want to mangle the packet, and register the + 522. * (possibly changed) expectation itself. */ + 523. > nf_nat_ftp = rcu_dereference(nf_nat_ftp_hook); + 524. if (nf_nat_ftp && ct->status & IPS_NAT_MASK) + 525. ret = nf_nat_ftp(skb, ctinfo, search[dir][i].ftptype, + +net/wireless/trace.h:374: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +drivers/gpu/drm/i915/i915_debugfs.c:395: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 393. } + 394. + 395. > print_file_stats(m, "[k]batch pool", stats); + 396. } + 397. + +drivers/gpu/drm/i915/i915_debugfs.c:395: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 393. } + 394. + 395. > print_file_stats(m, "[k]batch pool", stats); + 396. } + 397. + +drivers/gpu/drm/i915/i915_debugfs.c:395: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 393. } + 394. + 395. > print_file_stats(m, "[k]batch pool", stats); + 396. } + 397. + +drivers/gpu/drm/i915/i915_debugfs.c:395: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 393. } + 394. + 395. > print_file_stats(m, "[k]batch pool", stats); + 396. } + 397. + +drivers/gpu/drm/i915/i915_debugfs.c:395: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 393. } + 394. + 395. > print_file_stats(m, "[k]batch pool", stats); + 396. } + 397. + +drivers/gpu/drm/i915/i915_debugfs.c:395: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 393. } + 394. + 395. > print_file_stats(m, "[k]batch pool", stats); + 396. } + 397. + +drivers/gpu/drm/i915/i915_debugfs.c:395: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 393. } + 394. + 395. > print_file_stats(m, "[k]batch pool", stats); + 396. } + 397. + +drivers/pci/access.c:379: error: DEAD_STORE + The value written to &max_sleep (type unsigned long) is never used. + 377. struct pci_vpd *vpd = dev->vpd; + 378. unsigned long timeout = jiffies + msecs_to_jiffies(125); + 379. > unsigned long max_sleep = 16; + 380. u16 status; + 381. int ret; + +drivers/pci/access.c:378: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 376. { + 377. struct pci_vpd *vpd = dev->vpd; + 378. > unsigned long timeout = jiffies + msecs_to_jiffies(125); + 379. unsigned long max_sleep = 16; + 380. u16 status; + +net/core/net_namespace.c:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. static void net_free(struct net *net) + 376. { + 377. > kfree(rcu_access_pointer(net->gen)); + 378. kmem_cache_free(net_cachep, net); + 379. } + +net/ipv4/proc.c:397: error: UNINITIALIZED_VALUE + The value read from buff64[_] was never initialized. + 395. offsetof(struct ipstats_mib, syncp)); + 396. for (i = 0; snmp4_ipstats_list[i].name; i++) + 397. > seq_printf(seq, " %llu", buff64[i]); + 398. + 399. return 0; + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +lib/sbitmap.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. + 383. hint = this_cpu_read(*sbq->alloc_hint); + 384. > depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + 386. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +net/netlabel/netlabel_unlabeled.c:408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 406. } else { + 407. ifindex = 0; + 408. > iface = rcu_dereference(netlbl_unlhsh_def); + 409. } + 410. if (iface == NULL) { + +net/ipv4/udp.c:422: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 420. } + 421. + 422. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 423. score++; + 424. return score; + +net/sunrpc/svc_xprt.c:411: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 409. /* find a thread for this xprt */ + 410. rcu_read_lock(); + 411. > list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) { + 412. if (test_and_set_bit(RQ_BUSY, &rqstp->rq_flags)) + 413. continue; + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +sound/pci/hda/hda_controller.c:391: error: DEAD_STORE + The value written to &timeout (type unsigned int) is never used. + 389. bool direction; + 390. u32 dma_select; + 391. > u32 timeout = 200; + 392. u32 retry_count = 0; + 393. + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +kernel/locking/rwsem-xadd.c:383: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 381. static noinline bool rwsem_spin_on_owner(struct rw_semaphore *sem) + 382. { + 383. > struct task_struct *owner = READ_ONCE(sem->owner); + 384. + 385. if (!rwsem_owner_is_writer(owner)) + +net/ipv4/inet_connection_sock.c:424: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 422. } + 423. finish_wait(sk_sleep(sk), &wait); + 424. > return err; + 425. } + 426. + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_base_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_top_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +kernel/kprobes.c:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. struct kprobe *kp; + 386. + 387. > list_for_each_entry_rcu(kp, &p->list, list) { + 388. if (kp->pre_handler && likely(!kprobe_disabled(kp))) { + 389. set_kprobe_instance(kp); + +kernel/sched/core.c:386: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 384. { + 385. struct thread_info *ti = task_thread_info(p); + 386. > return !(fetch_or(&ti->flags, _TIF_NEED_RESCHED) & _TIF_POLLING_NRFLAG); + 387. } + 388. + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +kernel/time/timer.c:386: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 384. unsigned long round_jiffies_relative(unsigned long j) + 385. { + 386. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 387. } + 388. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +kernel/time/timer.c:386: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 384. unsigned long round_jiffies_relative(unsigned long j) + 385. { + 386. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 387. } + 388. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +net/xfrm/xfrm_policy.c:413: error: DEAD_STORE + The value written to &entry0 (type hlist_node*) is never used. + 411. hlist_add_behind_rcu(&pol->bydst, entry0); + 412. } + 413. > entry0 = &pol->bydst; + 414. } + 415. if (!hlist_empty(list)) { + +net/xfrm/xfrm_policy.c:406: error: DEAD_STORE + The value written to &h0 (type unsigned int) is never used. + 404. hlist_del_rcu(&pol->bydst); + 405. hlist_add_head_rcu(&pol->bydst, ndsttable + h); + 406. > h0 = h; + 407. } else { + 408. if (h != h0) + +drivers/gpu/drm/drm_ioc32.c:402: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 400. return err; + 401. + 402. > if (put_user(req32.count, &argp->count)) + 403. return -EFAULT; + 404. + +drivers/gpu/drm/drm_mm.c:387: error: DEAD_STORE + The value written to &end (type unsigned long long) is never used. + 385. int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node) + 386. { + 387. > u64 end = node->start + node->size; + 388. struct drm_mm_node *hole; + 389. u64 hole_start, hole_end; + +kernel/cgroup/freezer.c:409: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 398 could be null and is dereferenced at line 409, column 10. + 407. else + 408. freezer_apply_state(pos_f, + 409. > parent->state & CGROUP_FREEZING, + 410. CGROUP_FREEZING_PARENT); + 411. + +drivers/gpu/drm/i915/i915_gem_shrinker.c:392: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 390. int timeout_ms) + 391. { + 392. > unsigned long timeout = jiffies + msecs_to_jiffies_timeout(timeout_ms); + 393. + 394. do { + +drivers/net/ethernet/intel/e1000/e1000_main.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. struct e1000_rx_ring *ring = &adapter->rx_ring[i]; + 408. adapter->alloc_rx_buf(adapter, ring, + 409. > E1000_DESC_UNUSED(ring)); + 410. } + 411. } + +security/selinux/ss/avtab.c:489: error: DEAD_STORE + The value written to &items (type unsigned int) is never used. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:486: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 484. + 485. items = 0; + 486. > key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:487: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 485. items = 0; + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. > key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:488: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. > key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + 490. + +security/selinux/ss/avtab.c:489: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:413: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 411. return rc; + 412. } + 413. > items2 = le32_to_cpu(buf32[0]); + 414. if (items2 > ARRAY_SIZE(buf32)) { + 415. printk(KERN_ERR "SELinux: avtab: entry overflow\n"); + +security/selinux/ss/avtab.c:426: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 424. items = 0; + 425. + 426. > val = le32_to_cpu(buf32[items++]); + 427. key.source_type = (u16)val; + 428. if (key.source_type != val) { + +security/selinux/ss/avtab.c:432: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 430. return -EINVAL; + 431. } + 432. > val = le32_to_cpu(buf32[items++]); + 433. key.target_type = (u16)val; + 434. if (key.target_type != val) { + +security/selinux/ss/avtab.c:438: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 436. return -EINVAL; + 437. } + 438. > val = le32_to_cpu(buf32[items++]); + 439. key.target_class = (u16)val; + 440. if (key.target_class != val) { + +security/selinux/ss/avtab.c:445: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 443. } + 444. + 445. > val = le32_to_cpu(buf32[items++]); + 446. enabled = (val & AVTAB_ENABLED_OLD) ? AVTAB_ENABLED : 0; + 447. + +security/selinux/ss/avtab.c:465: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 463. if (val & spec_order[i]) { + 464. key.specified = spec_order[i] | enabled; + 465. > datum.u.data = le32_to_cpu(buf32[items++]); + 466. rc = insertf(a, &key, &datum, p); + 467. if (rc) + +security/selinux/ss/avtab.c:532: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 530. } + 531. for (i = 0; i < ARRAY_SIZE(xperms.perms.p); i++) + 532. > xperms.perms.p[i] = le32_to_cpu(buf32[i]); + 533. datum.u.xperms = &xperms; + 534. } else { + +block/blk-mq-sched.c:407: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 405. + 406. rcu_read_lock(); + 407. > list_for_each_entry_rcu_rr(q, queue, &set->tag_list, + 408. tag_set_list) { + 409. queue_for_each_hw_ctx(q, hctx2, i) + +kernel/pid.c:405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 403. task = task->group_leader; + 404. } + 405. > nr = pid_nr_ns(rcu_dereference(task->pids[type].pid), ns); + 406. } + 407. rcu_read_unlock(); + +net/ipv6/anycast.c:399: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 397. found = ipv6_chk_acast_dev(dev, addr); + 398. else + 399. > for_each_netdev_rcu(net, dev) + 400. if (ipv6_chk_acast_dev(dev, addr)) { + 401. found = true; + +init/main.c:410: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 408. rcu_read_lock(); + 409. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 410. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 411. rcu_read_unlock(); + 412. + +init/main.c:410: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 408. rcu_read_lock(); + 409. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 410. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 411. rcu_read_unlock(); + 412. + +net/ipv4/tcp.c:393: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 391. static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp) + 392. { + 393. > u32 rate = READ_ONCE(tp->rate_delivered); + 394. u32 intv = READ_ONCE(tp->rate_interval_us); + 395. u64 rate64 = 0; + +net/ipv4/tcp.c:394: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 392. { + 393. u32 rate = READ_ONCE(tp->rate_delivered); + 394. > u32 intv = READ_ONCE(tp->rate_interval_us); + 395. u64 rate64 = 0; + 396. + +drivers/gpu/drm/i915/dvo_ns2501.c:418: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 416. + 417. if (i2c_transfer(adapter, msgs, 2) == 2) { + 418. > *ch = in_buf[0]; + 419. return true; + 420. } + +drivers/gpu/drm/i915/i915_gem_object.h:395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 393. i915_gem_object_is_framebuffer(const struct drm_i915_gem_object *obj) + 394. { + 395. > return READ_ONCE(obj->framebuffer_references); + 396. } + 397. + +net/wireless/trace.h:392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 390. ); + 391. + 392. > DECLARE_EVENT_CLASS(key_handle, + 393. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 394. bool pairwise, const u8 *mac_addr), + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +net/ipv6/raw.c:395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 393. static inline int rawv6_rcv_skb(struct sock *sk, struct sk_buff *skb) + 394. { + 395. > if ((raw6_sk(sk)->checksum || rcu_access_pointer(sk->sk_filter)) && + 396. skb_checksum_complete(skb)) { + 397. atomic_inc(&sk->sk_drops); + +net/netlabel/netlabel_calipso.c:396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 394. static const struct netlbl_calipso_ops *netlbl_calipso_ops_get(void) + 395. { + 396. > return READ_ONCE(calipso_ops); + 397. } + 398. + +include/trace/events/rcu.h:395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 393. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 394. */ + 395. > TRACE_EVENT(rcu_fqs, + 396. + 397. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/rcu.h:395: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 393. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 394. */ + 395. > TRACE_EVENT(rcu_fqs, + 396. + 397. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/rcu.h:395: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 393. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 394. */ + 395. > TRACE_EVENT(rcu_fqs, + 396. + 397. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +kernel/sched/core.c:405: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 403. if (val & _TIF_NEED_RESCHED) + 404. return true; + 405. > old = cmpxchg(&ti->flags, val, val | _TIF_NEED_RESCHED); + 406. if (old == val) + 407. break; + +kernel/sched/core.c:398: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 396. { + 397. struct thread_info *ti = task_thread_info(p); + 398. > typeof(ti->flags) old, val = READ_ONCE(ti->flags); + 399. + 400. for (;;) { + +kernel/softirq.c:404: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 402. account_irq_exit_time(current); + 403. preempt_count_sub(HARDIRQ_OFFSET); + 404. > if (!in_interrupt() && local_softirq_pending()) + 405. invoke_softirq(); + 406. + +net/xfrm/xfrm_state.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. return NULL; + 408. + 409. > mode = READ_ONCE(afinfo->mode_map[encap]); + 410. if (unlikely(mode && !try_module_get(mode->owner))) + 411. mode = NULL; + +drivers/cpuidle/sysfs.c:398: error: DEAD_STORE + The value written to &ret (type int) is never used. + 396. static int cpuidle_add_state_sysfs(struct cpuidle_device *device) + 397. { + 398. > int i, ret = -ENOMEM; + 399. struct cpuidle_state_kobj *kobj; + 400. struct cpuidle_device_kobj *kdev = device->kobj_dev; + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +net/ipv6/ip6_fib.c:419: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 417. struct fib6_table *tb; + 418. + 419. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) + 420. fib6_table_dump(net, tb, w); + 421. } + +usr/gen_init_cpio.c:448: error: MEMORY_LEAK + memory dynamically allocated by call to `malloc()` at line 422, column 11 is not reachable after line 448, column 6. + 446. mode, uid, gid, nlinks); + 447. fail: + 448. > if (dname_len) free(dname); + 449. return rc; + 450. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:530: error: DEAD_STORE + The value written to &icr (type unsigned int) is never used. + 528. + 529. /* Clear any pending interrupt events. */ + 530. > icr = er32(ICR); + 531. + 532. /* If MWI was previously enabled, reenable it. */ + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +security/selinux/ss/conditional.c:412: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 410. goto err; + 411. + 412. > node->cur_state = le32_to_cpu(buf[0]); + 413. + 414. /* expr */ + +security/selinux/ss/conditional.c:415: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 413. + 414. /* expr */ + 415. > len = le32_to_cpu(buf[1]); + 416. + 417. for (i = 0; i < len; i++) { + +security/selinux/ss/conditional.c:427: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 425. goto err; + 426. + 427. > expr->expr_type = le32_to_cpu(buf[0]); + 428. expr->bool = le32_to_cpu(buf[1]); + 429. + +security/selinux/ss/conditional.c:428: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 426. + 427. expr->expr_type = le32_to_cpu(buf[0]); + 428. > expr->bool = le32_to_cpu(buf[1]); + 429. + 430. if (!expr_isvalid(p, expr)) { + +net/ipv4/proc.c:420: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 418. /* MaxConn field is signed, RFC 2012 */ + 419. if (snmp4_tcp_list[i].entry == TCP_MIB_MAXCONN) + 420. > seq_printf(seq, " %ld", buff[i]); + 421. else + 422. seq_printf(seq, " %lu", buff[i]); + +net/ipv4/proc.c:422: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 420. seq_printf(seq, " %ld", buff[i]); + 421. else + 422. > seq_printf(seq, " %lu", buff[i]); + 423. } + 424. + +net/ipv4/proc.c:434: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 432. seq_puts(seq, "\nUdp:"); + 433. for (i = 0; snmp4_udp_list[i].name; i++) + 434. > seq_printf(seq, " %lu", buff[i]); + 435. + 436. memset(buff, 0, TCPUDP_MIB_MAX * sizeof(unsigned long)); + +net/ipv4/proc.c:446: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 444. seq_puts(seq, "\nUdpLite:"); + 445. for (i = 0; snmp4_udp_list[i].name; i++) + 446. > seq_printf(seq, " %lu", buff[i]); + 447. + 448. seq_putc(seq, '\n'); + +net/sunrpc/rpc_pipe.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. rcu_read_lock(); + 408. seq_printf(m, "RPC server: %s\n", + 409. > rcu_dereference(clnt->cl_xprt)->servername); + 410. seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_program->name, + 411. clnt->cl_prog, clnt->cl_vers); + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/power/user.c:422: error: UNINITIALIZED_VALUE + The value read from offset was never initialized. + 420. err = snapshot_ioctl(file, cmd, (unsigned long) &offset); + 421. set_fs(old_fs); + 422. > if (!err && put_user(offset, uoffset)) + 423. err = -EFAULT; + 424. return err; + +kernel/seccomp.c:416: error: UNINITIALIZED_VALUE + The value read from fprog32.filter was never initialized. + 414. goto out; + 415. fprog.len = fprog32.len; + 416. > fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + 418. #endif + +kernel/seccomp.c:415: error: UNINITIALIZED_VALUE + The value read from fprog32.len was never initialized. + 413. if (copy_from_user(&fprog32, user_filter, sizeof(fprog32))) + 414. goto out; + 415. > fprog.len = fprog32.len; + 416. fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + +lib/idr.c:410: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 408. + 409. radix_tree_for_each_slot(slot, &ida->ida_rt, &iter, 0) { + 410. > struct ida_bitmap *bitmap = rcu_dereference_raw(*slot); + 411. if (!radix_tree_exception(bitmap)) + 412. kfree(bitmap); + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > TRACE_EVENT(xs_tcp_data_ready, + 406. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 407. + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > TRACE_EVENT(xs_tcp_data_ready, + 406. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 407. + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > TRACE_EVENT(xs_tcp_data_ready, + 406. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 407. + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/pcmcia/ds.c:430: error: UNINITIALIZED_VALUE + The value read from func_id.func was never initialized. + 428. CISTPL_FUNCID, &func_id)) { + 429. mutex_lock(&p_dev->socket->ops_mutex); + 430. > p_dev->func_id = func_id.func; + 431. p_dev->has_func_id = 1; + 432. mutex_unlock(&p_dev->socket->ops_mutex); + +drivers/pcmcia/ds.c:421: error: UNINITIALIZED_VALUE + The value read from manf_id.card was never initialized. + 419. mutex_lock(&p_dev->socket->ops_mutex); + 420. p_dev->manf_id = manf_id.manf; + 421. > p_dev->card_id = manf_id.card; + 422. p_dev->has_manf_id = 1; + 423. p_dev->has_card_id = 1; + +drivers/pcmcia/ds.c:420: error: UNINITIALIZED_VALUE + The value read from manf_id.manf was never initialized. + 418. CISTPL_MANFID, &manf_id)) { + 419. mutex_lock(&p_dev->socket->ops_mutex); + 420. > p_dev->manf_id = manf_id.manf; + 421. p_dev->card_id = manf_id.card; + 422. p_dev->has_manf_id = 1; + +crypto/api.c:439: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 437. } + 438. + 439. > return ERR_PTR(err); + 440. } + 441. EXPORT_SYMBOL_GPL(crypto_alloc_base); + +drivers/base/cpu.c:415: error: DEAD_STORE + The value written to &retval (type int) is never used. + 413. { + 414. struct device *dev = NULL; + 415. > int retval = -ENODEV; + 416. + 417. dev = kzalloc(sizeof(*dev), GFP_KERNEL); + +drivers/gpu/drm/i915/i915_guc_submission.c:437: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 435. + 436. /* Free space is guaranteed. */ + 437. > wq_off = READ_ONCE(desc->tail); + 438. GEM_BUG_ON(CIRC_SPACE(wq_off, READ_ONCE(desc->head), + 439. GUC_WQ_SIZE) < wqi_size); + +kernel/rcu/srcutree.c:423: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 421. smp_mb(); /* Order prior store to ->srcu_gp_seq_needed vs. GP start. */ + 422. rcu_seq_start(&sp->srcu_gp_seq); + 423. > state = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 424. WARN_ON_ONCE(state != SRCU_STATE_SCAN1); + 425. } + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +lib/kfifo.c:419: error: DEAD_STORE + The value written to &recsize (type unsigned long) is never used. + 417. l = __KFIFO_PEEK(data, fifo->out, mask); + 418. + 419. > if (--recsize) + 420. l |= __KFIFO_PEEK(data, fifo->out + 1, mask) << 8; + 421. + +lib/genalloc.c:419: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 417. + 418. rcu_read_lock(); + 419. > list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) + 420. func(pool, chunk, data); + 421. rcu_read_unlock(); + +drivers/gpu/drm/i915/i915_debugfs.c:432: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 430. mutex_unlock(&dev->struct_mutex); + 431. + 432. > print_file_stats(m, "[k]contexts", stats); + 433. } + 434. + +drivers/gpu/drm/i915/i915_debugfs.c:432: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 430. mutex_unlock(&dev->struct_mutex); + 431. + 432. > print_file_stats(m, "[k]contexts", stats); + 433. } + 434. + +drivers/gpu/drm/i915/i915_debugfs.c:432: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 430. mutex_unlock(&dev->struct_mutex); + 431. + 432. > print_file_stats(m, "[k]contexts", stats); + 433. } + 434. + +drivers/gpu/drm/i915/i915_debugfs.c:432: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 430. mutex_unlock(&dev->struct_mutex); + 431. + 432. > print_file_stats(m, "[k]contexts", stats); + 433. } + 434. + +drivers/gpu/drm/i915/i915_debugfs.c:432: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 430. mutex_unlock(&dev->struct_mutex); + 431. + 432. > print_file_stats(m, "[k]contexts", stats); + 433. } + 434. + +drivers/gpu/drm/i915/i915_debugfs.c:432: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 430. mutex_unlock(&dev->struct_mutex); + 431. + 432. > print_file_stats(m, "[k]contexts", stats); + 433. } + 434. + +drivers/gpu/drm/i915/i915_debugfs.c:432: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 430. mutex_unlock(&dev->struct_mutex); + 431. + 432. > print_file_stats(m, "[k]contexts", stats); + 433. } + 434. + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +net/compat.c:435: error: UNINITIALIZED_VALUE + The value read from ktime.tv_sec was never initialized. + 433. if (put_user(sizeof(*up), optlen) || + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. > __put_user(ktime.tv_sec, &up->tv_sec) || + 436. __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + +net/compat.c:436: error: UNINITIALIZED_VALUE + The value read from ktime.tv_usec was never initialized. + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. __put_user(ktime.tv_sec, &up->tv_sec) || + 436. > __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + 438. } + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/netlabel/netlabel_domainhash.c:450: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 448. u32 bkt = netlbl_domhsh_hash(entry->domain); + 449. list_add_tail_rcu(&entry->list, + 450. > &rcu_dereference(netlbl_domhsh)->tbl[bkt]); + 451. } else { + 452. INIT_LIST_HEAD(&entry->list); + +kernel/time/posix-cpu-timers.c:423: error: DEAD_STORE + The value written to &head (type list_head*) is never used. + 421. cleanup_timers_list(head); + 422. cleanup_timers_list(++head); + 423. > cleanup_timers_list(++head); + 424. } + 425. + +net/ipv6/raw.c:430: error: NULL_DEREFERENCE + pointer `rp` last assigned on line 422 could be null and is dereferenced at line 430, column 7. + 428. } + 429. + 430. > if (!rp->checksum) + 431. skb->ip_summed = CHECKSUM_UNNECESSARY; + 432. + +crypto/jitterentropy.c:463: error: UNINITIALIZED_VALUE + The value read from mixer.u64 was never initialized. + 461. if ((entropy_collector->data >> i) & 1) + 462. mixer.u64 ^= constant.u64; + 463. > mixer.u64 = jent_rol64(mixer.u64, 1); + 464. } + 465. entropy_collector->data ^= mixer.u64; + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +kernel/events/core.c:428: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 426. tmp = div_u64(tmp, 100); + 427. if (!tmp) + 428. > tmp = 1; + 429. + 430. WRITE_ONCE(perf_sample_allowed_ns, tmp); + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +net/wireless/util.c:509: error: UNINITIALIZED_VALUE + The value read from payload.proto was never initialized. + 507. + 508. skb_copy_bits(skb, hdrlen, &payload, sizeof(payload)); + 509. > tmp.h_proto = payload.proto; + 510. + 511. if (likely((ether_addr_equal(payload.hdr, rfc1042_header) && + +drivers/gpu/drm/i915/intel_guc_ct.c:425: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 423. int intel_guc_enable_ct(struct intel_guc *guc) + 424. { + 425. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 426. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 427. int err; + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +net/ipv4/ip_output.c:440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 438. */ + 439. rcu_read_lock(); + 440. > inet_opt = rcu_dereference(inet->inet_opt); + 441. fl4 = &fl->u.ip4; + 442. rt = skb_rtable(skb); + +block/blk-merge.c:445: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 430 could be null and is dereferenced at line 445, column 3. + 443. (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1; + 444. + 445. > sg->length += pad_len; + 446. rq->extra_len += pad_len; + 447. } + +block/blk-merge.c:453: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 430 could be null and is dereferenced by call to `sg_unmark_end()` at line 453, column 3. + 451. memset(q->dma_drain_buffer, 0, q->dma_drain_size); + 452. + 453. > sg_unmark_end(sg); + 454. sg = sg_next(sg); + 455. sg_set_page(sg, virt_to_page(q->dma_drain_buffer), + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:463: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 461. + 462. /* ...and verify the command was successful. */ + 463. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 464. + 465. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:437: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 435. if (unlikely(p == NULL)) + 436. return -ENOSPC; + 437. > count = be32_to_cpup(p++); + 438. for (i = 0; i < count; i++) { + 439. gssx_dec_name_attr(xdr, &dummy); + +net/wireless/mlme.c:435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 433. + 434. spin_lock_bh(&rdev->mlme_unreg_lock); + 435. > while ((reg = list_first_entry_or_null(&rdev->mlme_unreg, + 436. struct cfg80211_mgmt_registration, + 437. list))) { + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/scsi/scsi_logging.c:476: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 474. + 475. if (db_string) + 476. > off += scnprintf(logbuf + off, logbuf_len - off, + 477. "driverbyte=%s", db_string); + 478. else + +drivers/scsi/scsi_logging.c:479: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 477. "driverbyte=%s", db_string); + 478. else + 479. > off += scnprintf(logbuf + off, logbuf_len - off, + 480. "driverbyte=0x%02x", driver_byte(cmd->result)); + 481. out_printk: + +lib/sbitmap.c:449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 447. wait_cnt = atomic_dec_return(&ws->wait_cnt); + 448. if (wait_cnt <= 0) { + 449. > wake_batch = READ_ONCE(sbq->wake_batch); + 450. /* + 451. * Pairs with the memory barrier in sbitmap_queue_resize() to + +net/ipv6/anycast.c:436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 434. + 435. state->idev = NULL; + 436. > for_each_netdev_rcu(net, state->dev) { + 437. struct inet6_dev *idev; + 438. idev = __in6_dev_get(state->dev); + +include/linux/tcp.h:434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 432. { + 433. struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue; + 434. > int somaxconn = READ_ONCE(sock_net(sk)->core.sysctl_somaxconn); + 435. + 436. queue->fastopenq.max_qlen = min_t(unsigned int, backlog, somaxconn); + +drivers/md/dm-io.c:461: error: UNINITIALIZED_VALUE + The value read from sio.error_bits was never initialized. + 459. + 460. if (error_bits) + 461. > *error_bits = sio.error_bits; + 462. + 463. return sio.error_bits ? -EIO : 0; + +drivers/md/md.c:440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 438. atomic_set(&mddev->flush_pending, 1); + 439. rcu_read_lock(); + 440. > rdev_for_each_rcu(rdev, mddev) + 441. if (rdev->raid_disk >= 0 && + 442. !test_bit(Faulty, &rdev->flags)) { + +net/wireless/trace.h:433: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +kernel/time/timer.c:436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 434. unsigned long round_jiffies_up(unsigned long j) + 435. { + 436. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 437. } + 438. EXPORT_SYMBOL_GPL(round_jiffies_up); + +kernel/time/timer.c:436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 434. unsigned long round_jiffies_up(unsigned long j) + 435. { + 436. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 437. } + 438. EXPORT_SYMBOL_GPL(round_jiffies_up); + +lib/genalloc.c:442: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 440. + 441. rcu_read_lock(); + 442. > list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) { + 443. if (start >= chunk->start_addr && start <= chunk->end_addr) { + 444. if (end <= chunk->end_addr) { + +drivers/gpu/drm/i915/i915_debugfs.c:556: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 554. * Therefore, we need to protect this ->comm access using RCU. + 555. */ + 556. > request = list_first_entry_or_null(&file_priv->mm.request_list, + 557. struct drm_i915_gem_request, + 558. client_link); + +drivers/gpu/drm/i915/i915_debugfs.c:563: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 561. request->ctx->pid : file->pid, + 562. PIDTYPE_PID); + 563. > print_file_stats(m, task ? task->comm : "", stats); + 564. rcu_read_unlock(); + 565. + +drivers/gpu/drm/i915/i915_debugfs.c:563: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 561. request->ctx->pid : file->pid, + 562. PIDTYPE_PID); + 563. > print_file_stats(m, task ? task->comm : "", stats); + 564. rcu_read_unlock(); + 565. + +drivers/gpu/drm/i915/i915_debugfs.c:563: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 561. request->ctx->pid : file->pid, + 562. PIDTYPE_PID); + 563. > print_file_stats(m, task ? task->comm : "", stats); + 564. rcu_read_unlock(); + 565. + +drivers/gpu/drm/i915/i915_debugfs.c:563: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 561. request->ctx->pid : file->pid, + 562. PIDTYPE_PID); + 563. > print_file_stats(m, task ? task->comm : "", stats); + 564. rcu_read_unlock(); + 565. + +drivers/gpu/drm/i915/i915_debugfs.c:563: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 561. request->ctx->pid : file->pid, + 562. PIDTYPE_PID); + 563. > print_file_stats(m, task ? task->comm : "", stats); + 564. rcu_read_unlock(); + 565. + +drivers/gpu/drm/i915/i915_debugfs.c:563: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 561. request->ctx->pid : file->pid, + 562. PIDTYPE_PID); + 563. > print_file_stats(m, task ? task->comm : "", stats); + 564. rcu_read_unlock(); + 565. + +drivers/gpu/drm/i915/i915_debugfs.c:563: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 561. request->ctx->pid : file->pid, + 562. PIDTYPE_PID); + 563. > print_file_stats(m, task ? task->comm : "", stats); + 564. rcu_read_unlock(); + 565. + +include/trace/events/rcu.h:435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 433. * events use the lower bits. + 434. */ + 435. > TRACE_EVENT(rcu_dyntick, + 436. + 437. TP_PROTO(const char *polarity, long long oldnesting, long long newnesting), + +include/trace/events/rcu.h:435: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 433. * events use the lower bits. + 434. */ + 435. > TRACE_EVENT(rcu_dyntick, + 436. + 437. TP_PROTO(const char *polarity, long long oldnesting, long long newnesting), + +include/trace/events/rcu.h:435: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 433. * events use the lower bits. + 434. */ + 435. > TRACE_EVENT(rcu_dyntick, + 436. + 437. TP_PROTO(const char *polarity, long long oldnesting, long long newnesting), + +drivers/cpuidle/sysfs.c:441: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 438 could be null and is dereferenced at line 441, column 18. + 439. int i; + 440. + 441. > for (i = 0; i < drv->state_count; i++) + 442. cpuidle_free_state_kobj(device, i); + 443. } + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +kernel/cgroup/freezer.c:442: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 440 could be null and is dereferenced at line 442, column 16. + 440. struct freezer *freezer = css_freezer(css); + 441. + 442. > return (bool)(freezer->state & CGROUP_FREEZING_SELF); + 443. } + 444. + +kernel/auditsc.c:452: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 450. unsigned int sessionid; + 451. + 452. > cred = rcu_dereference_check(tsk->cred, tsk == current || task_creation); + 453. + 454. for (i = 0; i < rule->field_count; i++) { + +kernel/auditsc.c:632: error: UNINITIALIZED_VALUE + The value read from sid was never initialized. + 630. need_sid = 0; + 631. } + 632. > result = security_audit_rule_match(sid, f->type, + 633. f->op, + 634. f->lsm_rule, + +net/ipv4/udp.c:453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 451. result = NULL; + 452. badness = 0; + 453. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 454. score = compute_score(sk, net, saddr, sport, + 455. daddr, hnum, dif, sdif, exact_dif); + +net/netfilter/nf_conntrack_helper.c:449: error: NULL_DEREFERENCE + pointer `help` last assigned on line 442 could be null and is dereferenced at line 449, column 9. + 447. return true; + 448. + 449. > this = rcu_dereference_protected(help->helper, + 450. lockdep_is_held(&nf_conntrack_expect_lock)); + 451. return this == me; + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +net/ipv4/inet_hashtables.c:448: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 446. kuid_t uid = sock_i_uid(sk); + 447. + 448. > sk_for_each_rcu(sk2, &ilb->head) { + 449. if (sk2 != sk && + 450. sk2->sk_family == sk->sk_family && + +net/xfrm/xfrm_policy.c:456: error: DEAD_STORE + The value written to &odst (type hlist_head*) is never used. + 454. write_seqcount_begin(&xfrm_policy_hash_generation); + 455. + 456. > odst = rcu_dereference_protected(net->xfrm.policy_bydst[dir].table, + 457. lockdep_is_held(&net->xfrm.xfrm_policy_lock)); + 458. + +include/trace/events/sunrpc.h:442: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 440. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 441. + 442. > TRACE_EVENT(xs_tcp_data_recv, + 443. TP_PROTO(struct sock_xprt *xs), + 444. + +include/trace/events/sunrpc.h:442: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 440. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 441. + 442. > TRACE_EVENT(xs_tcp_data_recv, + 443. TP_PROTO(struct sock_xprt *xs), + 444. + +include/trace/events/sunrpc.h:442: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 440. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 441. + 442. > TRACE_EVENT(xs_tcp_data_recv, + 443. TP_PROTO(struct sock_xprt *xs), + 444. + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +kernel/module.c:473: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 471. return true; + 472. + 473. > list_for_each_entry_rcu(mod, &modules, list) { + 474. struct symsearch arr[] = { + 475. { mod->syms, mod->syms + mod->num_syms, mod->crcs, + +net/ipv6/ip6_flowlabel.c:454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 452. + 453. rcu_read_lock_bh(); + 454. > for_each_sk_fl_rcu(np, sfl) + 455. count++; + 456. rcu_read_unlock_bh(); + +net/ipv6/seg6.c:445: error: DEAD_STORE + The value written to &err (type int) is never used. + 443. int __init seg6_init(void) + 444. { + 445. > int err = -ENOMEM; + 446. + 447. err = genl_register_family(&seg6_genl_family); + +kernel/cgroup/freezer.c:450: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 448 could be null and is dereferenced at line 450, column 16. + 448. struct freezer *freezer = css_freezer(css); + 449. + 450. > return (bool)(freezer->state & CGROUP_FREEZING_PARENT); + 451. } + 452. + +drivers/gpu/drm/i915/intel_guc_ct.c:448: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 446. void intel_guc_disable_ct(struct intel_guc *guc) + 447. { + 448. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 449. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 450. + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +net/unix/af_unix.c:454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 452. rcu_read_lock(); + 453. if (unix_writable(sk)) { + 454. > wq = rcu_dereference(sk->sk_wq); + 455. if (skwq_has_sleeper(wq)) + 456. wake_up_interruptible_sync_poll(&wq->wait, + +drivers/gpu/drm/drm_ioc32.c:465: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 463. return err; + 464. + 465. > if (put_user(req32.count, &argp->count) + 466. || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:466: error: UNINITIALIZED_VALUE + The value read from req32.virtual was never initialized. + 464. + 465. if (put_user(req32.count, &argp->count) + 466. > || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + 468. + +kernel/time/timer.c:451: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 449. unsigned long round_jiffies_up_relative(unsigned long j) + 450. { + 451. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 452. } + 453. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +kernel/time/timer.c:451: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 449. unsigned long round_jiffies_up_relative(unsigned long j) + 450. { + 451. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 452. } + 453. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +net/ipv4/igmp.c:465: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 463. return skb; + 464. + 465. > mtu = READ_ONCE(dev->mtu); + 466. if (mtu < IPV4_MIN_MTU) + 467. return skb; + +net/ipv6/mcast.c:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. } + 483. + 484. > for_each_pmc_rcu(inet6, pmc) { + 485. if (pmc->ifindex != gsf->gf_interface) + 486. continue; + +drivers/gpu/drm/i915/i915_sysfs.c:466: error: UNINITIALIZED_VALUE + The value read from val was never initialized. + 464. BUG(); + 465. + 466. > return snprintf(buf, PAGE_SIZE, "%d\n", val); + 467. } + 468. + +drivers/gpu/drm/i915/intel_sdvo.c:457: error: DEAD_STORE + The value written to &ret (type int) is never used. + 455. u8 *buf, status; + 456. struct i2c_msg *msgs; + 457. > int i, ret = true; + 458. + 459. /* Would be simpler to allocate both in one go ? */ + +net/sunrpc/auth.c:456: error: DEAD_STORE + The value written to &expired (type unsigned long) is never used. + 454. spinlock_t *cache_lock; + 455. struct rpc_cred *cred, *next; + 456. > unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; + 457. long freed = 0; + 458. + +net/sunrpc/auth.c:461: error: DEAD_STORE + The value written to &nr_to_scan (type int) is never used. + 459. list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { + 460. + 461. > if (nr_to_scan-- == 0) + 462. break; + 463. /* + +net/core/rtnetlink.c:456: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 454. const struct rtnl_af_ops *ops; + 455. + 456. > list_for_each_entry_rcu(ops, &rtnl_af_ops, list) { + 457. if (ops->family == family) + 458. return ops; + +drivers/dma-buf/reservation.c:466: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 464. rcu_read_lock(); + 465. + 466. > fence = rcu_dereference(obj->fence_excl); + 467. if (fence && !test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags)) { + 468. if (!dma_fence_get_rcu(fence)) + +drivers/dma-buf/reservation.c:482: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 480. if (!fence && wait_all) { + 481. struct reservation_object_list *fobj = + 482. > rcu_dereference(obj->fence); + 483. + 484. if (fobj) + +drivers/dma-buf/reservation.c:488: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 486. + 487. for (i = 0; i < shared_count; ++i) { + 488. > struct dma_fence *lfence = rcu_dereference(fobj->shared[i]); + 489. + 490. if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, + +drivers/input/input.c:464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 462. + 463. rcu_read_lock(); + 464. > grab = rcu_dereference(dev->grab); + 465. if (!grab || grab == handle) + 466. input_handle_event(dev, type, code, value); + +kernel/rcu/tree.c:460: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 458. rcu_preempt_note_context_switch(preempt); + 459. /* Load rcu_urgent_qs before other flags. */ + 460. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) + 461. goto out; + 462. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + +kernel/rcu/tree.c:463: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 461. goto out; + 462. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 463. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) + 464. rcu_momentary_dyntick_idle(); + 465. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +net/sunrpc/xprtsock.c:483: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 481. + 482. rcu_read_lock(); + 483. > wq = rcu_dereference(sk->sk_wq); + 484. set_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags); + 485. rcu_read_unlock(); + +drivers/gpu/drm/drm_plane.c:466: error: DEAD_STORE + The value written to &config (type drm_mode_config*) is never used. + 464. return -EINVAL; + 465. + 466. > config = &dev->mode_config; + 467. plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr); + 468. + +include/linux/tcp.h:459: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 457. * This happens for listeners. + 458. */ + 459. > u16 user_mss = READ_ONCE(tp->rx_opt.user_mss); + 460. + 461. return (user_mss && user_mss < mss) ? user_mss : mss; + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +security/selinux/ss/conditional.c:466: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 464. return rc; + 465. + 466. > len = le32_to_cpu(buf[0]); + 467. + 468. rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel); + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +kernel/cgroup/cgroup.c:460: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 458. { + 459. if (ss) + 460. > return rcu_dereference_check(cgrp->subsys[ss->id], + 461. lockdep_is_held(&cgroup_mutex)); + 462. else + +net/core/neighbour.c:467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 465. + 466. rcu_read_lock_bh(); + 467. > nht = rcu_dereference_bh(tbl->nht); + 468. hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); + 469. + +net/core/neighbour.c:470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 468. hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); + 469. + 470. > for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 471. n != NULL; + 472. n = rcu_dereference_bh(n->next)) { + +net/core/neighbour.c:472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 470. for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 471. n != NULL; + 472. > n = rcu_dereference_bh(n->next)) { + 473. if (!memcmp(n->primary_key, pkey, key_len) && + 474. net_eq(dev_net(n->dev), net)) { + +net/wireless/trace.h:457: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/ipv6/tcp_ipv6.c:490: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 488. opt = ireq->ipv6_opt; + 489. if (!opt) + 490. > opt = rcu_dereference(np->opt); + 491. err = ip6_xmit(sk, skb, fl6, sk->sk_mark, opt, np->tclass); + 492. rcu_read_unlock(); + +lib/genalloc.c:466: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 464. + 465. rcu_read_lock(); + 466. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) + 467. avail += atomic_long_read(&chunk->avail); + 468. rcu_read_unlock(); + +net/ipv6/addrlabel.c:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. + 468. rcu_read_lock(); + 469. > hlist_for_each_entry_rcu(p, &net->ipv6.ip6addrlbl_table.head, list) { + 470. if (idx >= s_idx) { + 471. err = ip6addrlbl_fill(skb, p, + +include/linux/cgroup.h:464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 462. static inline struct css_set *task_css_set(struct task_struct *task) + 463. { + 464. > return task_css_set_check(task, false); + 465. } + 466. + +kernel/softirq.c:469: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 467. local_irq_save(flags); + 468. t->next = NULL; + 469. > *__this_cpu_read(tasklet_vec.tail) = t; + 470. __this_cpu_write(tasklet_vec.tail, &(t->next)); + 471. raise_softirq_irqoff(TASKLET_SOFTIRQ); + +net/ipv6/esp6.c:490: error: UNINITIALIZED_VALUE + The value read from nexthdr[_] was never initialized. + 488. + 489. ret = -EINVAL; + 490. > padlen = nexthdr[0]; + 491. if (padlen + 2 + alen >= elen) { + 492. net_dbg_ratelimited("ipsec esp packet is garbage padlen=%d, elen=%d\n", + +net/ipv6/esp6.c:505: error: UNINITIALIZED_VALUE + The value read from nexthdr[_] was never initialized. + 503. pskb_trim(skb, skb->len - trimlen); + 504. + 505. > ret = nexthdr[1]; + 506. + 507. out: + +drivers/gpu/drm/i915/i915_guc_submission.c:479: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 477. + 478. /* we're not expecting the doorbell cookie to change behind our back */ + 479. > cookie = READ_ONCE(db->cookie); + 480. WARN_ON_ONCE(xchg(&db->cookie, cookie + 1) != cookie); + 481. + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/iommu/dmar.c:475: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 473. + 474. rhsa = (struct acpi_dmar_rhsa *)header; + 475. > for_each_drhd_unit(drhd) { + 476. if (drhd->reg_base_addr == rhsa->base_address) { + 477. int node = acpi_map_pxm_to_node(rhsa->proximity_domain); + +lib/rhashtable.c:478: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 476. int err; + 477. + 478. > old_tbl = rht_dereference_rcu(ht->tbl, ht); + 479. + 480. size = tbl->size; + +lib/rhashtable.c:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. fail: + 507. /* Do not fail the insert if someone else did a rehash. */ + 508. > if (likely(rcu_dereference_raw(tbl->future_tbl))) + 509. return 0; + 510. + +net/ipv4/tcp_fastopen.c:475: error: DEAD_STORE + The value written to &tfo_bh_timeout (type unsigned int) is never used. + 473. bool tcp_fastopen_active_should_disable(struct sock *sk) + 474. { + 475. > unsigned int tfo_bh_timeout = sock_net(sk)->ipv4.sysctl_tcp_fastopen_blackhole_timeout; + 476. int tfo_da_times = atomic_read(&sock_net(sk)->ipv4.tfo_active_disable_times); + 477. unsigned long timeout; + +include/linux/cgroup.h:477: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 475. int subsys_id) + 476. { + 477. > return task_css_check(task, subsys_id, false); + 478. } + 479. + +kernel/trace/trace.c:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. return -ENOMEM; + 499. + 500. > pid_list->pid_max = READ_ONCE(pid_max); + 501. + 502. /* Only truncating will shrink pid_max */ + +net/wireless/trace.h:474: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +security/selinux/ss/services.c:536: error: UNINITIALIZED_VALUE + The value read from permission_names[_] was never initialized. + 534. audit_log_format(ab, "%s%s", + 535. need_comma ? "," : "", + 536. > permission_names[index] + 537. ? permission_names[index] : "????"); + 538. need_comma = true; + +kernel/softirq.c:482: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 480. local_irq_save(flags); + 481. t->next = NULL; + 482. > *__this_cpu_read(tasklet_hi_vec.tail) = t; + 483. __this_cpu_write(tasklet_hi_vec.tail, &(t->next)); + 484. raise_softirq_irqoff(HI_SOFTIRQ); + +drivers/gpu/drm/drm_ioc32.c:487: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 485. return -EFAULT; + 486. + 487. > request.count = req32.count; + 488. request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:488: error: UNINITIALIZED_VALUE + The value read from req32.list was never initialized. + 486. + 487. request.count = req32.count; + 488. > request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + 490. } + +net/ipv6/ip6_flowlabel.c:495: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 493. rcu_read_lock_bh(); + 494. + 495. > for_each_sk_fl_rcu(np, sfl) { + 496. if (sfl->fl->label == (np->flow_label & IPV6_FLOWLABEL_MASK)) { + 497. spin_lock_bh(&ip6_fl_lock); + +drivers/cpuidle/cpuidle.c:484: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 482 could be null and is dereferenced at line 484, column 22. + 482. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 483. + 484. > if (!try_module_get(drv->owner)) + 485. return -EINVAL; + 486. + +kernel/trace/trace_events_trigger.c:486: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 484. list_for_each_entry(file, &tr->events, list) { + 485. struct event_trigger_data *data; + 486. > list_for_each_entry_rcu(data, &file->triggers, list) { + 487. trace_event_trigger_enable_disable(file, 0); + 488. if (data->ops->free) + +lib/genalloc.c:485: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 483. + 484. rcu_read_lock(); + 485. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) + 486. size += chunk_size(chunk); + 487. rcu_read_unlock(); + +kernel/sched/core.c:493: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 491. cpu = cpu_of(rq); + 492. + 493. > if (cpu == smp_processor_id()) { + 494. set_tsk_need_resched(curr); + 495. set_preempt_need_resched(); + +net/ipv4/udp.c:525: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 523. result = NULL; + 524. badness = 0; + 525. > sk_for_each_rcu(sk, &hslot->head) { + 526. score = compute_score(sk, net, saddr, sport, + 527. daddr, hnum, dif, sdif, exact_dif); + +net/ipv6/exthdrs.c:496: error: DEAD_STORE + The value written to &accept_source_route (type int) is never used. + 494. idev = __in6_dev_get(skb->dev); + 495. if (idev && accept_source_route > idev->cnf.accept_source_route) + 496. > accept_source_route = idev->cnf.accept_source_route; + 497. + 498. if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) || + +include/trace/events/sunrpc.h:483: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 481. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 482. + 483. > TRACE_EVENT(svc_recv, + 484. TP_PROTO(struct svc_rqst *rqst, int status), + 485. + +include/trace/events/sunrpc.h:483: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 481. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 482. + 483. > TRACE_EVENT(svc_recv, + 484. TP_PROTO(struct svc_rqst *rqst, int status), + 485. + +include/trace/events/sunrpc.h:483: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 481. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 482. + 483. > TRACE_EVENT(svc_recv, + 484. TP_PROTO(struct svc_rqst *rqst, int status), + 485. + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +net/ipv4/ping.c:511: error: UNINITIALIZED_VALUE + The value read from family was never initialized. + 509. /* We assume the packet has already been checked by icmp_unreach */ + 510. + 511. > if (!ping_supported(family, icmph->type, icmph->code)) + 512. return; + 513. + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +drivers/i2c/i2c-core-smbus.c:506: error: DEAD_STORE + The value written to &orig_jiffies (type unsigned long) is never used. + 504. + 505. /* Retry automatically on arbitration loss */ + 506. > orig_jiffies = jiffies; + 507. for (res = 0, try = 0; try <= adapter->retries; try++) { + 508. res = adapter->algo->smbus_xfer(adapter, addr, flags, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +drivers/gpu/drm/i915/intel_cdclk.c:511: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 509. val |= (cmd << DSPFREQGUAR_SHIFT); + 510. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 511. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 512. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 513. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:532: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 530. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 531. + 532. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 533. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 534. 50)) + +kernel/time/tick-common.c:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. trace_suspend_resume(TPS("timekeeping_freeze"), + 492. > smp_processor_id(), true); + 493. timekeeping_suspend(); + 494. } else { + +kernel/time/tick-common.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. tick_freeze_depth++; + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. > trace_suspend_resume(TPS("timekeeping_freeze"), + 492. smp_processor_id(), true); + 493. timekeeping_suspend(); + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:525: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 523. * only the first byte of the word is being modified + 524. */ + 525. > ret_val = e1000_read_eeprom(hw, last_word, 1, + 526. &eeprom_buff[last_word - first_word]); + 527. } + +kernel/rcu/tree.c:495: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 493. preempt_disable(); + 494. /* Load rcu_urgent_qs before other flags. */ + 495. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) { + 496. preempt_enable(); + 497. return; + +kernel/rcu/tree.c:491: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 489. unsigned long flags; + 490. + 491. > if (!raw_cpu_read(rcu_dynticks.rcu_urgent_qs)) + 492. return; + 493. preempt_disable(); + +kernel/rcu/tree.c:501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 499. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 500. barrier(); /* Avoid RCU read-side critical sections leaking down. */ + 501. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) { + 502. local_irq_save(flags); + 503. rcu_momentary_dyntick_idle(); + +kernel/rcu/tree.c:506: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 504. local_irq_restore(flags); + 505. } + 506. > if (unlikely(raw_cpu_read(rcu_sched_data.cpu_no_qs.b.exp))) + 507. rcu_sched_qs(); + 508. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +net/ipv6/sit.c:492: error: DEAD_STORE + The value written to &code (type int) is never used. + 490. const struct iphdr *iph = (const struct iphdr *)skb->data; + 491. const int type = icmp_hdr(skb)->type; + 492. > const int code = icmp_hdr(skb)->code; + 493. unsigned int data_len = 0; + 494. struct ip_tunnel *t; + +net/ipv6/sit.c:490: error: DEAD_STORE + The value written to &iph (type iphdr const *) is never used. + 488. static int ipip6_err(struct sk_buff *skb, u32 info) + 489. { + 490. > const struct iphdr *iph = (const struct iphdr *)skb->data; + 491. const int type = icmp_hdr(skb)->type; + 492. const int code = icmp_hdr(skb)->code; + +include/linux/cgroup.h:502: error: UNINITIALIZED_VALUE + The value read from css was never initialized. + 500. } + 501. rcu_read_unlock(); + 502. > return css; + 503. } + 504. + +kernel/softirq.c:494: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 492. + 493. local_irq_disable(); + 494. > list = __this_cpu_read(tasklet_vec.head); + 495. __this_cpu_write(tasklet_vec.head, NULL); + 496. __this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head)); + +kernel/softirq.c:518: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 516. local_irq_disable(); + 517. t->next = NULL; + 518. > *__this_cpu_read(tasklet_vec.tail) = t; + 519. __this_cpu_write(tasklet_vec.tail, &(t->next)); + 520. __raise_softirq_irqoff(TASKLET_SOFTIRQ); + +kernel/softirq.c:494: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 492. + 493. local_irq_disable(); + 494. > list = __this_cpu_read(tasklet_vec.head); + 495. __this_cpu_write(tasklet_vec.head, NULL); + 496. __this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head)); + +block/blk-core.c:531: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 531, column 33. + 529. */ + 530. if (drain_all) { + 531. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 532. drain |= !list_empty(&q->queue_head); + 533. for (i = 0; i < 2; i++) { + +drivers/firmware/dmi_scan.c:511: error: DEAD_STORE + The value written to &c (type int) is never used. + 509. dmi_get_system_info(DMI_BIOS_VERSION)); + 510. c += scnprintf(buf + c, len - c, " "); + 511. > c += print_filtered(buf + c, len - c, + 512. dmi_get_system_info(DMI_BIOS_DATE)); + 513. } + +drivers/tty/tty_buffer.c:511: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 509. * is advancing to the next buffer + 510. */ + 511. > next = smp_load_acquire(&head->next); + 512. /* paired w/ release in __tty_buffer_request_room() or in + 513. * tty_buffer_flush(); ensures we see the committed buffer data + +drivers/tty/tty_buffer.c:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. * tty_buffer_flush(); ensures we see the committed buffer data + 514. */ + 515. > count = smp_load_acquire(&head->commit) - head->read; + 516. if (!count) { + 517. if (next == NULL) + +lib/assoc_array.c:656: error: UNINITIALIZED_VALUE + The value read from j was never initialized. + 654. } + 655. found_slot_for_multiple_occupancy: + 656. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 657. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 658. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +lib/assoc_array.c:656: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 654. } + 655. found_slot_for_multiple_occupancy: + 656. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 657. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 658. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +lib/assoc_array.c:661: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 659. BUG_ON(slot >= ASSOC_ARRAY_FAN_OUT); + 660. + 661. > new_n1->parent_slot = slot; + 662. + 663. /* Metadata pointers cannot change slot */ + +drivers/gpu/drm/drm_lease.c:504: error: DEAD_STORE + The value written to &fd (type int) is never used. + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + 504. > int fd = -1; + 505. uint32_t *object_ids; + 506. + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/umh.c:535: error: UNINITIALIZED_VALUE + The value read from cap_array[_] was never initialized. + 533. */ + 534. for (i = 0; i < _KERNEL_CAPABILITY_U32S; i++) + 535. > new_cap.cap[i] = cap_array[i]; + 536. + 537. /* + +net/core/rtnetlink.c:502: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 500. + 501. rcu_read_lock(); + 502. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 503. if (af_ops->get_link_af_size) { + 504. /* AF_* + nested data */ + +drivers/gpu/drm/i915/i915_guc_submission.c:509: error: DEAD_STORE + The value written to &count (type unsigned int) is never used. + 507. rq = port_unpack(&port[n], &count); + 508. if (rq && count == 0) { + 509. > port_set(&port[n], port_pack(rq, ++count)); + 510. + 511. if (i915_vma_is_map_and_fenceable(rq->ring->vma)) + +drivers/pci/pcie/aer/aerdrv_core.c:495: error: DEAD_STORE + The value written to &result (type unsigned int) is never used. + 493. static void do_recovery(struct pci_dev *dev, int severity) + 494. { + 495. > pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED; + 496. enum pci_channel_state state; + 497. + +net/ipv6/route.c:505: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 503. goto out; + 504. + 505. > for (sprt = rt; sprt; sprt = rcu_dereference(sprt->dst.rt6_next)) { + 506. struct net_device *dev = sprt->dst.dev; + 507. + +kernel/locking/rwsem-xadd.c:504: error: DEAD_STORE + The value written to &count (type long) is never used. + 502. + 503. /* undo write bias from down_write operation, stop active locking */ + 504. > count = atomic_long_sub_return(RWSEM_ACTIVE_WRITE_BIAS, &sem->count); + 505. + 506. /* do optimistic spinning and steal lock if possible */ + +net/ipv4/route.c:498: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 496. u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ; + 497. atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ; + 498. > u32 old = READ_ONCE(*p_tstamp); + 499. u32 now = (u32)jiffies; + 500. u32 new, delta = 0; + +drivers/usb/early/ehci-dbgp.c:572: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugInEndpoint was never initialized. + 570. } + 571. dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. > dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + 574. /* Move the device to 127 if it isn't already there */ + +drivers/usb/early/ehci-dbgp.c:571: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugOutEndpoint was never initialized. + 569. goto err; + 570. } + 571. > dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + +net/sched/cls_api.c:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. reclassify: + 507. #endif + 508. > for (; tp; tp = rcu_dereference_bh(tp->next)) { + 509. int err; + 510. + +drivers/gpu/drm/drm_ioc32.c:507: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 505. return -EFAULT; + 506. + 507. > request.ctx_id = req32.ctx_id; + 508. request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + +drivers/gpu/drm/drm_ioc32.c:508: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 506. + 507. request.ctx_id = req32.ctx_id; + 508. > request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + 510. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +kernel/capability.c:504: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 502. const struct cred *cred; + 503. rcu_read_lock(); + 504. > cred = rcu_dereference(tsk->ptracer_cred); + 505. if (cred) + 506. ret = security_capable_noaudit(cred, ns, CAP_SYS_PTRACE); + +kernel/futex.c:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. tail = page; + 574. page = compound_head(page); + 575. > mapping = READ_ONCE(page->mapping); + 576. + 577. /* + +kernel/futex.c:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. } + 659. + 660. > inode = READ_ONCE(mapping->host); + 661. if (!inode) { + 662. rcu_read_unlock(); + +kernel/rcu/srcutree.c:531: error: DEAD_STORE + The value written to &idxnext (type int) is never used. + 529. /* Initiate callback invocation as needed. */ + 530. idx = rcu_seq_ctr(gpseq) % ARRAY_SIZE(snp->srcu_have_cbs); + 531. > idxnext = (idx + 1) % ARRAY_SIZE(snp->srcu_have_cbs); + 532. rcu_for_each_node_breadth_first(sp, snp) { + 533. raw_spin_lock_irq_rcu_node(snp); + +net/sched/ematch.c:529: error: UNINITIALIZED_VALUE + The value read from stack[_] was never initialized. + 527. pop_stack: + 528. if (stackp > 0) { + 529. > match_idx = stack[--stackp]; + 530. cur_match = tcf_em_get_match(tree, match_idx); + 531. + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +net/ipv4/raw.c:527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 525. */ + 526. hdrincl = inet->hdrincl; + 527. > hdrincl = READ_ONCE(hdrincl); + 528. /* + 529. * Check the flags. + +net/ipv4/raw.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. + 588. rcu_read_lock(); + 589. > inet_opt = rcu_dereference(inet->inet_opt); + 590. if (inet_opt) { + 591. memcpy(&opt_copy, inet_opt, + +include/trace/events/rcu.h:503: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 501. * total number of callbacks queued. + 502. */ + 503. > TRACE_EVENT(rcu_callback, + 504. + 505. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +include/trace/events/rcu.h:503: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 501. * total number of callbacks queued. + 502. */ + 503. > TRACE_EVENT(rcu_callback, + 504. + 505. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +include/trace/events/rcu.h:503: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 501. * total number of callbacks queued. + 502. */ + 503. > TRACE_EVENT(rcu_callback, + 504. + 505. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +kernel/events/core.c:506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 504. void perf_sample_event_took(u64 sample_len_ns) + 505. { + 506. > u64 max_len = READ_ONCE(perf_sample_allowed_ns); + 507. u64 running_len; + 508. u64 avg_len; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +kernel/rcu/update.c:506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 504. int rcu_jiffies_till_stall_check(void) + 505. { + 506. > int till_stall_check = READ_ONCE(rcu_cpu_stall_timeout); + 507. + 508. /* + +kernel/trace/trace_events_trigger.c:509: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 507. bool set_cond = false; + 508. + 509. > list_for_each_entry_rcu(data, &file->triggers, list) { + 510. if (data->filter || event_command_post_trigger(data->cmd_ops) || + 511. event_command_needs_rec(data->cmd_ops)) { + +drivers/gpu/drm/i915/i915_gem_request.h:557: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 555. struct drm_i915_gem_request *request; + 556. + 557. > request = rcu_dereference(active->request); + 558. if (!request || i915_gem_request_completed(request)) + 559. return NULL; + +drivers/gpu/drm/i915/i915_gem_request.h:602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 600. * rcu_assign_pointer(). + 601. */ + 602. > if (!request || request == rcu_access_pointer(active->request)) + 603. return rcu_pointer_handoff(request); + 604. + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +include/linux/dma-mapping.h:518: error: UNINITIALIZED_VALUE + The value read from cpu_addr was never initialized. + 516. + 517. if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr)) + 518. > return cpu_addr; + 519. + 520. if (!arch_dma_alloc_attrs(&dev, &flag)) + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +kernel/trace/trace_events.c:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. struct trace_array *tr = data; + 514. + 515. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 516. trace_filter_add_remove_task(pid_list, NULL, task); + 517. } + +net/ipv4/inet_hashtables.c:526: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 524. } + 525. spin_lock_bh(lock); + 526. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 527. reuseport_detach_sock(sk); + 528. if (listener) + +arch/x86/events/intel/pt.c:513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 511. { + 512. struct pt *pt = this_cpu_ptr(&pt_ctx); + 513. > u64 ctl = READ_ONCE(event->hw.config); + 514. + 515. /* may be already stopped by a PMI */ + +block/blk-mq-sched.c:512: error: DEAD_STORE + The value written to &set (type blk_mq_tag_set*) is never used. + 510. static void blk_mq_sched_tags_teardown(struct request_queue *q) + 511. { + 512. > struct blk_mq_tag_set *set = q->tag_set; + 513. struct blk_mq_hw_ctx *hctx; + 514. int i; + +drivers/md/dm.c:519: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 517. io->start_time = jiffies; + 518. + 519. > cpu = part_stat_lock(); + 520. part_round_stats(md->queue, cpu, &dm_disk(md)->part0); + 521. part_stat_unlock(); + +drivers/md/dm.c:519: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 517. io->start_time = jiffies; + 518. + 519. > cpu = part_stat_lock(); + 520. part_round_stats(md->queue, cpu, &dm_disk(md)->part0); + 521. part_stat_unlock(); + +kernel/time/tick-common.c:517: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 515. timekeeping_resume(); + 516. trace_suspend_resume(TPS("timekeeping_freeze"), + 517. > smp_processor_id(), false); + 518. } else { + 519. tick_resume_local(); + +kernel/time/tick-common.c:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. if (tick_freeze_depth == num_online_cpus()) { + 515. timekeeping_resume(); + 516. > trace_suspend_resume(TPS("timekeeping_freeze"), + 517. smp_processor_id(), false); + 518. } else { + +include/net/sock.h:514: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 512. { + 513. if (unlikely(flags & MSG_PEEK)) { + 514. > return READ_ONCE(sk->sk_peek_off); + 515. } + 516. + +include/linux/interrupt.h:514: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 512. static inline struct task_struct *this_cpu_ksoftirqd(void) + 513. { + 514. > return this_cpu_read(ksoftirqd); + 515. } + 516. + +include/linux/interrupt.h:514: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 512. static inline struct task_struct *this_cpu_ksoftirqd(void) + 513. { + 514. > return this_cpu_read(ksoftirqd); + 515. } + 516. + +net/socket.c:534: error: DEAD_STORE + The value written to &buffer (type char*) is never used. + 532. return -ERANGE; + 533. memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len); + 534. > buffer += len; + 535. } + 536. + +block/kyber-iosched.c:516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 514. void *key) + 515. { + 516. > struct blk_mq_hw_ctx *hctx = READ_ONCE(wait->private); + 517. + 518. list_del_init(&wait->entry); + +drivers/gpu/drm/drm_ioc32.c:524: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 522. return -EFAULT; + 523. + 524. > req.ctx_id = req32.ctx_id; + 525. err = drm_ioctl_kernel(file, drm_legacy_getsareactx, &req, DRM_AUTH); + 526. if (err) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/md/dm-stats.c:542: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 540. preempt_disable(); + 541. #endif + 542. > p = &s->stat_percpu[smp_processor_id()][entry]; + 543. + 544. if (!end) { + +include/linux/cgroup.h:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. static inline bool task_css_is_root(struct task_struct *task, int subsys_id) + 514. { + 515. > return task_css_check(task, subsys_id, true) == + 516. init_css_set.subsys[subsys_id]; + 517. } + +lib/bitmap.c:525: error: DEAD_STORE + The value written to &group_size (type unsigned int) is never used. + 523. totaldigits = c = 0; + 524. old_a = old_b = 0; + 525. > group_size = used_size = 0; + 526. bitmap_zero(maskp, nmaskbits); + 527. do { + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +net/ipv6/ip6_flowlabel.c:563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 561. case IPV6_FL_A_RENEW: + 562. rcu_read_lock_bh(); + 563. > for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + +net/ipv6/ip6_flowlabel.c:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. err = -EEXIST; + 612. rcu_read_lock_bh(); + 613. > for_each_sk_fl_rcu(np, sfl) { + 614. if (sfl->fl->label == freq.flr_label) { + 615. if (freq.flr_flags&IPV6_FL_F_EXCL) { + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +net/ipv6/ip6_flowlabel.c:574: error: UNINITIALIZED_VALUE + The value read from freq.flr_label was never initialized. + 572. if (freq.flr_share == IPV6_FL_S_NONE && + 573. ns_capable(net->user_ns, CAP_NET_ADMIN)) { + 574. > fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &ret (type int) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +drivers/gpu/drm/i915/i915_gem_gtt.c:574: error: UNINITIALIZED_VALUE + The value read from addr was never initialized. + 572. + 573. vm->scratch_page.page = page; + 574. > vm->scratch_page.daddr = addr; + 575. vm->scratch_page.order = order; + 576. + +drivers/gpu/drm/i915/i915_gem_gtt.c:575: error: UNINITIALIZED_VALUE + The value read from order was never initialized. + 573. vm->scratch_page.page = page; + 574. vm->scratch_page.daddr = addr; + 575. > vm->scratch_page.order = order; + 576. + 577. return 0; + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +lib/rhashtable.c:550: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 548. + 549. RCU_INIT_POINTER(list->next, plist); + 550. > head = rht_dereference_bucket(head->next, tbl, hash); + 551. RCU_INIT_POINTER(list->rhead.next, head); + 552. rcu_assign_pointer(*pprev, obj); + +lib/rhashtable.c:547: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 545. + 546. list = container_of(obj, struct rhlist_head, rhead); + 547. > plist = container_of(head, struct rhlist_head, rhead); + 548. + 549. RCU_INIT_POINTER(list->next, plist); + +net/ipv6/netfilter/nf_conntrack_reasm.c:553: error: UNINITIALIZED_VALUE + The value read from hdr.nexthdr was never initialized. + 551. prev_nhoff = start; + 552. + 553. > nexthdr = hdr.nexthdr; + 554. len -= hdrlen; + 555. start += hdrlen; + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +kernel/trace/trace_events.c:527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 525. struct trace_array *tr = data; + 526. + 527. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 528. trace_filter_add_remove_task(pid_list, self, task); + 529. } + +include/net/sock.h:525: error: DEAD_STORE + The value written to &off (type int) is never used. + 523. + 524. if (unlikely(off >= 0)) { + 525. > off = max_t(s32, off - val, 0); + 526. WRITE_ONCE(sk->sk_peek_off, off); + 527. } + +include/net/sock.h:522: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 520. static inline void sk_peek_offset_bwd(struct sock *sk, int val) + 521. { + 522. > s32 off = READ_ONCE(sk->sk_peek_off); + 523. + 524. if (unlikely(off >= 0)) { + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +net/ipv6/tcp_ipv6.c:558: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 556. + 557. if (ipv6_addr_v4mapped(&sin6->sin6_addr)) + 558. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3], + 559. AF_INET, prefixlen, cmd.tcpm_key, + 560. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:562: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 560. cmd.tcpm_keylen, GFP_KERNEL); + 561. + 562. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr, + 563. AF_INET6, prefixlen, cmd.tcpm_key, + 564. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:538: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 536. if (optname == TCP_MD5SIG_EXT && + 537. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 538. > prefixlen = cmd.tcpm_prefixlen; + 539. if (prefixlen > 128 || (ipv6_addr_v4mapped(&sin6->sin6_addr) && + 540. prefixlen > 32)) + +block/blk-flush.c:545: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 544 could be null and is dereferenced at line 545, column 2. + 543. + 544. bio = bio_alloc(gfp_mask, 0); + 545. > bio_set_dev(bio, bdev); + 546. bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; + 547. + +net/ipv6/ip6_fib.c:563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 561. e = 0; + 562. head = &net->ipv6.fib_table_hash[h]; + 563. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) { + 564. if (e < s_e) + 565. goto next; + +usr/gen_init_cpio.c:568: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 568, column 9. + 566. } + 567. + 568. > while (fgets(line, LINE_SIZE, cpio_list)) { + 569. int type_idx; + 570. size_t slen = strlen(line); + +usr/gen_init_cpio.c:580: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 580, column 12. + 578. + 579. if (! (type = strtok(line, " \t"))) { + 580. > fprintf(stderr, + 581. "ERROR: incorrect format, could not locate file type line %d: '%s'\n", + 582. line_nr, line); + +include/net/sch_generic.h:528: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 526. for (i = 0; i < dev->num_tx_queues; i++) { + 527. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + 528. > if (rcu_access_pointer(txq->qdisc) != txq->qdisc_sleeping) + 529. return true; + 530. } + +drivers/gpu/drm/i915/intel_hotplug.c:535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 533. mutex_lock(&dev->mode_config.mutex); + 534. + 535. > enabled = READ_ONCE(dev_priv->hotplug.poll_enabled); + 536. + 537. drm_connector_list_iter_begin(dev, &conn_iter); + +crypto/api.c:556: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 554. } + 555. + 556. > return ERR_PTR(err); + 557. } + 558. EXPORT_SYMBOL_GPL(crypto_alloc_tfm); + +kernel/sched/core.c:534: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 532. + 533. rcu_read_lock(); + 534. > for_each_domain(cpu, sd) { + 535. for_each_cpu(i, sched_domain_span(sd)) { + 536. if (cpu == i) + +kernel/sched/core.c:527: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 525. int get_nohz_timer_target(void) + 526. { + 527. > int i, cpu = smp_processor_id(); + 528. struct sched_domain *sd; + 529. + +kernel/sched/core.c:527: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 525. int get_nohz_timer_target(void) + 526. { + 527. > int i, cpu = smp_processor_id(); + 528. struct sched_domain *sd; + 529. + +kernel/softirq.c:530: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 528. + 529. local_irq_disable(); + 530. > list = __this_cpu_read(tasklet_hi_vec.head); + 531. __this_cpu_write(tasklet_hi_vec.head, NULL); + 532. __this_cpu_write(tasklet_hi_vec.tail, this_cpu_ptr(&tasklet_hi_vec.head)); + +kernel/softirq.c:554: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 552. local_irq_disable(); + 553. t->next = NULL; + 554. > *__this_cpu_read(tasklet_hi_vec.tail) = t; + 555. __this_cpu_write(tasklet_hi_vec.tail, &(t->next)); + 556. __raise_softirq_irqoff(HI_SOFTIRQ); + +kernel/softirq.c:530: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 528. + 529. local_irq_disable(); + 530. > list = __this_cpu_read(tasklet_hi_vec.head); + 531. __this_cpu_write(tasklet_hi_vec.head, NULL); + 532. __this_cpu_write(tasklet_hi_vec.tail, this_cpu_ptr(&tasklet_hi_vec.head)); + +drivers/tty/serial/serial_core.c:545: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 543. ret = 1; + 544. } + 545. > uart_port_unlock(port, flags); + 546. return ret; + 547. } + +net/netfilter/nf_conntrack_core.c:541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 539. bucket = reciprocal_scale(hash, hsize); + 540. + 541. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[bucket], hnnode) { + 542. struct nf_conn *ct; + 543. + +net/sunrpc/svc_xprt.c:536: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 534. + 535. rcu_read_lock(); + 536. > list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) { + 537. /* skip any that aren't queued */ + 538. if (test_bit(RQ_BUSY, &rqstp->rq_flags)) + +net/wireless/scan.c:540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 538. return true; + 539. + 540. > ies = rcu_access_pointer(a->ies); + 541. if (!ies) + 542. return false; + +block/blk-mq.c:547: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 545. } + 546. + 547. > cpu = get_cpu(); + 548. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 549. shared = cpus_share_cache(cpu, ctx->cpu); + +block/blk-mq.c:547: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 545. } + 546. + 547. > cpu = get_cpu(); + 548. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 549. shared = cpus_share_cache(cpu, ctx->cpu); + +drivers/gpu/drm/i915/intel_hdmi.c:539: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 535 could be null and is dereferenced at line 539, column 13. + 537. i915_reg_t reg = VIDEO_DIP_CTL; + 538. u32 val = I915_READ(reg); + 539. > u32 port = VIDEO_DIP_PORT(intel_dig_port->port); + 540. + 541. assert_hdmi_port_disabled(intel_hdmi); + +net/netfilter/core.c:536: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 534. if (skb->_nfct) { + 535. rcu_read_lock(); + 536. > attach = rcu_dereference(ip_ct_attach); + 537. if (attach) + 538. attach(new, skb); + +kernel/power/swap.c:572: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 570. pr_info("Image saving done\n"); + 571. swsusp_show_speed(start, stop, nr_to_write, "Wrote"); + 572. > return ret; + 573. } + 574. + +security/keys/process_keys.c:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. + 612. rcu_read_lock(); + 613. > key = rcu_dereference(ctx.cred->session_keyring); + 614. __key_get(key); + 615. rcu_read_unlock(); + +include/trace/events/sunrpc.h:534: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 532. ); + 533. + 534. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 535. TP_PROTO(struct svc_rqst *rqst), + 536. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:534: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 532. ); + 533. + 534. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 535. TP_PROTO(struct svc_rqst *rqst), + 536. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:534: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 532. ); + 533. + 534. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 535. TP_PROTO(struct svc_rqst *rqst), + 536. TP_ARGS(rqst)); + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +include/net/sch_generic.h:541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 539. for (i = 0; i < dev->num_tx_queues; i++) { + 540. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + 541. > if (rcu_access_pointer(txq->qdisc) != &noop_qdisc) + 542. return false; + 543. } + +drivers/gpu/drm/i915/intel_fbdev.c:634: error: DEAD_STORE + The value written to &intel_crtc (type intel_crtc*) is never used. + 632. /* Final pass to check if any active pipes don't have fbs */ + 633. for_each_crtc(dev, crtc) { + 634. > intel_crtc = to_intel_crtc(crtc); + 635. + 636. if (!crtc->state->active) + +net/netfilter/nf_conntrack_expect.c:542: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 540. + 541. for (st->bucket = 0; st->bucket < nf_ct_expect_hsize; st->bucket++) { + 542. > n = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket])); + 543. if (n) + 544. return n; + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +kernel/trace/trace_events_trigger.c:544: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 542. int ret = 0; + 543. + 544. > list_for_each_entry_rcu(test, &file->triggers, list) { + 545. if (test->cmd_ops->trigger_type == data->cmd_ops->trigger_type) { + 546. ret = -EEXIST; + +kernel/tracepoint.c:543: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 541. if (!sys_tracepoint_refcount) { + 542. read_lock(&tasklist_lock); + 543. > for_each_process_thread(p, t) { + 544. set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); + 545. } + +lib/decompress_unlzma.c:592: error: UNINITIALIZED_VALUE + The value read from header.pos was never initialized. + 590. + 591. mi = 0; + 592. > lc = header.pos; + 593. while (lc >= 9) { + 594. mi++; + +include/linux/radix-tree.h:577: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 575. + 576. found: + 577. > if (unlikely(radix_tree_is_internal_node(rcu_dereference_raw(*slot)))) + 578. return __radix_tree_next_slot(slot, iter, flags); + 579. return slot; + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 536. TP_ARGS(rqst)); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 536. TP_ARGS(rqst)); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 536. TP_ARGS(rqst)); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/rcu.h:539: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 537. * fifth argument is the total number of callbacks queued. + 538. */ + 539. > TRACE_EVENT(rcu_kfree_callback, + 540. + 541. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +include/trace/events/rcu.h:539: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 537. * fifth argument is the total number of callbacks queued. + 538. */ + 539. > TRACE_EVENT(rcu_kfree_callback, + 540. + 541. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +include/trace/events/rcu.h:539: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 537. * fifth argument is the total number of callbacks queued. + 538. */ + 539. > TRACE_EVENT(rcu_kfree_callback, + 540. + 541. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +net/ipv6/mcast.c:569: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 567. */ + 568. + 569. > for_each_pmc_rcu(inet6, pmc) { + 570. if (pmc->ifindex != gsf->gf_interface) + 571. continue; + +drivers/gpu/drm/drm_ioc32.c:553: error: UNINITIALIZED_VALUE + The value read from res32.contexts was never initialized. + 551. + 552. res.count = res32.count; + 553. > res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + 555. if (err) + +drivers/gpu/drm/drm_ioc32.c:552: error: UNINITIALIZED_VALUE + The value read from res32.count was never initialized. + 550. return -EFAULT; + 551. + 552. > res.count = res32.count; + 553. res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + +drivers/usb/core/config.c:701: error: UNINITIALIZED_VALUE + The value read from inums[_] was never initialized. + 699. j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. > dev_warn(ddev, "too many alternate settings for " + 702. "config %d interface %d: %d, " + 703. "using maximum allowed: %d\n", + +drivers/usb/core/config.c:750: error: UNINITIALIZED_VALUE + The value read from inums[_] was never initialized. + 748. } + 749. if (n >= intfc->num_altsetting) + 750. > dev_warn(ddev, "config %d interface %d has no " + 751. "altsetting %d\n", cfgno, inums[i], j); + 752. } + +drivers/usb/core/config.c:699: error: UNINITIALIZED_VALUE + The value read from nalts[_] was never initialized. + 697. /* Allocate the usb_interface_caches and altsetting arrays */ + 698. for (i = 0; i < nintf; ++i) { + 699. > j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. dev_warn(ddev, "too many alternate settings for " + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +drivers/gpu/drm/drm_dp_helper.c:600: error: UNINITIALIZED_VALUE + The value read from rev[_] was never initialized. + 598. len = drm_dp_dpcd_read(aux, DP_BRANCH_SW_REV, rev, 2); + 599. if (len > 0) + 600. > seq_printf(m, "\t\tSW: %d.%d\n", rev[0], rev[1]); + 601. + 602. if (detailed_cap_info) { + +net/sched/act_api.c:545: error: DEAD_STORE + The value written to &err (type int) is never used. + 543. tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) + 544. { + 545. > int err = -EINVAL; + 546. unsigned char *b = skb_tail_pointer(skb); + 547. struct nlattr *nest; + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +net/ipv6/calipso.c:555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 553. + 554. rcu_read_lock(); + 555. > list_for_each_entry_rcu(iter_doi, &calipso_doi_list, list) + 556. if (refcount_read(&iter_doi->refcount) > 0) { + 557. if (doi_cnt++ < *skip_cnt) + +kernel/trace/trace_events.c:553: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 551. struct trace_pid_list *pid_list; + 552. + 553. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 554. + 555. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +net/netfilter/core.c:552: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 550. + 551. rcu_read_lock(); + 552. > destroy = rcu_dereference(nf_ct_destroy); + 553. BUG_ON(destroy == NULL); + 554. destroy(nfct); + +net/sunrpc/auth.c:560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 558. + 559. rcu_read_lock(); + 560. > hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) { + 561. if (!entry->cr_ops->crmatch(acred, entry, flags)) + 562. continue; + +kernel/exit.c:553: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 551. struct task_struct *t; + 552. + 553. > for_each_thread(p, t) { + 554. if (!(t->flags & PF_EXITING)) + 555. return t; + +net/netfilter/nf_conntrack_expect.c:554: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 552. struct ct_expect_iter_state *st = seq->private; + 553. + 554. > head = rcu_dereference(hlist_next_rcu(head)); + 555. while (head == NULL) { + 556. if (++st->bucket >= nf_ct_expect_hsize) + +net/netfilter/nf_conntrack_expect.c:558: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 556. if (++st->bucket >= nf_ct_expect_hsize) + 557. return NULL; + 558. > head = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket])); + 559. } + 560. return head; + +net/netfilter/nf_conntrack_ftp.c:557: error: NULL_DEREFERENCE + pointer `ftp` last assigned on line 551 could be null and is dereferenced at line 557, column 2. + 555. * failover breaks. + 556. */ + 557. > ftp->flags[IP_CT_DIR_ORIGINAL] |= NF_CT_FTP_SEQ_PICKUP; + 558. ftp->flags[IP_CT_DIR_REPLY] |= NF_CT_FTP_SEQ_PICKUP; + 559. return 0; + +security/keys/keyring.c:555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 553. struct keyring_search_context *ctx = iterator_data; + 554. const struct key *key = keyring_ptr_to_key(object); + 555. > unsigned long kflags = READ_ONCE(key->flags); + 556. short state = READ_ONCE(key->state); + 557. + +security/keys/keyring.c:556: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 554. const struct key *key = keyring_ptr_to_key(object); + 555. unsigned long kflags = READ_ONCE(key->flags); + 556. > short state = READ_ONCE(key->state); + 557. + 558. kenter("{%d}", key->serial); + +security/keys/keyring.c:568: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 566. /* skip invalidated, revoked and expired keys */ + 567. if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) { + 568. > time64_t expiry = READ_ONCE(key->expiry); + 569. + 570. if (kflags & ((1 << KEY_FLAG_INVALIDATED) | + +kernel/tracepoint.c:560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 558. if (!sys_tracepoint_refcount) { + 559. read_lock(&tasklist_lock); + 560. > for_each_process_thread(p, t) { + 561. clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); + 562. } + +net/ipv4/devinet.c:561: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 559. dev = dev_get_by_index_rcu(net, ifindex); + 560. if (dev) + 561. > in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 562. rcu_read_unlock(); + 563. return in_dev; + +drivers/tty/serial/serial_core.c:591: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 589. + 590. __uart_start(tty); + 591. > uart_port_unlock(port, flags); + 592. return ret; + 593. } + +drivers/dma-buf/reservation.c:571: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 569. + 570. struct reservation_object_list *fobj = + 571. > rcu_dereference(obj->fence); + 572. + 573. if (fobj) + +drivers/dma-buf/reservation.c:577: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 575. + 576. for (i = 0; i < shared_count; ++i) { + 577. > struct dma_fence *fence = rcu_dereference(fobj->shared[i]); + 578. + 579. ret = reservation_object_test_signaled_single(fence); + +drivers/dma-buf/reservation.c:591: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 589. + 590. if (!shared_count) { + 591. > struct dma_fence *fence_excl = rcu_dereference(obj->fence_excl); + 592. + 593. if (fence_excl) { + +security/selinux/ss/avtab.c:568: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 566. goto bad; + 567. } + 568. > nel = le32_to_cpu(buf[0]); + 569. if (!nel) { + 570. printk(KERN_ERR "SELinux: avtab: table is empty\n"); + +drivers/input/mouse/alps.c:586: error: DEAD_STORE + The value written to &z (type int) is never used. + 584. x = (s8)(((packet[0] & 0x20) << 2) | (packet[1] & 0x7f)); + 585. y = (s8)(((packet[0] & 0x10) << 3) | (packet[2] & 0x7f)); + 586. > z = (packet[4] & 0x7c) >> 2; + 587. + 588. /* + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +drivers/ata/libata-sff.c:584: error: UNINITIALIZED_VALUE + The value read from pad[_] was never initialized. + 582. if (rw == READ) { + 583. ioread16_rep(data_addr, pad, 1); + 584. > *buf = pad[0]; + 585. } else { + 586. pad[0] = *buf; + +include/linux/sched/signal.h:560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 558. static inline struct task_struct *next_thread(const struct task_struct *p) + 559. { + 560. > return list_entry_rcu(p->thread_group.next, + 561. struct task_struct, thread_group); + 562. } + +kernel/cgroup/cgroup.c:572: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 570. */ + 571. if (cft->ss) + 572. > return rcu_dereference_raw(cgrp->subsys[cft->ss->id]); + 573. else + 574. return &cgrp->self; + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +block/scsi_ioctl.c:642: error: UNINITIALIZED_VALUE + The value read from cgc.buffer was never initialized. + 640. break; + 641. + 642. > hdr.dxferp = cgc.buffer; + 643. hdr.sbp = cgc.sense; + 644. if (hdr.sbp) + +block/scsi_ioctl.c:621: error: UNINITIALIZED_VALUE + The value read from cgc.buflen was never initialized. + 619. hdr.interface_id = 'S'; + 620. hdr.cmd_len = sizeof(cgc.cmd); + 621. > hdr.dxfer_len = cgc.buflen; + 622. err = 0; + 623. switch (cgc.data_direction) { + +block/scsi_ioctl.c:643: error: UNINITIALIZED_VALUE + The value read from cgc.sense was never initialized. + 641. + 642. hdr.dxferp = cgc.buffer; + 643. > hdr.sbp = cgc.sense; + 644. if (hdr.sbp) + 645. hdr.mx_sb_len = sizeof(struct request_sense); + +block/scsi_ioctl.c:617: error: UNINITIALIZED_VALUE + The value read from cgc.timeout was never initialized. + 615. if (copy_from_user(&cgc, arg, sizeof(cgc))) + 616. break; + 617. > cgc.timeout = clock_t_to_jiffies(cgc.timeout); + 618. memset(&hdr, 0, sizeof(hdr)); + 619. hdr.interface_id = 'S'; + +kernel/exit.c:565: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 564 could be null and is dereferenced at line 565, column 31. + 563. { + 564. struct pid_namespace *pid_ns = task_active_pid_ns(father); + 565. > struct task_struct *reaper = pid_ns->child_reaper; + 566. + 567. if (likely(reaper != father)) + +kernel/trace/trace_events.c:567: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 565. struct trace_pid_list *pid_list; + 566. + 567. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 568. + 569. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +drivers/gpu/drm/i915/intel_cdclk.c:598: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 596. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 597. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 598. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 599. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 600. 50)) { + +net/core/sock.c:564: error: DEAD_STORE + The value written to &ret (type int) is never used. + 562. int optlen) + 563. { + 564. > int ret = -ENOPROTOOPT; + 565. #ifdef CONFIG_NETDEVICES + 566. struct net *net = sock_net(sk); + +net/wireless/trace.h:561: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 559. ); + 560. + 561. > DECLARE_EVENT_CLASS(wiphy_netdev_evt, + 562. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 563. TP_ARGS(wiphy, netdev), + +ipc/mqueue.c:600: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 598. spin_unlock(&info->lock); + 599. out: + 600. > return retval; + 601. } + 602. + +kernel/workqueue.c:576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 574. return wq->dfl_pwq; + 575. + 576. > return rcu_dereference_raw(wq->numa_pwq_tbl[node]); + 577. } + 578. + +kernel/sched/core.c:567: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 565. struct rq *rq = cpu_rq(cpu); + 566. + 567. > if (cpu == smp_processor_id()) + 568. return; + 569. + +lib/rhashtable.c:596: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 594. return ERR_PTR(-ENOMEM); + 595. + 596. > head = rht_dereference_bucket(*pprev, tbl, hash); + 597. + 598. RCU_INIT_POINTER(obj->next, head); + +lib/rhashtable.c:579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 577. return ERR_CAST(data); + 578. + 579. > new_tbl = rcu_dereference(tbl->future_tbl); + 580. if (new_tbl) + 581. return new_tbl; + +net/wireless/scan.c:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. return b->channel->center_freq - a->channel->center_freq; + 574. + 575. > a_ies = rcu_access_pointer(a->ies); + 576. if (!a_ies) + 577. return -1; + +net/wireless/scan.c:578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 576. if (!a_ies) + 577. return -1; + 578. > b_ies = rcu_access_pointer(b->ies); + 579. if (!b_ies) + 580. return 1; + +include/net/sch_generic.h:568: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 566. { + 567. #ifdef CONFIG_NET_SCHED + 568. > struct qdisc_size_table *stab = rcu_dereference_bh(sch->stab); + 569. + 570. if (stab) + +net/ipv4/route.c:572: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 570. + 571. rcu_read_lock(); + 572. > inet_opt = rcu_dereference(inet->inet_opt); + 573. if (inet_opt && inet_opt->opt.srr) + 574. daddr = inet_opt->opt.faddr; + +drivers/ata/ata_piix.c:638: error: UNINITIALIZED_VALUE + The value read from slave_data was never initialized. + 636. pci_write_config_word(dev, master_port, master_data); + 637. if (is_slave) + 638. > pci_write_config_byte(dev, slave_port, slave_data); + 639. + 640. /* Ensure the UDMA bit is off - it will be turned back on if + +net/ipv4/inet_connection_sock.c:579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 577. struct rtable *rt; + 578. + 579. > opt = rcu_dereference(ireq->ireq_opt); + 580. fl4 = &newinet->cork.fl.u.ip4; + 581. + +arch/x86/events/intel/rapl.c:578: error: NULL_DEREFERENCE + pointer `pmu` last assigned on line 571 could be null and is dereferenced at line 578, column 2. + 576. return 0; + 577. + 578. > pmu->cpu = -1; + 579. /* Find a new cpu to collect rapl events */ + 580. target = cpumask_any_but(topology_core_cpumask(cpu), cpu); + +include/trace/events/sunrpc.h:569: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 567. ); + 568. + 569. > DEFINE_EVENT(svc_rqst_status, svc_process, + 570. TP_PROTO(struct svc_rqst *rqst, int status), + 571. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:569: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 567. ); + 568. + 569. > DEFINE_EVENT(svc_rqst_status, svc_process, + 570. TP_PROTO(struct svc_rqst *rqst, int status), + 571. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:569: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 567. ); + 568. + 569. > DEFINE_EVENT(svc_rqst_status, svc_process, + 570. TP_PROTO(struct svc_rqst *rqst, int status), + 571. TP_ARGS(rqst, status)); + +block/kyber-iosched.c:581: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 579. + 580. rqs = &khd->rqs[khd->cur_domain]; + 581. > rq = list_first_entry_or_null(rqs, struct request, queuelist); + 582. + 583. /* + +block/kyber-iosched.c:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. kyber_flush_busy_ctxs(khd, hctx); + 589. *flushed = true; + 590. > rq = list_first_entry_or_null(rqs, struct request, queuelist); + 591. } + 592. + +kernel/cgroup/cpuset.c:577: error: MEMORY_LEAK + `pos_css` is not reachable after line 577, column 2. + 575. + 576. rcu_read_lock(); + 577. > cpuset_for_each_descendant_pre(cp, pos_css, root_cs) { + 578. /* skip the whole subtree if @cp doesn't have any CPU */ + 579. if (cpumask_empty(cp->cpus_allowed)) { + +drivers/gpu/drm/drm_vblank.c:657: error: UNINITIALIZED_VALUE + The value read from duration_ns was never initialized. + 655. + 656. /* Return upper bound of timestamp precision error. */ + 657. > *max_error = duration_ns; + 658. + 659. /* Convert scanout position into elapsed time at raw_time query + +drivers/gpu/drm/drm_vblank.c:667: error: UNINITIALIZED_VALUE + The value read from etime was never initialized. + 665. + 666. /* save this only for debugging purposes */ + 667. > ts_etime = ktime_to_timespec64(etime); + 668. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 669. /* Subtract time delta from raw timestamp to get final + +drivers/gpu/drm/drm_vblank.c:675: error: UNINITIALIZED_VALUE + The value read from hpos was never initialized. + 673. *vblank_time = etime; + 674. + 675. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 676. pipe, hpos, vpos, + 677. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/drm_vblank.c:675: error: UNINITIALIZED_VALUE + The value read from vpos was never initialized. + 673. *vblank_time = etime; + 674. + 675. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 676. pipe, hpos, vpos, + 677. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +net/netfilter/nf_conntrack_proto.c:581: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 574 could be null and is dereferenced by call to `nf_ct_l4proto_register_sysctl()` at line 581, column 8. + 579. if (err < 0) + 580. return err; + 581. > err = nf_ct_l4proto_register_sysctl(net, + 582. pn, + 583. &nf_conntrack_l4proto_generic); + +security/selinux/avc.c:579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 577. hvalue = avc_hash(ssid, tsid, tclass); + 578. head = &avc_cache.slots[hvalue]; + 579. > hlist_for_each_entry_rcu(node, head, list) { + 580. if (ssid == node->ae.ssid && + 581. tclass == node->ae.tclass && + +drivers/scsi/sg.c:668: error: UNINITIALIZED_VALUE + The value read from cmnd[_] was never initialized. + 666. */ + 667. if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) { + 668. > printk_ratelimited(KERN_WARNING + 669. "sg_write: data in/out %d/%d bytes " + 670. "for SCSI command 0x%x-- guessing " + +drivers/scsi/sg.c:658: error: UNINITIALIZED_VALUE + The value read from old_hdr.pack_id was never initialized. + 656. hp->timeout = old_hdr.reply_len; /* structure abuse ... */ + 657. hp->flags = input_size; /* structure abuse ... */ + 658. > hp->pack_id = old_hdr.pack_id; + 659. hp->usr_ptr = NULL; + 660. if (__copy_from_user(cmnd, buf, cmd_size)) + +drivers/scsi/sg.c:632: error: UNINITIALIZED_VALUE + The value read from old_hdr.reply_len was never initialized. + 630. /* Determine buffer size. */ + 631. input_size = count - cmd_size; + 632. > mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len; + 633. mxsize -= SZ_SG_HEADER; + 634. input_size -= SZ_SG_HEADER; + +drivers/scsi/sg.c:656: error: UNINITIALIZED_VALUE + The value read from old_hdr.reply_len was never initialized. + 654. hp->dxferp = NULL; + 655. hp->sbp = NULL; + 656. > hp->timeout = old_hdr.reply_len; /* structure abuse ... */ + 657. hp->flags = input_size; /* structure abuse ... */ + 658. hp->pack_id = old_hdr.pack_id; + +drivers/gpu/drm/i915/i915_debugfs.c:584: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 582. int count, ret; + 583. + 584. > nobject = READ_ONCE(dev_priv->mm.object_count); + 585. objects = kvmalloc_array(nobject, sizeof(*objects), GFP_KERNEL); + 586. if (!objects) + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 571. TP_ARGS(rqst, status)); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_send, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 571. TP_ARGS(rqst, status)); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_send, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 571. TP_ARGS(rqst, status)); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_send, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +kernel/trace/trace_events.c:583: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 581. return; + 582. + 583. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 584. + 585. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +kernel/trace/trace_events.c:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. + 579. /* Nothing to do if we are already tracing */ + 580. > if (!this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 581. return; + 582. + +drivers/char/hw_random/core.c:576: error: DEAD_STORE + The value written to &ret (type int) is never used. + 574. static int __init hwrng_modinit(void) + 575. { + 576. > int ret = -ENOMEM; + 577. + 578. /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +include/trace/events/rcu.h:574: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 572. * the current RCU-callback batch limit. + 573. */ + 574. > TRACE_EVENT(rcu_batch_start, + 575. + 576. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +include/trace/events/rcu.h:574: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 572. * the current RCU-callback batch limit. + 573. */ + 574. > TRACE_EVENT(rcu_batch_start, + 575. + 576. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +include/trace/events/rcu.h:574: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 572. * the current RCU-callback batch limit. + 573. */ + 574. > TRACE_EVENT(rcu_batch_start, + 575. + 576. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +net/sched/act_api.c:578: error: DEAD_STORE + The value written to &err (type int) is never used. + 576. { + 577. struct tc_action *a; + 578. > int err = -EINVAL; + 579. struct nlattr *nest; + 580. + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +kernel/sched/core.c:587: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 585. return true; /* Don't try to wake offline CPUs. */ + 586. if (tick_nohz_full_cpu(cpu)) { + 587. > if (cpu != smp_processor_id() || + 588. tick_nohz_tick_stopped()) + 589. tick_nohz_full_kick_cpu(cpu); + +net/ipv4/igmp.c:584: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 582. if (!pmc) { + 583. rcu_read_lock(); + 584. > for_each_pmc_rcu(in_dev, pmc) { + 585. if (pmc->multiaddr == IGMP_ALL_HOSTS) + 586. continue; + +drivers/char/hpet.c:594: error: DEAD_STORE + The value written to &hpet (type hpet*) is never used. + 592. case HPET_IRQFREQ: + 593. timer = devp->hd_timer; + 594. > hpet = devp->hd_hpet; + 595. hpetp = devp->hd_hpets; + 596. break; + +drivers/md/dm.c:581: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 579. *srcu_idx = srcu_read_lock(&md->io_barrier); + 580. + 581. > return srcu_dereference(md->map, &md->io_barrier); + 582. } + 583. + +kernel/time/posix-timers.c:586: error: MEMORY_LEAK + `return` is not reachable after line 586, column 3. + 584. if (copy_from_user(&event, timer_event_spec, sizeof (event))) + 585. return -EFAULT; + 586. > return do_timer_create(which_clock, &event, created_timer_id); + 587. } + 588. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:588: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 588, column 9. + 586. return do_timer_create(which_clock, &event, created_timer_id); + 587. } + 588. > return do_timer_create(which_clock, NULL, created_timer_id); + 589. } + 590. + +net/sunrpc/auth_gss/gss_rpc_xdr.c:620: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 618. + 619. /* ctx->ctx_flags */ + 620. > p = xdr_encode_hyper(p, ctx->ctx_flags); + 621. + 622. /* ctx->locally_initiated */ + +arch/x86/events/amd/ibs.c:645: error: DEAD_STORE + The value written to &buf (type unsigned long long*) is never used. + 643. } + 644. if (ibs_caps & IBS_CAPS_OPDATA4) { + 645. > rdmsrl(MSR_AMD64_IBSOPDATA4, *buf++); + 646. size++; + 647. } + +drivers/gpu/drm/drm_ioc32.c:602: error: UNINITIALIZED_VALUE + The value read from d.granted_count was never initialized. + 600. + 601. if (put_user(d.request_size, &argp->request_size) + 602. > || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + 604. + +drivers/gpu/drm/drm_ioc32.c:601: error: UNINITIALIZED_VALUE + The value read from d.request_size was never initialized. + 599. return err; + 600. + 601. > if (put_user(d.request_size, &argp->request_size) + 602. || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:589: error: UNINITIALIZED_VALUE + The value read from d32.context was never initialized. + 587. return -EFAULT; + 588. + 589. > d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + +drivers/gpu/drm/drm_ioc32.c:593: error: UNINITIALIZED_VALUE + The value read from d32.flags was never initialized. + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. > d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + +drivers/gpu/drm/drm_ioc32.c:594: error: UNINITIALIZED_VALUE + The value read from d32.request_count was never initialized. + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. > d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + +drivers/gpu/drm/drm_ioc32.c:595: error: UNINITIALIZED_VALUE + The value read from d32.request_indices was never initialized. + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. > d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:596: error: UNINITIALIZED_VALUE + The value read from d32.request_sizes was never initialized. + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. > d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + 598. if (err) + +drivers/gpu/drm/drm_ioc32.c:590: error: UNINITIALIZED_VALUE + The value read from d32.send_count was never initialized. + 588. + 589. d.context = d32.context; + 590. > d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + +drivers/gpu/drm/drm_ioc32.c:591: error: UNINITIALIZED_VALUE + The value read from d32.send_indices was never initialized. + 589. d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. > d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + +drivers/gpu/drm/drm_ioc32.c:592: error: UNINITIALIZED_VALUE + The value read from d32.send_sizes was never initialized. + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. > d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + +kernel/module.c:594: error: UNINITIALIZED_VALUE + The value read from fsa.crc was never initialized. + 592. *owner = fsa.owner; + 593. if (crc) + 594. > *crc = fsa.crc; + 595. return fsa.sym; + 596. } + +kernel/module.c:592: error: UNINITIALIZED_VALUE + The value read from fsa.owner was never initialized. + 590. if (each_symbol_section(find_symbol_in_section, &fsa)) { + 591. if (owner) + 592. > *owner = fsa.owner; + 593. if (crc) + 594. *crc = fsa.crc; + +kernel/module.c:595: error: UNINITIALIZED_VALUE + The value read from fsa.sym was never initialized. + 593. if (crc) + 594. *crc = fsa.crc; + 595. > return fsa.sym; + 596. } + 597. + +net/ipv4/tcp_minisocks.c:735: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 733. + 734. if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_nxt)) + 735. > req->ts_recent = tmp_opt.rcv_tsval; + 736. + 737. if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn) { + +drivers/gpu/drm/i915/intel_fbc.c:583: error: DEAD_STORE + The value written to &compressed_llb (type drm_mm_node*) is never used. + 581. struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 582. struct intel_fbc *fbc = &dev_priv->fbc; + 583. > struct drm_mm_node *uninitialized_var(compressed_llb); + 584. int size, fb_cpp, ret; + 585. + +drivers/md/md-bitmap.c:588: error: DEAD_STORE + The value written to &err (type int) is never used. + 586. int nodes = 0; + 587. unsigned long sectors_reserved = 0; + 588. > int err = -EINVAL; + 589. struct page *sb_page; + 590. loff_t offset = bitmap->mddev->bitmap_info.offset; + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +kernel/trace/trace_events_trigger.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. bool unregistered = false; + 588. + 589. > list_for_each_entry_rcu(data, &file->triggers, list) { + 590. if (data->cmd_ops->trigger_type == test->cmd_ops->trigger_type) { + 591. unregistered = true; + +sound/core/pcm_native.c:609: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 607. if (trace_hw_interval_param_enabled()) { + 608. if (hw_is_interval(*v)) + 609. > old_interval = *hw_param_interval(params, *v); + 610. } + 611. if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) + +sound/core/pcm_native.c:605: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 603. if (trace_hw_mask_param_enabled()) { + 604. if (hw_is_mask(*v)) + 605. > old_mask = *hw_param_mask(params, *v); + 606. } + 607. if (trace_hw_interval_param_enabled()) { + +drivers/gpu/drm/i915/intel_ringbuffer.h:587: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 585. { + 586. /* Ensure that the compiler doesn't optimize away the load. */ + 587. > return READ_ONCE(engine->status_page.page_addr[reg]); + 588. } + 589. + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/ipv6/udp.c:609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 607. + 608. /* if we're overly short, let UDP handle it */ + 609. > encap_rcv = READ_ONCE(up->encap_rcv); + 610. if (encap_rcv) { + 611. int ret; + +net/ipv6/udp.c:647: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 645. + 646. prefetch(&sk->sk_rmem_alloc); + 647. > if (rcu_access_pointer(sk->sk_filter) && + 648. udp_lib_checksum_complete(skb)) + 649. goto csum_error; + +drivers/hid/usbhid/hiddev.c:748: error: UNINITIALIZED_VALUE + The value read from finfo.report_id was never initialized. + 746. + 747. rinfo.report_type = finfo.report_type; + 748. > rinfo.report_id = finfo.report_id; + 749. + 750. report = hiddev_lookup_report(hid, &rinfo); + +drivers/hid/usbhid/hiddev.c:747: error: UNINITIALIZED_VALUE + The value read from finfo.report_type was never initialized. + 745. } + 746. + 747. > rinfo.report_type = finfo.report_type; + 748. rinfo.report_id = finfo.report_id; + 749. + +drivers/gpu/drm/i915/i915_gem_request.c:626: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 624. + 625. /* Move the oldest request to the slab-cache (if not in use!) */ + 626. > req = list_first_entry_or_null(&engine->timeline->requests, + 627. typeof(*req), link); + 628. if (req && i915_gem_request_completed(req)) + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +include/linux/pagemap.h:609: error: DEAD_STORE + The value written to &c (type char) is never used. + 607. if (((unsigned long)uaddr & PAGE_MASK) == + 608. ((unsigned long)end & PAGE_MASK)) { + 609. > return __get_user(c, end); + 610. } + 611. + +kernel/trace/trace_events.c:599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 597. return; + 598. + 599. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 600. + 601. /* Set tracing if current is enabled */ + +kernel/trace/trace_events.c:596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 594. + 595. /* Nothing to do if we are not tracing */ + 596. > if (this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 597. return; + 598. + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +drivers/usb/host/ohci-q.c:682: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 680. && cnt < urb_priv->length) { + 681. td_fill (ohci, info, 0, 0, urb, cnt); + 682. > cnt++; + 683. } + 684. /* maybe kickstart bulk list */ + +drivers/usb/host/ohci-q.c:706: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 704. ? TD_CC | TD_DP_IN | TD_T_DATA1 + 705. : TD_CC | TD_DP_OUT | TD_T_DATA1; + 706. > td_fill (ohci, info, data, 0, urb, cnt++); + 707. /* maybe kickstart control list */ + 708. wmb (); + +include/linux/sched/signal.h:594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 592. unsigned int limit) + 593. { + 594. > return READ_ONCE(tsk->signal->rlim[limit].rlim_cur); + 595. } + 596. + +net/netfilter/nf_conntrack_proto.c:596: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 593 could be null and is dereferenced at line 596, column 2. + 594. &nf_conntrack_l4proto_generic); + 595. + 596. > pn->users--; + 597. nf_ct_l4proto_unregister_sysctl(net, + 598. pn, + +net/netlabel/netlabel_domainhash.c:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. if (entry->valid) { + 602. entry->valid = 0; + 603. > if (entry == rcu_dereference(netlbl_domhsh_def_ipv4)) + 604. RCU_INIT_POINTER(netlbl_domhsh_def_ipv4, NULL); + 605. else if (entry == rcu_dereference(netlbl_domhsh_def_ipv6)) + +net/netlabel/netlabel_domainhash.c:605: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 603. if (entry == rcu_dereference(netlbl_domhsh_def_ipv4)) + 604. RCU_INIT_POINTER(netlbl_domhsh_def_ipv4, NULL); + 605. > else if (entry == rcu_dereference(netlbl_domhsh_def_ipv6)) + 606. RCU_INIT_POINTER(netlbl_domhsh_def_ipv6, NULL); + 607. else + +drivers/gpu/drm/i915/intel_breadcrumbs.c:615: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 613. */ + 614. rcu_read_lock(); + 615. > request = rcu_dereference(b->first_signal); + 616. if (request) + 617. request = i915_gem_request_get_rcu(request); + +drivers/gpu/drm/i915/intel_breadcrumbs.c:638: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 636. * the oldest before picking the next one. + 637. */ + 638. > if (request == rcu_access_pointer(b->first_signal)) { + 639. struct rb_node *rb = + 640. rb_next(&request->signaling.node); + +include/trace/events/sunrpc.h:592: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 590. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 591. + 592. > TRACE_EVENT(svc_xprt_do_enqueue, + 593. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 594. + +include/trace/events/sunrpc.h:592: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 590. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 591. + 592. > TRACE_EVENT(svc_xprt_do_enqueue, + 593. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 594. + +include/trace/events/sunrpc.h:592: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 590. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 591. + 592. > TRACE_EVENT(svc_xprt_do_enqueue, + 593. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 594. + +kernel/time/posix-timers.c:601: error: MEMORY_LEAK + `return` is not reachable after line 601, column 3. + 599. if (get_compat_sigevent(&event, timer_event_spec)) + 600. return -EFAULT; + 601. > return do_timer_create(which_clock, &event, created_timer_id); + 602. } + 603. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:603: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 603, column 9. + 601. return do_timer_create(which_clock, &event, created_timer_id); + 602. } + 603. > return do_timer_create(which_clock, NULL, created_timer_id); + 604. } + 605. #endif + +net/ipv6/ip6_fib.c:645: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 643. /* remove null_entry in the root node */ + 644. } else if (fn->fn_flags & RTN_TL_ROOT && + 645. > rcu_access_pointer(fn->leaf) == + 646. net->ipv6.ip6_null_entry) { + 647. RCU_INIT_POINTER(fn->leaf, NULL); + +net/netfilter/nf_conntrack_expect.c:625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 623. seq_printf(s, "%sUSERSPACE", delim); + 624. + 625. > helper = rcu_dereference(nfct_help(expect->master)->helper); + 626. if (helper) { + 627. seq_printf(s, "%s%s", expect->flags ? " " : "", helper->name); + +drivers/dma/dmaengine.c:595: error: DEAD_STORE + The value written to &err (type int) is never used. + 593. struct dma_chan *dma_get_slave_channel(struct dma_chan *chan) + 594. { + 595. > int err = -EBUSY; + 596. + 597. /* lock against __dma_request_channel */ + +net/ipv4/ip_sockglue.c:1015: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 1013. memset(&mreq, 0, sizeof(mreq)); + 1014. mreq.imr_multiaddr = psin->sin_addr; + 1015. > mreq.imr_ifindex = greq.gr_interface; + 1016. + 1017. if (optname == MCAST_JOIN_GROUP) + +net/ipv4/ip_sockglue.c:1062: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1060. mreq.imr_multiaddr = psin->sin_addr; + 1061. mreq.imr_address.s_addr = 0; + 1062. > mreq.imr_ifindex = greqs.gsr_interface; + 1063. err = ip_mc_join_group(sk, &mreq); + 1064. if (err && err != -EADDRINUSE) + +net/ipv4/ip_sockglue.c:1073: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1071. add = 0; + 1072. } + 1073. > err = ip_mc_source(add, omode, sk, &mreqs, + 1074. greqs.gsr_interface); + 1075. break; + +net/ipv4/ip_sockglue.c:879: error: UNINITIALIZED_VALUE + The value read from mreq.imr_ifindex was never initialized. + 877. mreq.imr_ifindex = dev->ifindex; + 878. } else + 879. > dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex); + 880. + 881. + +net/ipv4/ip_sockglue.c:896: error: UNINITIALIZED_VALUE + The value read from mreq.imr_ifindex was never initialized. + 894. break; + 895. + 896. > inet->mc_index = mreq.imr_ifindex; + 897. inet->mc_addr = mreq.imr_address.s_addr; + 898. err = 0; + +net/ipv4/ip_sockglue.c:984: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_interface was never initialized. + 982. + 983. mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 984. > mreq.imr_address.s_addr = mreqs.imr_interface; + 985. mreq.imr_ifindex = 0; + 986. err = ip_mc_join_group(sk, &mreq); + +net/ipv4/ip_sockglue.c:983: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_multiaddr was never initialized. + 981. struct ip_mreqn mreq; + 982. + 983. > mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 984. mreq.imr_address.s_addr = mreqs.imr_interface; + 985. mreq.imr_ifindex = 0; + +kernel/sched/cputime.c:624: error: DEAD_STORE + The value written to &utime (type unsigned long long) is never used. + 622. */ + 623. if (stime == 0) { + 624. > utime = rtime; + 625. goto update; + 626. } + +net/ipv4/route.c:598: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 596. struct rtable *rt; + 597. + 598. > rt = rcu_dereference(fnhe->fnhe_rth_input); + 599. if (rt) { + 600. RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL); + +net/ipv4/route.c:604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 602. dst_release(&rt->dst); + 603. } + 604. > rt = rcu_dereference(fnhe->fnhe_rth_output); + 605. if (rt) { + 606. RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL); + +drivers/tty/serial/serial_core.c:604: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 602. port = uart_port_lock(state, flags); + 603. ret = uart_circ_chars_free(&state->xmit); + 604. > uart_port_unlock(port, flags); + 605. return ret; + 606. } + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +lib/iov_iter.c:608: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 606. if (iter_is_iovec(i)) + 607. might_fault(); + 608. > iterate_all_kinds(i, bytes, v, ({ + 609. if (copyin((to += v.iov_len) - v.iov_len, + 610. v.iov_base, v.iov_len)) + +net/sunrpc/clnt.c:606: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 604. err = -ENOMEM; + 605. rcu_read_lock(); + 606. > xprt = xprt_get(rcu_dereference(clnt->cl_xprt)); + 607. xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 608. rcu_read_unlock(); + +net/sunrpc/clnt.c:607: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 605. rcu_read_lock(); + 606. xprt = xprt_get(rcu_dereference(clnt->cl_xprt)); + 607. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 608. rcu_read_unlock(); + 609. if (xprt == NULL || xps == NULL) { + +drivers/ata/libata-scsi.c:639: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 637. scsi_cmd[0] = ATA_16; + 638. + 639. > scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + +drivers/ata/libata-scsi.c:641: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 639. scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. > scsi_cmd[6] = args[3]; + 642. scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + +drivers/ata/libata-scsi.c:642: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + 642. > scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + 644. scsi_cmd[12] = 0xc2; + +drivers/ata/libata-scsi.c:646: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 644. scsi_cmd[12] = 0xc2; + 645. } else { + 646. > scsi_cmd[6] = args[1]; + 647. } + 648. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:648: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 646. scsi_cmd[6] = args[1]; + 647. } + 648. > scsi_cmd[14] = args[0]; + 649. + 650. /* Good values for timeout and retries? Values below + +include/linux/sched/signal.h:600: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 598. unsigned int limit) + 599. { + 600. > return READ_ONCE(tsk->signal->rlim[limit].rlim_max); + 601. } + 602. + +drivers/md/dm.c:602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 600. { + 601. rcu_read_lock(); + 602. > return rcu_dereference(md->map); + 603. } + 604. + +lib/radix-tree.c:602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 600. struct radix_tree_node **nodep, unsigned long *maxindex) + 601. { + 602. > struct radix_tree_node *node = rcu_dereference_raw(root->rnode); + 603. + 604. *nodep = node; + +drivers/gpu/drm/drm_dp_mst_topology.c:620: error: DEAD_STORE + The value written to &idx (type int) is never used. + 618. msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1; + 619. msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7); + 620. > idx++; + 621. return true; + 622. fail_len: + +include/linux/rhashtable.h:612: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 610. unsigned int hash; + 611. + 612. > tbl = rht_dereference_rcu(ht->tbl, ht); + 613. restart: + 614. hash = rht_key_hashfn(ht, tbl, key, params); + +include/linux/rhashtable.h:615: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 613. restart: + 614. hash = rht_key_hashfn(ht, tbl, key, params); + 615. > rht_for_each_rcu(he, tbl, hash) { + 616. if (params.obj_cmpfn ? + 617. params.obj_cmpfn(&arg, rht_obj(ht, he)) : + +include/linux/rhashtable.h:626: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 624. smp_rmb(); + 625. + 626. > tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 627. if (unlikely(tbl)) + 628. goto restart; + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +net/ipv4/devinet.c:609: error: DEAD_STORE + The value written to &err (type int) is never used. + 607. struct ifaddrmsg *ifm; + 608. struct in_ifaddr *ifa, **ifap; + 609. > int err = -EINVAL; + 610. + 611. ASSERT_RTNL(); + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +net/ipv4/ip_options.c:654: error: UNINITIALIZED_VALUE + The value read from nexthop was never initialized. + 652. if (srrptr <= srrspace) { + 653. opt->srr_is_hit = 1; + 654. > opt->nexthop = nexthop; + 655. opt->is_changed = 1; + 656. } + +crypto/drbg.c:607: error: DEAD_STORE + The value written to &ret (type int) is never used. + 605. int reseed) + 606. { + 607. > int ret = -EFAULT; + 608. int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + +include/trace/events/rcu.h:604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 602. * a pointer to the RCU callback itself. + 603. */ + 604. > TRACE_EVENT(rcu_invoke_callback, + 605. + 606. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +include/trace/events/rcu.h:604: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 602. * a pointer to the RCU callback itself. + 603. */ + 604. > TRACE_EVENT(rcu_invoke_callback, + 605. + 606. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +include/trace/events/rcu.h:604: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 602. * a pointer to the RCU callback itself. + 603. */ + 604. > TRACE_EVENT(rcu_invoke_callback, + 605. + 606. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +lib/vsprintf.c:625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 623. rcu_read_lock(); + 624. for (i = 0; i < depth; i++, d = p) { + 625. > p = READ_ONCE(d->d_parent); + 626. array[i] = READ_ONCE(d->d_name.name); + 627. if (p == d) { + +lib/vsprintf.c:626: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 624. for (i = 0; i < depth; i++, d = p) { + 625. p = READ_ONCE(d->d_parent); + 626. > array[i] = READ_ONCE(d->d_name.name); + 627. if (p == d) { + 628. if (i) + +lib/vsprintf.c:634: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 632. } + 633. } + 634. > s = array[--i]; + 635. for (n = 0; n != spec.precision; n++, buf++) { + 636. char c = *s++; + +lib/vsprintf.c:641: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 639. break; + 640. c = '/'; + 641. > s = array[--i]; + 642. } + 643. if (buf < end) + +kernel/module.c:614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 612. module_assert_mutex_or_preempt(); + 613. + 614. > list_for_each_entry_rcu(mod, &modules, list) { + 615. if (!even_unformed && mod->state == MODULE_STATE_UNFORMED) + 616. continue; + +kernel/sched/core.c:609: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 607. static inline bool got_nohz_idle_kick(void) + 608. { + 609. > int cpu = smp_processor_id(); + 610. + 611. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +kernel/sched/core.c:609: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 607. static inline bool got_nohz_idle_kick(void) + 608. { + 609. > int cpu = smp_processor_id(); + 610. + 611. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +drivers/tty/serial/serial_core.c:617: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 615. port = uart_port_lock(state, flags); + 616. ret = uart_circ_chars_pending(&state->xmit); + 617. > uart_port_unlock(port, flags); + 618. return ret; + 619. } + +drivers/pcmcia/ds.c:614: error: DEAD_STORE + The value written to &ret (type int) is never used. + 612. cistpl_longlink_mfc_t mfc; + 613. unsigned int no_funcs, i, no_chains; + 614. > int ret = -EAGAIN; + 615. + 616. mutex_lock(&s->ops_mutex); + +drivers/pcmcia/ds.c:655: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 653. + 654. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) + 655. > no_funcs = mfc.nfn; + 656. else + 657. no_funcs = 1; + +net/ipv6/mcast.c:619: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 617. + 618. rcu_read_lock(); + 619. > for_each_pmc_rcu(np, mc) { + 620. if (ipv6_addr_equal(&mc->addr, mc_addr)) + 621. break; + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &ret (type int) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +net/ipv4/route.c:616: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 614. struct fib_nh_exception *fnhe, *oldest; + 615. + 616. > oldest = rcu_dereference(hash->chain); + 617. for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe; + 618. fnhe = rcu_dereference(fnhe->fnhe_next)) { + +net/ipv4/route.c:617: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 615. + 616. oldest = rcu_dereference(hash->chain); + 617. > for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe; + 618. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 619. if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp)) + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/tty/pty.c:617: error: DEAD_STORE + The value written to &fd (type int) is never used. + 615. int ptm_open_peer(struct file *master, struct tty_struct *tty, int flags) + 616. { + 617. > int fd = -1; + 618. struct file *filp; + 619. int retval = -EINVAL; + +drivers/tty/pty.c:619: error: DEAD_STORE + The value written to &retval (type int) is never used. + 617. int fd = -1; + 618. struct file *filp; + 619. > int retval = -EINVAL; + 620. struct path path; + 621. + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.act_mask was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_nr was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_size was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.end_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.pid was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.start_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +lib/rhashtable.c:624: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 622. void *data; + 623. + 624. > tbl = rcu_dereference(ht->tbl); + 625. + 626. /* All insertions must grab the oldest table containing + +lib/rhashtable.c:638: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 636. + 637. spin_unlock_bh(lock); + 638. > tbl = rcu_dereference(tbl->future_tbl); + 639. } + 640. + +lib/rhashtable.c:641: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 639. } + 640. + 641. > data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 642. new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 643. if (PTR_ERR(new_tbl) != -EEXIST) + +lib/rhashtable.c:642: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 640. + 641. data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 642. > new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 643. if (PTR_ERR(new_tbl) != -EEXIST) + 644. data = ERR_CAST(new_tbl); + +net/netfilter/nf_conntrack_core.c:626: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 624. unsigned int sequence; + 625. + 626. > zone = nf_ct_zone(ct); + 627. + 628. local_bh_disable(); + +lib/radix-tree.c:631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 629. maxshift += RADIX_TREE_MAP_SHIFT; + 630. + 631. > entry = rcu_dereference_raw(root->rnode); + 632. if (!entry && (!is_idr(root) || root_tag_get(root, IDR_FREE))) + 633. goto out; + +net/core/sock.c:622: error: DEAD_STORE + The value written to &ret (type int) is never used. + 620. int __user *optlen, int len) + 621. { + 622. > int ret = -ENOPROTOOPT; + 623. #ifdef CONFIG_NETDEVICES + 624. struct net *net = sock_net(sk); + +kernel/trace/trace_events_filter.c:642: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 640. * n_preds, root and filter->preds are protect with preemption disabled. + 641. */ + 642. > root = rcu_dereference_sched(filter->root); + 643. if (!root) + 644. return 1; + +kernel/trace/trace_events_filter.c:646: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 644. return 1; + 645. + 646. > data.preds = preds = rcu_dereference_sched(filter->preds); + 647. ret = walk_pred_tree(preds, root, filter_match_preds_cb, &data); + 648. WARN_ON(ret); + +net/sunrpc/svc_xprt.c:649: error: DEAD_STORE + The value written to &i (type int) is never used. + 647. } + 648. rqstp->rq_page_end = &rqstp->rq_pages[i]; + 649. > rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */ + 650. + 651. /* Make arg->head point to first page and arg->pages point to rest */ + +drivers/md/dm-stats.c:654: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 652. + 653. got_precise_time = false; + 654. > list_for_each_entry_rcu(s, &stats->list, list_entry) { + 655. if (s->stat_flags & STAT_PRECISE_TIMESTAMPS && !got_precise_time) { + 656. if (!end) + +drivers/tty/serial/serial_core.c:644: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 642. if (port->ops->flush_buffer) + 643. port->ops->flush_buffer(port); + 644. > uart_port_unlock(port, flags); + 645. tty_port_tty_wakeup(&state->port); + 646. } + +net/netfilter/nfnetlink_log.c:687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 685. size += nla_total_size(sizeof(u_int32_t)); + 686. if (inst->flags & NFULNL_CFG_F_CONNTRACK) { + 687. > nfnl_ct = rcu_dereference(nfnl_ct_hook); + 688. if (nfnl_ct != NULL) { + 689. ct = nfnl_ct->get_ct(skb, &ctinfo); + +net/ipv4/udp.c:628: error: DEAD_STORE + The value written to &code (type int) is never used. + 626. struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2)); + 627. const int type = icmp_hdr(skb)->type; + 628. > const int code = icmp_hdr(skb)->code; + 629. struct sock *sk; + 630. int harderr; + +net/netlabel/netlabel_kapi.c:624: error: DEAD_STORE + The value written to &iter (type netlbl_lsm_catmap*) is never used. + 622. int netlbl_catmap_walk(struct netlbl_lsm_catmap *catmap, u32 offset) + 623. { + 624. > struct netlbl_lsm_catmap *iter = catmap; + 625. u32 idx; + 626. u32 bit; + +net/ipv4/cipso_ipv4.c:632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 630. + 631. rcu_read_lock(); + 632. > list_for_each_entry_rcu(iter_doi, &cipso_v4_doi_list, list) + 633. if (refcount_read(&iter_doi->refcount) > 0) { + 634. if (doi_cnt++ < *skip_cnt) + +net/wireless/util.c:645: error: UNINITIALIZED_VALUE + The value read from eth.h_proto was never initialized. + 643. + 644. skb_copy_bits(skb, offset, ð, sizeof(eth)); + 645. > len = ntohs(eth.h_proto); + 646. subframe_len = sizeof(struct ethhdr) + len; + 647. padding = (4 - subframe_len) & 0x3; + +kernel/audit.c:641: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 639. + 640. rcu_read_lock(); + 641. > ac = rcu_dereference(auditd_conn); + 642. if (!ac) { + 643. rcu_read_unlock(); + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +drivers/gpu/drm/drm_dp_mst_topology.c:643: error: DEAD_STORE + The value written to &idx (type int) is never used. + 641. + 642. msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]); + 643. > idx++; + 644. return true; + 645. fail_len: + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +block/blk-merge.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. int cpu; + 633. + 634. > cpu = part_stat_lock(); + 635. part = req->part; + 636. + +block/blk-merge.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. int cpu; + 633. + 634. > cpu = part_stat_lock(); + 635. part = req->part; + 636. + +drivers/usb/core/message.c:653: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 651. break; + 652. } + 653. > return result; + 654. } + 655. EXPORT_SYMBOL_GPL(usb_get_descriptor); + +drivers/char/random.c:643: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 641. + 642. retry: + 643. > entropy_count = orig = READ_ONCE(r->entropy_count); + 644. if (nfrac < 0) { + 645. /* Debit */ + +include/trace/events/rcu.h:633: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 631. * data structure. + 632. */ + 633. > TRACE_EVENT(rcu_invoke_kfree_callback, + 634. + 635. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +include/trace/events/rcu.h:633: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 631. * data structure. + 632. */ + 633. > TRACE_EVENT(rcu_invoke_kfree_callback, + 634. + 635. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +include/trace/events/rcu.h:633: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 631. * data structure. + 632. */ + 633. > TRACE_EVENT(rcu_invoke_kfree_callback, + 634. + 635. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +sound/core/info.c:635: error: DEAD_STORE + The value written to &c (type int) is never used. + 633. int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) + 634. { + 635. > int c = -1; + 636. + 637. if (snd_BUG_ON(!buffer || !buffer->buffer)) + +net/ipv4/igmp.c:677: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 675. + 676. /* change recs */ + 677. > for_each_pmc_rcu(in_dev, pmc) { + 678. spin_lock_bh(&pmc->lock); + 679. if (pmc->sfcount[MCAST_EXCLUDE]) { + +drivers/gpu/drm/i915/i915_gem_request.h:642: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 640. i915_gem_active_isset(const struct i915_gem_active *active) + 641. { + 642. > return rcu_access_pointer(active->request); + 643. } + 644. + +drivers/gpu/drm/i915/intel_dpio_phy.c:645: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 644 could be null and is dereferenced at line 645, column 34. + 643. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 644. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 645. > struct intel_crtc *intel_crtc = to_intel_crtc(dport->base.base.crtc); + 646. enum dpio_channel ch = vlv_dport_to_channel(dport); + 647. enum pipe pipe = intel_crtc->pipe; + +drivers/gpu/drm/drm_ioc32.c:652: error: UNINITIALIZED_VALUE + The value read from info.agp_version_major was never initialized. + 650. return err; + 651. + 652. > i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + +drivers/gpu/drm/drm_ioc32.c:653: error: UNINITIALIZED_VALUE + The value read from info.agp_version_minor was never initialized. + 651. + 652. i32.agp_version_major = info.agp_version_major; + 653. > i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + +drivers/gpu/drm/drm_ioc32.c:655: error: UNINITIALIZED_VALUE + The value read from info.aperture_base was never initialized. + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. > i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + +drivers/gpu/drm/drm_ioc32.c:656: error: UNINITIALIZED_VALUE + The value read from info.aperture_size was never initialized. + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. > i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + +drivers/gpu/drm/drm_ioc32.c:660: error: UNINITIALIZED_VALUE + The value read from info.id_device was never initialized. + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. > i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + 662. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:659: error: UNINITIALIZED_VALUE + The value read from info.id_vendor was never initialized. + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. > i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + +drivers/gpu/drm/drm_ioc32.c:657: error: UNINITIALIZED_VALUE + The value read from info.memory_allowed was never initialized. + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. > i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + +drivers/gpu/drm/drm_ioc32.c:658: error: UNINITIALIZED_VALUE + The value read from info.memory_used was never initialized. + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. > i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + +drivers/gpu/drm/drm_ioc32.c:654: error: UNINITIALIZED_VALUE + The value read from info.mode was never initialized. + 652. i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. > i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + +include/linux/atomic.h:653: error: UNINITIALIZED_VALUE + The value read from dec was never initialized. + 651. c = old; + 652. } + 653. > return dec; + 654. } + 655. #endif + +net/netfilter/nf_conntrack_sip.c:662: error: UNINITIALIZED_VALUE + The value read from end was never initialized. + 660. return 0; + 661. if (endp) + 662. > *endp = end; + 663. return 1; + 664. } + +net/sunrpc/auth_gss/gss_rpc_xdr.c:683: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 681. + 682. /* ctx->ctx_flags */ + 683. > p = xdr_decode_hyper(p, &ctx->ctx_flags); + 684. + 685. /* ctx->locally_initiated */ + +security/keys/keyring.c:706: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 704. * slots 1-15). + 705. */ + 706. > ptr = READ_ONCE(keyring->keys.root); + 707. if (!ptr) + 708. goto not_this_keyring; + +security/keys/keyring.c:720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 718. goto not_this_keyring; + 719. + 720. > ptr = READ_ONCE(shortcut->next_node); + 721. node = assoc_array_ptr_to_node(ptr); + 722. goto begin_node; + +security/keys/keyring.c:740: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 738. shortcut = assoc_array_ptr_to_shortcut(ptr); + 739. smp_read_barrier_depends(); + 740. > ptr = READ_ONCE(shortcut->next_node); + 741. BUG_ON(!assoc_array_ptr_is_node(ptr)); + 742. } + +security/keys/keyring.c:752: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 750. /* Go through the slots in a node */ + 751. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 752. > ptr = READ_ONCE(node->slots[slot]); + 753. + 754. if (assoc_array_ptr_is_meta(ptr) && node->back_pointer) + +security/keys/keyring.c:790: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 788. * to ascend to the parent and continue processing there. + 789. */ + 790. > ptr = READ_ONCE(node->back_pointer); + 791. slot = node->parent_slot; + 792. + +security/keys/keyring.c:796: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 794. shortcut = assoc_array_ptr_to_shortcut(ptr); + 795. smp_read_barrier_depends(); + 796. > ptr = READ_ONCE(shortcut->back_pointer); + 797. slot = shortcut->parent_slot; + 798. } + +net/netlabel/netlabel_unlabeled.c:665: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 663. iface = netlbl_unlhsh_search_iface(dev->ifindex); + 664. } else + 665. > iface = rcu_dereference(netlbl_unlhsh_def); + 666. if (iface == NULL) { + 667. ret_val = -ENOENT; + +drivers/gpu/drm/i915/intel_cdclk.c:676: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 674. * However, extensive testing shows that this can take longer. + 675. */ + 676. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 677. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 678. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:711: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 709. I915_WRITE(LCPLL_CTL, val); + 710. + 711. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 712. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 713. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:676: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 674. * However, extensive testing shows that this can take longer. + 675. */ + 676. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 677. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 678. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:711: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 709. I915_WRITE(LCPLL_CTL, val); + 710. + 711. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 712. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 713. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:676: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 674. * However, extensive testing shows that this can take longer. + 675. */ + 676. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 677. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 678. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:711: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 709. I915_WRITE(LCPLL_CTL, val); + 710. + 711. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 712. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 713. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:676: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 674. * However, extensive testing shows that this can take longer. + 675. */ + 676. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 677. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 678. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:711: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 709. I915_WRITE(LCPLL_CTL, val); + 710. + 711. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 712. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 713. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/i915_gem_stolen.c:704: error: DEAD_STORE + The value written to &ret (type int) is never used. + 702. vma = i915_vma_instance(obj, &ggtt->base, NULL); + 703. if (IS_ERR(vma)) { + 704. > ret = PTR_ERR(vma); + 705. goto err_pages; + 706. } + +kernel/relay.c:686: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 684. } + 685. + 686. > curr_cpu = get_cpu(); + 687. /* + 688. * The CPU hotplug notifier ran before us and created buffers with + +kernel/relay.c:686: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 684. } + 685. + 686. > curr_cpu = get_cpu(); + 687. /* + 688. * The CPU hotplug notifier ran before us and created buffers with + +kernel/locking/mutex.c:653: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 651. { + 652. struct ww_mutex *ww = container_of(lock, struct ww_mutex, base); + 653. > struct ww_acquire_ctx *hold_ctx = READ_ONCE(ww->ctx); + 654. struct mutex_waiter *cur; + 655. + +net/ipv4/route.c:663: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 661. spin_lock_bh(&fnhe_lock); + 662. + 663. > hash = rcu_dereference(nh->nh_exceptions); + 664. if (!hash) { + 665. hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC); + +net/ipv4/route.c:674: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 672. + 673. depth = 0; + 674. > for (fnhe = rcu_dereference(hash->chain); fnhe; + 675. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 676. if (fnhe->fnhe_daddr == daddr) + +net/ipv4/route.c:675: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 673. depth = 0; + 674. for (fnhe = rcu_dereference(hash->chain); fnhe; + 675. > fnhe = rcu_dereference(fnhe->fnhe_next)) { + 676. if (fnhe->fnhe_daddr == daddr) + 677. break; + +net/ipv4/route.c:690: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 688. fnhe->fnhe_expires = max(1UL, expires); + 689. /* Update all cached dsts too */ + 690. > rt = rcu_dereference(fnhe->fnhe_rth_input); + 691. if (rt) + 692. fill_route_from_fnhe(rt, fnhe); + +net/ipv4/route.c:693: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 691. if (rt) + 692. fill_route_from_fnhe(rt, fnhe); + 693. > rt = rcu_dereference(fnhe->fnhe_rth_output); + 694. if (rt) + 695. fill_route_from_fnhe(rt, fnhe); + +net/ipv4/route.c:717: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 715. * applies to them. + 716. */ + 717. > rt = rcu_dereference(nh->nh_rth_input); + 718. if (rt) + 719. rt->dst.obsolete = DST_OBSOLETE_KILL; + +net/ipv4/route.c:724: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 722. struct rtable __rcu **prt; + 723. prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i); + 724. > rt = rcu_dereference(*prt); + 725. if (rt) + 726. rt->dst.obsolete = DST_OBSOLETE_KILL; + +net/sunrpc/rpcb_clnt.c:652: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 650. { + 651. struct rpc_clnt *parent = clnt->cl_parent; + 652. > struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch); + 653. + 654. while (parent != clnt) { + +net/sunrpc/rpcb_clnt.c:655: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 653. + 654. while (parent != clnt) { + 655. > if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps) + 656. break; + 657. if (clnt->cl_autobind) + +net/sunrpc/xprtsock.c:744: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 742. } + 743. + 744. > return status; + 745. } + 746. + +drivers/gpu/drm/i915/intel_sdvo.c:661: error: UNINITIALIZED_VALUE + The value read from response.input0_trained was never initialized. + 659. return false; + 660. + 661. > *input_1 = response.input0_trained; + 662. *input_2 = response.input1_trained; + 663. return true; + +drivers/gpu/drm/i915/intel_sdvo.c:662: error: UNINITIALIZED_VALUE + The value read from response.input1_trained was never initialized. + 660. + 661. *input_1 = response.input0_trained; + 662. > *input_2 = response.input1_trained; + 663. return true; + 664. } + +include/trace/events/sunrpc.h:652: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 650. ); + 651. + 652. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 653. TP_PROTO(struct svc_xprt *xprt), + 654. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:652: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 650. ); + 651. + 652. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 653. TP_PROTO(struct svc_xprt *xprt), + 654. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:652: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 650. ); + 651. + 652. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 653. TP_PROTO(struct svc_xprt *xprt), + 654. TP_ARGS(xprt)); + +net/ipv4/devinet.c:666: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 664. + 665. rcu_read_lock(); + 666. > hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) { + 667. unsigned long age; + 668. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/time/tick-sched.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static inline bool local_timer_softirq_pending(void) + 654. { + 655. > return local_softirq_pending() & TIMER_SOFTIRQ; + 656. } + 657. + +drivers/iommu/dmar.c:661: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 659. + 660. while (dev) { + 661. > for_each_active_dev_scope(devices, cnt, index, tmp) + 662. if (dev_is_pci(tmp) && dev == to_pci_dev(tmp)) + 663. return 1; + +block/bio.c:699: error: NULL_DEREFERENCE + pointer `bio->bi_io_vec` last assigned on line 684 could be null and is dereferenced at line 699, column 3. + 697. break; + 698. case REQ_OP_WRITE_SAME: + 699. > bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0]; + 700. break; + 701. default: + +net/sunrpc/svcauth_unix.c:662: error: DEAD_STORE + The value written to &cred (type svc_cred*) is never used. + 660. struct ip_map *ipm; + 661. struct group_info *gi; + 662. > struct svc_cred *cred = &rqstp->rq_cred; + 663. struct svc_xprt *xprt = rqstp->rq_xprt; + 664. struct net *net = xprt->xpt_net; + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 654. TP_ARGS(xprt)); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 654. TP_ARGS(xprt)); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 654. TP_ARGS(xprt)); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +kernel/softirq.c:661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 659. { + 660. local_irq_disable(); + 661. > if (local_softirq_pending()) { + 662. /* + 663. * We can safely run softirq on inline stack, as we are not deep + +kernel/time/tick-sched.c:661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 659. ktime_t now, int cpu) + 660. { + 661. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 662. u64 basemono, next_tick, next_tmr, next_rcu, delta, expires; + 663. unsigned long seq, basejiff; + +kernel/time/tick-sched.c:661: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 659. ktime_t now, int cpu) + 660. { + 661. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 662. u64 basemono, next_tick, next_tmr, next_rcu, delta, expires; + 663. unsigned long seq, basejiff; + +include/linux/netdevice.h:668: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 666. + 667. /* We only give a hint, preemption can change CPU under us */ + 668. > val |= raw_smp_processor_id(); + 669. + 670. if (table->ents[index] != val) + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > TRACE_EVENT(svc_wake_up, + 661. TP_PROTO(int pid), + 662. + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > TRACE_EVENT(svc_wake_up, + 661. TP_PROTO(int pid), + 662. + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > TRACE_EVENT(svc_wake_up, + 661. TP_PROTO(int pid), + 662. + +kernel/exit.c:676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 674. reaper = find_new_reaper(father, reaper); + 675. list_for_each_entry(p, &father->children, sibling) { + 676. > for_each_thread(p, t) { + 677. t->real_parent = reaper; + 678. BUG_ON((!t->ptrace) != (t->parent == father)); + +drivers/base/core.c:671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 669. * never change once they are set, so they don't need special care. + 670. */ + 671. > drv = READ_ONCE(dev->driver); + 672. return drv ? drv->name : + 673. (dev->bus ? dev->bus->name : + +drivers/gpu/drm/i915/i915_trace.h:663: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 661. ); + 662. + 663. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 664. TP_PROTO(struct drm_i915_gem_request *req), + 665. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:663: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 661. ); + 662. + 663. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 664. TP_PROTO(struct drm_i915_gem_request *req), + 665. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:663: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 661. ); + 662. + 663. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 664. TP_PROTO(struct drm_i915_gem_request *req), + 665. TP_ARGS(req) + +lib/iov_iter.c:673: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 671. if (unlikely(i->count < bytes)) + 672. return false; + 673. > iterate_all_kinds(i, bytes, v, ({ + 674. if (__copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len, + 675. v.iov_base, v.iov_len)) + +include/trace/events/rcu.h:666: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 664. * rcu_is_callbacks_kthread(). + 665. */ + 666. > TRACE_EVENT(rcu_batch_end, + 667. + 668. TP_PROTO(const char *rcuname, int callbacks_invoked, + +include/trace/events/rcu.h:666: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 664. * rcu_is_callbacks_kthread(). + 665. */ + 666. > TRACE_EVENT(rcu_batch_end, + 667. + 668. TP_PROTO(const char *rcuname, int callbacks_invoked, + +include/trace/events/rcu.h:666: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 664. * rcu_is_callbacks_kthread(). + 665. */ + 666. > TRACE_EVENT(rcu_batch_end, + 667. + 668. TP_PROTO(const char *rcuname, int callbacks_invoked, + +net/ipv4/ipconfig.c:742: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 740. } + 741. + 742. > *e++ = 255; /* End of the list */ + 743. } + 744. + +drivers/md/dm-stats.c:675: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 673. + 674. local_irq_disable(); + 675. > p = &s->stat_percpu[smp_processor_id()][x]; + 676. dm_stat_round(s, shared, p); + 677. local_irq_enable(); + +ipc/sem.c:717: error: DEAD_STORE + The value written to &result (type int) is never used. + 715. curr = &sma->sems[sop->sem_num]; + 716. sem_op = sop->sem_op; + 717. > result = curr->semval; + 718. + 719. if (sop->sem_flg & SEM_UNDO) { + +kernel/cpu.c:674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 672. { + 673. BUG_ON(smpboot_register_percpu_thread(&cpuhp_threads)); + 674. > kthread_unpark(this_cpu_read(cpuhp_state.thread)); + 675. } + 676. + +drivers/iommu/dmar.c:681: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 679. + 680. rcu_read_lock(); + 681. > for_each_drhd_unit(dmaru) { + 682. drhd = container_of(dmaru->hdr, + 683. struct acpi_dmar_hardware_unit, + +net/ipv6/af_inet6.c:697: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 695. + 696. rcu_read_lock(); + 697. > final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), + 698. &final); + 699. rcu_read_unlock(); + +kernel/kexec_core.c:759: error: DEAD_STORE + The value written to &addr (type unsigned long) is never used. + 757. continue; + 758. } + 759. > addr = old_addr; + 760. page = old_page; + 761. break; + +drivers/gpu/drm/drm_ioc32.c:685: error: UNINITIALIZED_VALUE + The value read from req32.size was never initialized. + 683. return -EFAULT; + 684. + 685. > request.size = req32.size; + 686. request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:686: error: UNINITIALIZED_VALUE + The value read from req32.type was never initialized. + 684. + 685. request.size = req32.size; + 686. > request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + 688. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +drivers/gpu/drm/drm_ioc32.c:692: error: UNINITIALIZED_VALUE + The value read from request.handle was never initialized. + 690. return err; + 691. + 692. > req32.handle = request.handle; + 693. req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + +drivers/gpu/drm/drm_ioc32.c:693: error: UNINITIALIZED_VALUE + The value read from request.physical was never initialized. + 691. + 692. req32.handle = request.handle; + 693. > req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + 695. drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, + +drivers/gpu/drm/i915/intel_runtime_pm.c:681: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 680 could be null and is dereferenced at line 681, column 6. + 679. + 680. power_well = lookup_power_well(dev_priv, BXT_DPIO_CMN_A); + 681. > if (power_well->count > 0) + 682. bxt_ddi_phy_verify_state(dev_priv, power_well->bxt.phy); + 683. + +drivers/gpu/drm/i915/intel_runtime_pm.c:685: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 684 could be null and is dereferenced at line 685, column 6. + 683. + 684. power_well = lookup_power_well(dev_priv, BXT_DPIO_CMN_BC); + 685. > if (power_well->count > 0) + 686. bxt_ddi_phy_verify_state(dev_priv, power_well->bxt.phy); + 687. + +include/trace/events/sunrpc.h:676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 674. ); + 675. + 676. > TRACE_EVENT(svc_handle_xprt, + 677. TP_PROTO(struct svc_xprt *xprt, int len), + 678. + +include/trace/events/sunrpc.h:676: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 674. ); + 675. + 676. > TRACE_EVENT(svc_handle_xprt, + 677. TP_PROTO(struct svc_xprt *xprt, int len), + 678. + +include/trace/events/sunrpc.h:676: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 674. ); + 675. + 676. > TRACE_EVENT(svc_handle_xprt, + 677. TP_PROTO(struct svc_xprt *xprt, int len), + 678. + +net/ipv4/inet_connection_sock.c:721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 719. } + 720. } + 721. > defer_accept = READ_ONCE(queue->rskq_defer_accept); + 722. if (defer_accept) + 723. max_retries = defer_accept; + +net/ipv6/addrconf.c:697: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 695. cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ + 696. net->dev_base_seq; + 697. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 698. if (idx < s_idx) + 699. goto cont; + +lib/decompress_bunzip2.c:686: error: DEAD_STORE + The value written to &i (type int) is never used. + 684. { + 685. struct bunzip_data *bd; + 686. > int i = -1; + 687. unsigned char *inbuf; + 688. + +drivers/gpu/drm/i915/intel_hdmi.c:690: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 686 could be null and is dereferenced at line 690, column 13. + 688. i915_reg_t reg = TVIDEO_DIP_CTL(intel_crtc->pipe); + 689. u32 val = I915_READ(reg); + 690. > u32 port = VIDEO_DIP_PORT(intel_dig_port->port); + 691. + 692. assert_hdmi_port_disabled(intel_hdmi); + +drivers/pcmcia/ds.c:707: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 705. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 706. &mfc)) + 707. > new_funcs = mfc.nfn; + 708. else + 709. new_funcs = 1; + +drivers/usb/core/message.c:699: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 697. break; + 698. } + 699. > return result; + 700. } + 701. + +lib/radix-tree.c:685: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 683. + 684. for (;;) { + 685. > struct radix_tree_node *node = rcu_dereference_raw(root->rnode); + 686. struct radix_tree_node *child; + 687. + +lib/radix-tree.c:699: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 697. if (node->count != 1) + 698. break; + 699. > child = rcu_dereference_raw(node->slots[0]); + 700. if (!child) + 701. break; + +kernel/module.c:687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 685. preempt_disable(); + 686. + 687. > list_for_each_entry_rcu(mod, &modules, list) { + 688. if (mod->state == MODULE_STATE_UNFORMED) + 689. continue; + +kernel/rcu/tree.c:701: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 699. if (rsp == NULL) + 700. return; + 701. > *flags = READ_ONCE(rsp->gp_flags); + 702. *gpnum = READ_ONCE(rsp->gpnum); + 703. *completed = READ_ONCE(rsp->completed); + +kernel/rcu/tree.c:702: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 700. return; + 701. *flags = READ_ONCE(rsp->gp_flags); + 702. > *gpnum = READ_ONCE(rsp->gpnum); + 703. *completed = READ_ONCE(rsp->completed); + 704. } + +kernel/rcu/tree.c:703: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 701. *flags = READ_ONCE(rsp->gp_flags); + 702. *gpnum = READ_ONCE(rsp->gpnum); + 703. > *completed = READ_ONCE(rsp->completed); + 704. } + 705. EXPORT_SYMBOL_GPL(rcutorture_get_gp_data); + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +kernel/cgroup/cgroup-v1.c:700: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 698 could be null and is dereferenced at line 700, column 7. + 698. for_each_subsys(ss, i) + 699. seq_printf(m, "%s\t%d\t%d\t%d\n", + 700. > ss->legacy_name, ss->root->hierarchy_id, + 701. atomic_read(&ss->root->nr_cgrps), + 702. cgroup_ssid_enabled(i)); + +drivers/gpu/drm/i915/i915_gem_gtt.c:693: error: DEAD_STORE + The value written to &ret (type int) is never used. + 691. { + 692. struct i915_page_directory_pointer *pdp; + 693. > int ret = -ENOMEM; + 694. + 695. WARN_ON(!use_4lvl(vm)); + +kernel/cpu.c:703: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 701. WARN_ON(cpu_online(cpu)); + 702. rcu_read_lock(); + 703. > for_each_process(p) { + 704. struct task_struct *t; + 705. + +drivers/iommu/intel-iommu.c:694: error: DEAD_STORE + The value written to &agaw (type int) is never used. + 692. { + 693. unsigned long sagaw; + 694. > int agaw = -1; + 695. + 696. sagaw = cap_sagaw(iommu->cap); + +drivers/md/md.c:695: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 693. struct md_rdev *rdev; + 694. + 695. > rdev_for_each_rcu(rdev, mddev) + 696. if (rdev->desc_nr == nr) + 697. return rdev; + +net/core/net-sysfs.c:705: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 703. + 704. rcu_read_lock(); + 705. > map = rcu_dereference(queue->rps_map); + 706. if (map) + 707. for (i = 0; i < map->len; i++) + +net/ipv4/ip_fragment.c:712: error: UNINITIALIZED_VALUE + The value read from iph.tot_len was never initialized. + 710. return skb; + 711. + 712. > len = ntohs(iph.tot_len); + 713. if (skb->len < netoff + len || len < (iph.ihl * 4)) + 714. return skb; + +net/ipv6/ndisc.c:715: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 698 could be null and is dereferenced by call to `ndisc_send_ns()` at line 715, column 3. + 713. __func__, target); + 714. } + 715. > ndisc_send_ns(dev, target, target, saddr, 0); + 716. } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) { + 717. neigh_app_ns(neigh); + +net/ipv6/ndisc.c:720: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 698 could be null and is dereferenced by call to `ndisc_send_ns()` at line 720, column 3. + 718. } else { + 719. addrconf_addr_solict_mult(target, &mcaddr); + 720. > ndisc_send_ns(dev, target, &mcaddr, saddr, 0); + 721. } + 722. } + +sound/pci/hda/hda_proc.c:699: error: DEAD_STORE + The value written to &curr (type int) is never used. + 697. struct hda_codec *codec, hda_nid_t nid) + 698. { + 699. > int i, curr = -1; + 700. u8 dev_list[AC_MAX_DEV_LIST_LEN]; + 701. int devlist_len; + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +kernel/sched/core.c:712: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 710. if (ret) + 711. goto out; + 712. > list_for_each_entry_rcu(child, &parent->children, siblings) { + 713. parent = child; + 714. goto down; + +drivers/iommu/dmar.c:711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 709. struct acpi_dmar_pci_path *path; + 710. + 711. > for_each_drhd_unit(dmaru) { + 712. drhd = container_of(dmaru->hdr, + 713. struct acpi_dmar_hardware_unit, + +drivers/iommu/dmar.c:728: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 726. dev_name(&adev->dev), dmaru->reg_base_addr, + 727. scope->bus, path->device, path->function); + 728. > for_each_dev_scope(dmaru->devices, dmaru->devices_cnt, i, tmp) + 729. if (tmp == NULL) { + 730. dmaru->devices[i].bus = scope->bus; + +net/ipv4/ping.c:763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 761. + 762. rcu_read_lock(); + 763. > inet_opt = rcu_dereference(inet->inet_opt); + 764. if (inet_opt) { + 765. memcpy(&opt_copy, inet_opt, + +net/ipv4/ping.c:827: error: UNINITIALIZED_VALUE + The value read from user_icmph.code was never initialized. + 825. + 826. pfh.icmph.type = user_icmph.type; /* already checked */ + 827. > pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + 829. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv4/ping.c:826: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 824. lock_sock(sk); + 825. + 826. > pfh.icmph.type = user_icmph.type; /* already checked */ + 827. pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + +net/ipv4/ping.c:848: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 846. kfree(ipc.opt); + 847. if (!err) { + 848. > icmp_out_count(sock_net(sk), user_icmph.type); + 849. return len; + 850. } + +net/sunrpc/auth_gss/gss_rpc_xdr.c:711: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 709. if (!p) + 710. return -ENOSPC; + 711. > p = xdr_encode_hyper(p, cb->initiator_addrtype); + 712. + 713. /* cb->initiator_address */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:722: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 720. if (!p) + 721. return -ENOSPC; + 722. > p = xdr_encode_hyper(p, cb->acceptor_addrtype); + 723. + 724. /* cb->acceptor_address */ + +drivers/ata/libata-scsi.c:726: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 724. scsi_cmd[1] = (3 << 1); /* Non-data */ + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. > scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + +drivers/ata/libata-scsi.c:727: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. scsi_cmd[4] = args[1]; + 727. > scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + +drivers/ata/libata-scsi.c:728: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 726. scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. > scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + +drivers/ata/libata-scsi.c:729: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. > scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + +drivers/ata/libata-scsi.c:730: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. > scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:732: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. > scsi_cmd[14] = args[0]; + 733. + 734. /* Good values for timeout and retries? Values below + +net/ipv6/ip6_flowlabel.c:711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 709. + 710. for (state->bucket = 0; state->bucket <= FL_HASH_MASK; ++state->bucket) { + 711. > for_each_fl_rcu(state->bucket, fl) { + 712. if (net_eq(fl->fl_net, net)) + 713. goto out; + +net/netlabel/netlabel_cipso_v4.c:706: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 704. static int netlbl_cipsov4_remove(struct sk_buff *skb, struct genl_info *info) + 705. { + 706. > int ret_val = -EINVAL; + 707. struct netlbl_domhsh_walk_arg cb_arg; + 708. struct netlbl_audit audit_info; + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +kernel/softirq.c:714: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 712. /* Find end, append list for that CPU. */ + 713. if (&per_cpu(tasklet_vec, cpu).head != per_cpu(tasklet_vec, cpu).tail) { + 714. > *__this_cpu_read(tasklet_vec.tail) = per_cpu(tasklet_vec, cpu).head; + 715. this_cpu_write(tasklet_vec.tail, per_cpu(tasklet_vec, cpu).tail); + 716. per_cpu(tasklet_vec, cpu).head = NULL; + +kernel/softirq.c:722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 720. + 721. if (&per_cpu(tasklet_hi_vec, cpu).head != per_cpu(tasklet_hi_vec, cpu).tail) { + 722. > *__this_cpu_read(tasklet_hi_vec.tail) = per_cpu(tasklet_hi_vec, cpu).head; + 723. __this_cpu_write(tasklet_hi_vec.tail, per_cpu(tasklet_hi_vec, cpu).tail); + 724. per_cpu(tasklet_hi_vec, cpu).head = NULL; + +net/ipv6/udp.c:717: error: DEAD_STORE + The value written to &dif (type int) is never used. + 715. unsigned int offset = offsetof(typeof(*sk), sk_node); + 716. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 717. > int dif = inet6_iif(skb); + 718. struct hlist_node *node; + 719. struct sk_buff *nskb; + +net/ipv6/udp.c:715: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 713. unsigned short hnum = ntohs(uh->dest); + 714. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 715. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 716. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 717. int dif = inet6_iif(skb); + +net/ipv6/udp.c:727: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 725. start_lookup: + 726. hslot = &udptable->hash2[hash2]; + 727. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 728. } + 729. + +net/ipv6/udp.c:730: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 728. } + 729. + 730. > sk_for_each_entry_offset_rcu(sk, node, &hslot->head, offset) { + 731. if (!__udp_v6_is_mcast_sock(net, sk, uh->dest, daddr, + 732. uh->source, saddr, dif, hnum)) + +drivers/char/agp/intel-gtt.c:710: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 708. static void i830_chipset_flush(void) + 709. { + 710. > unsigned long timeout = jiffies + msecs_to_jiffies(1000); + 711. + 712. /* Forcibly evict everything from the CPU write buffers. + +include/trace/events/rcu.h:708: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 706. */ + 707. #define RCUTORTURENAME_LEN 8 + 708. > TRACE_EVENT(rcu_torture_read, + 709. + 710. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/trace/events/rcu.h:708: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 706. */ + 707. #define RCUTORTURENAME_LEN 8 + 708. > TRACE_EVENT(rcu_torture_read, + 709. + 710. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/trace/events/rcu.h:708: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 706. */ + 707. #define RCUTORTURENAME_LEN 8 + 708. > TRACE_EVENT(rcu_torture_read, + 709. + 710. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/linux/rhashtable.h:766: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 764. + 765. RCU_INIT_POINTER(list->next, plist); + 766. > head = rht_dereference_bucket(head->next, tbl, hash); + 767. RCU_INIT_POINTER(list->rhead.next, head); + 768. rcu_assign_pointer(*pprev, obj); + +include/linux/rhashtable.h:783: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 781. goto slow_path; + 782. + 783. > head = rht_dereference_bucket(*pprev, tbl, hash); + 784. + 785. RCU_INIT_POINTER(obj->next, head); + +include/linux/rhashtable.h:763: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 761. + 762. list = container_of(obj, struct rhlist_head, rhead); + 763. > plist = container_of(head, struct rhlist_head, rhead); + 764. + 765. RCU_INIT_POINTER(list->next, plist); + +include/linux/rhashtable.h:727: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 725. rcu_read_lock(); + 726. + 727. > tbl = rht_dereference_rcu(ht->tbl, ht); + 728. hash = rht_head_hashfn(ht, tbl, obj, params); + 729. lock = rht_bucket_lock(tbl, hash); + +net/wireless/scan.c:719: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 717. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); + 718. struct cfg80211_internal_bss *bss, *res = NULL; + 719. > unsigned long now = jiffies; + 720. int bss_privacy; + 721. + +net/wireless/trace.h:710: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 708. ); + 709. + 710. > DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, + 711. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 712. TP_ARGS(wiphy, netdev, mac), + +lib/swiotlb.c:766: error: UNINITIALIZED_VALUE + The value read from dev_addr was never initialized. + 764. } + 765. + 766. > *dma_handle = dev_addr; + 767. memset(ret, 0, size); + 768. + +net/ipv6/route.c:724: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 722. match = NULL; + 723. cont = NULL; + 724. > for (rt = rr_head; rt; rt = rcu_dereference(rt->dst.rt6_next)) { + 725. if (rt->rt6i_metric != metric) { + 726. cont = rt; + +net/ipv6/route.c:734: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 732. + 733. for (rt = leaf; rt && rt != rr_head; + 734. > rt = rcu_dereference(rt->dst.rt6_next)) { + 735. if (rt->rt6i_metric != metric) { + 736. cont = rt; + +net/ipv6/route.c:746: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 744. return match; + 745. + 746. > for (rt = cont; rt; rt = rcu_dereference(rt->dst.rt6_next)) + 747. match = find_match(rt, oif, strict, &mpri, match, do_rr); + 748. + +drivers/md/md.c:718: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 716. struct md_rdev *rdev; + 717. + 718. > rdev_for_each_rcu(rdev, mddev) + 719. if (rdev->bdev->bd_dev == dev) + 720. return rdev; + +kernel/signal.c:717: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 715. { + 716. const struct cred *cred = current_cred(); + 717. > const struct cred *tcred = __task_cred(t); + 718. + 719. if (uid_eq(cred->euid, tcred->suid) || + +drivers/cpufreq/cpufreq.c:715: error: UNINITIALIZED_VALUE + The value read from new_policy.min was never initialized. + 713. } + 714. + 715. > store_one(scaling_min_freq, min); + 716. store_one(scaling_max_freq, max); + 717. + +arch/x86/events/intel/p4.c:724: error: NULL_DEREFERENCE + pointer `bind` last assigned on line 723 could be null and is dereferenced at line 724, column 9. + 722. config = p4_general_events[hw_event]; + 723. bind = p4_config_get_bind(config); + 724. > esel = P4_OPCODE_ESEL(bind->opcode); + 725. config |= p4_config_pack_cccr(P4_CCCR_ESEL(esel)); + 726. + +drivers/cpufreq/cpufreq.c:716: error: UNINITIALIZED_VALUE + The value read from new_policy.max was never initialized. + 714. + 715. store_one(scaling_min_freq, min); + 716. > store_one(scaling_max_freq, max); + 717. + 718. /** + +drivers/md/dm-stats.c:729: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 727. __dm_stat_init_temporary_percpu_totals(shared, s, x); + 728. local_irq_disable(); + 729. > p = &s->stat_percpu[smp_processor_id()][x]; + 730. p->sectors[READ] -= shared->tmp.sectors[READ]; + 731. p->sectors[WRITE] -= shared->tmp.sectors[WRITE]; + +drivers/md/dm-stats.c:747: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 745. for (i = 0; i < s->n_histogram_entries + 1; i++) { + 746. local_irq_disable(); + 747. > p = &s->stat_percpu[smp_processor_id()][x]; + 748. p->histogram[i] -= shared->tmp.histogram[i]; + 749. local_irq_enable(); + +net/sunrpc/svcsock.c:753: error: DEAD_STORE + The value written to &err (type int) is never used. + 751. BUG(); + 752. } + 753. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 754. (char *)&one, sizeof(one)); + 755. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:753: error: UNINITIALIZED_VALUE + The value read from level was never initialized. + 751. BUG(); + 752. } + 753. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 754. (char *)&one, sizeof(one)); + 755. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:753: error: UNINITIALIZED_VALUE + The value read from optname was never initialized. + 751. BUG(); + 752. } + 753. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 754. (char *)&one, sizeof(one)); + 755. dprintk("svc: kernel_setsockopt returned %d\n", err); + +kernel/auditsc.c:725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 723. + 724. rcu_read_lock(); + 725. > list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) { + 726. if (audit_filter_rules(tsk, &e->rule, NULL, NULL, + 727. &state, true)) { + +kernel/trace/trace_events_trigger.c:744: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 742. goto out; + 743. assign: + 744. > tmp = rcu_access_pointer(data->filter); + 745. + 746. rcu_assign_pointer(data->filter, filter); + +kernel/trace/trace_events_trigger.c:760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 758. data->filter_str = kstrdup(filter_str, GFP_KERNEL); + 759. if (!data->filter_str) { + 760. > free_event_filter(rcu_access_pointer(data->filter)); + 761. data->filter = NULL; + 762. ret = -ENOMEM; + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +drivers/gpu/drm/drm_ioc32.c:731: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 729. return -EFAULT; + 730. + 731. > request.handle = req32.handle; + 732. request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:732: error: UNINITIALIZED_VALUE + The value read from req32.offset was never initialized. + 730. + 731. request.handle = req32.handle; + 732. > request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + 734. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +net/ipv6/ip6_flowlabel.c:726: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 724. struct net *net = seq_file_net(seq); + 725. + 726. > for_each_fl_continue_rcu(fl) { + 727. if (net_eq(fl->fl_net, net)) + 728. goto out; + +net/ipv6/ip6_flowlabel.c:733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 731. try_again: + 732. if (++state->bucket <= FL_HASH_MASK) { + 733. > for_each_fl_rcu(state->bucket, fl) { + 734. if (net_eq(fl->fl_net, net)) + 735. goto out; + +net/netfilter/nf_conntrack_core.c:748: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 746. return NF_ACCEPT; + 747. + 748. > zone = nf_ct_zone(ct); + 749. local_bh_disable(); + 750. + +drivers/usb/host/ohci-hcd.c:788: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 786. + 787. /* find the last TD processed by the controller. */ + 788. > head = hc32_to_cpu(ohci, READ_ONCE(ed->hwHeadP)) & TD_MASK; + 789. td_start = td; + 790. td_next = list_prepare_entry(td, &ed->td_list, td_list); + +net/wireless/trace.h:727: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 725. ); + 726. + 727. > DECLARE_EVENT_CLASS(station_del, + 728. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 729. struct station_del_parameters *params), + +include/trace/events/sunrpc.h:729: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 727. ); + 728. + 729. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 730. TP_PROTO(struct svc_deferred_req *dr), + 731. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:729: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 727. ); + 728. + 729. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 730. TP_PROTO(struct svc_deferred_req *dr), + 731. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:729: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 727. ); + 728. + 729. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 730. TP_PROTO(struct svc_deferred_req *dr), + 731. TP_ARGS(dr)); + +kernel/cgroup/cgroup-v1.c:749: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 747. */ + 748. rcu_read_lock(); + 749. > cgrp = rcu_dereference(*(void __rcu __force **)&kn->priv); + 750. if (!cgrp || cgroup_is_dead(cgrp)) { + 751. rcu_read_unlock(); + +arch/x86/events/amd/ibs.c:738: error: DEAD_STORE + The value written to &attr (type attribute**) is never used. + 736. if (ibs_caps & IBS_CAPS_OPCNT) { + 737. perf_ibs_op.config_mask |= IBS_OP_CNT_CTL; + 738. > *attr++ = &format_attr_cnt_ctl.attr; + 739. } + 740. perf_ibs_pmu_init(&perf_ibs_op, "ibs_op"); + +kernel/rcu/tree.c:738: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 736. + 737. lockdep_assert_irqs_disabled(); + 738. > return READ_ONCE(*fp); + 739. } + 740. + +drivers/gpu/drm/i915/i915_vma.c:775: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 773. __i915_vma_unpin(vma); + 774. if (ret) + 775. > return ret; + 776. } + 777. GEM_BUG_ON(i915_vma_is_active(vma)); + +include/trace/events/sunrpc.h:732: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 730. TP_PROTO(struct svc_deferred_req *dr), + 731. TP_ARGS(dr)); + 732. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 733. TP_PROTO(struct svc_deferred_req *dr), + 734. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:732: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 730. TP_PROTO(struct svc_deferred_req *dr), + 731. TP_ARGS(dr)); + 732. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 733. TP_PROTO(struct svc_deferred_req *dr), + 734. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:732: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 730. TP_PROTO(struct svc_deferred_req *dr), + 731. TP_ARGS(dr)); + 732. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 733. TP_PROTO(struct svc_deferred_req *dr), + 734. TP_ARGS(dr)); + +kernel/smp.c:739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 737. preempt_disable(); + 738. for_each_online_cpu(cpu) { + 739. > if (cpu == smp_processor_id()) + 740. continue; + 741. + +kernel/rcu/srcutree.c:762: error: DEAD_STORE + The value written to &t (type unsigned long) is never used. + 760. + 761. /* First, see if enough time has passed since the last GP. */ + 762. > t = ktime_get_mono_fast_ns(); + 763. if (exp_holdoff == 0 || + 764. time_in_range_open(t, sp->srcu_last_gp_end, + +drivers/iommu/intel-iommu.c:761: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 759. /* No hardware attached; use lowest common denominator */ + 760. rcu_read_lock(); + 761. > for_each_active_iommu(iommu, drhd) { + 762. if (!ecap_coherent(iommu->ecap)) { + 763. domain->iommu_coherency = 0; + +drivers/gpu/drm/i915/i915_trace.h:741: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 739. #endif + 740. + 741. > TRACE_EVENT(intel_engine_notify, + 742. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 743. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/i915_trace.h:741: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 739. #endif + 740. + 741. > TRACE_EVENT(intel_engine_notify, + 742. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 743. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/i915_trace.h:741: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 739. #endif + 740. + 741. > TRACE_EVENT(intel_engine_notify, + 742. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 743. TP_ARGS(engine, waiters), + +drivers/pcmcia/ti113x.h:780: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 778. default: + 779. if (operation == HOOK_POWER_PRE) + 780. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + +drivers/pcmcia/ti113x.h:782: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 780. mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + 783. } + 784. + +drivers/pcmcia/ds.c:776: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 774. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 775. &mfc)) + 776. > new_funcs = mfc.nfn; + 777. + 778. if (old_funcs != new_funcs) + +kernel/rcu/tree.c:758: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 756. if (!rcu_segcblist_restempty(&rdp->cblist, RCU_NEXT_READY_TAIL)) + 757. return true; /* Yes, CPU has newly registered callbacks. */ + 758. > if (rcu_segcblist_future_gp_needed(&rdp->cblist, + 759. READ_ONCE(rsp->completed))) + 760. return true; /* Yes, CBs for future grace period. */ + +drivers/gpu/drm/i915/intel_ringbuffer.h:756: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 754. * a hint and nothing more. + 755. */ + 756. > return READ_ONCE(engine->timeline->seqno); + 757. } + 758. + +net/ipv4/ipconfig.c:775: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 773. *e++ = 150; + 774. + 775. > *e++ = 255; /* End of the list */ + 776. } + 777. + +sound/core/control.c:758: error: UNINITIALIZED_VALUE + The value read from list.offset was never initialized. + 756. if (copy_from_user(&list, _list, sizeof(list))) + 757. return -EFAULT; + 758. > offset = list.offset; + 759. space = list.space; + 760. + +sound/core/control.c:759: error: UNINITIALIZED_VALUE + The value read from list.space was never initialized. + 757. return -EFAULT; + 758. offset = list.offset; + 759. > space = list.space; + 760. + 761. down_read(&card->controls_rwsem); + +drivers/video/fbdev/core/fbmem.c:795: error: DEAD_STORE + The value written to &dst (type unsigned char*) is never used. + 793. dst = buffer; + 794. fb_memcpy_fromfb(dst, src, c); + 795. > dst += c; + 796. src += c; + 797. + +lib/rhashtable.c:761: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 759. + 760. if (!iter->walker.tbl) { + 761. > iter->walker.tbl = rht_dereference_rcu(ht->tbl, ht); + 762. return -EAGAIN; + 763. } + +scripts/asn1_compiler.c:769: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 769, column 3. + 767. types = type_list = calloc(nr + 1, sizeof(type_list[0])); + 768. if (!type_list) { + 769. > perror(NULL); + 770. exit(1); + 771. } + +scripts/asn1_compiler.c:774: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 774, column 3. + 772. type_index = calloc(nr, sizeof(type_index[0])); + 773. if (!type_index) { + 774. > perror(NULL); + 775. exit(1); + 776. } + +drivers/gpu/drm/i915/intel_crt.c:824: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 822. out: + 823. intel_display_power_put(dev_priv, intel_encoder->power_domain); + 824. > return status; + 825. } + 826. + +net/ipv6/icmp.c:784: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 782. */ + 783. + 784. > ipprot = rcu_dereference(inet6_protos[nexthdr]); + 785. if (ipprot && ipprot->err_handler) + 786. ipprot->err_handler(skb, NULL, type, code, inner_offset, info); + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +lib/radix-tree.c:763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 761. if (node->count) { + 762. if (node_to_entry(node) == + 763. > rcu_dereference_raw(root->rnode)) + 764. deleted |= radix_tree_shrink(root, + 765. update_node); + +net/ipv4/tcp_metrics.c:765: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 763. + 764. rcu_read_lock(); + 765. > for (col = 0, tm = rcu_dereference(hb->chain); tm; + 766. tm = rcu_dereference(tm->tcpm_next), col++) { + 767. if (!net_eq(tm_net(tm), net)) + +net/ipv4/tcp_metrics.c:766: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 764. rcu_read_lock(); + 765. for (col = 0, tm = rcu_dereference(hb->chain); tm; + 766. > tm = rcu_dereference(tm->tcpm_next), col++) { + 767. if (!net_eq(tm_net(tm), net)) + 768. continue; + +net/ipv6/route.c:755: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 753. int oif, int strict) + 754. { + 755. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 756. struct rt6_info *match, *rt0; + 757. bool do_rr = false; + +net/ipv6/route.c:763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 761. return net->ipv6.ip6_null_entry; + 762. + 763. > rt0 = rcu_dereference(fn->rr_ptr); + 764. if (!rt0) + 765. rt0 = leaf; + +net/ipv6/route.c:784: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 782. + 783. if (do_rr) { + 784. > struct rt6_info *next = rcu_dereference(rt0->dst.rt6_next); + 785. + 786. /* no entries matched; do round-robin */ + +net/ipv4/icmp.c:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. raw_icmp_error(skb, protocol, info); + 768. + 769. > ipprot = rcu_dereference(inet_protos[protocol]); + 770. if (ipprot && ipprot->err_handler) + 771. ipprot->err_handler(skb, info); + +drivers/gpu/drm/i915/intel_breadcrumbs.c:767: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 765. + 766. if (!RB_EMPTY_NODE(&request->signaling.node)) { + 767. > if (request == rcu_access_pointer(b->first_signal)) { + 768. struct rb_node *rb = + 769. rb_next(&request->signaling.node); + +drivers/scsi/scsi_transport_spi.c:811: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 809. } + 810. } + 811. > return retval; + 812. } + 813. + +include/trace/events/rcu.h:756: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 754. * is the count of remaining callbacks, and "done" is the piggybacking count. + 755. */ + 756. > TRACE_EVENT(rcu_barrier, + 757. + 758. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/trace/events/rcu.h:756: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 754. * is the count of remaining callbacks, and "done" is the piggybacking count. + 755. */ + 756. > TRACE_EVENT(rcu_barrier, + 757. + 758. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/trace/events/rcu.h:756: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 754. * is the count of remaining callbacks, and "done" is the piggybacking count. + 755. */ + 756. > TRACE_EVENT(rcu_barrier, + 757. + 758. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +kernel/printk/printk.c:809: error: DEAD_STORE + The value written to &len (type unsigned long) is never used. + 807. facility = LOG_FACILITY(u); + 808. endp++; + 809. > len -= endp - line; + 810. line = endp; + 811. } + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +drivers/ata/ahci.c:812: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 810. + 811. DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class); + 812. > return rc; + 813. } + 814. + +drivers/gpu/drm/i915/i915_gem_userptr.c:821: error: UNINITIALIZED_VALUE + The value read from handle was never initialized. + 819. return ret; + 820. + 821. > args->handle = handle; + 822. return 0; + 823. } + +kernel/auditsc.c:771: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 769. rcu_read_lock(); + 770. if (!list_empty(list)) { + 771. > list_for_each_entry_rcu(e, list, list) { + 772. if (audit_in_mask(&e->rule, ctx->major) && + 773. audit_filter_rules(tsk, &e->rule, ctx, NULL, + +net/core/dev.c:766: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 764. struct hlist_head *head = dev_name_hash(net, name); + 765. + 766. > hlist_for_each_entry_rcu(dev, head, name_hlist) + 767. if (!strncmp(dev->name, name, IFNAMSIZ)) + 768. return dev; + +kernel/time/timer.c:769: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 767. timer->entry.pprev = NULL; + 768. timer->function = func; + 769. > timer->flags = flags | raw_smp_processor_id(); + 770. lockdep_init_map(&timer->lockdep_map, name, key, 0); + 771. } + +net/sunrpc/clnt.c:768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 766. + 767. rcu_read_lock(); + 768. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 769. rcu_read_unlock(); + 770. if (xps == NULL) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +arch/x86/events/intel/pt.c:769: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 765 could be null and is dereferenced at line 769, column 9. + 767. + 768. /* offset of the first region in this table from the beginning of buf */ + 769. > base = buf->cur->offset + buf->output_off; + 770. + 771. /* offset of the current output region within this table */ + +arch/x86/events/perf_event.h:766: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 764. u64 enable_mask) + 765. { + 766. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 767. + 768. if (hwc->extra_reg.reg) + +arch/x86/events/perf_event.h:766: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 764. u64 enable_mask) + 765. { + 766. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 767. + 768. if (hwc->extra_reg.reg) + +drivers/gpu/drm/i915/i915_trace.h:764: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 762. ); + 763. + 764. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 765. TP_PROTO(struct drm_i915_gem_request *req), + 766. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:764: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 762. ); + 763. + 764. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 765. TP_PROTO(struct drm_i915_gem_request *req), + 766. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:764: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 762. ); + 763. + 764. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 765. TP_PROTO(struct drm_i915_gem_request *req), + 766. TP_ARGS(req) + +drivers/i2c/busses/i2c-i801.c:812: error: UNINITIALIZED_VALUE + The value read from hostc was never initialized. + 810. && read_write == I2C_SMBUS_WRITE) { + 811. /* restore saved configuration register value */ + 812. > pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc); + 813. } + 814. return result; + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +drivers/gpu/drm/i915/i915_trace.h:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. ); + 768. + 769. > TRACE_EVENT(i915_gem_request_wait_begin, + 770. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 771. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:769: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 767. ); + 768. + 769. > TRACE_EVENT(i915_gem_request_wait_begin, + 770. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 771. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:769: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 767. ); + 768. + 769. > TRACE_EVENT(i915_gem_request_wait_begin, + 770. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 771. TP_ARGS(req, flags), + +drivers/iommu/intel-iommu.c:777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 775. + 776. rcu_read_lock(); + 777. > for_each_active_iommu(iommu, drhd) { + 778. if (iommu != skip) { + 779. if (!ecap_sc_support(iommu->ecap)) { + +kernel/rcu/tree.c:781: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 779. !user && !is_idle_task(current)) { + 780. struct task_struct *idle __maybe_unused = + 781. > idle_task(smp_processor_id()); + 782. + 783. trace_rcu_dyntick(TPS("Error on entry: not idle task"), rdtp->dynticks_nesting, 0); + +kernel/rcu/tree.c:781: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 779. !user && !is_idle_task(current)) { + 780. struct task_struct *idle __maybe_unused = + 781. > idle_task(smp_processor_id()); + 782. + 783. trace_rcu_dyntick(TPS("Error on entry: not idle task"), rdtp->dynticks_nesting, 0); + +drivers/gpu/drm/i915/intel_lrc.c:827: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 825. + 826. head = execlists->csb_head; + 827. > tail = READ_ONCE(buf[write_idx]); + 828. } + 829. + +drivers/gpu/drm/i915/intel_lrc.c:855: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 853. */ + 854. + 855. > status = READ_ONCE(buf[2 * head]); /* maybe mmio! */ + 856. if (!(status & GEN8_CTX_STATUS_COMPLETED_MASK)) + 857. continue; + +net/wireless/trace.h:772: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +lib/iov_iter.c:786: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 784. return 0; + 785. } + 786. > iterate_all_kinds(i, bytes, v, + 787. copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len), + 788. memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page, + +net/ipv4/fib_semantics.c:856: error: UNINITIALIZED_VALUE + The value read from res.scope was never initialized. + 854. goto out; + 855. } + 856. > nh->nh_scope = res.scope; + 857. nh->nh_oif = FIB_RES_OIF(res); + 858. nh->nh_dev = dev = FIB_RES_DEV(res); + +drivers/usb/core/usb.c:777: error: DEAD_STORE + The value written to &jiffies_expire (type unsigned long) is never used. + 775. const struct usb_interface *iface) + 776. { + 777. > unsigned long jiffies_expire = jiffies + HZ; + 778. + 779. if (udev->state == USB_STATE_NOTATTACHED) + +net/ipv4/icmp.c:779: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 777. + 778. rcu_read_lock(); + 779. > ok = rcu_dereference(inet_protos[proto])->icmp_strict_tag_validation; + 780. rcu_read_unlock(); + 781. return ok; + +net/wireless/util.c:778: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 776. const struct cfg80211_bss_ies *ies; + 777. + 778. > ies = rcu_dereference(bss->ies); + 779. if (!ies) + 780. return NULL; + +net/core/net-sysfs.c:782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 780. + 781. rcu_read_lock(); + 782. > flow_table = rcu_dereference(queue->rps_flow_table); + 783. if (flow_table) + 784. val = (unsigned long)flow_table->mask + 1; + +net/ipv4/tcp_input.c:799: error: DEAD_STORE + The value written to &rate (type unsigned long long) is never used. + 797. + 798. if (likely(tp->srtt_us)) + 799. > do_div(rate, tp->srtt_us); + 800. + 801. /* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate + +lib/rhashtable.c:790: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 788. + 789. if (p) { + 790. > if (!rhlist || !(list = rcu_dereference(list->next))) { + 791. p = rcu_dereference(p->next); + 792. list = container_of(p, struct rhlist_head, rhead); + +lib/rhashtable.c:791: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 789. if (p) { + 790. if (!rhlist || !(list = rcu_dereference(list->next))) { + 791. > p = rcu_dereference(p->next); + 792. list = container_of(p, struct rhlist_head, rhead); + 793. } + +lib/rhashtable.c:800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 798. int skip = iter->skip; + 799. + 800. > rht_for_each_rcu(p, tbl, iter->slot) { + 801. if (rhlist) { + 802. list = container_of(p, struct rhlist_head, + +lib/rhashtable.c:808: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 806. goto next; + 807. skip--; + 808. > list = rcu_dereference(list->next); + 809. } while (list); + 810. + +lib/rhashtable.c:834: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 832. smp_rmb(); + 833. + 834. > iter->walker.tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 835. if (iter->walker.tbl) { + 836. iter->slot = 0; + +net/wireless/sme.c:850: error: DEAD_STORE + The value written to &next (type unsigned char*) is never used. + 848. ev->cr.pmkid = next; + 849. memcpy((void *)ev->cr.pmkid, params->pmkid, WLAN_PMKID_LEN); + 850. > next += WLAN_PMKID_LEN; + 851. } + 852. ev->cr.update_erp_next_seq_num = params->update_erp_next_seq_num; + +drivers/ata/libata-scsi.c:789: error: DEAD_STORE + The value written to &rc (type int) is never used. + 787. { + 788. unsigned long val; + 789. > int rc = -EINVAL; + 790. unsigned long flags; + 791. + +drivers/input/serio/i8042.c:787: error: DEAD_STORE + The value written to &retval (type int) is never used. + 785. static int __init i8042_check_aux(void) + 786. { + 787. > int retval = -1; + 788. bool irq_registered = false; + 789. bool aux_loop_broken = false; + +tools/lib/subcmd/parse-options.c:788: error: DEAD_STORE + The value written to &o (type option const *) is never used. + 786. { + 787. int nr_opts = 0, len; + 788. > const struct option *o = opts; + 789. struct option *ordered; + 790. + +drivers/gpu/drm/drm_dp_mst_topology.c:796: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 794. * provided by the wake_up/wait_event pair are enough. + 795. */ + 796. > state = READ_ONCE(txmsg->state); + 797. return (state == DRM_DP_SIDEBAND_TX_RX || + 798. state == DRM_DP_SIDEBAND_TX_TIMEOUT); + +drivers/gpu/drm/i915/intel_runtime_pm.c:811: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 809. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 810. + 811. > if (wait_for(COND, 100)) + 812. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 813. state, + +drivers/char/agp/frontend.c:795: error: UNINITIALIZED_VALUE + The value read from mode.agp_mode was never initialized. + 793. return -EFAULT; + 794. + 795. > agp_enable(agp_bridge, mode.agp_mode); + 796. return 0; + 797. } + +kernel/auditsc.c:800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 798. return 0; + 799. + 800. > list_for_each_entry_rcu(e, list, list) { + 801. if (audit_in_mask(&e->rule, ctx->major) && + 802. audit_filter_rules(tsk, &e->rule, ctx, n, &state, false)) { + +drivers/iommu/intel-iommu.c:802: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 800. /* set iommu_superpage to the smallest common denominator */ + 801. rcu_read_lock(); + 802. > for_each_active_iommu(iommu, drhd) { + 803. if (iommu != skip) { + 804. mask &= cap_super_page_val(iommu->cap); + +kernel/trace/trace.c:796: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 794. + 795. /* If this is the temp buffer, we need to commit fully */ + 796. > if (this_cpu_read(trace_buffered_event) == event) { + 797. /* Length is in event->array[0] */ + 798. ring_buffer_write(buffer, event->array[0], &event->array[1]); + +net/ipv4/fib_frontend.c:811: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 809. e = 0; + 810. head = &net->ipv4.fib_table_hash[h]; + 811. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 812. if (e < s_e) + 813. goto next; + +sound/pci/hda/hda_controller.c:802: error: DEAD_STORE + The value written to &loopcounter (type unsigned long) is never used. + 800. timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. > for (loopcounter = 0;; loopcounter++) { + 803. spin_lock_irq(&bus->reg_lock); + 804. if (chip->polling_mode || do_poll) + +sound/pci/hda/hda_controller.c:800: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 798. + 799. again: + 800. > timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. for (loopcounter = 0;; loopcounter++) { + +drivers/md/md.c:810: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 806 could be null and is dereferenced at line 810, column 2. + 808. atomic_inc(&rdev->nr_pending); + 809. + 810. > bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev); + 811. bio->bi_iter.bi_sector = sector; + 812. bio_add_page(bio, page, size, 0); + +drivers/gpu/drm/i915/intel_audio.c:818: error: DEAD_STORE + The value written to &pipe (type int) is never used. + 816. /* pipe passed from the audio driver will be -1 for Non-MST case */ + 817. crtc = to_intel_crtc(intel_encoder->base.crtc); + 818. > pipe = crtc->pipe; + 819. + 820. adjusted_mode = &crtc->config->base.adjusted_mode; + +net/core/fib_rules.c:816: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 814. + 815. if (rule->action == FR_ACT_GOTO && + 816. > rcu_access_pointer(rule->ctarget) == NULL) + 817. frh->flags |= FIB_RULE_UNRESOLVED; + 818. + +net/wireless/trace.h:793: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +block/blk-mq.c:799: error: DEAD_STORE + The value written to &data (type blk_mq_timeout_data*) is never used. + 797. struct request *rq, void *priv, bool reserved) + 798. { + 799. > struct blk_mq_timeout_data *data = priv; + 800. unsigned long deadline; + 801. + +block/blk-mq.c:811: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 809. smp_rmb(); + 810. + 811. > deadline = READ_ONCE(rq->deadline); + 812. + 813. /* + +arch/x86/pci/mmconfig-shared.c:804: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 802. + 803. mutex_lock(&pci_mmcfg_lock); + 804. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) + 805. if (cfg->segment == seg && cfg->start_bus == start && + 806. cfg->end_bus == end) { + +drivers/char/agp/frontend.c:812: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 810. return -EFAULT; + 811. + 812. > client = agp_find_client_by_pid(reserve.pid); + 813. + 814. if (reserve.seg_count == 0) { + +drivers/char/agp/frontend.c:816: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 814. if (reserve.seg_count == 0) { + 815. /* remove a client */ + 816. > client_priv = agp_find_private(reserve.pid); + 817. + 818. if (client_priv != NULL) { + +drivers/char/agp/frontend.c:826: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 824. return 0; + 825. } + 826. > return agp_remove_client(reserve.pid); + 827. } else { + 828. struct agp_segment *segment; + +drivers/char/agp/frontend.c:848: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 846. if (client == NULL) { + 847. /* Create the client and add the segment */ + 848. > client = agp_create_client(reserve.pid); + 849. + 850. if (client == NULL) { + +drivers/char/agp/frontend.c:854: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 852. return -ENOMEM; + 853. } + 854. > client_priv = agp_find_private(reserve.pid); + 855. + 856. if (client_priv != NULL) { + +kernel/time/posix-cpu-timers.c:820: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 818. tsk_expires->virt_exp = expires; + 819. + 820. > tsk_expires->sched_exp = check_timers_list(++timers, firing, + 821. tsk->se.sum_exec_runtime); + 822. + +drivers/usb/mon/mon_bin.c:849: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 847. } + 848. nbytes -= step_len; + 849. > buf += step_len; + 850. rp->b_read += step_len; + 851. done += step_len; + +drivers/usb/mon/mon_bin.c:848: error: DEAD_STORE + The value written to &nbytes (type unsigned long) is never used. + 846. return -EFAULT; + 847. } + 848. > nbytes -= step_len; + 849. buf += step_len; + 850. rp->b_read += step_len; + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +drivers/gpu/drm/i915/i915_trace.h:803: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 801. ); + 802. + 803. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 804. TP_PROTO(struct drm_i915_gem_request *req), + 805. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 801. ); + 802. + 803. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 804. TP_PROTO(struct drm_i915_gem_request *req), + 805. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 801. ); + 802. + 803. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 804. TP_PROTO(struct drm_i915_gem_request *req), + 805. TP_ARGS(req) + +kernel/resource.c:824: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 822. } + 823. + 824. > for (next = first; ; next = next->sibling) { + 825. /* Partial overlap? Bad, and unfixable */ + 826. if (next->start < new->start || next->end > new->end) + +kernel/resource.c:836: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 834. new->parent = parent; + 835. new->sibling = next->sibling; + 836. > new->child = first; + 837. + 838. next->sibling = NULL; + +kernel/resource.c:839: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 837. + 838. next->sibling = NULL; + 839. > for (next = first; next; next = next->sibling) + 840. next->parent = new; + 841. + +kernel/signal.c:824: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 822. siginitset(&flush, sigmask(SIGCONT)); + 823. flush_sigqueue_mask(&flush, &signal->shared_pending); + 824. > for_each_thread(p, t) + 825. flush_sigqueue_mask(&flush, &t->pending); + 826. } else if (sig == SIGCONT) { + +kernel/signal.c:833: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 831. siginitset(&flush, SIG_KERNEL_STOP_MASK); + 832. flush_sigqueue_mask(&flush, &signal->shared_pending); + 833. > for_each_thread(p, t) { + 834. flush_sigqueue_mask(&flush, &t->pending); + 835. task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING); + +net/ipv4/ipmr.c:821: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 819. goto out; + 820. + 821. > now = jiffies; + 822. expires = 10*HZ; + 823. + +drivers/base/power/wakeup.c:814: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 812. + 813. srcuidx = srcu_read_lock(&wakeup_srcu); + 814. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) { + 815. if (ws->active) { + 816. pr_debug("active wakeup source: %s\n", ws->name); + +arch/x86/events/intel/pt.c:832: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 832, column 32. + 830. */ + 831. if (!pt_cap_get(PT_CAP_topa_multiple_entries) || + 832. > buf->output_off == sizes(TOPA_ENTRY(buf->cur, buf->cur_idx)->size)) { + 833. perf_aux_output_flag(&pt->handle, + 834. PERF_AUX_FLAG_TRUNCATED); + +arch/x86/events/intel/pt.c:843: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 843, column 52. + 841. * before the output reaches its output region's boundary. + 842. */ + 843. > if (!pt_cap_get(PT_CAP_topa_multiple_entries) && !buf->snapshot && + 844. pt_buffer_region_size(buf) - buf->output_off <= TOPA_PMI_MARGIN) { + 845. void *head = pt_buffer_region(buf); + +lib/radix-tree.c:831: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 829. return error; + 830. shift = error; + 831. > child = rcu_dereference_raw(root->rnode); + 832. } + 833. + +net/wireless/trace.h:810: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 808. ); + 809. + 810. > DECLARE_EVENT_CLASS(mpath_evt, + 811. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 812. u8 *next_hop), + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +net/netfilter/nf_conntrack_netlink.c:819: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 817. struct hlist_nulls_node *n; + 818. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 819. > u_int8_t l3proto = nfmsg->nfgen_family; + 820. struct nf_conn *nf_ct_evict[8]; + 821. int res, i; + +net/netfilter/nf_conntrack_netlink.c:814: error: DEAD_STORE + The value written to &net (type net*) is never used. + 812. ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) + 813. { + 814. > struct net *net = sock_net(skb->sk); + 815. struct nf_conn *ct, *last; + 816. struct nf_conntrack_tuple_hash *h; + +net/wireless/scan.c:822: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 820. u32 n_entries = 0; + 821. + 822. > ies = rcu_access_pointer(new->pub.beacon_ies); + 823. if (WARN_ON(!ies)) + 824. return false; + +net/wireless/scan.c:856: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 854. if (bss->pub.scan_width != new->pub.scan_width) + 855. continue; + 856. > if (rcu_access_pointer(bss->pub.beacon_ies)) + 857. continue; + 858. ies = rcu_access_pointer(bss->pub.ies); + +net/wireless/scan.c:858: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 856. if (rcu_access_pointer(bss->pub.beacon_ies)) + 857. continue; + 858. > ies = rcu_access_pointer(bss->pub.ies); + 859. if (!ies) + 860. continue; + +drivers/video/fbdev/core/fbmem.c:873: error: DEAD_STORE + The value written to &src (type unsigned char*) is never used. + 871. fb_memcpy_tofb(dst, src, c); + 872. dst += c; + 873. > src += c; + 874. *ppos += c; + 875. buf += c; + +net/xfrm/xfrm_state.c:826: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 824. struct xfrm_state *x; + 825. + 826. > hlist_for_each_entry_rcu(x, net->xfrm.state_byspi + h, byspi) { + 827. if (x->props.family != family || + 828. x->id.spi != spi || + +drivers/net/ethernet/intel/e1000e/ich8lan.c:891: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 889. + 890. data &= ~I82579_LPI_100_PLL_SHUT; + 891. > ret_val = e1000_write_emi_reg_locked(hw, I82579_LPI_PLL_SHUT, + 892. data); + 893. } + +net/netfilter/nfnetlink_log.c:860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 858. + 859. if ((flags & NFULNL_CFG_F_CONNTRACK) && + 860. > !rcu_access_pointer(nfnl_ct_hook)) { + 861. #ifdef CONFIG_MODULES + 862. nfnl_unlock(NFNL_SUBSYS_ULOG); + +net/netfilter/nfnetlink_log.c:865: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 863. request_module("ip_conntrack_netlink"); + 864. nfnl_lock(NFNL_SUBSYS_ULOG); + 865. > if (rcu_access_pointer(nfnl_ct_hook)) { + 866. ret = -EAGAIN; + 867. goto out_put; + +kernel/kprobes.c:838: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 836. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 837. head = &kprobe_table[i]; + 838. > hlist_for_each_entry_rcu(p, head, hlist) + 839. if (!kprobe_disabled(p)) + 840. optimize_kprobe(p); + +drivers/scsi/scsi_sysfs.c:826: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 824. }; + 825. + 826. > sdev_vpd_pg_attr(pg83); + 827. sdev_vpd_pg_attr(pg80); + 828. + +drivers/scsi/scsi_sysfs.c:827: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 825. + 826. sdev_vpd_pg_attr(pg83); + 827. > sdev_vpd_pg_attr(pg80); + 828. + 829. static ssize_t show_inquiry(struct file *filep, struct kobject *kobj, + +net/ipv4/tcp_metrics.c:859: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 857. ret = -ESRCH; + 858. rcu_read_lock(); + 859. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 860. tm = rcu_dereference(tm->tcpm_next)) { + 861. if (addr_same(&tm->tcpm_daddr, &daddr) && + +net/ipv4/tcp_metrics.c:860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 858. rcu_read_lock(); + 859. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 860. > tm = rcu_dereference(tm->tcpm_next)) { + 861. if (addr_same(&tm->tcpm_daddr, &daddr) && + 862. (!src || addr_same(&tm->tcpm_saddr, &saddr)) && + +kernel/trace/trace_uprobe.c:840: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 838. + 839. rcu_read_lock(); + 840. > list_for_each_entry_rcu(link, &tu->tp.files, list) + 841. __uprobe_trace_func(tu, 0, regs, ucb, dsize, link->file); + 842. rcu_read_unlock(); + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +drivers/md/md.c:842: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 838 could be null and is dereferenced at line 842, column 3. + 840. + 841. if (metadata_op && rdev->meta_bdev) + 842. > bio_set_dev(bio, rdev->meta_bdev); + 843. else + 844. bio_set_dev(bio, rdev->bdev); + +drivers/md/md.c:844: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 838 could be null and is dereferenced at line 844, column 3. + 842. bio_set_dev(bio, rdev->meta_bdev); + 843. else + 844. > bio_set_dev(bio, rdev->bdev); + 845. bio_set_op_attrs(bio, op, op_flags); + 846. if (metadata_op) + +net/core/dev.c:840: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 838. struct hlist_head *head = dev_index_hash(net, ifindex); + 839. + 840. > hlist_for_each_entry_rcu(dev, head, index_hlist) + 841. if (dev->ifindex == ifindex) + 842. return dev; + +scripts/kconfig/zconf.lex.c_shipped:847: error: NULL_DEREFERENCE + pointer `text` last assigned on line 842 could be null and is dereferenced at line 847, column 2. + 845. memcpy(text + text_size, str, size); + 846. text_size += size; + 847. > text[text_size] = 0; + 848. } + 849. + +drivers/pci/pci-sysfs.c:904: error: DEAD_STORE + The value written to &off (type long long) is never used. + 902. pci_user_read_config_byte(dev, off, &val); + 903. data[off - init_off] = val; + 904. > off++; + 905. --size; + 906. } + +drivers/pci/pci-sysfs.c:905: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 903. data[off - init_off] = val; + 904. off++; + 905. > --size; + 906. } + 907. + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +scripts/asn1_compiler.c:843: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 843, column 3. + 841. struct element *e = calloc(1, sizeof(*e)); + 842. if (!e) { + 843. > perror(NULL); + 844. exit(1); + 845. } + +drivers/gpu/drm/i915/intel_ringbuffer.h:842: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 840. static inline bool intel_engine_has_waiter(const struct intel_engine_cs *engine) + 841. { + 842. > return READ_ONCE(engine->breadcrumbs.irq_wait); + 843. } + 844. + +net/netfilter/nf_conntrack_sip.c:913: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 911. + 912. if (direct_rtp) { + 913. > hooks = rcu_dereference(nf_nat_sip_hooks); + 914. if (hooks && + 915. !hooks->sdp_port(skb, protoff, dataoff, dptr, datalen, + +net/netfilter/nf_conntrack_sip.c:935: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 933. IPPROTO_UDP, NULL, &rtcp_port); + 934. + 935. > hooks = rcu_dereference(nf_nat_sip_hooks); + 936. if (hooks && ct->status & IPS_NAT_MASK && !direct_rtp) + 937. ret = hooks->sdp_media(skb, protoff, dataoff, dptr, + +net/netfilter/nf_conntrack_core.c:853: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 851. struct nf_conn *ct; + 852. + 853. > zone = nf_ct_zone(ignored_conntrack); + 854. + 855. rcu_read_lock(); + +net/netfilter/nf_conntrack_core.c:860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 858. hash = __hash_conntrack(net, tuple, hsize); + 859. + 860. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[hash], hnnode) { + 861. ct = nf_ct_tuplehash_to_ctrack(h); + 862. + +kernel/time/time.c:854: error: UNINITIALIZED_VALUE + The value read from kts.tv_nsec was never initialized. + 852. + 853. ts->tv_sec = kts.tv_sec; + 854. > ts->tv_nsec = kts.tv_nsec; + 855. + 856. return 0; + +kernel/time/time.c:853: error: UNINITIALIZED_VALUE + The value read from kts.tv_sec was never initialized. + 851. return -EFAULT; + 852. + 853. > ts->tv_sec = kts.tv_sec; + 854. ts->tv_nsec = kts.tv_nsec; + 855. + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/xfrm/xfrm_state.c:851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 849. struct xfrm_state *x; + 850. + 851. > hlist_for_each_entry_rcu(x, net->xfrm.state_bysrc + h, bysrc) { + 852. if (x->props.family != family || + 853. x->id.proto != proto || + +drivers/gpu/drm/i915/i915_trace.h:844: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 842. ); + 843. + 844. > TRACE_EVENT_CONDITION(i915_reg_rw, + 845. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 846. + +drivers/gpu/drm/i915/i915_trace.h:844: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 842. ); + 843. + 844. > TRACE_EVENT_CONDITION(i915_reg_rw, + 845. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 846. + +drivers/gpu/drm/i915/i915_trace.h:844: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 842. ); + 843. + 844. > TRACE_EVENT_CONDITION(i915_reg_rw, + 845. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 846. + +net/sunrpc/rpcb_clnt.c:858: error: NULL_DEREFERENCE + pointer `p` last assigned on line 858 could be null and is dereferenced at line 858, column 2. + 856. + 857. p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2); + 858. > *p++ = cpu_to_be32(rpcb->r_prog); + 859. *p++ = cpu_to_be32(rpcb->r_vers); + 860. *p++ = cpu_to_be32(rpcb->r_prot); + +kernel/trace/trace_uprobe.c:854: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 852. + 853. rcu_read_lock(); + 854. > list_for_each_entry_rcu(link, &tu->tp.files, list) + 855. __uprobe_trace_func(tu, func, regs, ucb, dsize, link->file); + 856. rcu_read_unlock(); + +drivers/gpu/drm/i915/intel_breadcrumbs.c:855: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 853. WARN_ON(READ_ONCE(b->irq_wait)); + 854. WARN_ON(!RB_EMPTY_ROOT(&b->waiters)); + 855. > WARN_ON(rcu_access_pointer(b->first_signal)); + 856. WARN_ON(!RB_EMPTY_ROOT(&b->signals)); + 857. + +kernel/kprobes.c:865: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 863. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 864. head = &kprobe_table[i]; + 865. > hlist_for_each_entry_rcu(p, head, hlist) { + 866. if (!kprobe_disabled(p)) + 867. unoptimize_kprobe(p, false); + +drivers/char/agp/generic.c:867: error: DEAD_STORE + The value written to &size (type int) is never used. + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + 867. > size = page_order = num_entries = 0; + 868. + 869. if (bridge->driver->size_type != FIXED_APER_SIZE) { + +drivers/char/agp/generic.c:873: error: DEAD_STORE + The value written to &size (type int) is never used. + 871. switch (bridge->driver->size_type) { + 872. case U8_APER_SIZE: + 873. > size = A_SIZE_8(temp)->size; + 874. page_order = + 875. A_SIZE_8(temp)->page_order; + +drivers/char/agp/generic.c:880: error: DEAD_STORE + The value written to &size (type int) is never used. + 878. break; + 879. case U16_APER_SIZE: + 880. > size = A_SIZE_16(temp)->size; + 881. page_order = A_SIZE_16(temp)->page_order; + 882. num_entries = A_SIZE_16(temp)->num_entries; + +drivers/char/agp/generic.c:885: error: DEAD_STORE + The value written to &size (type int) is never used. + 883. break; + 884. case U32_APER_SIZE: + 885. > size = A_SIZE_32(temp)->size; + 886. page_order = A_SIZE_32(temp)->page_order; + 887. num_entries = A_SIZE_32(temp)->num_entries; + +drivers/char/agp/generic.c:893: error: DEAD_STORE + The value written to &size (type int) is never used. + 891. case LVL2_APER_SIZE: + 892. default: + 893. > size = page_order = num_entries = 0; + 894. break; + 895. } + +drivers/char/agp/generic.c:923: error: DEAD_STORE + The value written to &size (type int) is never used. + 921. } while (!table && (i < bridge->driver->num_aperture_sizes)); + 922. } else { + 923. > size = ((struct aper_size_info_fixed *) temp)->size; + 924. page_order = ((struct aper_size_info_fixed *) temp)->page_order; + 925. num_entries = ((struct aper_size_info_fixed *) temp)->num_entries; + +net/wireless/trace.h:849: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +kernel/sched/sched.h:853: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 851. static inline u64 __rq_clock_broken(struct rq *rq) + 852. { + 853. > return READ_ONCE(rq->clock); + 854. } + 855. + +kernel/time/tick-sched.c:884: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 882. return false; + 883. + 884. > if (unlikely(local_softirq_pending() && cpu_online(cpu))) { + 885. static int ratelimit; + 886. + +kernel/time/tick-sched.c:888: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 886. + 887. if (ratelimit < 10 && + 888. > (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +net/ipv4/ip_output.c:1095: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1093. cork->length -= length; + 1094. IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS); + 1095. > return err; + 1096. } + 1097. + +drivers/usb/host/ehci-hub.c:1108: error: DEAD_STORE + The value written to &temp1 (type unsigned int) is never used. + 1106. // status may be from integrated TT + 1107. if (ehci->has_hostpc) { + 1108. > temp1 = ehci_readl(ehci, hostpc_reg); + 1109. status |= ehci_port_speed(ehci, temp1); + 1110. } else + +kernel/sched/topology.c:890: error: NULL_DEREFERENCE + pointer `last` last assigned on line 863 could be null and is dereferenced at line 890, column 2. + 888. last = sg; + 889. } + 890. > last->next = first; + 891. sd->groups = first; + 892. + +drivers/iommu/intel-iommu.c:893: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 891. + 892. rcu_read_lock(); + 893. > for_each_active_iommu(iommu, drhd) { + 894. if (pdev && segment != drhd->segment) + 895. continue; + +drivers/iommu/intel-iommu.c:897: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 895. continue; + 896. + 897. > for_each_active_dev_scope(drhd->devices, + 898. drhd->devices_cnt, i, tmp) { + 899. if (tmp == dev) { + +kernel/sys.c:866: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 864. + 865. rcu_read_lock(); + 866. > pid = task_tgid_vnr(rcu_dereference(current->real_parent)); + 867. rcu_read_unlock(); + 868. + +drivers/gpu/drm/i915/intel_breadcrumbs.c:876: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 874. } + 875. + 876. > if (rcu_access_pointer(b->first_signal)) { + 877. wake_up_process(b->signaler); + 878. busy = true; + +drivers/usb/class/usblp.c:899: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 897. set_current_state(TASK_RUNNING); + 898. remove_wait_queue(&usblp->wwait, &waita); + 899. > return rc; + 900. } + 901. + +kernel/time/timer.c:877: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 875. return; + 876. + 877. > jnow = READ_ONCE(jiffies); + 878. base->must_forward_clk = base->is_idle; + 879. if ((long)(jnow - base->clk) < 2) + +net/core/fib_rules.c:873: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 871. + 872. rcu_read_lock(); + 873. > list_for_each_entry_rcu(rule, &ops->rules_list, list) { + 874. if (idx < cb->args[1]) + 875. goto skip; + +net/ipv4/udp.c:966: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 964. + 965. rcu_read_lock(); + 966. > inet_opt = rcu_dereference(inet->inet_opt); + 967. if (inet_opt) { + 968. memcpy(&opt_copy, inet_opt, + +net/ipv4/route.c:884: error: DEAD_STORE + The value written to &log_martians (type int) is never used. + 882. return; + 883. } + 884. > log_martians = IN_DEV_LOG_MARTIANS(in_dev); + 885. vif = l3mdev_master_ifindex_rcu(rt->dst.dev); + 886. rcu_read_unlock(); + +net/sunrpc/clnt.c:884: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 882. rpc_free_iostats(clnt->cl_metrics); + 883. clnt->cl_metrics = NULL; + 884. > xprt_put(rcu_dereference_raw(clnt->cl_xprt)); + 885. xprt_iter_destroy(&clnt->cl_xpi); + 886. rpciod_down(); + +lib/radix-tree.c:876: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 874. + 875. for (;;) { + 876. > void *entry = rcu_dereference_raw(child->slots[offset]); + 877. if (radix_tree_is_internal_node(entry) && + 878. !is_sibling_entry(child, entry)) { + +drivers/gpu/drm/drm_ioc32.c:892: error: UNINITIALIZED_VALUE + The value read from req64.fb_id was never initialized. + 890. return err; + 891. + 892. > if (put_user(req64.fb_id, &argp->fb_id)) + 893. return -EFAULT; + 894. + +drivers/gpu/drm/i915/i915_trace.h:872: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 870. ); + 871. + 872. > TRACE_EVENT(intel_gpu_freq_change, + 873. TP_PROTO(u32 freq), + 874. TP_ARGS(freq), + +drivers/gpu/drm/i915/i915_trace.h:872: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 870. ); + 871. + 872. > TRACE_EVENT(intel_gpu_freq_change, + 873. TP_PROTO(u32 freq), + 874. TP_ARGS(freq), + +drivers/gpu/drm/i915/i915_trace.h:872: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 870. ); + 871. + 872. > TRACE_EVENT(intel_gpu_freq_change, + 873. TP_PROTO(u32 freq), + 874. TP_ARGS(freq), + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +net/wireless/trace.h:873: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +net/ipv6/ip6_fib.c:1061: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1059. iter->rt6i_node = NULL; + 1060. fib6_purge_rt(iter, fn, info->nl_net); + 1061. > if (rcu_access_pointer(fn->rr_ptr) == iter) + 1062. fn->rr_ptr = NULL; + 1063. rt6_release(iter); + +net/ipv6/ip6_fib.c:1077: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1075. iter->rt6i_node = NULL; + 1076. fib6_purge_rt(iter, fn, info->nl_net); + 1077. > if (rcu_access_pointer(fn->rr_ptr) == iter) + 1078. fn->rr_ptr = NULL; + 1079. rt6_release(iter); + +net/netfilter/x_tables.c:896: error: UNINITIALIZED_VALUE + The value read from compat_tmp.num_counters was never initialized. + 894. + 895. memcpy(info->name, compat_tmp.name, sizeof(info->name) - 1); + 896. > info->num_counters = compat_tmp.num_counters; + 897. user += sizeof(compat_tmp); + 898. } else + +kernel/workqueue.c:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. + 893. /* this can only happen on the local cpu */ + 894. > if (WARN_ON_ONCE(pool->cpu != raw_smp_processor_id())) + 895. return NULL; + 896. + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +net/ipv6/route.c:890: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 888. if (fn->fn_flags & RTN_TL_ROOT) + 889. return NULL; + 890. > pn = rcu_dereference(fn->parent); + 891. sn = FIB6_SUBTREE(pn); + 892. if (sn && sn != fn) + +net/wireless/scan.c:900: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 898. spin_lock_bh(&rdev->bss_lock); + 899. + 900. > if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) { + 901. spin_unlock_bh(&rdev->bss_lock); + 902. return NULL; + +net/wireless/scan.c:909: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 907. if (found) { + 908. /* Update IEs */ + 909. > if (rcu_access_pointer(tmp->pub.proberesp_ies)) { + 910. const struct cfg80211_bss_ies *old; + 911. + +net/wireless/scan.c:912: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 910. const struct cfg80211_bss_ies *old; + 911. + 912. > old = rcu_access_pointer(found->pub.proberesp_ies); + 913. + 914. rcu_assign_pointer(found->pub.proberesp_ies, + +net/wireless/scan.c:922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 920. kfree_rcu((struct cfg80211_bss_ies *)old, + 921. rcu_head); + 922. > } else if (rcu_access_pointer(tmp->pub.beacon_ies)) { + 923. const struct cfg80211_bss_ies *old; + 924. struct cfg80211_internal_bss *bss; + +net/wireless/scan.c:940: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 938. */ + 939. + 940. > f = rcu_access_pointer(tmp->pub.beacon_ies); + 941. kfree_rcu((struct cfg80211_bss_ies *)f, + 942. rcu_head); + +net/wireless/scan.c:946: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 944. } + 945. + 946. > old = rcu_access_pointer(found->pub.beacon_ies); + 947. + 948. rcu_assign_pointer(found->pub.beacon_ies, + +net/wireless/scan.c:952: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 950. + 951. /* Override IEs if they were from a beacon before */ + 952. > if (old == rcu_access_pointer(found->pub.ies)) + 953. rcu_assign_pointer(found->pub.ies, + 954. tmp->pub.beacon_ies); + +net/wireless/scan.c:961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 959. const struct cfg80211_bss_ies *ies; + 960. + 961. > ies = rcu_access_pointer(bss->pub.beacon_ies); + 962. WARN_ON(ies != old); + 963. + +net/wireless/scan.c:998: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 996. GFP_ATOMIC); + 997. if (!new) { + 998. > ies = (void *)rcu_dereference(tmp->pub.beacon_ies); + 999. if (ies) + 1000. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:1001: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 999. if (ies) + 1000. kfree_rcu(ies, rcu_head); + 1001. > ies = (void *)rcu_dereference(tmp->pub.proberesp_ies); + 1002. if (ies) + 1003. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:1010: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1008. INIT_LIST_HEAD(&new->hidden_list); + 1009. + 1010. > if (rcu_access_pointer(tmp->pub.proberesp_ies)) { + 1011. hidden = rb_find_bss(rdev, tmp, BSS_CMP_HIDE_ZLEN); + 1012. if (!hidden) + +net/sunrpc/cache.c:894: error: DEAD_STORE + The value written to &ret (type long) is never used. + 892. struct page *page; + 893. char *kaddr; + 894. > ssize_t ret = -ENOMEM; + 895. + 896. if (count >= PAGE_SIZE) + +kernel/cgroup/cgroup-v1.c:897: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 895 could be null and is dereferenced at line 897, column 25. + 895. for_each_subsys(ss, ssid) + 896. if (root->subsys_mask & (1 << ssid)) + 897. > seq_show_option(seq, ss->legacy_name, NULL); + 898. if (root->flags & CGRP_ROOT_NOPREFIX) + 899. seq_puts(seq, ",noprefix"); + +drivers/md/dm.c:902: error: DEAD_STORE + The value written to &offset (type unsigned long) is never used. + 900. offset = dm_target_offset(ti, sector); + 901. if (unlikely(ti->max_io_len & (ti->max_io_len - 1))) + 902. > max_len = sector_div(offset, ti->max_io_len); + 903. else + 904. max_len = offset & (ti->max_io_len - 1); + +net/core/fib_rules.c:911: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 909. + 910. rcu_read_lock(); + 911. > list_for_each_entry_rcu(ops, &net->rules_ops, list) { + 912. if (idx < cb->args[0] || !try_module_get(ops->owner)) + 913. goto skip; + +drivers/net/ethernet/intel/e1000e/82571.c:919: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 917. } else { + 918. data &= ~IGP02E1000_PM_D0_LPLU; + 919. > ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data); + 920. /* LPLU and SmartSpeed are mutually exclusive. LPLU is used + 921. * during Dx states where the power conservation is most + +net/ipv4/igmp.c:906: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 904. + 905. rcu_read_lock(); + 906. > for_each_pmc_rcu(in_dev, im) { + 907. if (im->multiaddr == group) { + 908. igmp_stop_timer(im); + +net/netfilter/nf_conntrack_core.c:901: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 899. struct nf_conn *tmp; + 900. + 901. > hlist_nulls_for_each_entry_rcu(h, n, head, hnnode) { + 902. tmp = nf_ct_tuplehash_to_ctrack(h); + 903. + +kernel/trace/ring_buffer.c:907: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 905. val &= ~RB_FLAG_MASK; + 906. + 907. > ret = cmpxchg((unsigned long *)&list->next, + 908. val | old_flag, val | new_flag); + 909. + +net/wireless/trace.h:894: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +drivers/hid/hid-ntrig.c:956: error: DEAD_STORE + The value written to &ret (type int) is never used. + 954. ntrig_report_version(hdev); + 955. + 956. > ret = sysfs_create_group(&hdev->dev.kobj, + 957. &ntrig_attribute_group); + 958. + +kernel/time/posix-cpu-timers.c:932: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 930. prof_expires = check_timers_list(timers, firing, ptime); + 931. virt_expires = check_timers_list(++timers, firing, utime); + 932. > sched_expires = check_timers_list(++timers, firing, sum_sched_runtime); + 933. + 934. /* + +net/ipv4/tcp_output.c:933: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 931. + 932. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 933. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 934. if (nval != oval) + 935. continue; + +net/ipv4/tcp_output.c:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. goto out; + 924. + 925. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 926. struct tsq_tasklet *tsq; + 927. bool empty; + +drivers/gpu/drm/drm_plane.c:915: error: DEAD_STORE + The value written to &ret (type int) is never used. + 913. u32 target_vblank = page_flip->sequence; + 914. struct drm_modeset_acquire_ctx ctx; + 915. > int ret = -EINVAL; + 916. + 917. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +net/core/neighbour.c:917: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 915. state = neigh->nud_state; + 916. now = jiffies; + 917. > next = now + HZ; + 918. + 919. if (!(state & NUD_IN_TIMER)) + +net/core/neighbour.c:926: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 924. neigh->confirmed + neigh->parms->reachable_time)) { + 925. neigh_dbg(2, "neigh %p is still alive\n", neigh); + 926. > next = neigh->confirmed + neigh->parms->reachable_time; + 927. } else if (time_before_eq(now, + 928. neigh->used + + +net/core/neighbour.c:934: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 932. neigh->updated = jiffies; + 933. neigh_suspect(neigh); + 934. > next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); + 935. } else { + 936. neigh_dbg(2, "neigh %p is suspected\n", neigh); + +net/core/neighbour.c:951: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 949. neigh_connect(neigh); + 950. notify = 1; + 951. > next = neigh->confirmed + neigh->parms->reachable_time; + 952. } else { + 953. neigh_dbg(2, "neigh %p is probed\n", neigh); + +net/core/neighbour.c:958: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 956. atomic_set(&neigh->probes, 0); + 957. notify = 1; + 958. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 959. } + 960. } else { + +net/core/neighbour.c:962: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 960. } else { + 961. /* NUD_PROBE|NUD_INCOMPLETE */ + 962. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 963. } + 964. + +net/ipv6/udp.c:918: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 916. struct sock *sk; + 917. + 918. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 919. if (sk->sk_state == TCP_ESTABLISHED && + 920. INET6_MATCH(sk, net, rmt_addr, loc_addr, ports, dif, sdif)) + +net/ipv4/tcp_ipv4.c:919: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 917. + 918. /* caller either holds rcu_read_lock() or socket lock */ + 919. > md5sig = rcu_dereference_check(tp->md5sig_info, + 920. lockdep_sock_is_held(sk)); + 921. if (!md5sig) + +net/ipv4/tcp_ipv4.c:924: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 922. return NULL; + 923. + 924. > hlist_for_each_entry_rcu(key, &md5sig->head, node) { + 925. if (key->family != family) + 926. continue; + +net/sunrpc/rpcb_clnt.c:920: error: NULL_DEREFERENCE + pointer `p` last assigned on line 919 could be null and is dereferenced by call to `xdr_encode_opaque()` at line 920, column 2. + 918. len = maxstrlen; + 919. p = xdr_reserve_space(xdr, 4 + len); + 920. > xdr_encode_opaque(p, string, len); + 921. } + 922. + +include/net/sock.h:912: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 910. static inline void sk_incoming_cpu_update(struct sock *sk) + 911. { + 912. > int cpu = raw_smp_processor_id(); + 913. + 914. if (unlikely(sk->sk_incoming_cpu != cpu)) + +include/net/sock.h:912: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 910. static inline void sk_incoming_cpu_update(struct sock *sk) + 911. { + 912. > int cpu = raw_smp_processor_id(); + 913. + 914. if (unlikely(sk->sk_incoming_cpu != cpu)) + +drivers/pci/pci-sysfs.c:965: error: DEAD_STORE + The value written to &off (type long long) is never used. + 963. if (size) { + 964. pci_user_write_config_byte(dev, off, data[off - init_off]); + 965. > off++; + 966. --size; + 967. } + +drivers/pci/pci-sysfs.c:966: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 964. pci_user_write_config_byte(dev, off, data[off - init_off]); + 965. off++; + 966. > --size; + 967. } + 968. + +drivers/usb/early/ehci-dbgp.c:954: error: DEAD_STORE + The value written to &ret (type int) is never used. + 952. } + 953. if (chunk > 0) { + 954. > ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, + 955. dbgp_endpoint_out, buf, chunk); + 956. } + +kernel/time/timer.c:926: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 924. * and spin_lock(). + 925. */ + 926. > tf = READ_ONCE(timer->flags); + 927. + 928. if (!(tf & TIMER_MIGRATING)) { + +drivers/gpu/drm/i915/i915_trace.h:914: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 912. ) + 913. + 914. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 915. TP_PROTO(struct i915_address_space *vm), + 916. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:914: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 912. ) + 913. + 914. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 915. TP_PROTO(struct i915_address_space *vm), + 916. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:914: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 912. ) + 913. + 914. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 915. TP_PROTO(struct i915_address_space *vm), + 916. TP_ARGS(vm) + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +drivers/char/agp/frontend.c:924: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 922. return -EFAULT; + 923. + 924. > memory = agp_find_mem_by_key(bind_info.key); + 925. + 926. if (memory == NULL) + +drivers/char/agp/frontend.c:929: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 927. return -EINVAL; + 928. + 929. > return agp_bind_memory(memory, bind_info.pg_start); + 930. } + 931. + +net/ipv4/igmp.c:1004: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1002. */ + 1003. rcu_read_lock(); + 1004. > for_each_pmc_rcu(in_dev, im) { + 1005. int changed; + 1006. + +include/net/sock.h:924: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 922. + 923. rcu_read_lock(); + 924. > sock_flow_table = rcu_dereference(rps_sock_flow_table); + 925. rps_record_sock_flow(sock_flow_table, hash); + 926. rcu_read_unlock(); + +kernel/cgroup/cgroup-v1.c:922: error: DEAD_STORE + The value written to &mask (type unsigned short) is never used. + 920. char *token, *o = data; + 921. bool all_ss = false, one_ss = false; + 922. > u16 mask = U16_MAX; + 923. struct cgroup_subsys *ss; + 924. int nr_opts = 0; + +net/ipv6/route.c:928: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 926. fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); + 927. restart: + 928. > rt = rcu_dereference(fn->leaf); + 929. if (!rt) { + 930. rt = net->ipv6.ip6_null_entry; + +net/wireless/trace.h:918: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +drivers/gpu/drm/i915/i915_trace.h:919: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 917. ); + 918. + 919. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 920. TP_PROTO(struct i915_address_space *vm), + 921. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:919: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 917. ); + 918. + 919. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 920. TP_PROTO(struct i915_address_space *vm), + 921. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:919: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 917. ); + 918. + 919. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 920. TP_PROTO(struct i915_address_space *vm), + 921. TP_ARGS(vm) + +net/core/ethtool.c:931: error: UNINITIALIZED_VALUE + The value read from info.sset_mask was never initialized. + 929. + 930. /* store copy of mask, because we zero struct later on */ + 931. > sset_mask = info.sset_mask; + 932. if (!sset_mask) + 933. return 0; + +net/sunrpc/rpcb_clnt.c:936: error: NULL_DEREFERENCE + pointer `p` last assigned on line 936 could be null and is dereferenced at line 936, column 2. + 934. + 935. p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2); + 936. > *p++ = cpu_to_be32(rpcb->r_prog); + 937. *p = cpu_to_be32(rpcb->r_vers); + 938. + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +drivers/iommu/iommu.c:945: error: UNINITIALIZED_VALUE + The value read from data.group was never initialized. + 943. */ + 944. if (pci_for_each_dma_alias(pdev, get_pci_alias_or_group, &data)) + 945. > return data.group; + 946. + 947. pdev = data.pdev; + +drivers/iommu/iommu.c:947: error: UNINITIALIZED_VALUE + The value read from data.pdev was never initialized. + 945. return data.group; + 946. + 947. > pdev = data.pdev; + 948. + 949. /* + +drivers/usb/class/usblp.c:951: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 949. set_current_state(TASK_RUNNING); + 950. remove_wait_queue(&usblp->rwait, &waita); + 951. > return rc; + 952. } + 953. + +net/ipv6/udp.c:956: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 954. skb->sk = sk; + 955. skb->destructor = sock_efree; + 956. > dst = READ_ONCE(sk->sk_rx_dst); + 957. + 958. if (dst) + +net/xfrm/xfrm_state.c:953: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 951. rcu_read_lock(); + 952. h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, encap_family); + 953. > hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h, bydst) { + 954. if (x->props.family == encap_family && + 955. x->props.reqid == tmpl->reqid && + +net/xfrm/xfrm_state.c:969: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 967. + 968. h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, encap_family); + 969. > hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h_wildcard, bydst) { + 970. if (x->props.family == encap_family && + 971. x->props.reqid == tmpl->reqid && + +kernel/rcu/tree.c:942: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 940. !user && !is_idle_task(current)) { + 941. struct task_struct *idle __maybe_unused = + 942. > idle_task(smp_processor_id()); + 943. + 944. trace_rcu_dyntick(TPS("Error on exit: not idle task"), + +kernel/rcu/tree.c:942: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 940. !user && !is_idle_task(current)) { + 941. struct task_struct *idle __maybe_unused = + 942. > idle_task(smp_processor_id()); + 943. + 944. trace_rcu_dyntick(TPS("Error on exit: not idle task"), + +drivers/char/agp/frontend.c:941: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 939. return -EFAULT; + 940. + 941. > memory = agp_find_mem_by_key(unbind.key); + 942. + 943. if (memory == NULL) + +drivers/net/ethernet/broadcom/tg3.c:954: error: DEAD_STORE + The value written to &apedata (type unsigned int) is never used. + 952. APE_HOST_SEG_LEN_MAGIC); + 953. apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT); + 954. > tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata); + 955. tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID, + 956. APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM)); + +net/ipv4/fib_trie.c:948: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 946. do { + 947. pn = n; + 948. > n = get_child_rcu(n, index); + 949. + 950. if (!n) + +drivers/gpu/drm/i915/intel_dpio_phy.c:947: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 944 could be null and is dereferenced at line 947, column 6. + 945. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 946. + 947. > if (dport->release_cl2_override) { + 948. chv_phy_powergate_ch(dev_priv, DPIO_PHY0, DPIO_CH1, false); + 949. dport->release_cl2_override = false; + +net/core/dev.c:951: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 949. struct net_device *dev; + 950. + 951. > for_each_netdev_rcu(net, dev) + 952. if (dev->type == type && + 953. !memcmp(dev->dev_addr, ha, dev->addr_len)) + +drivers/usb/core/hub.c:956: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 955 could be null and is dereferenced at line 956, column 9. + 954. return -EINVAL; + 955. hub = usb_hub_to_struct_hub(udev->parent); + 956. > intf = to_usb_interface(hub->intfdev); + 957. + 958. usb_autopm_get_interface(intf); + +net/ipv4/tcp_ipv4.c:959: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 957. + 958. /* caller either holds rcu_read_lock() or socket lock */ + 959. > md5sig = rcu_dereference_check(tp->md5sig_info, + 960. lockdep_sock_is_held(sk)); + 961. if (!md5sig) + +net/ipv4/tcp_ipv4.c:967: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 965. size = sizeof(struct in6_addr); + 966. #endif + 967. > hlist_for_each_entry_rcu(key, &md5sig->head, node) { + 968. if (key->family != family) + 969. continue; + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +net/netlabel/netlabel_domainhash.c:965: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 963. rcu_read_lock(); + 964. for (iter_bkt = *skip_bkt; + 965. > iter_bkt < rcu_dereference(netlbl_domhsh)->size; + 966. iter_bkt++, chain_cnt = 0) { + 967. iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + +net/netlabel/netlabel_domainhash.c:967: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 965. iter_bkt < rcu_dereference(netlbl_domhsh)->size; + 966. iter_bkt++, chain_cnt = 0) { + 967. > iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + 968. list_for_each_entry_rcu(iter_entry, iter_list, list) + 969. if (iter_entry->valid) { + +net/netlabel/netlabel_domainhash.c:968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 966. iter_bkt++, chain_cnt = 0) { + 967. iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + 968. > list_for_each_entry_rcu(iter_entry, iter_list, list) + 969. if (iter_entry->valid) { + 970. if (chain_cnt++ < *skip_chain) + +drivers/gpu/drm/i915/i915_trace.h:953: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 951. ) + 952. + 953. > DEFINE_EVENT(i915_context, i915_context_create, + 954. TP_PROTO(struct i915_gem_context *ctx), + 955. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:953: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 951. ) + 952. + 953. > DEFINE_EVENT(i915_context, i915_context_create, + 954. TP_PROTO(struct i915_gem_context *ctx), + 955. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:953: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 951. ) + 952. + 953. > DEFINE_EVENT(i915_context, i915_context_create, + 954. TP_PROTO(struct i915_gem_context *ctx), + 955. TP_ARGS(ctx) + +net/ipv4/tcp_output.c:968: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 966. + 967. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 968. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 969. if (nval != oval) + 970. continue; + +net/ipv4/tcp_output.c:960: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 958. unsigned long nval, oval; + 959. + 960. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 961. struct tsq_tasklet *tsq; + 962. bool empty; + +net/ipv4/ipconfig.c:1015: error: DEAD_STORE + The value written to &h (type iphdr*) is never used. + 1013. + 1014. b = (struct bootp_pkt *)skb_network_header(skb); + 1015. > h = &b->iph; + 1016. + 1017. /* One reply at a time, please. */ + +net/wireless/trace.h:956: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +drivers/gpu/drm/i915/i915_trace.h:958: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 956. ); + 957. + 958. > DEFINE_EVENT(i915_context, i915_context_free, + 959. TP_PROTO(struct i915_gem_context *ctx), + 960. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:958: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 956. ); + 957. + 958. > DEFINE_EVENT(i915_context, i915_context_free, + 959. TP_PROTO(struct i915_gem_context *ctx), + 960. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:958: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 956. ); + 957. + 958. > DEFINE_EVENT(i915_context, i915_context_free, + 959. TP_PROTO(struct i915_gem_context *ctx), + 960. TP_ARGS(ctx) + +net/ipv4/netfilter/ip_tables.c:985: error: DEAD_STORE + The value written to &ret (type int) is never used. + 983. + 984. if (compat) { + 985. > ret = compat_table_info(private, &tmp); + 986. xt_compat_flush_offsets(AF_INET); + 987. private = &tmp; + +drivers/i2c/i2c-core-base.c:987: error: DEAD_STORE + The value written to &blank (type char*) is never used. + 985. + 986. /* Parse remaining parameters, reject extra parameters */ + 987. > res = sscanf(++blank, "%hi%c", &info.addr, &end); + 988. if (res < 1) { + 989. dev_err(dev, "%s: Can't parse I2C address\n", "new_device"); + +net/netfilter/nfnetlink_log.c:976: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 974. + 975. if (!hlist_empty(head)) + 976. > return rcu_dereference_bh(hlist_first_rcu(head)); + 977. } + 978. return NULL; + +drivers/gpu/drm/i915/i915_trace.h:970: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 968. * called only if full ppgtt is enabled. + 969. */ + 970. > TRACE_EVENT(switch_mm, + 971. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 972. + +drivers/gpu/drm/i915/i915_trace.h:970: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 968. * called only if full ppgtt is enabled. + 969. */ + 970. > TRACE_EVENT(switch_mm, + 971. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 972. + +drivers/gpu/drm/i915/i915_trace.h:970: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 968. * called only if full ppgtt is enabled. + 969. */ + 970. > TRACE_EVENT(switch_mm, + 971. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 972. + +drivers/usb/core/sysfs.c:977: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 975. + 976. intf = to_usb_interface(dev); + 977. > string = READ_ONCE(intf->cur_altsetting->string); + 978. if (!string) + 979. return 0; + +net/core/skbuff.c:1000: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 998. uarg->len++; + 999. uarg->bytelen = bytelen; + 1000. > atomic_set(&sk->sk_zckey, ++next); + 1001. sock_zerocopy_get(uarg); + 1002. return uarg; + +ipc/msg.c:1091: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1089. * signal) it will either see the message and continue ... + 1090. */ + 1091. > msg = READ_ONCE(msr_d.r_msg); + 1092. if (msg != ERR_PTR(-EAGAIN)) + 1093. goto out_unlock1; + +net/core/dev.c:978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 976. + 977. rcu_read_lock(); + 978. > for_each_netdev_rcu(net, dev) + 979. if (dev->type == type) { + 980. dev_hold(dev); + +net/wireless/trace.h:973: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +net/ipv6/netfilter/ip6_tables.c:1003: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1001. + 1002. if (compat) { + 1003. > ret = compat_table_info(private, &tmp); + 1004. xt_compat_flush_offsets(AF_INET6); + 1005. private = &tmp; + +kernel/fork.c:986: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 984. * this mm -- see comment above for justification. + 985. */ + 986. > old_exe_file = rcu_dereference_raw(mm->exe_file); + 987. + 988. if (new_exe_file) + +net/netfilter/nf_conntrack_core.c:992: error: DEAD_STORE + The value written to &nf_conntrack_max95 (type unsigned int) is never used. + 990. i = gc_work->last_bucket; + 991. if (gc_work->early_drop) + 992. > nf_conntrack_max95 = nf_conntrack_max / 100u * 95u; + 993. + 994. do { + +net/netfilter/nf_conntrack_core.c:1008: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1006. i = 0; + 1007. + 1008. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[i], hnnode) { + 1009. struct net *net; + 1010. + +net/netfilter/nf_conntrack_sip.c:996: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 994. int ret = NF_ACCEPT; + 995. + 996. > hooks = rcu_dereference(nf_nat_sip_hooks); + 997. + 998. /* Find beginning of session description */ + +net/netfilter/nf_conntrack_sip.c:1079: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1077. + 1078. /* Update session connection and owner addresses */ + 1079. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1080. if (hooks && ct->status & IPS_NAT_MASK) + 1081. ret = hooks->sdp_session(skb, protoff, dataoff, + +net/netfilter/nfnetlink_log.c:984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 982. struct hlist_node *h) + 983. { + 984. > h = rcu_dereference_bh(hlist_next_rcu(h)); + 985. while (!h) { + 986. struct nfnl_log_net *log; + +net/netfilter/nfnetlink_log.c:994: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 992. log = nfnl_log_pernet(net); + 993. head = &log->instance_table[st->bucket]; + 994. > h = rcu_dereference_bh(hlist_first_rcu(head)); + 995. } + 996. return h; + +drivers/usb/core/sysfs.c:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. intf = to_usb_interface(dev); + 992. udev = interface_to_usbdev(intf); + 993. > alt = READ_ONCE(intf->cur_altsetting); + 994. + 995. return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" + +drivers/usb/mon/mon_bin.c:1067: error: UNINITIALIZED_VALUE + The value read from getb.alloc was never initialized. + 1065. if (getb.alloc > 0x10000000) /* Want to cast to u32 */ + 1066. return -EINVAL; + 1067. > ret = mon_bin_get_event(file, rp, getb.hdr, + 1068. (cmd == MON_IOCX_GET)? PKT_SZ_API0: PKT_SZ_API1, + 1069. getb.data, (unsigned int)getb.alloc); + +drivers/usb/mon/mon_bin.c:1090: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch was never initialized. + 1088. return -EFAULT; + 1089. } + 1090. > ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch); + 1091. if (ret < 0) + 1092. return ret; + +drivers/usb/mon/mon_bin.c:1084: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush was never initialized. + 1082. + 1083. if (mfetch.nflush) { + 1084. > ret = mon_bin_flush(rp, mfetch.nflush); + 1085. if (ret < 0) + 1086. return ret; + +drivers/gpu/drm/i915/intel_dpio_phy.c:993: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 992 could be null and is dereferenced by call to `vlv_dport_to_channel()` at line 993, column 27. + 991. struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc); + 992. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 993. > enum dpio_channel port = vlv_dport_to_channel(dport); + 994. int pipe = intel_crtc->pipe; + 995. + +drivers/cdrom/cdrom.c:1025: error: UNINITIALIZED_VALUE + The value read from entry.cdte_ctrl was never initialized. + 1023. tracks->audio++; + 1024. } + 1025. > cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n", + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + +drivers/cdrom/cdrom.c:1009: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk0 was never initialized. + 1007. /* check what type of tracks are on this disc */ + 1008. entry.cdte_format = CDROM_MSF; + 1009. > for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) { + 1010. entry.cdte_track = i; + 1011. if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) { + +drivers/cdrom/cdrom.c:1028: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk1 was never initialized. + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + 1028. > cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n", + 1029. header.cdth_trk1, tracks->audio, tracks->data, + 1030. tracks->cdi, tracks->xa); + +drivers/gpu/drm/i915/i915_gem_gtt.c:1040: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1038. kunmap_atomic(vaddr); + 1039. + 1040. > return ret; + 1041. } + 1042. + +kernel/trace/ring_buffer.c:1000: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 998. val |= RB_PAGE_HEAD; + 999. + 1000. > ret = cmpxchg(ptr, val, (unsigned long)&new->list); + 1001. + 1002. return ret == val; + +net/ipv4/tcp_output.c:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. static bool tcp_needs_internal_pacing(const struct sock *sk) + 992. { + 993. > return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED; + 994. } + 995. + +kernel/relay.c:997: error: DEAD_STORE + The value written to &consumed (type unsigned long) is never used. + 995. size_t n_subbufs = buf->chan->n_subbufs; + 996. size_t produced = buf->subbufs_produced; + 997. > size_t consumed = buf->subbufs_consumed; + 998. + 999. relay_file_read_consume(buf, read_pos, 0); + +kernel/trace/trace_events.c:997: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 995. { + 996. struct trace_array *tr = m->private; + 997. > struct trace_pid_list *pid_list = rcu_dereference_sched(tr->filtered_pids); + 998. + 999. return trace_pid_next(pid_list, v, pos); + +kernel/trace/trace_kprobe.c:998: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 996. struct event_file_link *link; + 997. + 998. > list_for_each_entry_rcu(link, &tk->tp.files, list) + 999. __kprobe_trace_func(tk, regs, link->file); + 1000. } + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +net/wireless/trace.h:993: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +security/selinux/ss/policydb.c:1006: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1004. + 1005. rc = -EINVAL; + 1006. > items = le32_to_cpu(buf[0]); + 1007. if (items > ARRAY_SIZE(buf)) { + 1008. printk(KERN_ERR "SELinux: mls: range overflow\n"); + +security/selinux/ss/policydb.c:1018: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1016. } + 1017. + 1018. > r->level[0].sens = le32_to_cpu(buf[0]); + 1019. if (items > 1) + 1020. r->level[1].sens = le32_to_cpu(buf[1]); + +security/selinux/ss/policydb.c:1020: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1018. r->level[0].sens = le32_to_cpu(buf[0]); + 1019. if (items > 1) + 1020. > r->level[1].sens = le32_to_cpu(buf[1]); + 1021. else + 1022. r->level[1].sens = r->level[0].sens; + +security/selinux/avc.c:1022: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1020. node = avc_lookup(ssid, tsid, tclass); + 1021. if (unlikely(!node)) { + 1022. > node = avc_compute_av(ssid, tsid, tclass, &avd, xp_node); + 1023. } else { + 1024. memcpy(&avd, &node->ae.avd, sizeof(avd)); + +security/selinux/avc.c:1049: error: UNINITIALIZED_VALUE + The value read from avd.seqno was never initialized. + 1047. &local_xpd); + 1048. rcu_read_lock(); + 1049. > avc_update_node(AVC_CALLBACK_ADD_XPERMS, requested, driver, xperm, + 1050. ssid, tsid, tclass, avd.seqno, &local_xpd, 0); + 1051. } else { + +kernel/fork.c:1006: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1004. + 1005. rcu_read_lock(); + 1006. > exe_file = rcu_dereference(mm->exe_file); + 1007. if (exe_file && !get_file_rcu(exe_file)) + 1008. exe_file = NULL; + +kernel/trace/trace_events.c:1017: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1015. rcu_read_lock_sched(); + 1016. + 1017. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 1018. + 1019. if (!pid_list) + +drivers/pci/pci.c:1027: error: DEAD_STORE + The value written to &i (type int) is never used. + 1025. pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]); + 1026. pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]); + 1027. > pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]); + 1028. + 1029. return 0; + +drivers/video/fbdev/core/fbmon.c:1074: error: UNINITIALIZED_VALUE + The value read from svd[_] was never initialized. + 1072. + 1073. for (i = specs->modedb_len + num; i < specs->modedb_len + num + svd_n; i++) { + 1074. > int idx = svd[i - specs->modedb_len - num]; + 1075. if (!idx || idx >= ARRAY_SIZE(cea_modes)) { + 1076. pr_warn("Reserved SVD code %d\n", idx); + +arch/x86/events/core.c:1013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1011. + 1012. hwc->idx = cpuc->assign[i]; + 1013. > hwc->last_cpu = smp_processor_id(); + 1014. hwc->last_tag = ++cpuc->tags[i]; + 1015. + +arch/x86/events/core.c:1013: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1011. + 1012. hwc->idx = cpuc->assign[i]; + 1013. > hwc->last_cpu = smp_processor_id(); + 1014. hwc->last_tag = ++cpuc->tags[i]; + 1015. + +net/ipv6/ipv6_sockglue.c:1296: error: UNINITIALIZED_VALUE + The value read from freq.flr_flags was never initialized. + 1294. + 1295. len = sizeof(freq); + 1296. > flags = freq.flr_flags; + 1297. + 1298. memset(&freq, 0, sizeof(freq)); + +drivers/gpu/drm/i915/i915_gem_request.c:1023: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1021. * stop busywaiting, see busywait_stop(). + 1022. */ + 1023. > *cpu = get_cpu(); + 1024. t = local_clock() >> 10; + 1025. put_cpu(); + +drivers/gpu/drm/i915/i915_gem_request.c:1023: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1021. * stop busywaiting, see busywait_stop(). + 1022. */ + 1023. > *cpu = get_cpu(); + 1024. t = local_clock() >> 10; + 1025. put_cpu(); + +include/linux/rhashtable.h:1047: error: DEAD_STORE + The value written to &list (type rhlist_head*) is never used. + 1045. continue; + 1046. + 1047. > list = rht_dereference_bucket(list->next, tbl, hash); + 1048. RCU_INIT_POINTER(*lpprev, list); + 1049. err = 0; + +net/wireless/trace.h:1012: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +arch/x86/events/intel/ds.c:1067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1065. if (!kernel_ip(ip)) { + 1066. int bytes; + 1067. > u8 *buf = this_cpu_read(insn_buffer); + 1068. + 1069. /* 'size' must fit our buffer, see above */ + +arch/x86/events/intel/ds.c:1067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1065. if (!kernel_ip(ip)) { + 1066. int bytes; + 1067. > u8 *buf = this_cpu_read(insn_buffer); + 1068. + 1069. /* 'size' must fit our buffer, see above */ + +drivers/gpu/drm/i915/intel_display.c:1024: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 1022. static void wait_for_pipe_scanline_moving(struct intel_crtc *crtc, bool state) + 1023. { + 1024. > struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 1025. enum pipe pipe = crtc->pipe; + 1026. + +drivers/gpu/drm/i915/intel_display.c:1028: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1026. + 1027. /* Wait for the display line to settle/start moving */ + 1028. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1029. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1030. pipe_name(pipe), onoff(state)); + +net/ipv4/ping.c:1027: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1025. struct sock *sk; + 1026. struct ping_iter_state *state = seq->private; + 1027. > struct net *net = seq_file_net(seq); + 1028. + 1029. for (state->bucket = start; state->bucket < PING_HTABLE_SIZE; + +lib/vsprintf.c:1060: error: UNINITIALIZED_VALUE + The value read from zerolength[_] was never initialized. + 1058. for (i = 0; i < range; i++) { + 1059. if (zerolength[i] > longest) { + 1060. > longest = zerolength[i]; + 1061. colonpos = i; + 1062. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1067: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1065. if ((hw->mac_type == e1000_82545_rev_3) || + 1066. (hw->mac_type == e1000_82546_rev_3)) { + 1067. > ret_val = + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1070: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + 1070. > ret_val = + 1071. e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); + 1072. } + +net/xfrm/xfrm_user.c:1031: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1029. u32 pid, unsigned int group) + 1030. { + 1031. > struct sock *nlsk = rcu_dereference(net->xfrm.nlsk); + 1032. + 1033. if (nlsk) + +arch/x86/events/core.c:1035: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1033. { + 1034. return hwc->idx == cpuc->assign[i] && + 1035. > hwc->last_cpu == smp_processor_id() && + 1036. hwc->last_tag == cpuc->tags[i]; + 1037. } + +drivers/nvmem/core.c:1052: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1050. + 1051. /* setup the first byte with lsb bits from nvmem */ + 1052. > rc = nvmem_reg_read(nvmem, cell->offset, &v, 1); + 1053. *b++ |= GENMASK(bit_offset - 1, 0) & v; + 1054. + +drivers/nvmem/core.c:1069: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1067. if ((nbits + bit_offset) % BITS_PER_BYTE) { + 1068. /* setup the last byte with msb bits from nvmem */ + 1069. > rc = nvmem_reg_read(nvmem, + 1070. cell->offset + cell->bytes - 1, &v, 1); + 1071. *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v; + +drivers/pci/pci.c:1049: error: DEAD_STORE + The value written to &i (type int) is never used. + 1047. pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]); + 1048. pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]); + 1049. > pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]); + 1050. } + 1051. + +drivers/gpu/drm/i915/i915_gem.c:1088: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1086. * page_length = bytes to copy for this page + 1087. */ + 1088. > u32 page_base = node.start; + 1089. unsigned page_offset = offset_in_page(offset); + 1090. unsigned page_length = PAGE_SIZE - page_offset; + +drivers/base/power/wakeup.c:1046: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1044. + 1045. srcuidx = srcu_read_lock(&wakeup_srcu); + 1046. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 1047. print_wakeup_source_stats(m, ws); + 1048. srcu_read_unlock(&wakeup_srcu, srcuidx); + +net/ipv6/tcp_ipv6.c:1072: error: DEAD_STORE + The value written to &newinet (type inet_sock*) is never used. + 1070. inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; + 1071. + 1072. > newinet = inet_sk(newsk); + 1073. newnp = inet6_sk(newsk); + 1074. newtp = tcp_sk(newsk); + +net/ipv6/tcp_ipv6.c:1179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1177. opt = ireq->ipv6_opt; + 1178. if (!opt) + 1179. > opt = rcu_dereference(np->opt); + 1180. if (opt) { + 1181. opt = ipv6_dup_options(newsk, opt); + +drivers/gpu/drm/i915/intel_dpio_phy.c:1054: error: DEAD_STORE + The value written to &val (type unsigned int) is never used. + 1052. + 1053. /* Enable clock channels for this port */ + 1054. > val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(port)); + 1055. val = 0; + 1056. if (pipe) + +kernel/sched/sched.h:1045: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1043. struct sched_domain *sd, *hsd = NULL; + 1044. + 1045. > for_each_domain(cpu, sd) { + 1046. if (!(sd->flags & flag)) + 1047. break; + +drivers/gpu/drm/i915/intel_dp.c:1148: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1146. + 1147. if ((status & DP_AUX_CH_CTL_DONE) == 0) { + 1148. > DRM_ERROR("dp_aux_ch not done status 0x%08x\n", status); + 1149. ret = -EBUSY; + 1150. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1158: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1156. */ + 1157. if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) { + 1158. > DRM_ERROR("dp_aux_ch receive error status 0x%08x\n", status); + 1159. ret = -EIO; + 1160. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1166: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1164. * "normal" -- don't fill the kernel log with these */ + 1165. if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) { + 1166. > DRM_DEBUG_KMS("dp_aux_ch timeout status 0x%08x\n", status); + 1167. ret = -ETIMEDOUT; + 1168. goto out; + +kernel/trace/trace_kprobe.c:1048: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1046. struct event_file_link *link; + 1047. + 1048. > list_for_each_entry_rcu(link, &tk->tp.files, list) + 1049. __kretprobe_trace_func(tk, ri, regs, link->file); + 1050. } + +net/wireless/trace.h:1042: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/ipv6/route.c:1061: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1060 could be null and is dereferenced by call to `dev_net()` at line 1061, column 23. + 1059. rcu_read_lock(); + 1060. dev = ip6_rt_get_dev_rcu(ort); + 1061. > rt = __ip6_dst_alloc(dev_net(dev), dev, 0); + 1062. rcu_read_unlock(); + 1063. if (!rt) + +kernel/kprobes.c:1052: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1050. struct kprobe *kp; + 1051. + 1052. > list_for_each_entry_rcu(kp, &p->list, list) { + 1053. if (kp->pre_handler && likely(!kprobe_disabled(kp))) { + 1054. set_kprobe_instance(kp); + +net/ipv4/inet_connection_sock.c:1059: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1057. + 1058. rcu_read_lock(); + 1059. > inet_opt = rcu_dereference(inet->inet_opt); + 1060. if (inet_opt && inet_opt->opt.srr) + 1061. daddr = inet_opt->opt.faddr; + +kernel/exit.c:1055: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1053. int state, status; + 1054. pid_t pid = task_pid_vnr(p); + 1055. > uid_t uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1056. struct waitid_info *infop; + 1057. + +kernel/sched/sched.h:1058: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1056. struct sched_domain *sd; + 1057. + 1058. > for_each_domain(cpu, sd) { + 1059. if (sd->flags & flag) + 1060. break; + +security/selinux/ss/policydb.c:1066: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1064. goto out; + 1065. } + 1066. > c->user = le32_to_cpu(buf[0]); + 1067. c->role = le32_to_cpu(buf[1]); + 1068. c->type = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1067: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1065. } + 1066. c->user = le32_to_cpu(buf[0]); + 1067. > c->role = le32_to_cpu(buf[1]); + 1068. c->type = le32_to_cpu(buf[2]); + 1069. if (p->policyvers >= POLICYDB_VERSION_MLS) { + +security/selinux/ss/policydb.c:1068: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1066. c->user = le32_to_cpu(buf[0]); + 1067. c->role = le32_to_cpu(buf[1]); + 1068. > c->type = le32_to_cpu(buf[2]); + 1069. if (p->policyvers >= POLICYDB_VERSION_MLS) { + 1070. rc = mls_read_range_helper(&c->range, fp); + +kernel/time/tick-sched.c:1071: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1069. + 1070. if (ts->idle_active) + 1071. > tick_nohz_stop_idle(ts, now); + 1072. + 1073. if (ts->tick_stopped) { + +kernel/time/tick-sched.c:1074: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1072. + 1073. if (ts->tick_stopped) { + 1074. > tick_nohz_restart_sched_tick(ts, now); + 1075. tick_nohz_account_idle_ticks(ts); + 1076. } + +drivers/dma-buf/dma-buf.c:1097: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1095. seq = read_seqcount_begin(&robj->seq); + 1096. rcu_read_lock(); + 1097. > fobj = rcu_dereference(robj->fence); + 1098. shared_count = fobj ? fobj->shared_count : 0; + 1099. fence = rcu_dereference(robj->fence_excl); + +drivers/dma-buf/dma-buf.c:1099: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1097. fobj = rcu_dereference(robj->fence); + 1098. shared_count = fobj ? fobj->shared_count : 0; + 1099. > fence = rcu_dereference(robj->fence_excl); + 1100. if (!read_seqcount_retry(&robj->seq, seq)) + 1101. break; + +drivers/dma-buf/dma-buf.c:1111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1109. dma_fence_is_signaled(fence) ? "" : "un"); + 1110. for (i = 0; i < shared_count; i++) { + 1111. > fence = rcu_dereference(fobj->shared[i]); + 1112. if (!dma_fence_get_rcu(fence)) + 1113. continue; + +drivers/input/evdev.c:1134: error: UNINITIALIZED_VALUE + The value read from mask.codes_ptr was never initialized. + 1132. return -EFAULT; + 1133. + 1134. > codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1135. return evdev_get_mask(client, + 1136. mask.type, codes_ptr, mask.codes_size, + +drivers/input/evdev.c:1146: error: UNINITIALIZED_VALUE + The value read from mask.codes_ptr was never initialized. + 1144. return -EFAULT; + 1145. + 1146. > codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1147. return evdev_set_mask(client, + 1148. mask.type, codes_ptr, mask.codes_size, + +drivers/input/evdev.c:1135: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1133. + 1134. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1135. > return evdev_get_mask(client, + 1136. mask.type, codes_ptr, mask.codes_size, + 1137. compat_mode); + +drivers/input/evdev.c:1147: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1145. + 1146. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1147. > return evdev_set_mask(client, + 1148. mask.type, codes_ptr, mask.codes_size, + 1149. compat_mode); + +drivers/input/evdev.c:1135: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1133. + 1134. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1135. > return evdev_get_mask(client, + 1136. mask.type, codes_ptr, mask.codes_size, + 1137. compat_mode); + +drivers/input/evdev.c:1147: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1145. + 1146. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1147. > return evdev_set_mask(client, + 1148. mask.type, codes_ptr, mask.codes_size, + 1149. compat_mode); + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_ddi.c:1068: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1065 could be null and is dereferenced at line 1068, column 17. + 1066. enc_to_dig_port(&encoder->base); + 1067. + 1068. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1069. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1070. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +drivers/gpu/drm/i915/intel_ddi.c:1068: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 1064 could be null and is dereferenced at line 1068, column 2. + 1066. enc_to_dig_port(&encoder->base); + 1067. + 1068. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1069. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1070. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +kernel/kprobes.c:1069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1067. struct kprobe *kp; + 1068. + 1069. > list_for_each_entry_rcu(kp, &p->list, list) { + 1070. if (kp->post_handler && likely(!kprobe_disabled(kp))) { + 1071. set_kprobe_instance(kp); + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.data was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1094: error: UNINITIALIZED_VALUE + The value read from ctrl.timeout was never initialized. + 1092. goto done; + 1093. } + 1094. > tmo = ctrl.timeout; + 1095. snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1082: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1080. if (ret) + 1081. return ret; + 1082. > wLength = ctrl.wLength; /* To suppress 64k PAGE_SIZE warning */ + 1083. if (wLength > PAGE_SIZE) + 1084. return -EINVAL; + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1107: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1105. } + 1106. pipe = usb_rcvctrlpipe(dev, 0); + 1107. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, NULL, 0); + 1108. + 1109. usb_unlock_device(dev); + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1124: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1122. } else { + 1123. if (ctrl.wLength) { + 1124. > if (copy_from_user(tbuf, ctrl.data, ctrl.wLength)) { + 1125. ret = -EFAULT; + 1126. goto done; + +drivers/usb/core/devio.c:1130: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1128. } + 1129. pipe = usb_sndctrlpipe(dev, 0); + 1130. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, + 1131. tbuf, ctrl.wLength); + 1132. + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +kernel/rcu/srcutree.c:1083: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1081. * by the prior grace period. + 1082. */ + 1083. > idx = rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq)); /* ^^^ */ + 1084. if (idx == SRCU_STATE_IDLE) { + 1085. raw_spin_lock_irq_rcu_node(sp); + +kernel/rcu/srcutree.c:1092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1090. return; + 1091. } + 1092. > idx = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 1093. if (idx == SRCU_STATE_IDLE) + 1094. srcu_gp_start(sp); + +kernel/rcu/srcutree.c:1102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1100. } + 1101. + 1102. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN1) { + 1103. idx = 1 ^ (sp->srcu_idx & 1); + 1104. if (!try_check_zero(sp, idx, 1)) { + +kernel/rcu/srcutree.c:1112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1110. } + 1111. + 1112. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN2) { + 1113. + 1114. /* + +net/ipv4/tcp_ipv4.c:1098: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 1096. return -EINVAL; + 1097. + 1098. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr, + 1099. AF_INET, prefixlen, cmd.tcpm_key, cmd.tcpm_keylen, + 1100. GFP_KERNEL); + +net/ipv4/tcp_ipv4.c:1086: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 1084. if (optname == TCP_MD5SIG_EXT && + 1085. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 1086. > prefixlen = cmd.tcpm_prefixlen; + 1087. if (prefixlen > 32) + 1088. return -EINVAL; + +net/wireless/trace.h:1069: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +drivers/gpu/drm/drm_dp_mst_topology.c:1079: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1077. case DP_PEER_DEVICE_SST_SINK: + 1078. /* add i2c over sideband */ + 1079. > ret = drm_dp_mst_register_i2c_bus(&port->aux); + 1080. break; + 1081. case DP_PEER_DEVICE_MST_BRANCHING: + +drivers/md/dm-raid1.c:1142: error: DEAD_STORE + The value written to &argv (type char**) is never used. + 1140. goto err_destroy_wq; + 1141. + 1142. > argv += args_used; + 1143. argc -= args_used; + 1144. + +net/ipv4/cipso_ipv4.c:1105: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 1103. + 1104. for (iter = 0; array_cnt > 0;) { + 1105. > *((__be16 *)&net_cat[iter]) = htons(array[--array_cnt]); + 1106. iter += 2; + 1107. array_cnt--; + +net/ipv4/cipso_ipv4.c:1109: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 1107. array_cnt--; + 1108. if (array[array_cnt] != 0) { + 1109. > *((__be16 *)&net_cat[iter]) = htons(array[array_cnt]); + 1110. iter += 2; + 1111. } + +net/sunrpc/svc.c:1083: error: DEAD_STORE + The value written to &error (type int) is never used. + 1081. */ + 1082. if (error == -EPROTONOSUPPORT) + 1083. > error = rpcb_register(net, program, version, 0, 0); + 1084. + 1085. dprintk("svc: %s(%sv%u), error %d\n", + +drivers/tty/vt/vt_ioctl.c:1091: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 1089. op->width = 8; + 1090. op->height = cfdarg.charheight; + 1091. > op->charcount = cfdarg.charcount; + 1092. op->data = compat_ptr(cfdarg.chardata); + 1093. return con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:1099: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 1097. op->width = 8; + 1098. op->height = cfdarg.charheight; + 1099. > op->charcount = cfdarg.charcount; + 1100. op->data = compat_ptr(cfdarg.chardata); + 1101. i = con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:1092: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1090. op->height = cfdarg.charheight; + 1091. op->charcount = cfdarg.charcount; + 1092. > op->data = compat_ptr(cfdarg.chardata); + 1093. return con_font_op(vc_cons[fg_console].d, op); + 1094. case GIO_FONTX: + +drivers/tty/vt/vt_ioctl.c:1100: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1098. op->height = cfdarg.charheight; + 1099. op->charcount = cfdarg.charcount; + 1100. > op->data = compat_ptr(cfdarg.chardata); + 1101. i = con_font_op(vc_cons[fg_console].d, op); + 1102. if (i) + +drivers/tty/vt/vt_ioctl.c:1090: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 1088. op->flags = KD_FONT_FLAG_OLD; + 1089. op->width = 8; + 1090. > op->height = cfdarg.charheight; + 1091. op->charcount = cfdarg.charcount; + 1092. op->data = compat_ptr(cfdarg.chardata); + +drivers/tty/vt/vt_ioctl.c:1098: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 1096. op->flags = KD_FONT_FLAG_OLD; + 1097. op->width = 8; + 1098. > op->height = cfdarg.charheight; + 1099. op->charcount = cfdarg.charcount; + 1100. op->data = compat_ptr(cfdarg.chardata); + +drivers/iommu/intel-iommu.c:1078: error: DEAD_STORE + The value written to &large_page (type unsigned int) is never used. + 1076. unsigned long last_pfn) + 1077. { + 1078. > unsigned int large_page = 1; + 1079. struct dma_pte *first_pte, *pte; + 1080. + +drivers/pci/pci.c:1086: error: DEAD_STORE + The value written to &i (type int) is never used. + 1084. cap = (u16 *)&save_state->cap.data[0]; + 1085. + 1086. > pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]); + 1087. } + 1088. + +drivers/gpu/drm/i915/intel_dsi.c:1153: error: DEAD_STORE + The value written to &vbp (type unsigned short) is never used. + 1151. vfp = I915_READ(MIPI_VFP_COUNT(port)); + 1152. vsync = I915_READ(MIPI_VSYNC_PADDING_COUNT(port)); + 1153. > vbp = I915_READ(MIPI_VBP_COUNT(port)); + 1154. + 1155. adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp; + +net/xfrm/xfrm_policy.c:1103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1101. priority = ~0U; + 1102. ret = NULL; + 1103. > hlist_for_each_entry_rcu(pol, chain, bydst) { + 1104. err = xfrm_policy_match(pol, fl, type, family, dir); + 1105. if (err) { + +net/xfrm/xfrm_policy.c:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. } + 1118. chain = &net->xfrm.policy_inexact[dir]; + 1119. > hlist_for_each_entry_rcu(pol, chain, bydst) { + 1120. if ((pol->priority >= priority) && ret) + 1121. break; + +kernel/kprobes.c:1082: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1080. int trapnr) + 1081. { + 1082. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1083. + 1084. /* + +kernel/kprobes.c:1082: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1080. int trapnr) + 1081. { + 1082. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1083. + 1084. /* + +net/netlink/genetlink.c:1086: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1084. int err; + 1085. + 1086. > for_each_net_rcu(net) { + 1087. if (prev) { + 1088. tmp = skb_clone(skb, flags); + +include/linux/rhashtable.h:1092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1090. rcu_read_lock(); + 1091. + 1092. > tbl = rht_dereference_rcu(ht->tbl, ht); + 1093. + 1094. /* Because we have already taken (and released) the bucket + +include/linux/rhashtable.h:1101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1099. while ((err = __rhashtable_remove_fast_one(ht, tbl, obj, params, + 1100. rhlist)) && + 1101. > (tbl = rht_dereference_rcu(tbl->future_tbl, ht))) + 1102. ; + 1103. + +security/commoncap.c:1090: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1088. + 1089. rcu_read_lock(); + 1090. > is_subset = cap_issubset(__task_cred(p)->cap_permitted, + 1091. current_cred()->cap_permitted); + 1092. if (!is_subset && !ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) + +security/commoncap.c:1092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1090. is_subset = cap_issubset(__task_cred(p)->cap_permitted, + 1091. current_cred()->cap_permitted); + 1092. > if (!is_subset && !ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) + 1093. ret = -EPERM; + 1094. rcu_read_unlock(); + +net/netfilter/nf_conntrack_sip.c:1099: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1094 could be null and is dereferenced at line 1099, column 11. + 1097. (code >= 200 && code <= 299)) + 1098. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1099. > else if (ct_sip_info->invite_cseq == cseq) + 1100. flush_expectations(ct, true); + 1101. return NF_ACCEPT; + +net/wireless/trace.h:1087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/ipv6/route.c:1095: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1094 could be null and is dereferenced by call to `dev_net()` at line 1095, column 28. + 1093. rcu_read_lock(); + 1094. dev = ip6_rt_get_dev_rcu(rt); + 1095. > pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags); + 1096. rcu_read_unlock(); + 1097. if (!pcpu_rt) + +drivers/video/fbdev/core/fbmem.c:1188: error: UNINITIALIZED_VALUE + The value read from con2fb.framebuffer was never initialized. + 1186. return -EINVAL; + 1187. if (!registered_fb[con2fb.framebuffer]) + 1188. > request_module("fb%d", con2fb.framebuffer); + 1189. if (!registered_fb[con2fb.framebuffer]) { + 1190. ret = -EINVAL; + +net/core/rtnetlink.c:1194: error: UNINITIALIZED_VALUE + The value read from vf_stats.broadcast was never initialized. + 1192. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1193. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1194. > nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1195. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1196. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + +net/core/rtnetlink.c:1196: error: UNINITIALIZED_VALUE + The value read from vf_stats.multicast was never initialized. + 1194. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1195. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1196. > nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + 1197. vf_stats.multicast, IFLA_VF_STATS_PAD)) { + 1198. nla_nest_cancel(skb, vfstats); + +net/core/rtnetlink.c:1190: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_bytes was never initialized. + 1188. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1189. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1190. > nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1191. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1192. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + +net/core/rtnetlink.c:1186: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_packets was never initialized. + 1184. if (!vfstats) + 1185. goto nla_put_vf_failure; + 1186. > if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1187. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1188. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + +net/core/rtnetlink.c:1192: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_bytes was never initialized. + 1190. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1191. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1192. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1193. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1194. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + +net/core/rtnetlink.c:1188: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_packets was never initialized. + 1186. if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1187. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1188. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1189. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1190. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + +lib/rhashtable.c:1102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1100. union nested_table *ntbl; + 1101. + 1102. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1103. ntbl = rht_dereference_bucket_rcu(ntbl[index].table, tbl, hash); + 1104. subhash >>= tbl->nest; + +lib/rhashtable.c:1103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1101. + 1102. ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1103. > ntbl = rht_dereference_bucket_rcu(ntbl[index].table, tbl, hash); + 1104. subhash >>= tbl->nest; + 1105. + +lib/rhashtable.c:1108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1106. while (ntbl && size > (1 << shift)) { + 1107. index = subhash & ((1 << shift) - 1); + 1108. > ntbl = rht_dereference_bucket_rcu(ntbl[index].table, + 1109. tbl, hash); + 1110. size >>= shift; + +drivers/gpu/drm/drm_dp_mst_topology.c:1102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1100. if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) { + 1101. if (mstb->port_parent) { + 1102. > ret = drm_dp_send_dpcd_write( + 1103. mstb->mgr, + 1104. mstb->port_parent, + +drivers/gpu/drm/drm_dp_mst_topology.c:1110: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1108. } else { + 1109. + 1110. > ret = drm_dp_dpcd_write( + 1111. mstb->mgr->aux, + 1112. DP_GUID, + +net/ipv4/ipmr.c:1107: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1107, column 5. + 1105. + 1106. if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) { + 1107. > nlh->nlmsg_len = skb_tail_pointer(skb) - + 1108. (u8 *)nlh; + 1109. } else { + +net/ipv4/ipmr.c:1110: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1110, column 5. + 1108. (u8 *)nlh; + 1109. } else { + 1110. > nlh->nlmsg_type = NLMSG_ERROR; + 1111. nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr)); + 1112. skb_trim(skb, nlh->nlmsg_len); + +security/selinux/avc.c:1110: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1108. node = avc_lookup(ssid, tsid, tclass); + 1109. if (unlikely(!node)) + 1110. > node = avc_compute_av(ssid, tsid, tclass, avd, &xp_node); + 1111. else + 1112. memcpy(avd, &node->ae.avd, sizeof(*avd)); + +drivers/input/mouse/alps.c:1113: error: DEAD_STORE + The value written to &z (type int) is never used. + 1111. y = (packet[3] & 0x07) | (packet[4] & 0xb8) | + 1112. ((packet[3] & 0x20) << 1); + 1113. > z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1); + 1114. + 1115. left = (packet[1] & 0x01); + +kernel/kprobes.c:1098: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1096. static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs) + 1097. { + 1098. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1099. int ret = 0; + 1100. + +kernel/kprobes.c:1098: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1096. static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs) + 1097. { + 1098. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1099. int ret = 0; + 1100. + +net/core/sock.c:1374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1372. #ifdef CONFIG_NET_RX_BUSY_POLL + 1373. case SO_INCOMING_NAPI_ID: + 1374. > v.val = READ_ONCE(sk->sk_napi_id); + 1375. + 1376. /* aggregate non-NAPI IDs down to 0 */ + +drivers/char/random.c:1113: error: DEAD_STORE + The value written to &idx (type unsigned int) is never used. + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + 1113. > ptr += idx++; + 1114. WRITE_ONCE(f->reg_idx, idx); + 1115. return *ptr; + +drivers/char/random.c:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. if (regs == NULL) + 1109. return 0; + 1110. > idx = READ_ONCE(f->reg_idx); + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + +net/wireless/trace.h:1103: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +scripts/kconfig/confdata.c:1114: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1109 could be null and is dereferenced at line 1114, column 2. + 1112. * Set all non-assinged choice values to no + 1113. */ + 1114. > expr_list_for_each_sym(prop->expr, e, sym) { + 1115. if (!sym_has_value(sym)) + 1116. sym->def[S_DEF_USER].tri = no; + +net/netfilter/nf_conntrack_sip.c:1116: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1111 could be null and is dereferenced at line 1116, column 11. + 1114. (code >= 200 && code <= 299)) + 1115. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1116. > else if (ct_sip_info->invite_cseq == cseq) + 1117. flush_expectations(ct, true); + 1118. return NF_ACCEPT; + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +kernel/kprobes.c:1117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1115. p->nmissed++; + 1116. } else { + 1117. > list_for_each_entry_rcu(kp, &p->list, list) + 1118. kp->nmissed++; + 1119. } + +net/ipv4/netfilter/ip_tables.c:1137: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1135. tmp.name[sizeof(tmp.name)-1] = 0; + 1136. + 1137. > newinfo = xt_alloc_table_info(tmp.size); + 1138. if (!newinfo) + 1139. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1142: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1140. + 1141. loc_cpu_entry = newinfo->entries; + 1142. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1143. tmp.size) != 0) { + 1144. ret = -EFAULT; + +security/selinux/ss/policydb.c:1133: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1131. goto bad; + 1132. + 1133. > len = le32_to_cpu(buf[0]); + 1134. perdatum->value = le32_to_cpu(buf[1]); + 1135. + +security/selinux/ss/policydb.c:1134: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1132. + 1133. len = le32_to_cpu(buf[0]); + 1134. > perdatum->value = le32_to_cpu(buf[1]); + 1135. + 1136. rc = str_read(&key, GFP_KERNEL, fp, len); + +arch/x86/events/core.c:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. left = x86_pmu.limit_period(event, left); + 1156. + 1157. > per_cpu(pmc_prev_left[idx], smp_processor_id()) = left; + 1158. + 1159. if (!(hwc->flags & PERF_X86_EVENT_AUTO_RELOAD) || + +net/ipv6/route.c:1133: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1131. dst_hold(&pcpu_rt->dst); + 1132. p = this_cpu_ptr(rt->rt6i_pcpu); + 1133. > prev = cmpxchg(p, NULL, pcpu_rt); + 1134. BUG_ON(prev); + 1135. + +security/keys/keyctl.c:1138: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `keyctl_instantiate_key_common()` at line 1138, column 9. + 1136. } + 1137. + 1138. > return keyctl_instantiate_key_common(id, NULL, ringid); + 1139. } + 1140. + +net/netfilter/nf_conntrack_sip.c:1133: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1128 could be null and is dereferenced at line 1133, column 11. + 1131. (code >= 200 && code <= 299)) + 1132. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1133. > else if (ct_sip_info->invite_cseq == cseq) + 1134. flush_expectations(ct, true); + 1135. return NF_ACCEPT; + +lib/rhashtable.c:1133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1131. unsigned int nhash; + 1132. + 1133. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1134. hash >>= tbl->nest; + 1135. nhash = index; + +drivers/gpu/drm/i915/intel_ddi.c:1127: error: DEAD_STORE + The value written to &refclk (type int) is never used. + 1125. i915_reg_t reg) + 1126. { + 1127. > int refclk = LC_FREQ; + 1128. int n, p, r; + 1129. u32 wrpll; + +drivers/pci/msi.c:1129: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1129, column 9. + 1127. int minvec, int maxvec) + 1128. { + 1129. > return __pci_enable_msix_range(dev, entries, minvec, maxvec, NULL); + 1130. } + 1131. EXPORT_SYMBOL(pci_enable_msix_range); + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.alloc32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1146: error: UNINITIALIZED_VALUE + The value read from getb.data32 was never initialized. + 1144. ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. > compat_ptr(getb.data32), getb.alloc32); + 1147. if (ret < 0) + 1148. return ret; + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.hdr32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +drivers/usb/mon/mon_bin.c:1163: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush32 was never initialized. + 1161. + 1162. if (mfetch.nflush32) { + 1163. > ret = mon_bin_flush(rp, mfetch.nflush32); + 1164. if (ret < 0) + 1165. return ret; + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.offvec32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +net/wireless/trace.h:1127: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/ipv4/ipmr.c:1184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1182. + 1183. rcu_read_lock(); + 1184. > mroute_sk = rcu_dereference(mrt->mroute_sk); + 1185. if (!mroute_sk) { + 1186. rcu_read_unlock(); + +net/ipv6/ip6_fib.c:1138: error: DEAD_STORE + The value written to &err (type int) is never used. + 1136. struct fib6_table *table = rt->rt6i_table; + 1137. struct fib6_node *fn, *pn = NULL; + 1138. > int err = -ENOMEM; + 1139. int allow_create = 1; + 1140. int replace_required = 0; + +net/ipv6/ip6_fib.c:1167: error: DEAD_STORE + The value written to &pn (type fib6_node*) is never used. + 1165. } + 1166. + 1167. > pn = fn; + 1168. + 1169. #ifdef CONFIG_IPV6_SUBTREES + +net/ipv6/ip6_fib.c:1294: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1292. (!(fn->fn_flags & (RTN_RTINFO|RTN_ROOT)) || + 1293. (fn->fn_flags & RTN_TL_ROOT && + 1294. > !rcu_access_pointer(fn->leaf)))) + 1295. fib6_repair_tree(info->nl_net, table, fn); + 1296. /* Always release dst as dst->__refcnt is guaranteed + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_tv.c:1192: error: DEAD_STORE + The value written to &type (type int) is never used. + 1190. intel_wait_for_vblank(dev_priv, intel_crtc->pipe); + 1191. + 1192. > type = -1; + 1193. tv_dac = I915_READ(TV_DAC); + 1194. DRM_DEBUG_KMS("TV detected: %x, %x\n", tv_ctl, tv_dac); + +kernel/time/hrtimer.c:1142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1140. + 1141. do { + 1142. > cpu_base = READ_ONCE(timer->base->cpu_base); + 1143. seq = raw_read_seqcount_begin(&cpu_base->seq); + 1144. + +net/ipv6/netfilter/ip6_tables.c:1156: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1154. tmp.name[sizeof(tmp.name)-1] = 0; + 1155. + 1156. > newinfo = xt_alloc_table_info(tmp.size); + 1157. if (!newinfo) + 1158. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1161: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1159. + 1160. loc_cpu_entry = newinfo->entries; + 1161. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1162. tmp.size) != 0) { + 1163. ret = -EFAULT; + +kernel/audit.c:1404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1402. unsigned int t; + 1403. + 1404. > t = READ_ONCE(current->signal->audit_tty); + 1405. s.enabled = t & AUDIT_TTY_ENABLE; + 1406. s.log_passwd = !!(t & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1423. + 1424. if (err) + 1425. > t = READ_ONCE(current->signal->audit_tty); + 1426. else { + 1427. t = s.enabled | (-s.log_passwd & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1255: error: UNINITIALIZED_VALUE + The value read from s.backlog_limit was never initialized. + 1253. } + 1254. if (s.mask & AUDIT_STATUS_BACKLOG_LIMIT) { + 1255. > err = audit_set_backlog_limit(s.backlog_limit); + 1256. if (err < 0) + 1257. return err; + +kernel/audit.c:1264: error: UNINITIALIZED_VALUE + The value read from s.backlog_wait_time was never initialized. + 1262. if (s.backlog_wait_time > 10*AUDIT_BACKLOG_WAIT_TIME) + 1263. return -EINVAL; + 1264. > err = audit_set_backlog_wait_time(s.backlog_wait_time); + 1265. if (err < 0) + 1266. return err; + +kernel/audit.c:1180: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1178. memcpy(&s, data, min_t(size_t, sizeof(s), nlmsg_len(nlh))); + 1179. if (s.mask & AUDIT_STATUS_ENABLED) { + 1180. > err = audit_set_enabled(s.enabled); + 1181. if (err < 0) + 1182. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1185: error: UNINITIALIZED_VALUE + The value read from s.failure was never initialized. + 1183. } + 1184. if (s.mask & AUDIT_STATUS_FAILURE) { + 1185. > err = audit_set_failure(s.failure); + 1186. if (err < 0) + 1187. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.log_passwd was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1196: error: UNINITIALIZED_VALUE + The value read from s.pid was never initialized. + 1194. * run auditd from the initial pid namespace, but + 1195. * something to keep in mind if this changes */ + 1196. > pid_t new_pid = s.pid; + 1197. pid_t auditd_pid; + 1198. struct pid *req_pid = task_tgid(current); + +kernel/audit.c:1250: error: UNINITIALIZED_VALUE + The value read from s.rate_limit was never initialized. + 1248. } + 1249. if (s.mask & AUDIT_STATUS_RATE_LIMIT) { + 1250. > err = audit_set_rate_limit(s.rate_limit); + 1251. if (err < 0) + 1252. return err; + +kernel/audit.c:1351: error: UNINITIALIZED_VALUE + The value read from sizes[_] was never initialized. + 1349. bufp += 2 * sizeof(u32); + 1350. msglen -= 2 * sizeof(u32); + 1351. > old = audit_unpack_string(&bufp, &msglen, sizes[0]); + 1352. if (IS_ERR(old)) { + 1353. err = PTR_ERR(old); + +kernel/audit.c:1356: error: UNINITIALIZED_VALUE + The value read from sizes[_] was never initialized. + 1354. break; + 1355. } + 1356. > new = audit_unpack_string(&bufp, &msglen, sizes[1]); + 1357. if (IS_ERR(new)) { + 1358. err = PTR_ERR(new); + +net/netfilter/nf_conntrack_sip.c:1151: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1145 could be null and is dereferenced at line 1151, column 3. + 1149. ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1150. if (ret == NF_ACCEPT) + 1151. > ct_sip_info->invite_cseq = cseq; + 1152. return ret; + 1153. } + +drivers/tty/vt/vt_ioctl.c:1155: error: UNINITIALIZED_VALUE + The value read from tmp.entries was never initialized. + 1153. if (copy_from_user(&tmp, user_ud, sizeof tmp)) + 1154. return -EFAULT; + 1155. > tmp_entries = compat_ptr(tmp.entries); + 1156. switch (cmd) { + 1157. case PIO_UNIMAP: + +drivers/tty/vt/vt_ioctl.c:1160: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1158. if (!perm) + 1159. return -EPERM; + 1160. > return con_set_unimap(vc, tmp.entry_ct, tmp_entries); + 1161. case GIO_UNIMAP: + 1162. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:1164: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1162. if (!perm && fg_console != vc->vc_num) + 1163. return -EPERM; + 1164. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries); + 1165. } + 1166. return 0; + +kernel/cgroup/cpuset.c:1165: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 1156 could be null and is dereferenced at line 1165, column 16. + 1163. */ + 1164. if (is_in_v2_mode() && nodes_empty(*new_mems)) + 1165. > *new_mems = parent->effective_mems; + 1166. + 1167. /* Skip the whole subtree if the nodemask remains the same. */ + +net/sunrpc/svc.c:1163: error: DEAD_STORE + The value written to &rpc_stat (type unsigned int) is never used. + 1161. __be32 *reply_statp; + 1162. + 1163. > rpc_stat = rpc_success; + 1164. + 1165. if (argv->iov_len < 6*4) + +security/selinux/ss/policydb.c:1166: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1164. goto bad; + 1165. + 1166. > len = le32_to_cpu(buf[0]); + 1167. comdatum->value = le32_to_cpu(buf[1]); + 1168. + +security/selinux/ss/policydb.c:1167: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1165. + 1166. len = le32_to_cpu(buf[0]); + 1167. > comdatum->value = le32_to_cpu(buf[1]); + 1168. + 1169. rc = symtab_init(&comdatum->permissions, PERM_SYMTAB_SIZE); + +security/selinux/ss/policydb.c:1172: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1170. if (rc) + 1171. goto bad; + 1172. > comdatum->permissions.nprim = le32_to_cpu(buf[2]); + 1173. nel = le32_to_cpu(buf[3]); + 1174. + +security/selinux/ss/policydb.c:1173: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1171. goto bad; + 1172. comdatum->permissions.nprim = le32_to_cpu(buf[2]); + 1173. > nel = le32_to_cpu(buf[3]); + 1174. + 1175. rc = str_read(&key, GFP_KERNEL, fp, len); + +crypto/drbg.c:1153: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1151. static inline int drbg_alloc_state(struct drbg_state *drbg) + 1152. { + 1153. > int ret = -ENOMEM; + 1154. unsigned int sb_size = 0; + 1155. + +drivers/pci/msi.c:1167: error: NULL_DEREFERENCE + pointer `affd` last assigned on line 1163 could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1167, column 10. + 1165. + 1166. if (flags & PCI_IRQ_MSIX) { + 1167. > vecs = __pci_enable_msix_range(dev, NULL, min_vecs, max_vecs, + 1168. affd); + 1169. if (vecs > 0) + +scripts/asn1_compiler.c:1207: error: UNINITIALIZED_VALUE + The value read from children was never initialized. + 1205. + 1206. *_cursor = cursor; + 1207. > return children; + 1208. + 1209. overrun_error: + +drivers/usb/core/devio.c:1190: error: UNINITIALIZED_VALUE + The value read from bulk.data was never initialized. + 1188. tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. > if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + 1191. ret = -EINVAL; + 1192. goto done; + +drivers/usb/core/devio.c:1165: error: UNINITIALIZED_VALUE + The value read from bulk.ep was never initialized. + 1163. if (copy_from_user(&bulk, arg, sizeof(bulk))) + 1164. return -EFAULT; + 1165. > ret = findintfep(ps->dev, bulk.ep); + 1166. if (ret < 0) + 1167. return ret; + +drivers/usb/core/devio.c:1177: error: UNINITIALIZED_VALUE + The value read from bulk.len was never initialized. + 1175. if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN))) + 1176. return -EINVAL; + 1177. > len1 = bulk.len; + 1178. if (len1 >= (INT_MAX - sizeof(struct urb))) + 1179. return -EINVAL; + +drivers/usb/core/devio.c:1188: error: UNINITIALIZED_VALUE + The value read from bulk.timeout was never initialized. + 1186. goto done; + 1187. } + 1188. > tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + +net/ipv6/ip6_output.c:1208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1206. v6_cork->tclass = ipc6->tclass; + 1207. if (rt->dst.flags & DST_XFRM_TUNNEL) + 1208. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1209. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1210. else + +net/ipv6/ip6_output.c:1211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1209. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1210. else + 1211. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1212. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(rt->dst.path); + 1213. if (np->frag_size < mtu) { + +net/wireless/trace.h:1157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/sunrpc/auth_gss/svcauth_gss.c:1167: error: DEAD_STORE + The value written to &status (type int) is never used. + 1165. struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. > int status = -EINVAL; + 1168. + 1169. memset(&rsci, 0, sizeof(rsci)); + +net/sunrpc/auth_gss/svcauth_gss.c:1205: error: DEAD_STORE + The value written to &status (type int) is never used. + 1203. rsci.cred.cr_gss_mech = gm; + 1204. + 1205. > status = -EINVAL; + 1206. /* mech-specific data: */ + 1207. status = gss_import_sec_context(ud->out_handle.data, + +net/xfrm/xfrm_policy.c:1168: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1166. rcu_read_lock(); + 1167. again: + 1168. > pol = rcu_dereference(sk->sk_policy[dir]); + 1169. if (pol != NULL) { + 1170. bool match; + +net/sched/act_api.c:1176: error: DEAD_STORE + The value written to &t (type tcamsg*) is never used. + 1174. struct tc_action_ops *a_o; + 1175. int ret = 0; + 1176. > struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1177. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1178. struct nlattr *count_attr = NULL; + +drivers/tty/serial/serial_core.c:1220: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1218. uart_port_deref(uport); + 1219. + 1220. > return ret; + 1221. } + 1222. + +drivers/usb/host/uhci-q.c:1183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1181. int len; + 1182. + 1183. > ctrlstat = td_status(uhci, td); + 1184. status = uhci_status_bits(ctrlstat); + 1185. if (status & TD_CTRL_ACTIVE) + +net/netfilter/nf_conntrack_sip.c:1265: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1178 could be null and is dereferenced at line 1265, column 3. + 1263. store_cseq: + 1264. if (ret == NF_ACCEPT) + 1265. > ct_sip_info->register_cseq = cseq; + 1266. return ret; + 1267. } + +net/netfilter/nf_conntrack_sip.c:1250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1248. exp->flags = NF_CT_EXPECT_PERMANENT | NF_CT_EXPECT_INACTIVE; + 1249. + 1250. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1251. if (hooks && ct->status & IPS_NAT_MASK) + 1252. ret = hooks->expect(skb, protoff, dataoff, dptr, datalen, + +drivers/net/ethernet/broadcom/tg3.c:1207: error: DEAD_STORE + The value written to &frame_val (type unsigned int) is never used. + 1205. if ((frame_val & MI_COM_BUSY) == 0) { + 1206. udelay(5); + 1207. > frame_val = tr32(MAC_MI_COM); + 1208. break; + 1209. } + +net/sunrpc/clnt.c:1180: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1178. + 1179. rcu_read_lock(); + 1180. > xprt = rcu_dereference(clnt->cl_xprt); + 1181. + 1182. bytes = xprt->addrlen; + +net/ipv4/af_inet.c:1190: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1188. /* Reroute. */ + 1189. rcu_read_lock(); + 1190. > inet_opt = rcu_dereference(inet->inet_opt); + 1191. daddr = inet->inet_daddr; + 1192. if (inet_opt && inet_opt->opt.srr) + +net/netlabel/netlabel_unlabeled.c:1196: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1194. rcu_read_lock(); + 1195. for (iter_bkt = skip_bkt; + 1196. > iter_bkt < rcu_dereference(netlbl_unlhsh)->size; + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + +net/netlabel/netlabel_unlabeled.c:1198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1196. iter_bkt < rcu_dereference(netlbl_unlhsh)->size; + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. > iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + 1199. list_for_each_entry_rcu(iface, iter_list, list) { + 1200. if (!iface->valid || + +net/netlabel/netlabel_unlabeled.c:1199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + 1199. > list_for_each_entry_rcu(iface, iter_list, list) { + 1200. if (!iface->valid || + 1201. iter_chain++ < skip_chain) + +net/wireless/trace.h:1178: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +lib/radix-tree.c:1184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1182. radix_tree_update_node_t update_node) + 1183. { + 1184. > void *old = rcu_dereference_raw(*slot); + 1185. int exceptional = !!radix_tree_exceptional_entry(item) - + 1186. !!radix_tree_exceptional_entry(old); + +net/netfilter/nf_conntrack_core.c:1231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1229. + 1230. if (timeout_ext) + 1231. > nf_ct_timeout_ext_add(ct, rcu_dereference(timeout_ext->timeout), + 1232. GFP_ATOMIC); + 1233. + +net/ipv4/tcp.c:1424: error: UNINITIALIZED_VALUE + The value read from size_goal was never initialized. + 1422. if (copied) { + 1423. tcp_tx_timestamp(sk, sockc.tsflags); + 1424. > tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1425. } + 1426. out_nopush: + +net/ipv4/tcp.c:1423: error: UNINITIALIZED_VALUE + The value read from sockc.tsflags was never initialized. + 1421. out: + 1422. if (copied) { + 1423. > tcp_tx_timestamp(sk, sockc.tsflags); + 1424. tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1425. } + +arch/x86/events/core.c:1187: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1185. void x86_pmu_enable_event(struct perf_event *event) + 1186. { + 1187. > if (__this_cpu_read(cpu_hw_events.enabled)) + 1188. __x86_pmu_enable_event(&event->hw, + 1189. ARCH_PERFMON_EVENTSEL_ENABLE); + +net/netfilter/nf_conntrack_netlink.c:1240: error: DEAD_STORE + The value written to &err (type int) is never used. + 1238. ct = nf_ct_tuplehash_to_ctrack(h); + 1239. + 1240. > err = -ENOMEM; + 1241. skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); + 1242. if (skb2 == NULL) { + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1232: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1230. *batch++ = lower_32_bits(addr); + 1231. *batch++ = upper_32_bits(addr); + 1232. > *batch++ = upper_32_bits(target_offset); + 1233. } else { + 1234. *batch++ = (MI_STORE_DWORD_IMM_GEN4 | (1 << 21)) + 1; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1238: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1236. *batch++ = upper_32_bits(addr); + 1237. *batch++ = lower_32_bits(target_offset); + 1238. > *batch++ = upper_32_bits(target_offset); + 1239. } + 1240. } else if (gen >= 6) { + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1244: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1242. *batch++ = 0; + 1243. *batch++ = addr; + 1244. > *batch++ = target_offset; + 1245. } else if (gen >= 4) { + 1246. *batch++ = MI_STORE_DWORD_IMM_GEN4 | MI_USE_GGTT; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1249: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1247. *batch++ = 0; + 1248. *batch++ = addr; + 1249. > *batch++ = target_offset; + 1250. } else { + 1251. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1253: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1251. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + 1252. *batch++ = addr; + 1253. > *batch++ = target_offset; + 1254. } + 1255. + +arch/x86/pci/irq.c:1196: error: DEAD_STORE + The value written to &msg (type char*) is never used. + 1194. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin); + 1195. if (pin && !pcibios_lookup_irq(dev, 1)) { + 1196. > char *msg = ""; + 1197. + 1198. if (!io_apic_assign_pci_irqs && dev->irq) + +net/sunrpc/auth_gss/auth_gss.c:1194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1192. { + 1193. struct gss_auth *gss_auth; + 1194. > struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch); + 1195. + 1196. while (clnt != clnt->cl_parent) { + +net/sunrpc/auth_gss/auth_gss.c:1199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1197. struct rpc_clnt *parent = clnt->cl_parent; + 1198. /* Find the original parent for this transport */ + 1199. > if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps) + 1200. break; + 1201. clnt = parent; + +kernel/relay.c:1204: error: DEAD_STORE + The value written to &pos (type unsigned long long) is never used. + 1202. uint64_t pos = (uint64_t) *ppos; + 1203. uint32_t alloc_size = (uint32_t) rbuf->chan->alloc_size; + 1204. > size_t read_start = (size_t) do_div(pos, alloc_size); + 1205. size_t read_subbuf = read_start / subbuf_size; + 1206. size_t padding = rbuf->padding[read_subbuf]; + +net/socket.c:1247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1245. * Otherwise module support will break! + 1246. */ + 1247. > if (rcu_access_pointer(net_families[family]) == NULL) + 1248. request_module("net-pf-%d", family); + 1249. #endif + +net/socket.c:1252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1250. + 1251. rcu_read_lock(); + 1252. > pf = rcu_dereference(net_families[family]); + 1253. err = -EAFNOSUPPORT; + 1254. if (!pf) + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +net/rfkill/core.c:1230: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1228. if (rfkill->type == ev.type || + 1229. ev.type == RFKILL_TYPE_ALL) + 1230. > rfkill_set_block(rfkill, ev.soft); + 1231. ret = 0; + 1232. break; + +net/rfkill/core.c:1238: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1236. (rfkill->type == ev.type || + 1237. ev.type == RFKILL_TYPE_ALL)) + 1238. > rfkill_set_block(rfkill, ev.soft); + 1239. ret = 0; + 1240. break; + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.type was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +drivers/iommu/intel-iommu.c:1244: error: DEAD_STORE + The value written to &last_pte (type dma_pte*) is never used. + 1242. if (first_pte) + 1243. domain_flush_cache(domain, first_pte, + 1244. > (void *)++last_pte - (void *)first_pte); + 1245. + 1246. return freelist; + +security/selinux/ss/policydb.c:1213: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1211. if (rc < 0) + 1212. return -EINVAL; + 1213. > t->flags = le32_to_cpu(buf[0]); + 1214. + 1215. return 0; + +kernel/irq/irqdomain.c:1208: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1207 could be null and is dereferenced at line 1208, column 9. + 1206. for (i = 0; i < nr_irqs; i++) { + 1207. irq_data = irq_get_irq_data(virq + i); + 1208. > tmp = irq_data->parent_data; + 1209. irq_data->parent_data = NULL; + 1210. irq_data->domain = NULL; + +net/sunrpc/clnt.c:1206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1204. struct rpc_xprt *xprt; + 1205. + 1206. > xprt = rcu_dereference(clnt->cl_xprt); + 1207. + 1208. if (xprt->address_strings[format] != NULL) + +block/blk-mq.c:1210: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1208. * are mapped to it. + 1209. */ + 1210. > WARN_ON(!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1211. cpu_online(hctx->next_cpu)); + 1212. + +block/blk-mq.c:1210: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1208. * are mapped to it. + 1209. */ + 1210. > WARN_ON(!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1211. cpu_online(hctx->next_cpu)); + 1212. + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +net/wireless/trace.h:1206: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/ipv6/calipso.c:1216: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1212 could be null and is dereferenced at line 1216, column 6. + 1214. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1215. + 1216. > if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt) + 1217. old = req_inet->ipv6_opt->hopopt; + 1218. else + +net/core/net-sysfs.c:1230: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1228. + 1229. rcu_read_lock(); + 1230. > dev_maps = rcu_dereference(dev->xps_maps); + 1231. if (dev_maps) { + 1232. for_each_possible_cpu(cpu) { + +net/core/net-sysfs.c:1236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1234. struct xps_map *map; + 1235. + 1236. > map = rcu_dereference(dev_maps->cpu_map[tci]); + 1237. if (!map) + 1238. continue; + +kernel/exit.c:1241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1239. *p_code = 0; + 1240. + 1241. > uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1242. unlock_sig: + 1243. spin_unlock_irq(&p->sighand->siglock); + +include/linux/sched.h:1219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1217. rcu_read_lock(); + 1218. if (pid_alive(tsk)) + 1219. > pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns); + 1220. rcu_read_unlock(); + 1221. + +net/ipv6/addrconf.c:1259: error: UNINITIALIZED_VALUE + The value read from expires was never initialized. + 1257. + 1258. if (action != CLEANUP_PREFIX_RT_NOP) { + 1259. > cleanup_prefix_route(ifp, expires, + 1260. action == CLEANUP_PREFIX_RT_DEL); + 1261. } + +net/ipv4/igmp.c:1233: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1231. /* clear dead sources, too */ + 1232. rcu_read_lock(); + 1233. > for_each_pmc_rcu(in_dev, pmc) { + 1234. struct ip_sf_list *psf, *psf_next; + 1235. + +drivers/scsi/scsi_transport_spi.c:1223: error: DEAD_STORE + The value written to &msg (type unsigned char*) is never used. + 1221. if (cmd->flags & SCMD_TAGGED) { + 1222. *msg++ = SIMPLE_QUEUE_TAG; + 1223. > *msg++ = cmd->request->tag; + 1224. return 2; + 1225. } + +security/selinux/ss/policydb.c:1243: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1241. if (rc) + 1242. return rc; + 1243. > c->permissions = le32_to_cpu(buf[0]); + 1244. nexpr = le32_to_cpu(buf[1]); + 1245. le = NULL; + +security/selinux/ss/policydb.c:1244: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1242. return rc; + 1243. c->permissions = le32_to_cpu(buf[0]); + 1244. > nexpr = le32_to_cpu(buf[1]); + 1245. le = NULL; + 1246. depth = -1; + +security/selinux/ss/policydb.c:1260: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1258. if (rc) + 1259. return rc; + 1260. > e->expr_type = le32_to_cpu(buf[0]); + 1261. e->attr = le32_to_cpu(buf[1]); + 1262. e->op = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1261: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1259. return rc; + 1260. e->expr_type = le32_to_cpu(buf[0]); + 1261. > e->attr = le32_to_cpu(buf[1]); + 1262. e->op = le32_to_cpu(buf[2]); + 1263. + +security/selinux/ss/policydb.c:1262: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1260. e->expr_type = le32_to_cpu(buf[0]); + 1261. e->attr = le32_to_cpu(buf[1]); + 1262. > e->op = le32_to_cpu(buf[2]); + 1263. + 1264. switch (e->expr_type) { + +drivers/gpu/drm/i915/i915_gem.c:1291: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1289. * page_length = bytes to copy for this page + 1290. */ + 1291. > u32 page_base = node.start; + 1292. unsigned int page_offset = offset_in_page(offset); + 1293. unsigned int page_length = PAGE_SIZE - page_offset; + +kernel/irq/irqdomain.c:1230: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1229 could be null and is dereferenced at line 1230, column 3. + 1228. for (i = 0; i < nr_irqs; i++) { + 1229. irq_data = irq_get_irq_data(virq + i); + 1230. > irq_data->domain = domain; + 1231. + 1232. for (parent = domain->parent; parent; parent = parent->parent) { + +kernel/time/tick-sched.c:1238: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1236. u64 offset = ktime_to_ns(tick_period) >> 1; + 1237. do_div(offset, num_possible_cpus()); + 1238. > offset *= smp_processor_id(); + 1239. hrtimer_add_expires_ns(&ts->sched_timer, offset); + 1240. } + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1241: error: DEAD_STORE + The value written to &ctrl_reg (type unsigned int) is never used. + 1239. } + 1240. + 1241. > ctrl_reg = er32(CTRL); + 1242. + 1243. /* force 1000, set loopback */ + +net/ipv4/af_inet.c:1272: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1270. } + 1271. + 1272. > ops = rcu_dereference(inet_offloads[proto]); + 1273. if (likely(ops && ops->callbacks.gso_segment)) + 1274. segs = ops->callbacks.gso_segment(skb, features); + +net/wireless/trace.h:1224: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +drivers/net/ethernet/intel/e1000e/netdev.c:1230: error: DEAD_STORE + The value written to &hw (type e1000_hw*) is never used. + 1228. struct e1000_adapter *adapter = tx_ring->adapter; + 1229. struct net_device *netdev = adapter->netdev; + 1230. > struct e1000_hw *hw = &adapter->hw; + 1231. struct e1000_tx_desc *tx_desc, *eop_desc; + 1232. struct e1000_buffer *buffer_info; + +drivers/ata/libahci.c:1248: error: DEAD_STORE + The value written to &tmp (type unsigned int) is never used. + 1246. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1247. writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL); + 1248. > tmp = readl(mmio + HOST_CTL); + 1249. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1250. } + +net/ipv6/ip6_output.c:1527: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1525. cork->length -= length; + 1526. IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS); + 1527. > return err; + 1528. } + 1529. + +drivers/tty/serial/serial_core.c:1253: error: UNINITIALIZED_VALUE + The value read from cnow.brk was never initialized. + 1251. icount->overrun = cnow.overrun; + 1252. icount->parity = cnow.parity; + 1253. > icount->brk = cnow.brk; + 1254. icount->buf_overrun = cnow.buf_overrun; + 1255. + +drivers/tty/serial/serial_core.c:1254: error: UNINITIALIZED_VALUE + The value read from cnow.buf_overrun was never initialized. + 1252. icount->parity = cnow.parity; + 1253. icount->brk = cnow.brk; + 1254. > icount->buf_overrun = cnow.buf_overrun; + 1255. + 1256. return 0; + +drivers/tty/serial/serial_core.c:1244: error: UNINITIALIZED_VALUE + The value read from cnow.cts was never initialized. + 1242. uart_port_deref(uport); + 1243. + 1244. > icount->cts = cnow.cts; + 1245. icount->dsr = cnow.dsr; + 1246. icount->rng = cnow.rng; + +drivers/tty/serial/serial_core.c:1247: error: UNINITIALIZED_VALUE + The value read from cnow.dcd was never initialized. + 1245. icount->dsr = cnow.dsr; + 1246. icount->rng = cnow.rng; + 1247. > icount->dcd = cnow.dcd; + 1248. icount->rx = cnow.rx; + 1249. icount->tx = cnow.tx; + +drivers/tty/serial/serial_core.c:1245: error: UNINITIALIZED_VALUE + The value read from cnow.dsr was never initialized. + 1243. + 1244. icount->cts = cnow.cts; + 1245. > icount->dsr = cnow.dsr; + 1246. icount->rng = cnow.rng; + 1247. icount->dcd = cnow.dcd; + +drivers/tty/serial/serial_core.c:1250: error: UNINITIALIZED_VALUE + The value read from cnow.frame was never initialized. + 1248. icount->rx = cnow.rx; + 1249. icount->tx = cnow.tx; + 1250. > icount->frame = cnow.frame; + 1251. icount->overrun = cnow.overrun; + 1252. icount->parity = cnow.parity; + +drivers/tty/serial/serial_core.c:1251: error: UNINITIALIZED_VALUE + The value read from cnow.overrun was never initialized. + 1249. icount->tx = cnow.tx; + 1250. icount->frame = cnow.frame; + 1251. > icount->overrun = cnow.overrun; + 1252. icount->parity = cnow.parity; + 1253. icount->brk = cnow.brk; + +drivers/tty/serial/serial_core.c:1252: error: UNINITIALIZED_VALUE + The value read from cnow.parity was never initialized. + 1250. icount->frame = cnow.frame; + 1251. icount->overrun = cnow.overrun; + 1252. > icount->parity = cnow.parity; + 1253. icount->brk = cnow.brk; + 1254. icount->buf_overrun = cnow.buf_overrun; + +drivers/tty/serial/serial_core.c:1246: error: UNINITIALIZED_VALUE + The value read from cnow.rng was never initialized. + 1244. icount->cts = cnow.cts; + 1245. icount->dsr = cnow.dsr; + 1246. > icount->rng = cnow.rng; + 1247. icount->dcd = cnow.dcd; + 1248. icount->rx = cnow.rx; + +drivers/tty/serial/serial_core.c:1248: error: UNINITIALIZED_VALUE + The value read from cnow.rx was never initialized. + 1246. icount->rng = cnow.rng; + 1247. icount->dcd = cnow.dcd; + 1248. > icount->rx = cnow.rx; + 1249. icount->tx = cnow.tx; + 1250. icount->frame = cnow.frame; + +drivers/tty/serial/serial_core.c:1249: error: UNINITIALIZED_VALUE + The value read from cnow.tx was never initialized. + 1247. icount->dcd = cnow.dcd; + 1248. icount->rx = cnow.rx; + 1249. > icount->tx = cnow.tx; + 1250. icount->frame = cnow.frame; + 1251. icount->overrun = cnow.overrun; + +net/core/ethtool.c:1255: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1253. if (copy_from_user(&rxfh, useraddr, sizeof(rxfh))) + 1254. return -EFAULT; + 1255. > user_indir_size = rxfh.indir_size; + 1256. user_key_size = rxfh.key_size; + 1257. + +net/core/ethtool.c:1256: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1254. return -EFAULT; + 1255. user_indir_size = rxfh.indir_size; + 1256. > user_key_size = rxfh.key_size; + 1257. + 1258. /* Check that reserved fields are 0 for now */ + +kernel/rcu/tree.c:1236: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1234. static int rcu_is_cpu_rrupt_from_idle(void) + 1235. { + 1236. > return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 1; + 1237. } + 1238. + +kernel/signal.c:1246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1244. local_irq_save(*flags); + 1245. rcu_read_lock(); + 1246. > sighand = rcu_dereference(tsk->sighand); + 1247. if (unlikely(sighand == NULL)) { + 1248. rcu_read_unlock(); + +kernel/signal.c:1273: error: UNINITIALIZED_VALUE + The value read from sighand was never initialized. + 1271. } + 1272. + 1273. > return sighand; + 1274. } + 1275. + +net/ipv6/route.c:1252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1250. *bucket += hval; + 1251. + 1252. > hlist_for_each_entry_rcu(rt6_ex, &(*bucket)->chain, hlist) { + 1253. struct rt6_info *rt6 = rt6_ex->rt6i; + 1254. bool matched = ipv6_addr_equal(daddr, &rt6->rt6i_dst.addr); + +include/linux/sched.h:1241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1239. static inline unsigned int task_state_index(struct task_struct *tsk) + 1240. { + 1241. > unsigned int tsk_state = READ_ONCE(tsk->state); + 1242. unsigned int state = (tsk_state | tsk->exit_state) & TASK_REPORT; + 1243. + +kernel/events/core.c:1246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1244. again: + 1245. rcu_read_lock(); + 1246. > ctx = READ_ONCE(event->ctx); + 1247. if (!atomic_inc_not_zero(&ctx->refcount)) { + 1248. rcu_read_unlock(); + +net/ipv4/devinet.c:1284: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1282. in dev_base list. + 1283. */ + 1284. > for_each_netdev_rcu(net, dev) { + 1285. if (l3mdev_master_ifindex_rcu(dev) != master_idx) + 1286. continue; + +net/core/filter.c:1256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1254. if (err) + 1255. return err; + 1256. > } else if (!rcu_access_pointer(sk->sk_reuseport_cb)) { + 1257. /* The socket wasn't bound with SO_REUSEPORT */ + 1258. return -EINVAL; + +net/wireless/trace.h:1245: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/ipv6/calipso.c:1257: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1252 could be null and is dereferenced at line 1257, column 7. + 1255. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1256. + 1257. > if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt) + 1258. return; + 1259. + +block/blk-mq.c:1267: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1265. + 1266. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1267. > int cpu = get_cpu(); + 1268. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1269. __blk_mq_run_hw_queue(hctx); + +block/blk-mq.c:1267: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1265. + 1266. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1267. > int cpu = get_cpu(); + 1268. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1269. __blk_mq_run_hw_queue(hctx); + +drivers/char/random.c:1267: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1265. /* Can we pull enough? */ + 1266. retry: + 1267. > entropy_count = orig = READ_ONCE(r->entropy_count); + 1268. ibytes = nbytes; + 1269. /* never pull more than available */ + +scripts/kconfig/symbol.c:1267: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1266 could be null and is dereferenced at line 1267, column 2. + 1265. + 1266. prop = sym_get_choice_prop(choice); + 1267. > expr_list_for_each_sym(prop->expr, e, sym) + 1268. sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); + 1269. + +net/netlabel/netlabel_unlabeled.c:1274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1272. + 1273. rcu_read_lock(); + 1274. > iface = rcu_dereference(netlbl_unlhsh_def); + 1275. if (iface == NULL || !iface->valid) + 1276. goto unlabel_staticlistdef_return; + +kernel/trace/trace.h:1263: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1261. struct ring_buffer_event *event) + 1262. { + 1263. > if (this_cpu_read(trace_buffered_event) == event) { + 1264. /* Simply release the temp buffer */ + 1265. this_cpu_dec(trace_buffered_event_cnt); + +net/ipv4/route.c:1274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1272. return mtu; + 1273. + 1274. > mtu = READ_ONCE(dst->dev->mtu); + 1275. + 1276. if (unlikely(dst_metric_locked(dst, RTAX_MTU))) { + +drivers/gpu/drm/i915/intel_tv.c:1300: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 1298. + 1299. if (status == connector_status_connected) { + 1300. > intel_tv->type = type; + 1301. intel_tv_find_better_format(connector); + 1302. } + +net/ipv4/tcp_ipv4.c:1272: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1270. { + 1271. struct inet_request_sock *ireq = inet_rsk(req); + 1272. > struct net *net = sock_net(sk_listener); + 1273. + 1274. sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr); + +net/ipv6/addrconf.c:1326: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1324. * idev->desync_factor if it's larger + 1325. */ + 1326. > cnf_temp_preferred_lft = READ_ONCE(idev->cnf.temp_prefered_lft); + 1327. max_desync_factor = min_t(__u32, + 1328. idev->cnf.max_desync_factor, + +net/netfilter/nf_conntrack_sip.c:1293: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1276 could be null and is dereferenced at line 1293, column 6. + 1291. * request and compare it here. + 1292. */ + 1293. > if (ct_sip_info->register_cseq != cseq) + 1294. return NF_ACCEPT; + 1295. + +net/netfilter/nf_conntrack_netlink.c:1282: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 1280. struct hlist_nulls_node *n; + 1281. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 1282. > u_int8_t l3proto = nfmsg->nfgen_family; + 1283. int res; + 1284. int cpu; + +block/genhd.c:1299: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1297. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1298. while ((hd = disk_part_iter_next(&piter))) { + 1299. > cpu = part_stat_lock(); + 1300. part_round_stats(gp->queue, cpu, hd); + 1301. part_stat_unlock(); + +block/genhd.c:1299: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1297. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1298. while ((hd = disk_part_iter_next(&piter))) { + 1299. > cpu = part_stat_lock(); + 1300. part_round_stats(gp->queue, cpu, hd); + 1301. part_stat_unlock(); + +net/wireless/trace.h:1280: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +kernel/exit.c:1302: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1300. if (!unlikely(wo->wo_flags & WNOWAIT)) + 1301. p->signal->flags &= ~SIGNAL_STOP_CONTINUED; + 1302. > uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1303. spin_unlock_irq(&p->sighand->siglock); + 1304. + +drivers/usb/core/devio.c:1291: error: UNINITIALIZED_VALUE + The value read from gd.interface was never initialized. + 1289. if (copy_from_user(&gd, arg, sizeof(gd))) + 1290. return -EFAULT; + 1291. > intf = usb_ifnum_to_if(ps->dev, gd.interface); + 1292. if (!intf || !intf->dev.driver) + 1293. ret = -ENODATA; + +drivers/dma/dmaengine.c:1287: error: DEAD_STORE + The value written to &dma_sync_wait_timeout (type unsigned long) is never used. + 1285. dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx) + 1286. { + 1287. > unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000); + 1288. + 1289. if (!tx) + +net/ipv4/route.c:1288: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1286. static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr) + 1287. { + 1288. > struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions); + 1289. struct fib_nh_exception *fnhe; + 1290. u32 hval; + +net/ipv4/route.c:1297: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1295. hval = fnhe_hashfun(daddr); + 1296. + 1297. > for (fnhe = rcu_dereference(hash[hval].chain); fnhe; + 1298. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 1299. if (fnhe->fnhe_daddr == daddr) + +net/ipv4/route.c:1298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1296. + 1297. for (fnhe = rcu_dereference(hash[hval].chain); fnhe; + 1298. > fnhe = rcu_dereference(fnhe->fnhe_next)) { + 1299. if (fnhe->fnhe_daddr == daddr) + 1300. return fnhe; + +drivers/base/regmap/regmap.c:1301: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1299. kfree(map->work_buf); + 1300. while (!list_empty(&map->async_free)) { + 1301. > async = list_first_entry_or_null(&map->async_free, + 1302. struct regmap_async, + 1303. list); + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +net/sunrpc/auth_gss/svcauth_gss.c:1298: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1296. + 1297. WARN_ON_ONCE(type != 0 && type != 1); + 1298. > ret = cmpxchg(&sn->use_gss_proxy, -1, type); + 1299. if (ret != -1 && ret != type) + 1300. return -EBUSY; + +drivers/gpu/drm/i915/i915_debugfs.c:1364: error: UNINITIALIZED_VALUE + The value read from acthd[_] was never initialized. + 1362. spin_unlock_irq(&b->rb_lock); + 1363. + 1364. > seq_printf(m, "\tACTHD = 0x%08llx [current 0x%08llx]\n", + 1365. (long long)engine->hangcheck.acthd, + 1366. (long long)acthd[id]); + +drivers/gpu/drm/i915/i915_debugfs.c:1345: error: UNINITIALIZED_VALUE + The value read from seqno[_] was never initialized. + 1343. + 1344. seq_printf(m, "%s:\n", engine->name); + 1345. > seq_printf(m, "\tseqno = %x [current %x, last %x], inflight %d\n", + 1346. engine->hangcheck.seqno, seqno[id], + 1347. intel_engine_last_submit(engine), + +drivers/net/ethernet/marvell/sky2.c:1312: error: UNINITIALIZED_VALUE + The value read from rss_key[_] was never initialized. + 1310. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 1311. for (i = 0; i < nkeys; i++) + 1312. > sky2_write32(hw, SK_REG(sky2->port, RSS_KEY + i * 4), + 1313. rss_key[i]); + 1314. + +scripts/kconfig/symbol.c:1312: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1311 could be null and is dereferenced by call to `prop_get_symbol()` at line 1312, column 25. + 1310. dep_stack_insert(&stack, sym); + 1311. prop = sym_get_choice_prop(sym); + 1312. > sym2 = sym_check_deps(prop_get_symbol(prop)); + 1313. dep_stack_remove(); + 1314. } else if (sym_is_choice(sym)) { + +kernel/cgroup/cgroup-v1.c:1311: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 1310 could be null and is dereferenced at line 1311, column 22. + 1309. + 1310. for_each_subsys(ss, i) { + 1311. > if (strcmp(token, ss->name) && + 1312. strcmp(token, ss->legacy_name)) + 1313. continue; + +net/ipv4/fib_trie.c:1314: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1312. cindex = 0; + 1313. + 1314. > n = get_child_rcu(pn, cindex); + 1315. if (!n) + 1316. return -EAGAIN; + +net/ipv4/fib_trie.c:1355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1353. } + 1354. + 1355. > n = get_child_rcu(n, index); + 1356. if (unlikely(!n)) + 1357. goto backtrace; + +net/ipv4/fib_trie.c:1381: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1379. */ + 1380. + 1381. > while ((n = rcu_dereference(*cptr)) == NULL) { + 1382. backtrace: + 1383. #ifdef CONFIG_IP_FIB_TRIE_STATS + +net/ipv4/fib_trie.c:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. #endif + 1404. /* Get Child's index */ + 1405. > pn = node_parent_rcu(pn); + 1406. cindex = get_index(pkey, pn); + 1407. } + +net/ipv4/fib_trie.c:1422: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1420. + 1421. /* Step 3: Process the leaf, if that fails fall back to backtracing */ + 1422. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) { + 1423. struct fib_info *fi = fa->fa_info; + 1424. int nhsel, err; + +kernel/signal.c:1305: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1303. success = 0; + 1304. retval = -ESRCH; + 1305. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 1306. int err = group_send_sig_info(sig, info, p); + 1307. success |= !err; + +net/core/dev.c:1304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1302. + 1303. rcu_read_lock(); + 1304. > alias = rcu_dereference(dev->ifalias); + 1305. if (alias) + 1306. ret = snprintf(name, len, "%s", alias->ifalias); + +net/wireless/trace.h:1298: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +drivers/iommu/iommu.c:1315: error: NULL_DEREFERENCE + pointer `group` last assigned on line 1305 could be null and is dereferenced by call to `__iommu_attach_group()` at line 1315, column 8. + 1313. goto out_unlock; + 1314. + 1315. > ret = __iommu_attach_group(domain, group); + 1316. + 1317. out_unlock: + +net/core/ethtool.c:1360: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1358. rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE) { + 1359. indir = (u32 *)rss_config; + 1360. > ret = ethtool_copy_validate_indir(indir, + 1361. useraddr + rss_cfg_offset, + 1362. &rx_rings, + +net/core/ethtool.c:1374: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1372. if (rxfh.key_size) { + 1373. hkey = rss_config + indir_bytes; + 1374. > if (copy_from_user(hkey, + 1375. useraddr + rss_cfg_offset + indir_bytes, + 1376. rxfh.key_size)) { + +net/ipv4/route.c:1321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1319. else + 1320. porig = &fnhe->fnhe_rth_output; + 1321. > orig = rcu_dereference(*porig); + 1322. + 1323. if (fnhe->fnhe_genid != genid) { + +drivers/usb/host/ehci-hub.c:1313: error: DEAD_STORE + The value written to &portnum (type int) is never used. + 1311. if (ehci_is_TDI(ehci)) + 1312. return; + 1313. > set_owner(ehci, --portnum, PORT_OWNER); + 1314. } + 1315. + +lib/vsprintf.c:1317: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 1315. bool uc = false; + 1316. + 1317. > switch (*(++fmt)) { + 1318. case 'L': + 1319. uc = true; /* fall-through */ + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +block/bio.c:1340: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1338. + 1339. if (unlikely(offs & queue_dma_alignment(q))) { + 1340. > ret = -EINVAL; + 1341. j = 0; + 1342. } else { + +net/ipv6/ip6_fib.c:1333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1331. dir = addr_bit_set(args->addr, fn->fn_bit); + 1332. + 1333. > next = dir ? rcu_dereference(fn->right) : + 1334. rcu_dereference(fn->left); + 1335. + +net/ipv6/ip6_fib.c:1334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1332. + 1333. next = dir ? rcu_dereference(fn->right) : + 1334. > rcu_dereference(fn->left); + 1335. + 1336. if (next) { + +net/ipv6/ip6_fib.c:1347: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1345. + 1346. if (subtree || fn->fn_flags & RTN_RTINFO) { + 1347. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 1348. struct rt6key *key; + 1349. + +net/ipv6/ip6_fib.c:1373: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1371. break; + 1372. + 1373. > fn = rcu_dereference(fn->parent); + 1374. } + 1375. + +security/selinux/ss/policydb.c:1331: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1329. goto bad; + 1330. + 1331. > len = le32_to_cpu(buf[0]); + 1332. len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1332: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1330. + 1331. len = le32_to_cpu(buf[0]); + 1332. > len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + 1334. + +security/selinux/ss/policydb.c:1333: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1331. len = le32_to_cpu(buf[0]); + 1332. len2 = le32_to_cpu(buf[1]); + 1333. > cladatum->value = le32_to_cpu(buf[2]); + 1334. + 1335. rc = symtab_init(&cladatum->permissions, PERM_SYMTAB_SIZE); + +security/selinux/ss/policydb.c:1338: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1336. if (rc) + 1337. goto bad; + 1338. > cladatum->permissions.nprim = le32_to_cpu(buf[3]); + 1339. nel = le32_to_cpu(buf[4]); + 1340. + +security/selinux/ss/policydb.c:1339: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1337. goto bad; + 1338. cladatum->permissions.nprim = le32_to_cpu(buf[3]); + 1339. > nel = le32_to_cpu(buf[4]); + 1340. + 1341. ncons = le32_to_cpu(buf[5]); + +security/selinux/ss/policydb.c:1341: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1339. nel = le32_to_cpu(buf[4]); + 1340. + 1341. > ncons = le32_to_cpu(buf[5]); + 1342. + 1343. rc = str_read(&key, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:1374: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1372. if (rc) + 1373. goto bad; + 1374. > ncons = le32_to_cpu(buf[0]); + 1375. rc = read_cons_helper(p, &cladatum->validatetrans, + 1376. ncons, 1, fp); + +security/selinux/ss/policydb.c:1386: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1384. goto bad; + 1385. + 1386. > cladatum->default_user = le32_to_cpu(buf[0]); + 1387. cladatum->default_role = le32_to_cpu(buf[1]); + 1388. cladatum->default_range = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1387: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1385. + 1386. cladatum->default_user = le32_to_cpu(buf[0]); + 1387. > cladatum->default_role = le32_to_cpu(buf[1]); + 1388. cladatum->default_range = le32_to_cpu(buf[2]); + 1389. } + +security/selinux/ss/policydb.c:1388: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1386. cladatum->default_user = le32_to_cpu(buf[0]); + 1387. cladatum->default_role = le32_to_cpu(buf[1]); + 1388. > cladatum->default_range = le32_to_cpu(buf[2]); + 1389. } + 1390. + +security/selinux/ss/policydb.c:1395: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1393. if (rc) + 1394. goto bad; + 1395. > cladatum->default_type = le32_to_cpu(buf[0]); + 1396. } + 1397. + +kernel/auditfilter.c:1325: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1323. if (list_empty(&audit_filter_list[listtype])) + 1324. goto unlock_and_return; + 1325. > list_for_each_entry_rcu(e, &audit_filter_list[listtype], list) { + 1326. int i, result = 0; + 1327. + +net/ipv4/af_inet.c:1343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1341. + 1342. rcu_read_lock(); + 1343. > ops = rcu_dereference(inet_offloads[proto]); + 1344. if (!ops || !ops->callbacks.gro_receive) + 1345. goto out_unlock; + +net/netlink/af_netlink.c:1328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1326. + 1327. rcu_read_lock(); + 1328. > listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners); + 1329. + 1330. if (listeners && group - 1 < nl_table[sk->sk_protocol].groups) + +net/wireless/trace.h:1321: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +ipc/sem.c:1351: error: DEAD_STORE + The value written to &err (type int) is never used. + 1349. goto out_rcu_wakeup; + 1350. + 1351. > err = -EACCES; + 1352. switch (cmd) { + 1353. case GETALL: + +net/xfrm/xfrm_policy.c:1332: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1330. rcu_read_lock(); + 1331. for (i = 0; i < 2; i++) { + 1332. > p = rcu_dereference(osk->sk_policy[i]); + 1333. if (p) { + 1334. np = clone_policy(p, i); + +net/ipv4/tcp_ipv4.c:1364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1362. newsk->sk_bound_dev_if = ireq->ir_iif; + 1363. newinet->inet_saddr = ireq->ir_loc_addr; + 1364. > inet_opt = rcu_dereference(ireq->ireq_opt); + 1365. RCU_INIT_POINTER(newinet->inet_opt, inet_opt); + 1366. newinet->mc_index = inet_iif(skb); + +kernel/exit.c:1342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1340. * can't confuse the checks below. + 1341. */ + 1342. > int exit_state = READ_ONCE(p->exit_state); + 1343. int ret; + 1344. + +kernel/sched/core.c:1424: error: UNINITIALIZED_VALUE + The value read from ncsw was never initialized. + 1422. } + 1423. + 1424. > return ncsw; + 1425. } + 1426. + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +arch/x86/events/intel/p4.c:1347: error: DEAD_STORE + The value written to &high (type unsigned int) is never used. + 1345. BUILD_BUG_ON(ARCH_P4_MAX_CCCR > INTEL_PMC_MAX_GENERIC); + 1346. + 1347. > rdmsr(MSR_IA32_MISC_ENABLE, low, high); + 1348. if (!(low & (1 << 7))) { + 1349. pr_cont("unsupported Netburst CPU model %d ", + +drivers/iommu/iommu.c:1351: error: NULL_DEREFERENCE + pointer `group` last assigned on line 1343 could be null and is dereferenced by call to `__iommu_detach_group()` at line 1351, column 2. + 1349. } + 1350. + 1351. > __iommu_detach_group(domain, group); + 1352. + 1353. out_unlock: + +net/sunrpc/clnt.c:1349: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1347. + 1348. rcu_read_lock(); + 1349. > xprt = rcu_dereference(clnt->cl_xprt); + 1350. salen = xprt->addrlen; + 1351. memcpy(sap, &xprt->addr, salen); + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.altsetting was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +drivers/usb/core/devio.c:1349: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1347. if (copy_from_user(&setintf, arg, sizeof(setintf))) + 1348. return -EFAULT; + 1349. > ret = checkintf(ps, setintf.interface); + 1350. if (ret) + 1351. return ret; + +drivers/usb/core/devio.c:1353: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1351. return ret; + 1352. + 1353. > destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. return usb_set_interface(ps->dev, setintf.interface, + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +kernel/events/core.c:1359: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1357. local_irq_save(*flags); + 1358. rcu_read_lock(); + 1359. > ctx = rcu_dereference(task->perf_event_ctxp[ctxn]); + 1360. if (ctx) { + 1361. /* + +kernel/events/core.c:1372: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1370. */ + 1371. raw_spin_lock(&ctx->lock); + 1372. > if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) { + 1373. raw_spin_unlock(&ctx->lock); + 1374. rcu_read_unlock(); + +net/wireless/trace.h:1343: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +kernel/signal.c:1347: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1345. struct task_struct *target) + 1346. { + 1347. > const struct cred *pcred = __task_cred(target); + 1348. if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) && + 1349. !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid)) + +kernel/sys.c:1356: error: UNINITIALIZED_VALUE + The value read from r32.rlim_cur was never initialized. + 1354. r.rlim_cur = RLIM_INFINITY; + 1355. else + 1356. > r.rlim_cur = r32.rlim_cur; + 1357. if (r32.rlim_max == COMPAT_RLIM_INFINITY) + 1358. r.rlim_max = RLIM_INFINITY; + +kernel/sys.c:1360: error: UNINITIALIZED_VALUE + The value read from r32.rlim_max was never initialized. + 1358. r.rlim_max = RLIM_INFINITY; + 1359. else + 1360. > r.rlim_max = r32.rlim_max; + 1361. return do_prlimit(current, resource, &r, NULL); + 1362. } + +net/ipv4/devinet.c:1357: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1355. + 1356. rcu_read_lock(); + 1357. > for_each_netdev_rcu(net, dev) { + 1358. in_dev = __in_dev_get_rcu(dev); + 1359. if (in_dev) { + +net/packet/af_packet.c:1354: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1352. unsigned int num) + 1353. { + 1354. > return smp_processor_id() % num; + 1355. } + 1356. + +drivers/cpufreq/intel_pstate.c:1356: error: DEAD_STORE + The value written to &pstate (type int) is never used. + 1354. + 1355. update_turbo_state(); + 1356. > pstate = intel_pstate_get_base_pstate(cpu); + 1357. pstate = max(cpu->pstate.min_pstate, cpu->max_perf_ratio); + 1358. intel_pstate_set_pstate(cpu, pstate); + +net/ipv4/route.c:1368: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1366. */ + 1367. dst_hold(&rt->dst); + 1368. > prev = cmpxchg(p, orig, rt); + 1369. if (prev == orig) { + 1370. if (orig) { + +net/ipv4/tcp_input.c:1479: error: DEAD_STORE + The value written to &pcount (type int) is never used. + 1477. len = skb->len; + 1478. if (skb_shift(prev, skb, len)) { + 1479. > pcount += tcp_skb_pcount(skb); + 1480. tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb), + 1481. len, mss, 0); + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +net/sunrpc/clnt.c:1371: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1369. + 1370. rcu_read_lock(); + 1371. > xprt = rcu_dereference(clnt->cl_xprt); + 1372. if (xprt->ops->set_buffer_size) + 1373. xprt->ops->set_buffer_size(xprt, sndsize, rcvsize); + +net/sunrpc/auth_gss/auth_gss.c:1376: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1374. + 1375. rcu_read_lock(); + 1376. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1377. if (!ctx) + 1378. goto out; + +net/sunrpc/auth_gss/auth_gss.c:1392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1390. + 1391. rcu_read_lock(); + 1392. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1393. + 1394. /* did the ctx disappear or was it replaced by one with no acceptor? */ + +net/wireless/trace.h:1366: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +drivers/usb/host/uhci-q.c:1386: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1384. uhci_remove_tds_from_frame(uhci, qh->iso_frame); + 1385. + 1386. > ctrlstat = td_status(uhci, td); + 1387. if (ctrlstat & TD_CTRL_ACTIVE) { + 1388. status = -EXDEV; /* TD was added too late? */ + +kernel/fork.c:1374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1372. unsigned long cpu_limit; + 1373. + 1374. > cpu_limit = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); + 1375. if (cpu_limit != RLIM_INFINITY) { + 1376. sig->cputime_expires.prof_exp = cpu_limit * NSEC_PER_SEC; + +arch/x86/events/intel/ds.c:1476: error: UNINITIALIZED_VALUE + The value read from counts[_] was never initialized. + 1474. + 1475. if (counts[bit]) { + 1476. > __intel_pmu_pebs_event(event, iregs, base, + 1477. top, bit, counts[bit]); + 1478. } + +arch/x86/events/intel/ds.c:1469: error: UNINITIALIZED_VALUE + The value read from error[_] was never initialized. + 1467. /* log dropped samples number */ + 1468. if (error[bit]) { + 1469. > perf_log_lost_samples(event, error[bit]); + 1470. + 1471. if (perf_event_account_interrupt(event)) + +kernel/sched/rt.c:1392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1390. + 1391. rcu_read_lock(); + 1392. > curr = READ_ONCE(rq->curr); /* unlocked access */ + 1393. + 1394. /* + +net/sunrpc/clnt.c:1388: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1386. + 1387. rcu_read_lock(); + 1388. > protocol = rcu_dereference(clnt->cl_xprt)->prot; + 1389. rcu_read_unlock(); + 1390. return protocol; + +net/core/net-sysfs.c:1405: error: DEAD_STORE + The value written to &txq (type int) is never used. + 1403. if (error) + 1404. goto error; + 1405. > txq = real_tx; + 1406. + 1407. return 0; + +net/wireless/trace.h:1384: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/ipv6/route.c:1395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1393. struct rt6_info *res = NULL; + 1394. + 1395. > bucket = rcu_dereference(rt->rt6i_exception_bucket); + 1396. + 1397. #ifdef CONFIG_IPV6_SUBTREES + +drivers/gpu/drm/i915/intel_overlay.c:1429: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1427. if (IS_ERR(vma)) { + 1428. DRM_ERROR("failed to pin overlay register bo\n"); + 1429. > ret = PTR_ERR(vma); + 1430. goto out_free_bo; + 1431. } + +scripts/kconfig/symbol.c:1397: error: NULL_DEREFERENCE + pointer `sym2` last assigned on line 1396 could be null and is dereferenced at line 1397, column 14. + 1395. for_all_properties(sym, prop, P_ENV) { + 1396. sym2 = prop_get_symbol(prop); + 1397. > if (strcmp(sym2->name, env)) + 1398. menu_warn(current_entry, "redefining environment symbol from %s", + 1399. sym2->name); + +net/netfilter/nf_conntrack_netlink.c:1396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1394. int err; + 1395. + 1396. > parse_nat_setup = rcu_dereference(nfnetlink_parse_nat_setup_hook); + 1397. if (!parse_nat_setup) { + 1398. #ifdef CONFIG_MODULES + +net/core/rtnetlink.c:1402: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1400. return -EMSGSIZE; + 1401. + 1402. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 1403. struct nlattr *af; + 1404. int err; + +kernel/rcu/tree.c:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. WRITE_ONCE(rsp->jiffies_stall, j + j1); + 1404. rsp->jiffies_resched = j + j1 / 2; + 1405. > rsp->n_force_qs_gpstart = READ_ONCE(rsp->n_force_qs); + 1406. } + 1407. + +drivers/gpu/drm/i915/intel_runtime_pm.c:1422: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1420. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1421. + 1422. > if (wait_for(COND, 100)) + 1423. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1424. state, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1449: error: DEAD_STORE + The value written to &l (type int) is never used. + 1447. if (!ret_val) + 1448. good_cnt++; + 1449. > if (unlikely(++l == rxdr->count)) + 1450. l = 0; + 1451. /* time + 20 msecs (200 msecs on 2.4) is more than + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1435: error: DEAD_STORE + The value written to &time (type unsigned long) is never used. + 1433. E1000_WRITE_FLUSH(); + 1434. msleep(200); + 1435. > time = jiffies; /* set the start time for the receive */ + 1436. good_cnt = 0; + 1437. do { /* receive the sent packets */ + +kernel/signal.c:1422: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1420. struct task_struct * p; + 1421. + 1422. > for_each_process(p) { + 1423. if (task_pid_vnr(p) > 1 && + 1424. !same_thread_group(p, current)) { + +net/netfilter/nf_conntrack_sip.c:1423: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1405 could be null and is dereferenced at line 1423, column 3. + 1421. port != ct->tuplehash[dir].tuple.src.u.udp.port && + 1422. nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3)) + 1423. > ct_sip_info->forced_dport = port; + 1424. + 1425. for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) { + +net/sunrpc/clnt.c:1404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1402. + 1403. rcu_read_lock(); + 1404. > ret = rcu_dereference(clnt->cl_xprt)->xprt_net; + 1405. rcu_read_unlock(); + 1406. return ret; + +drivers/md/dm-raid1.c:1422: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1420. (unsigned long long)ms->nr_regions, buffer); + 1421. + 1422. > sz += log->type->status(log, type, result+sz, maxlen-sz); + 1423. + 1424. break; + +drivers/md/dm-raid1.c:1441: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1439. DMEMIT(" handle_errors"); + 1440. if (keep_log(ms)) + 1441. > DMEMIT(" keep_log"); + 1442. } + 1443. + +drivers/gpu/vga/vgaarb.c:1468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1466. + 1467. if (!vga_default_device()) { + 1468. > vgadev = list_first_entry_or_null(&vga_list, + 1469. struct vga_device, list); + 1470. if (vgadev) { + +net/wireless/trace.h:1405: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +security/selinux/ss/policydb.c:1427: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1425. goto bad; + 1426. + 1427. > len = le32_to_cpu(buf[0]); + 1428. role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +security/selinux/ss/policydb.c:1428: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1426. + 1427. len = le32_to_cpu(buf[0]); + 1428. > role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1430. role->bounds = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1430: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1428. role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1430. > role->bounds = le32_to_cpu(buf[2]); + 1431. + 1432. rc = str_read(&key, GFP_KERNEL, fp, len); + +drivers/net/ethernet/broadcom/tg3.c:1415: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 1414 could be null and is dereferenced at line 1415, column 10. + 1413. + 1414. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 1415. > switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) { + 1416. case PHY_ID_BCM50610: + 1417. case PHY_ID_BCM50610M: + +net/packet/af_packet.c:1418: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1416. + 1417. rcu_read_lock(); + 1418. > prog = rcu_dereference(f->bpf_prog); + 1419. if (prog) + 1420. ret = bpf_prog_run_clear_cb(prog, skb) % num; + +net/ipv6/route.c:1428: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1426. return -EINVAL; + 1427. + 1428. > if (!rcu_access_pointer(from->rt6i_exception_bucket)) + 1429. return -ENOENT; + 1430. + +drivers/gpu/drm/i915/intel_tv.c:1430: error: NULL_DEREFERENCE + pointer `old_state` last assigned on line 1427 could be null and is dereferenced at line 1430, column 6. + 1428. new_crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc); + 1429. + 1430. > if (old_state->tv.mode != new_state->tv.mode || + 1431. old_state->tv.margins.left != new_state->tv.margins.left || + 1432. old_state->tv.margins.right != new_state->tv.margins.right || + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1431: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1429. return -EFAULT; + 1430. + 1431. > if (tmp.oldlenp && get_user(oldlen, tmp.oldlenp)) + 1432. return -EFAULT; + 1433. + +kernel/sysctl_binary.c:1442: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1440. } + 1441. + 1442. > if (tmp.oldlenp && put_user(oldlen, tmp.oldlenp)) + 1443. return -EFAULT; + 1444. + +net/sunrpc/clnt.c:1424: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1422. + 1423. rcu_read_lock(); + 1424. > ret = rcu_dereference(clnt->cl_xprt)->max_payload; + 1425. rcu_read_unlock(); + 1426. return ret; + +net/ipv6/ip6_fib.c:1428: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1426. + 1427. for (fn = root; fn ; ) { + 1428. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 1429. struct rt6key *key; + 1430. + +net/ipv6/ip6_fib.c:1458: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1456. */ + 1457. if (addr_bit_set(addr, fn->fn_bit)) + 1458. > fn = rcu_dereference(fn->right); + 1459. else + 1460. fn = rcu_dereference(fn->left); + +net/ipv6/ip6_fib.c:1460: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1458. fn = rcu_dereference(fn->right); + 1459. else + 1460. > fn = rcu_dereference(fn->left); + 1461. } + 1462. out: + +kernel/rcu/tree.c:1427: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1425. + 1426. j = jiffies; + 1427. > gpa = READ_ONCE(rsp->gp_activity); + 1428. if (j - gpa > 2 * HZ) { + 1429. pr_err("%s kthread starved for %ld jiffies! g%lu c%lu f%#x %s(%d) ->state=%#lx ->cpu=%d\n", + +net/wireless/trace.h:1421: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/sunrpc/auth_gss/auth_gss.c:1430: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 1428. struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base); + 1429. struct gss_cl_ctx *ctx; + 1430. > unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ); + 1431. int ret = 0; + 1432. + +net/sunrpc/auth_gss/auth_gss.c:1434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1432. + 1433. rcu_read_lock(); + 1434. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1435. if (!ctx || time_after(timeout, ctx->gc_expiry)) + 1436. ret = -EACCES; + +net/ipv6/udp.c:1435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1433. if (static_key_false(&udpv6_encap_needed) && up->encap_type) { + 1434. void (*encap_destroy)(struct sock *sk); + 1435. > encap_destroy = READ_ONCE(up->encap_destroy); + 1436. if (encap_destroy) + 1437. encap_destroy(sk); + +drivers/base/regmap/regmap.c:1520: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1518. + 1519. spin_lock_irqsave(&map->async_lock, flags); + 1520. > async = list_first_entry_or_null(&map->async_free, + 1521. struct regmap_async, + 1522. list); + +kernel/kprobes.c:1438: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1436. + 1437. if (p != ap) { + 1438. > list_for_each_entry_rcu(list_p, &ap->list, list) + 1439. if (list_p == p) + 1440. /* kprobe p is a valid probe */ + +drivers/block/loop.c:1442: error: UNINITIALIZED_VALUE + The value read from info.lo_device was never initialized. + 1440. memset(info64, 0, sizeof(*info64)); + 1441. info64->lo_number = info.lo_number; + 1442. > info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + +drivers/block/loop.c:1448: error: UNINITIALIZED_VALUE + The value read from info.lo_encrypt_key_size was never initialized. + 1446. info64->lo_sizelimit = 0; + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. > info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. info64->lo_flags = info.lo_flags; + 1450. info64->lo_init[0] = info.lo_init[0]; + +drivers/block/loop.c:1447: error: UNINITIALIZED_VALUE + The value read from info.lo_encrypt_type was never initialized. + 1445. info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + 1447. > info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. info64->lo_flags = info.lo_flags; + +drivers/block/loop.c:1449: error: UNINITIALIZED_VALUE + The value read from info.lo_flags was never initialized. + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. > info64->lo_flags = info.lo_flags; + 1450. info64->lo_init[0] = info.lo_init[0]; + 1451. info64->lo_init[1] = info.lo_init[1]; + +drivers/block/loop.c:1443: error: UNINITIALIZED_VALUE + The value read from info.lo_inode was never initialized. + 1441. info64->lo_number = info.lo_number; + 1442. info64->lo_device = info.lo_device; + 1443. > info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + 1445. info64->lo_offset = info.lo_offset; + +drivers/block/loop.c:1441: error: UNINITIALIZED_VALUE + The value read from info.lo_number was never initialized. + 1439. + 1440. memset(info64, 0, sizeof(*info64)); + 1441. > info64->lo_number = info.lo_number; + 1442. info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + +drivers/block/loop.c:1445: error: UNINITIALIZED_VALUE + The value read from info.lo_offset was never initialized. + 1443. info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + 1445. > info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + +drivers/block/loop.c:1444: error: UNINITIALIZED_VALUE + The value read from info.lo_rdevice was never initialized. + 1442. info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + 1444. > info64->lo_rdevice = info.lo_rdevice; + 1445. info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + +net/packet/af_packet.c:1435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1433. { + 1434. struct packet_fanout *f = pt->af_packet_priv; + 1435. > unsigned int num = READ_ONCE(f->num_members); + 1436. struct net *net = read_pnet(&f->net); + 1437. struct packet_sock *po; + +ipc/mqueue.c:1445: error: UNINITIALIZED_VALUE + The value read from v.mq_curmsgs was never initialized. + 1443. attr->mq_maxmsg = v.mq_maxmsg; + 1444. attr->mq_msgsize = v.mq_msgsize; + 1445. > attr->mq_curmsgs = v.mq_curmsgs; + 1446. return 0; + 1447. } + +ipc/mqueue.c:1442: error: UNINITIALIZED_VALUE + The value read from v.mq_flags was never initialized. + 1440. + 1441. memset(attr, 0, sizeof(*attr)); + 1442. > attr->mq_flags = v.mq_flags; + 1443. attr->mq_maxmsg = v.mq_maxmsg; + 1444. attr->mq_msgsize = v.mq_msgsize; + +ipc/mqueue.c:1443: error: UNINITIALIZED_VALUE + The value read from v.mq_maxmsg was never initialized. + 1441. memset(attr, 0, sizeof(*attr)); + 1442. attr->mq_flags = v.mq_flags; + 1443. > attr->mq_maxmsg = v.mq_maxmsg; + 1444. attr->mq_msgsize = v.mq_msgsize; + 1445. attr->mq_curmsgs = v.mq_curmsgs; + +ipc/mqueue.c:1444: error: UNINITIALIZED_VALUE + The value read from v.mq_msgsize was never initialized. + 1442. attr->mq_flags = v.mq_flags; + 1443. attr->mq_maxmsg = v.mq_maxmsg; + 1444. > attr->mq_msgsize = v.mq_msgsize; + 1445. attr->mq_curmsgs = v.mq_curmsgs; + 1446. return 0; + +drivers/gpu/drm/i915/intel_uncore.c:1443: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1441. pci_write_config_byte(pdev, I915_GDRST, 0); + 1442. + 1443. > return wait_for(i915_reset_complete(pdev), 500); + 1444. } + 1445. + +drivers/gpu/drm/i915/intel_uncore.c:1443: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1441. pci_write_config_byte(pdev, I915_GDRST, 0); + 1442. + 1443. > return wait_for(i915_reset_complete(pdev), 500); + 1444. } + 1445. + +net/sunrpc/clnt.c:1440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1438. + 1439. rcu_read_lock(); + 1440. > xprt = rcu_dereference(clnt->cl_xprt); + 1441. ret = xprt->ops->bc_maxpayload(xprt); + 1442. rcu_read_unlock(); + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +drivers/base/power/main.c:1445: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1443. idx = device_links_read_lock(); + 1444. + 1445. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) { + 1446. spin_lock_irq(&link->supplier->power.lock); + 1447. link->supplier->power.direct_complete = false; + +kernel/sched/core.c:1446: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1444. preempt_disable(); + 1445. cpu = task_cpu(p); + 1446. > if ((cpu != smp_processor_id()) && task_curr(p)) + 1447. smp_send_reschedule(cpu); + 1448. preempt_enable(); + +net/wireless/trace.h:1441: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/sunrpc/auth_gss/auth_gss.c:1453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1451. /* Don't match with creds that have expired. */ + 1452. rcu_read_lock(); + 1453. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1454. if (!ctx || time_after(jiffies, ctx->gc_expiry)) { + 1455. rcu_read_unlock(); + +net/ipv4/ipmr.c:1467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1465. } + 1466. if (optname != MRT_INIT) { + 1467. > if (sk != rcu_access_pointer(mrt->mroute_sk) && + 1468. !ns_capable(net->user_ns, CAP_NET_ADMIN)) { + 1469. ret = -EACCES; + +net/ipv4/ipmr.c:1496: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1494. break; + 1495. case MRT_DONE: + 1496. > if (sk != rcu_access_pointer(mrt->mroute_sk)) { + 1497. ret = -EACCES; + 1498. } else { + +net/ipv4/ipmr.c:1542: error: UNINITIALIZED_VALUE + The value read from mfc.mfcc_parent was never initialized. + 1540. } + 1541. if (parent == 0) + 1542. > parent = mfc.mfcc_parent; + 1543. if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY) + 1544. ret = ipmr_mfc_delete(mrt, &mfc, parent); + +net/ipv4/ipmr.c:1521: error: UNINITIALIZED_VALUE + The value read from vif.vifc_vifi was never initialized. + 1519. sk == rtnl_dereference(mrt->mroute_sk)); + 1520. } else { + 1521. > ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL); + 1522. } + 1523. break; + +drivers/gpu/drm/drm_vblank.c:1548: error: DEAD_STORE + The value written to &end (type unsigned long) is never used. + 1546. DRM_DEBUG("waiting on vblank count %llu, crtc %u\n", + 1547. req_seq, pipe); + 1548. > DRM_WAIT_ON(ret, vblank->queue, 3 * HZ, + 1549. vblank_passed(drm_vblank_count(dev, pipe), + 1550. req_seq) || + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +net/ipv4/devinet.c:1471: error: DEAD_STORE + The value written to &in_dev (type in_device*) is never used. + 1469. /* Re-enabling IP */ + 1470. if (inetdev_valid_mtu(dev->mtu)) + 1471. > in_dev = inetdev_init(dev); + 1472. } + 1473. goto out; + +net/sunrpc/clnt.c:1456: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1454. if (clnt->cl_autobind) { + 1455. rcu_read_lock(); + 1456. > xprt_clear_bound(rcu_dereference(clnt->cl_xprt)); + 1457. rcu_read_unlock(); + 1458. } + +drivers/gpu/drm/i915/intel_uncore.c:1459: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1457. + 1458. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1459. > return wait_for(g4x_reset_complete(pdev), 500); + 1460. } + 1461. + +drivers/gpu/drm/i915/intel_uncore.c:1459: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1457. + 1458. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1459. > return wait_for(g4x_reset_complete(pdev), 500); + 1460. } + 1461. + +net/netfilter/nf_conntrack_sip.c:1468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1466. + 1467. if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) { + 1468. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1469. if (hooks && !hooks->msg(skb, protoff, dataoff, + 1470. dptr, datalen)) { + +kernel/trace/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1459. static inline void *event_file_data(struct file *filp) + 1460. { + 1461. > return READ_ONCE(file_inode(filp)->i_private); + 1462. } + 1463. + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.name was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1480: error: UNINITIALIZED_VALUE + The value read from tmp.newval was never initialized. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. > compat_ptr(tmp.newval), tmp.newlen); + 1481. + 1482. if (result >= 0) { + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1474: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1472. return -EFAULT; + 1473. + 1474. > compat_oldlenp = compat_ptr(tmp.oldlenp); + 1475. if (compat_oldlenp && get_user(oldlen, compat_oldlenp)) + 1476. return -EFAULT; + +kernel/sysctl_binary.c:1479: error: UNINITIALIZED_VALUE + The value read from tmp.oldval was never initialized. + 1477. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. > compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + 1481. + +net/ipv6/route.c:1473: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1471. + 1472. rcu_read_lock(); + 1473. > bucket = rcu_dereference(from->rt6i_exception_bucket); + 1474. + 1475. #ifdef CONFIG_IPV6_SUBTREES + +net/wireless/trace.h:1461: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +drivers/gpu/drm/i915/i915_debugfs.c:1472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1470. + 1471. for_each_fw_domain(fw_domain, i915, tmp) + 1472. > seq_printf(m, "%s.wake_count = %u\n", + 1473. intel_uncore_forcewake_domain_to_str(fw_domain->id), + 1474. READ_ONCE(fw_domain->wake_count)); + +drivers/gpu/drm/i915/intel_uncore.c:1474: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1472. pci_write_config_byte(pdev, I915_GDRST, + 1473. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1474. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1475. if (ret) { + 1476. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1482: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1480. pci_write_config_byte(pdev, I915_GDRST, + 1481. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1482. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1483. if (ret) { + 1484. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1474: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1472. pci_write_config_byte(pdev, I915_GDRST, + 1473. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1474. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1475. if (ret) { + 1476. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1482: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1480. pci_write_config_byte(pdev, I915_GDRST, + 1481. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1482. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1483. if (ret) { + 1484. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/net/ethernet/intel/e100.c:1472: error: DEAD_STORE + The value written to &stat (type unsigned short) is never used. + 1470. nic->mii.phy_id = (addr == 0) ? 1 : (addr == 1) ? 0 : addr; + 1471. bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR); + 1472. > stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1473. stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1474. if (!((bmcr == 0xFFFF) || ((stat == 0) && (bmcr == 0)))) + +kernel/trace/trace_events_trigger.c:1472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1470. int ret = 0; + 1471. + 1472. > list_for_each_entry_rcu(test, &file->triggers, list) { + 1473. test_enable_data = test->private_data; + 1474. if (test_enable_data && + +net/netlabel/netlabel_unlabeled.c:1472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1470. iface = netlbl_unlhsh_search_iface(skb->skb_iif); + 1471. if (iface == NULL) + 1472. > iface = rcu_dereference(netlbl_unlhsh_def); + 1473. if (iface == NULL || !iface->valid) + 1474. goto unlabel_getattr_nolabel; + +security/selinux/ss/policydb.c:1483: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1481. goto bad; + 1482. + 1483. > len = le32_to_cpu(buf[0]); + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + +security/selinux/ss/policydb.c:1484: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1482. + 1483. len = le32_to_cpu(buf[0]); + 1484. > typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + 1486. u32 prop = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1486: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + 1486. > u32 prop = le32_to_cpu(buf[2]); + 1487. + 1488. if (prop & TYPEDATUM_PROPERTY_PRIMARY) + +security/selinux/ss/policydb.c:1493: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1491. typdatum->attribute = 1; + 1492. + 1493. > typdatum->bounds = le32_to_cpu(buf[3]); + 1494. } else { + 1495. typdatum->primary = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1495: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1493. typdatum->bounds = le32_to_cpu(buf[3]); + 1494. } else { + 1495. > typdatum->primary = le32_to_cpu(buf[2]); + 1496. } + 1497. + +kernel/rcu/tree.c:1475: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1473. if (!rcu_kick_kthreads) + 1474. return; + 1475. > j = READ_ONCE(rsp->jiffies_kick_kthreads); + 1476. if (time_after(jiffies, j) && rsp->gp_kthread && + 1477. (rcu_gp_in_progress(rsp) || READ_ONCE(rsp->gp_flags))) { + +drivers/cpufreq/intel_pstate.c:1480: error: DEAD_STORE + The value written to &max_pstate (type int) is never used. + 1478. static int intel_pstate_prepare_request(struct cpudata *cpu, int pstate) + 1479. { + 1480. > int max_pstate = intel_pstate_get_base_pstate(cpu); + 1481. int min_pstate; + 1482. + +net/netfilter/nf_conntrack_sip.c:1555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1553. const struct nf_nat_sip_hooks *hooks; + 1554. + 1555. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1556. if (hooks) + 1557. hooks->seq_adjust(skb, protoff, tdiff); + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1502: error: DEAD_STORE + The value written to &c (type char) is never used. + 1500. end = addr + size; + 1501. for (; addr < end; addr += PAGE_SIZE) { + 1502. > int err = __get_user(c, addr); + 1503. if (err) + 1504. return err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1506: error: DEAD_STORE + The value written to &c (type char) is never used. + 1504. return err; + 1505. } + 1506. > return __get_user(c, end - 1); + 1507. } + 1508. + +drivers/hid/hid-sony.c:1619: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1617. err_stop: + 1618. kfree(buf); + 1619. > return ret; + 1620. } + 1621. + +sound/core/control.c:1510: error: UNINITIALIZED_VALUE + The value read from header.length was never initialized. + 1508. if (header.length < sizeof(unsigned int) * 2) + 1509. return -EINVAL; + 1510. > container_size = header.length; + 1511. container = buf->tlv; + 1512. + +sound/core/control.c:1513: error: UNINITIALIZED_VALUE + The value read from header.numid was never initialized. + 1511. container = buf->tlv; + 1512. + 1513. > kctl = snd_ctl_find_numid(file->card, header.numid); + 1514. if (kctl == NULL) + 1515. return -ENOENT; + +include/linux/blkdev.h:1493: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1491. { + 1492. unsigned int granularity = max(lim->physical_block_size, lim->io_min); + 1493. > unsigned int alignment = sector_div(sector, granularity >> 9) << 9; + 1494. + 1495. return (granularity + lim->alignment_offset - alignment) % granularity; + +net/ipv4/af_inet.c:1507: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1505. + 1506. rcu_read_lock(); + 1507. > ops = rcu_dereference(inet_offloads[proto]); + 1508. if (WARN_ON(!ops || !ops->callbacks.gro_complete)) + 1509. goto out_unlock; + +kernel/rcu/tree.c:1558: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1556. } else { + 1557. j = jiffies; + 1558. > gpa = READ_ONCE(rsp->gp_activity); + 1559. pr_err("All QSes seen, last %s kthread activity %ld (%ld-%ld), jiffies_till_next_fqs=%ld, root ->qsmask %#lx\n", + 1560. rsp->name, j - gpa, j, gpa, + +kernel/rcu/tree.c:1544: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1542. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1543. cpu)->cblist); + 1544. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1545. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1546. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +kernel/rcu/tree.c:1544: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1542. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1543. cpu)->cblist); + 1544. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1545. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1546. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +net/core/net-sysfs.c:1501: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1499. * device is dead and about to be freed. + 1500. */ + 1501. > kfree(rcu_access_pointer(dev->ifalias)); + 1502. netdev_freemem(dev); + 1503. } + +security/keys/keyctl.c:1540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1538. * there's no point */ + 1539. mycred = current_cred(); + 1540. > pcred = __task_cred(parent); + 1541. if (mycred == pcred || + 1542. mycred->session_keyring == pcred->session_keyring) { + +drivers/gpu/drm/i915/intel_cdclk.c:1506: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1504. + 1505. /* Timeout 200us */ + 1506. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1507. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1508. + +kernel/cgroup/cpuset.c:1503: error: DEAD_STORE + The value written to &cs (type cpuset*) is never used. + 1501. + 1502. cgroup_taskset_first(tset, &css); + 1503. > cs = css_cs(css); + 1504. + 1505. mutex_lock(&cpuset_mutex); + +net/ipv4/netfilter/ip_tables.c:1518: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1516. tmp.name[sizeof(tmp.name)-1] = 0; + 1517. + 1518. > newinfo = xt_alloc_table_info(tmp.size); + 1519. if (!newinfo) + 1520. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1523: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1521. + 1522. loc_cpu_entry = newinfo->entries; + 1523. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1524. tmp.size) != 0) { + 1525. ret = -EFAULT; + +net/netfilter/nf_conntrack_netlink.c:1521: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1519. if (help) { + 1520. rcu_read_lock(); + 1521. > helper = rcu_dereference(help->helper); + 1522. if (helper && !strcmp(helper->name, helpname)) + 1523. err = 0; + +kernel/trace/trace_events_trigger.c:1512: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1510. bool unregistered = false; + 1511. + 1512. > list_for_each_entry_rcu(data, &file->triggers, list) { + 1513. enable_data = data->private_data; + 1514. if (enable_data && + +net/wireless/trace.h:1506: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +kernel/trace/ring_buffer.c:1549: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1547. first_page->prev = prev_page; + 1548. + 1549. > r = cmpxchg(&prev_page->next, head_page_with_bit, first_page); + 1550. + 1551. if (r == head_page_with_bit) { + +net/ipv4/ip_output.c:1518: error: DEAD_STORE + The value written to &rt (type rtable*) is never used. + 1516. struct ipcm_cookie ipc; + 1517. struct flowi4 fl4; + 1518. > struct rtable *rt = skb_rtable(skb); + 1519. struct net *net = sock_net(sk); + 1520. struct sk_buff *nskb; + +net/ipv6/netfilter/ip6_tables.c:1529: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1527. tmp.name[sizeof(tmp.name)-1] = 0; + 1528. + 1529. > newinfo = xt_alloc_table_info(tmp.size); + 1530. if (!newinfo) + 1531. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1534: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1532. + 1533. loc_cpu_entry = newinfo->entries; + 1534. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1535. tmp.size) != 0) { + 1536. ret = -EFAULT; + +kernel/sched/deadline.c:1523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1521. + 1522. rcu_read_lock(); + 1523. > curr = READ_ONCE(rq->curr); /* unlocked access */ + 1524. + 1525. /* + +kernel/time/timer.c:1513: error: DEAD_STORE + The value written to &base (type timer_base*) is never used. + 1511. u64 get_next_timer_interrupt(unsigned long basej, u64 basem) + 1512. { + 1513. > struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]); + 1514. u64 expires = KTIME_MAX; + 1515. unsigned long nextevt; + +kernel/time/timer.c:1522: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1520. * Possible pending timers will be migrated later to an active cpu. + 1521. */ + 1522. > if (cpu_is_offline(smp_processor_id())) + 1523. return expires; + 1524. + +kernel/time/timer.c:1522: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1520. * Possible pending timers will be migrated later to an active cpu. + 1521. */ + 1522. > if (cpu_is_offline(smp_processor_id())) + 1523. return expires; + 1524. + +drivers/gpu/drm/i915/i915_debugfs.c:1520: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1518. int count = 0; + 1519. + 1520. > forcewake_count = READ_ONCE(dev_priv->uncore.fw_domain[FW_DOMAIN_ID_RENDER].wake_count); + 1521. if (forcewake_count) { + 1522. seq_puts(m, "RC information inaccurate because somebody " + +drivers/gpu/drm/i915/intel_cdclk.c:1524: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1522. + 1523. /* Timeout 200us */ + 1524. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1525. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1526. + +net/ipv4/tcp_ipv4.c:1540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1538. skb->destructor = sock_edemux; + 1539. if (sk_fullsock(sk)) { + 1540. > struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst); + 1541. + 1542. if (dst) + +security/selinux/ss/policydb.c:1528: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1526. return rc; + 1527. } + 1528. > lp->sens = le32_to_cpu(buf[0]); + 1529. + 1530. rc = ebitmap_read(&lp->cat, fp); + +include/linux/blkdev.h:1533: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1531. + 1532. /* Offset of the partition start in 'granularity' sectors */ + 1533. > offset = sector_div(sector, granularity); + 1534. + 1535. /* And why do we do this modulus *again* in blkdev_issue_discard()? */ + +drivers/cpufreq/intel_pstate.c:1529: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1527. + 1528. /* Don't allow remote callbacks */ + 1529. > if (smp_processor_id() != cpu->cpu) + 1530. return; + 1531. + +net/wireless/trace.h:1524: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +drivers/pci/setup-bus.c:1533: error: DEAD_STORE + The value written to &idx (type int) is never used. + 1531. unsigned old_flags = 0; + 1532. struct resource *b_res; + 1533. > int idx = 1; + 1534. + 1535. b_res = &dev->resource[PCI_BRIDGE_RESOURCES]; + +security/selinux/ss/policydb.c:1557: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1555. goto bad; + 1556. + 1557. > len = le32_to_cpu(buf[0]); + 1558. usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +security/selinux/ss/policydb.c:1558: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1556. + 1557. len = le32_to_cpu(buf[0]); + 1558. > usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1560. usrdatum->bounds = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1560: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1558. usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1560. > usrdatum->bounds = le32_to_cpu(buf[2]); + 1561. + 1562. rc = str_read(&key, GFP_KERNEL, fp, len); + +kernel/sys.c:1548: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1546. return 0; + 1547. + 1548. > tcred = __task_cred(task); + 1549. id_match = (uid_eq(cred->uid, tcred->euid) && + 1550. uid_eq(cred->uid, tcred->suid) && + +net/core/ethtool.c:1565: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1563. return -ENOMEM; + 1564. + 1565. > bytes_remaining = eeprom.len; + 1566. while (bytes_remaining > 0) { + 1567. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +net/ipv6/route.c:1549: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1547. int i; + 1548. + 1549. > if (!rcu_access_pointer(rt->rt6i_exception_bucket)) + 1550. return; + 1551. + +arch/x86/events/intel/ds.c:1545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1543. void perf_restore_debug_store(void) + 1544. { + 1545. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 1546. + 1547. if (!x86_pmu.bts && !x86_pmu.pebs) + +arch/x86/events/intel/ds.c:1545: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1543. void perf_restore_debug_store(void) + 1544. { + 1545. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 1546. + 1547. if (!x86_pmu.bts && !x86_pmu.pebs) + +drivers/base/power/runtime.c:1552: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1550. idx = device_links_read_lock(); + 1551. + 1552. > list_for_each_entry_rcu(link, &dev->links.consumers, s_node) { + 1553. if (link->flags & DL_FLAG_STATELESS) + 1554. continue; + +net/wireless/trace.h:1545: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/xfrm/xfrm_policy.c:1633: error: NULL_DEREFERENCE + pointer `dst_prev` last assigned on line 1554 could be null and is dereferenced at line 1633, column 2. + 1631. } + 1632. + 1633. > dst_prev->child = dst; + 1634. dst0->path = dst; + 1635. + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1565: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1563. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1564. + 1565. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1566. PORT_PLL_POWER_STATE), 200)) + 1567. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1565: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1563. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1564. + 1565. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1566. PORT_PLL_POWER_STATE), 200)) + 1567. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1565: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1563. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1564. + 1565. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1566. PORT_PLL_POWER_STATE), 200)) + 1567. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1565: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1563. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1564. + 1565. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1566. PORT_PLL_POWER_STATE), 200)) + 1567. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +net/wireless/util.c:1579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1577. if (params->radar_detect) { + 1578. rcu_read_lock(); + 1579. > regdom = rcu_dereference(cfg80211_regdomain); + 1580. if (regdom) + 1581. region = regdom->dfs_region; + +kernel/printk/printk.c:1568: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1566. if (!con->write) + 1567. continue; + 1568. > if (!cpu_online(smp_processor_id()) && + 1569. !(con->flags & CON_ANYTIME)) + 1570. continue; + +kernel/printk/printk.c:1568: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1566. if (!con->write) + 1567. continue; + 1568. > if (!cpu_online(smp_processor_id()) && + 1569. !(con->flags & CON_ANYTIME)) + 1570. continue; + +net/core/sock.c:1560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1558. sk->sk_destruct(sk); + 1559. + 1560. > filter = rcu_dereference_check(sk->sk_filter, + 1561. refcount_read(&sk->sk_wmem_alloc) == 0); + 1562. if (filter) { + +net/core/sock.c:1566: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1564. RCU_INIT_POINTER(sk->sk_filter, NULL); + 1565. } + 1566. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1567. reuseport_detach_sock(sk); + 1568. + +net/wireless/trace.h:1564: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +drivers/base/power/runtime.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. idx = device_links_read_lock(); + 1575. + 1576. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1577. if (link->flags & DL_FLAG_PM_RUNTIME) + 1578. pm_runtime_get_sync(link->supplier); + +net/core/net-sysfs.c:1596: error: DEAD_STORE + The value written to &groups (type attribute_group const **) is never used. + 1594. #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211) + 1595. if (ndev->ieee80211_ptr) + 1596. > *groups++ = &wireless_group; + 1597. #if IS_ENABLED(CONFIG_WIRELESS_EXT) + 1598. else if (ndev->wireless_handlers) + +kernel/rcu/tree.c:1596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1594. print_cpu_stall_info_begin(); + 1595. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1596. > print_cpu_stall_info(rsp, smp_processor_id()); + 1597. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1598. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1625: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1623. * switches for an entirely unreasonable amount of time. + 1624. */ + 1625. > resched_cpu(smp_processor_id()); + 1626. } + 1627. + +kernel/rcu/tree.c:1596: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1594. print_cpu_stall_info_begin(); + 1595. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1596. > print_cpu_stall_info(rsp, smp_processor_id()); + 1597. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1598. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1625: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1623. * switches for an entirely unreasonable amount of time. + 1624. */ + 1625. > resched_cpu(smp_processor_id()); + 1626. } + 1627. + +net/ipv4/fib_semantics.c:1589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1587. u8 last_tos = 0; + 1588. + 1589. > hlist_for_each_entry_rcu(fa, fa_head, fa_list) { + 1590. struct fib_info *next_fi = fa->fa_info; + 1591. + +drivers/base/power/runtime.c:1594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1592. idx = device_links_read_lock(); + 1593. + 1594. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1595. if (link->flags & DL_FLAG_PM_RUNTIME) + 1596. pm_runtime_put(link->supplier); + +net/wireless/trace.h:1587: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1585. ); + 1586. + 1587. > DECLARE_EVENT_CLASS(tx_rx_evt, + 1588. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1589. TP_ARGS(wiphy, rx, tx), + +security/selinux/ss/policydb.c:1604: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1602. goto bad; + 1603. + 1604. > len = le32_to_cpu(buf[0]); + 1605. levdatum->isalias = le32_to_cpu(buf[1]); + 1606. + +security/selinux/ss/policydb.c:1605: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1603. + 1604. len = le32_to_cpu(buf[0]); + 1605. > levdatum->isalias = le32_to_cpu(buf[1]); + 1606. + 1607. rc = str_read(&key, GFP_ATOMIC, fp, len); + +kernel/kprobes.c:1596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1594. struct kprobe *kp; + 1595. + 1596. > list_for_each_entry_rcu(kp, &ap->list, list) + 1597. if (!kprobe_disabled(kp)) + 1598. /* + +net/ipv4/fib_trie.c:1607: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1605. + 1606. /* descend into the next child */ + 1607. > n = get_child_rcu(pn, cindex++); + 1608. if (!n) + 1609. break; + +net/ipv4/fib_trie.c:1622: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1620. t_key pkey = pn->key; + 1621. + 1622. > pn = node_parent_rcu(pn); + 1623. cindex = get_index(pkey, pn) + 1; + 1624. continue; + +net/ipv4/fib_trie.c:1628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1626. + 1627. /* grab the next available node */ + 1628. > n = get_child_rcu(pn, cindex++); + 1629. if (!n) + 1630. continue; + +drivers/gpu/drm/drm_dp_mst_topology.c:1605: error: DEAD_STORE + The value written to &len (type int) is never used. + 1603. + 1604. txmsg->dst = mstb; + 1605. > len = build_link_address(txmsg); + 1606. + 1607. mstb->link_address_sent = true; + +drivers/scsi/scsi_transport_spi.c:1613: error: DEAD_STORE + The value written to &error (type int) is never used. + 1611. if (error) + 1612. return error; + 1613. > error = anon_transport_class_register(&spi_device_class); + 1614. return transport_class_register(&spi_host_class); + 1615. } + +net/ipv6/addrconf.c:1603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1601. struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx]; + 1602. + 1603. > list_for_each_entry_rcu(score->ifa, &idev->addr_list, if_list) { + 1604. int i; + 1605. + +net/sunrpc/auth_gss/svcauth_gss.c:1616: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1614. BUG_ON(integ_len % 4); + 1615. *p++ = htonl(integ_len); + 1616. > *p++ = htonl(gc->gc_seq); + 1617. if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset, integ_len)) { + 1618. WARN_ON_ONCE(1); + +kernel/signal.c:1641: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1639. rcu_read_lock(); + 1640. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); + 1641. > info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), + 1642. task_uid(tsk)); + 1643. rcu_read_unlock(); + +kernel/signal.c:1642: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1640. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); + 1641. info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), + 1642. > task_uid(tsk)); + 1643. rcu_read_unlock(); + 1644. + +drivers/gpu/drm/drm_atomic_helper.c:1605: error: DEAD_STORE + The value written to &completed (type _Bool) is never used. + 1603. { + 1604. struct drm_crtc_commit *commit, *stall_commit = NULL; + 1605. > bool completed = true; + 1606. int i; + 1607. long ret = 0; + +net/core/ethtool.c:1630: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1628. return -ENOMEM; + 1629. + 1630. > bytes_remaining = eeprom.len; + 1631. while (bytes_remaining > 0) { + 1632. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +net/ipv6/tcp_ipv6.c:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. skb->destructor = sock_edemux; + 1630. if (sk_fullsock(sk)) { + 1631. > struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst); + 1632. + 1633. if (dst) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +kernel/cgroup/cpuset.c:1614: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1609 could be null and is dereferenced by call to `is_cpuset_online()` at line 1614, column 7. + 1612. + 1613. mutex_lock(&cpuset_mutex); + 1614. > if (!is_cpuset_online(cs)) { + 1615. retval = -ENODEV; + 1616. goto out_unlock; + +drivers/scsi/scsi_lib.c:1610: error: DEAD_STORE + The value written to &wait_for (type unsigned long) is never used. + 1608. { + 1609. struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); + 1610. > unsigned long wait_for = (cmd->allowed + 1) * rq->timeout; + 1611. int disposition; + 1612. + +net/wireless/trace.h:1609: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1607. ); + 1608. + 1609. > DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, + 1610. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1611. TP_ARGS(wiphy, netdev, id), + +drivers/gpu/drm/i915/intel_uncore.c:1635: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1633. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1634. if (ret && slow_timeout_ms) + 1635. > ret = wait_for(done, slow_timeout_ms); + 1636. + 1637. if (out_value) + +drivers/gpu/drm/i915/intel_uncore.c:1633: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1631. ret = -ETIMEDOUT; + 1632. if (fast_timeout_us && fast_timeout_us <= 20000) + 1633. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1634. if (ret && slow_timeout_ms) + 1635. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1633: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1631. ret = -ETIMEDOUT; + 1632. if (fast_timeout_us && fast_timeout_us <= 20000) + 1633. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1634. if (ret && slow_timeout_ms) + 1635. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1633: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1631. ret = -ETIMEDOUT; + 1632. if (fast_timeout_us && fast_timeout_us <= 20000) + 1633. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1634. if (ret && slow_timeout_ms) + 1635. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1635: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1633. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1634. if (ret && slow_timeout_ms) + 1635. > ret = wait_for(done, slow_timeout_ms); + 1636. + 1637. if (out_value) + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from fault_reason was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from guest_addr was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from source_id was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +net/ipv6/route.c:1626: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1624. int i; + 1625. + 1626. > if (!rcu_access_pointer(rt->rt6i_exception_bucket)) + 1627. return; + 1628. + +net/ipv6/mcast.c:1658: error: DEAD_STORE + The value written to &payload_len (type int) is never used. + 1656. goto err_out; + 1657. + 1658. > payload_len = skb->len; + 1659. + 1660. err = NF_HOOK(NFPROTO_IPV6, NF_INET_LOCAL_OUT, + +kernel/sched/core.c:1639: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1637. schedstat_inc(p->se.statistics.nr_wakeups_remote); + 1638. rcu_read_lock(); + 1639. > for_each_domain(rq->cpu, sd) { + 1640. if (cpumask_test_cpu(cpu, sched_domain_span(sd))) { + 1641. schedstat_inc(sd->ttwu_wake_remote); + +kernel/sched/rt.c:1658: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1656. + 1657. rcu_read_lock(); + 1658. > for_each_domain(cpu, sd) { + 1659. if (sd->flags & SD_WAKE_AFFINE) { + 1660. int best_cpu; + +kernel/sched/rt.c:1626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1624. struct sched_domain *sd; + 1625. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1626. > int this_cpu = smp_processor_id(); + 1627. int cpu = task_cpu(task); + 1628. + +kernel/sched/rt.c:1626: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1624. struct sched_domain *sd; + 1625. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1626. > int this_cpu = smp_processor_id(); + 1627. int cpu = task_cpu(task); + 1628. + +net/unix/af_unix.c:1707: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 1705. goto out_free; + 1706. + 1707. > other = unix_find_other(net, sunaddr, namelen, sk->sk_type, + 1708. hash, &err); + 1709. if (other == NULL) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +kernel/rcu/tree.c:1660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1658. * and rsp->gp_start suffice to forestall false positives. + 1659. */ + 1660. > gpnum = READ_ONCE(rsp->gpnum); + 1661. smp_rmb(); /* Pick up ->gpnum first... */ + 1662. js = READ_ONCE(rsp->jiffies_stall); + +kernel/rcu/tree.c:1662: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1660. gpnum = READ_ONCE(rsp->gpnum); + 1661. smp_rmb(); /* Pick up ->gpnum first... */ + 1662. > js = READ_ONCE(rsp->jiffies_stall); + 1663. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1664. gps = READ_ONCE(rsp->gp_start); + +kernel/rcu/tree.c:1664: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1662. js = READ_ONCE(rsp->jiffies_stall); + 1663. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1664. > gps = READ_ONCE(rsp->gp_start); + 1665. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1666. completed = READ_ONCE(rsp->completed); + +kernel/rcu/tree.c:1666: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1664. gps = READ_ONCE(rsp->gp_start); + 1665. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1666. > completed = READ_ONCE(rsp->completed); + 1667. if (ULONG_CMP_GE(completed, gpnum) || + 1668. ULONG_CMP_LT(j, js) || + +security/selinux/ss/policydb.c:1645: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1643. goto bad; + 1644. + 1645. > len = le32_to_cpu(buf[0]); + 1646. catdatum->value = le32_to_cpu(buf[1]); + 1647. catdatum->isalias = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1646: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1644. + 1645. len = le32_to_cpu(buf[0]); + 1646. > catdatum->value = le32_to_cpu(buf[1]); + 1647. catdatum->isalias = le32_to_cpu(buf[2]); + 1648. + +security/selinux/ss/policydb.c:1647: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1645. len = le32_to_cpu(buf[0]); + 1646. catdatum->value = le32_to_cpu(buf[1]); + 1647. > catdatum->isalias = le32_to_cpu(buf[2]); + 1648. + 1649. rc = str_read(&key, GFP_ATOMIC, fp, len); + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1636: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +drivers/scsi/sd.c:1667: error: UNINITIALIZED_VALUE + The value read from res was never initialized. + 1665. + 1666. if (res) { + 1667. > sd_print_result(sdkp, "Synchronize Cache(10) failed", res); + 1668. + 1669. if (driver_byte(res) & DRIVER_SENSE) + +net/ipv4/devinet.c:1659: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1657. cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ + 1658. net->dev_base_seq; + 1659. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 1660. if (idx < s_idx) + 1661. goto cont; + +drivers/cdrom/cdrom.c:1764: error: UNINITIALIZED_VALUE + The value read from rpc_state.region_mask was never initialized. + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. > ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + 1766. break; + +drivers/cdrom/cdrom.c:1765: error: UNINITIALIZED_VALUE + The value read from rpc_state.rpc_scheme was never initialized. + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. > ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + 1766. break; + 1767. + +drivers/cdrom/cdrom.c:1761: error: UNINITIALIZED_VALUE + The value read from rpc_state.type_code was never initialized. + 1759. return ret; + 1760. + 1761. > ai->lrpcs.type = rpc_state.type_code; + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + +drivers/cdrom/cdrom.c:1763: error: UNINITIALIZED_VALUE + The value read from rpc_state.ucca was never initialized. + 1761. ai->lrpcs.type = rpc_state.type_code; + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. > ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + +drivers/cdrom/cdrom.c:1762: error: UNINITIALIZED_VALUE + The value read from rpc_state.vra was never initialized. + 1760. + 1761. ai->lrpcs.type = rpc_state.type_code; + 1762. > ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + +drivers/hid/usbhid/hid-core.c:1642: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1640. static int __init hid_init(void) + 1641. { + 1642. > int retval = -ENOMEM; + 1643. + 1644. retval = usbhid_quirks_init(quirks_param); + +kernel/kprobes.c:1671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1669. ap->break_handler = NULL; + 1670. if (p->post_handler && !kprobe_gone(p)) { + 1671. > list_for_each_entry_rcu(list_p, &ap->list, list) { + 1672. if ((list_p != p) && (list_p->post_handler)) + 1673. goto noclean; + +net/sunrpc/xprtsock.c:1654: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1652. return; + 1653. rcu_read_lock(); + 1654. > wq = rcu_dereference(sk->sk_wq); + 1655. if (!wq || test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags) == 0) + 1656. goto out; + +net/core/sock.c:1691: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1689. + 1690. rcu_read_lock(); + 1691. > filter = rcu_dereference(sk->sk_filter); + 1692. if (filter != NULL) + 1693. /* though it's an empty new sock, the charging may fail + +net/core/sock.c:1717: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1715. newsk->sk_err_soft = 0; + 1716. newsk->sk_priority = 0; + 1717. > newsk->sk_incoming_cpu = raw_smp_processor_id(); + 1718. atomic64_set(&newsk->sk_cookie, 0); + 1719. + +drivers/net/ethernet/intel/e1000e/ethtool.c:1690: error: DEAD_STORE + The value written to &time (type unsigned long) is never used. + 1688. e1e_flush(); + 1689. msleep(200); + 1690. > time = jiffies; /* set the start time for the receive */ + 1691. good_cnt = 0; + 1692. /* receive the sent packets */ + +net/sunrpc/auth_gss/svcauth_gss.c:1661: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1659. len = p++; + 1660. offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base; + 1661. > *p++ = htonl(gc->gc_seq); + 1662. inpages = resbuf->pages; + 1663. /* XXX: Would be better to write some xdr helper functions for + +drivers/gpu/drm/drm_dp_mst_topology.c:1659: error: DEAD_STORE + The value written to &len (type int) is never used. + 1657. + 1658. txmsg->dst = mstb; + 1659. > len = build_enum_path_resources(txmsg, port->port_num); + 1660. + 1661. drm_dp_queue_down_tx(mgr, txmsg); + +kernel/cgroup/cpuset.c:1661: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1656 could be null and is dereferenced by call to `is_cpuset_online()` at line 1661, column 7. + 1659. + 1660. mutex_lock(&cpuset_mutex); + 1661. > if (!is_cpuset_online(cs)) + 1662. goto out_unlock; + 1663. + +drivers/gpu/drm/i915/intel_hdmi.c:1664: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1659 could be null and is dereferenced at line 1664, column 2. + 1662. intel_hdmi_prepare(encoder, pipe_config); + 1663. + 1664. > intel_dig_port->set_infoframes(&encoder->base, + 1665. pipe_config->has_infoframe, + 1666. pipe_config, conn_state); + +net/ipv6/ip6_fib.c:1682: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1680. + 1681. /* Reset round-robin state, if necessary */ + 1682. > if (rcu_access_pointer(fn->rr_ptr) == rt) + 1683. fn->rr_ptr = NULL; + 1684. + +net/ipv6/ip6_fib.c:1713: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1711. * 2. For other nodes, expunge its radix tree node. + 1712. */ + 1713. > if (!rcu_access_pointer(fn->leaf)) { + 1714. if (!(fn->fn_flags & RTN_TL_ROOT)) { + 1715. fn->fn_flags &= ~RTN_RTINFO; + +drivers/gpu/drm/i915/intel_uncore.c:1684: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1682. + 1683. if (ret) + 1684. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1685. timeout_ms); + 1686. + +drivers/gpu/drm/i915/intel_uncore.c:1684: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1682. + 1683. if (ret) + 1684. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1685. timeout_ms); + 1686. + +drivers/net/ethernet/broadcom/tg3.c:1693: error: DEAD_STORE + The value written to &data (type unsigned int*) is never used. + 1691. else + 1692. val = 0; + 1693. > *data++ = val; + 1694. } + 1695. + +net/ipv4/route.c:1717: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1715. if (do_cache) { + 1716. if (fnhe) { + 1717. > rth = rcu_dereference(fnhe->fnhe_rth_input); + 1718. if (rth && rth->dst.expires && + 1719. time_after(jiffies, rth->dst.expires)) { + +net/ipv4/route.c:1727: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1725. } + 1726. + 1727. > rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input); + 1728. + 1729. rt_cache: + +drivers/tty/n_tty.c:1688: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1686. * read_tail (so this producer will not overwrite unread data) + 1687. */ + 1688. > size_t tail = smp_load_acquire(&ldata->read_tail); + 1689. + 1690. room = N_TTY_BUF_SIZE - (ldata->read_head - tail); + +drivers/tty/n_tty.c:1718: error: UNINITIALIZED_VALUE + The value read from room was never initialized. + 1716. } + 1717. + 1718. > tty->receive_room = room; + 1719. + 1720. /* Unthrottle if handling overflow on pty */ + +kernel/time/hrtimer.c:1668: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1666. void __init hrtimers_init(void) + 1667. { + 1668. > hrtimers_prepare_cpu(smp_processor_id()); + 1669. } + 1670. + +kernel/time/hrtimer.c:1668: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1666. void __init hrtimers_init(void) + 1667. { + 1668. > hrtimers_prepare_cpu(smp_processor_id()); + 1669. } + 1670. + +drivers/gpu/drm/i915/intel_hdmi.c:1683: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1673 could be null and is dereferenced at line 1683, column 2. + 1681. 0x2b247878); + 1682. + 1683. > dport->set_infoframes(&encoder->base, + 1684. pipe_config->has_infoframe, + 1685. pipe_config, conn_state); + +drivers/usb/host/uhci-q.c:1694: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1692. urbp = list_entry(qh->queue.next, struct urb_priv, node); + 1693. td = list_entry(urbp->td_list.next, struct uhci_td, list); + 1694. > status = td_status(uhci, td); + 1695. if (!(status & TD_CTRL_ACTIVE)) { + 1696. + +drivers/hid/hid-core.c:1723: error: DEAD_STORE + The value written to &len (type int) is never used. + 1721. ((struct hiddev *)hdev->hiddev)->minor); + 1722. if (hdev->claimed & HID_CLAIMED_HIDRAW) + 1723. > len += sprintf(buf + len, "%shidraw%d", len ? "," : "", + 1724. ((struct hidraw *)hdev->hidraw)->minor); + 1725. + +net/wireless/trace.h:1675: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +drivers/md/dm-ioctl.c:1689: error: UNINITIALIZED_VALUE + The value read from version[_] was never initialized. + 1687. if ((DM_VERSION_MAJOR != version[0]) || + 1688. (DM_VERSION_MINOR < version[1])) { + 1689. > DMWARN("ioctl interface mismatch: " + 1690. "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)", + 1691. DM_VERSION_MAJOR, DM_VERSION_MINOR, + +net/ipv6/addrconf.c:1762: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1760. } + 1761. + 1762. > for_each_netdev_rcu(net, dev) { + 1763. /* only consider addresses on devices in the + 1764. * same L3 domain + +include/net/sock.h:1695: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1693. { + 1694. BUILD_BUG_ON(offsetof(struct socket_wq, wait) != 0); + 1695. > return &rcu_dereference_raw(sk->sk_wq)->wait; + 1696. } + 1697. /* Detach socket from process context. + +net/wireless/trace.h:1692: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/core/filter.c:1700: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1698. int ret; + 1699. + 1700. > if (unlikely(__this_cpu_read(xmit_recursion) > XMIT_RECURSION_LIMIT)) { + 1701. net_crit_ratelimited("bpf: recursion limit reached on datapath, buggy bpf program?\n"); + 1702. kfree_skb(skb); + +net/ipv4/netfilter/ip_tables.c:1733: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1731. target = 0; + 1732. + 1733. > try_then_request_module(xt_find_revision(AF_INET, rev.name, + 1734. rev.revision, + 1735. target, &ret), + +block/bio.c:1702: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1700. unsigned long sectors, struct hd_struct *part) + 1701. { + 1702. > int cpu = part_stat_lock(); + 1703. + 1704. part_round_stats(q, cpu, part); + +block/bio.c:1702: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1700. unsigned long sectors, struct hd_struct *part) + 1701. { + 1702. > int cpu = part_stat_lock(); + 1703. + 1704. part_round_stats(q, cpu, part); + +kernel/signal.c:1727: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1725. rcu_read_lock(); + 1726. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); + 1727. > info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); + 1728. rcu_read_unlock(); + 1729. + +kernel/signal.c:1727: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1725. rcu_read_lock(); + 1726. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); + 1727. > info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); + 1728. rcu_read_unlock(); + 1729. + +net/ipv4/fib_trie.c:1728: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1726. struct key_vector *local_l = NULL, *local_tp; + 1727. + 1728. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1729. struct fib_alias *new_fa; + 1730. + +net/ipv4/udp.c:1718: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1716. + 1717. spin_lock_bh(&hslot->lock); + 1718. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1719. reuseport_detach_sock(sk); + 1720. if (sk_del_node_init_rcu(sk)) { + +net/ipv6/netfilter/ip6_tables.c:1744: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1742. target = 0; + 1743. + 1744. > try_then_request_module(xt_find_revision(AF_INET6, rev.name, + 1745. rev.revision, + 1746. target, &ret), + +net/ipv6/mcast.c:1722: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1720. return skb; + 1721. + 1722. > mtu = READ_ONCE(dev->mtu); + 1723. if (mtu < IPV6_MIN_MTU) + 1724. return skb; + +net/sunrpc/auth_gss/svcauth_gss.c:1716: error: DEAD_STORE + The value written to &stat (type int) is never used. + 1714. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1715. struct xdr_buf *resbuf = &rqstp->rq_res; + 1716. > int stat = -EINVAL; + 1717. struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id); + 1718. + +drivers/gpu/drm/drm_dp_mst_topology.c:1747: error: DEAD_STORE + The value written to &len (type int) is never used. + 1745. + 1746. txmsg->dst = mstb; + 1747. > len = build_allocate_payload(txmsg, port_num, + 1748. id, + 1749. pbn, port->num_sdp_streams, sinks); + +lib/radix-tree.c:1767: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1765. else + 1766. while (++offset < RADIX_TREE_MAP_SIZE) { + 1767. > void *slot = rcu_dereference_raw( + 1768. node->slots[offset]); + 1769. if (is_sibling_entry(node, slot)) + +lib/radix-tree.c:1781: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1779. if (offset == RADIX_TREE_MAP_SIZE) + 1780. goto restart; + 1781. > child = rcu_dereference_raw(node->slots[offset]); + 1782. } + 1783. + +block/bio.c:1717: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1715. { + 1716. unsigned long duration = jiffies - start_time; + 1717. > int cpu = part_stat_lock(); + 1718. + 1719. part_stat_add(cpu, part, ticks[rw], duration); + +block/bio.c:1717: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1715. { + 1716. unsigned long duration = jiffies - start_time; + 1717. > int cpu = part_stat_lock(); + 1718. + 1719. part_stat_add(cpu, part, ticks[rw], duration); + +kernel/rcu/tree_plugin.h:1716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1714. { + 1715. rdp->ticks_this_gp = 0; + 1716. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1717. } + 1718. + +kernel/rcu/tree_plugin.h:1716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1714. { + 1715. rdp->ticks_this_gp = 0; + 1716. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1717. } + 1718. + +drivers/iommu/dmar.c:1722: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1720. * Enable fault control interrupt. + 1721. */ + 1722. > for_each_iommu(iommu, drhd) { + 1723. u32 fault_status; + 1724. int ret = dmar_set_interrupt(iommu); + +drivers/gpu/drm/drm_fb_helper.c:1791: error: UNINITIALIZED_VALUE + The value read from sizes.surface_height was never initialized. + 1789. + 1790. sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1791. > sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1792. + 1793. for (j = 0; j < mode_set->num_connectors; j++) { + +drivers/gpu/drm/drm_fb_helper.c:1790: error: UNINITIALIZED_VALUE + The value read from sizes.surface_width was never initialized. + 1788. gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size; + 1789. + 1790. > sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1791. sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1792. + +net/xfrm/xfrm_policy.c:1725: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1723. struct xfrm_dst *old; + 1724. + 1725. > old = this_cpu_read(xfrm_last_dst); + 1726. if (old && !xfrm_bundle_ok(old)) + 1727. xfrm_last_dst_update(NULL, old); + +net/xfrm/xfrm_policy.c:1725: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1723. struct xfrm_dst *old; + 1724. + 1725. > old = this_cpu_read(xfrm_last_dst); + 1726. if (old && !xfrm_bundle_ok(old)) + 1727. xfrm_last_dst_update(NULL, old); + +net/ipv4/devinet.c:1725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1723. u32 ext_filter_mask) + 1724. { + 1725. > struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 1726. + 1727. if (!in_dev) + +net/wireless/trace.h:1732: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/ipv4/devinet.c:1736: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1734. u32 ext_filter_mask) + 1735. { + 1736. > struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 1737. struct nlattr *nla; + 1738. int i; + +net/ipv4/udp.c:1749: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1747. + 1748. if (hslot2 != nhslot2 || + 1749. > rcu_access_pointer(sk->sk_reuseport_cb)) { + 1750. hslot = udp_hashslot(udptable, sock_net(sk), + 1751. udp_sk(sk)->udp_port_hash); + +net/ipv4/udp.c:1754: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1752. /* we must lock primary chain too */ + 1753. spin_lock_bh(&hslot->lock); + 1754. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1755. reuseport_detach_sock(sk); + 1756. + +net/xfrm/xfrm_policy.c:1752: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1750. old = per_cpu(xfrm_last_dst, cpu); + 1751. if (old && !xfrm_bundle_ok(old)) { + 1752. > if (smp_processor_id() == cpu) { + 1753. __xfrm_pcpu_work_fn(); + 1754. continue; + +drivers/gpu/drm/i915/intel_hdmi.c:1754: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1744 could be null and is dereferenced at line 1754, column 2. + 1752. chv_set_phy_signal_level(encoder, 128, 102, false); + 1753. + 1754. > dport->set_infoframes(&encoder->base, + 1755. pipe_config->has_infoframe, + 1756. pipe_config, conn_state); + +include/net/xfrm.h:1749: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1747. + 1748. rcu_read_lock(); + 1749. > nlsk = rcu_dereference(net->xfrm.nlsk); + 1750. if (nlsk) + 1751. ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS); + +sound/core/timer.c:1835: error: UNINITIALIZED_VALUE + The value read from params.filter was never initialized. + 1833. } + 1834. } + 1835. > tu->filter = params.filter; + 1836. tu->ticks = params.ticks; + 1837. spin_unlock_irq(&tu->qlock); + +sound/core/timer.c:1812: error: UNINITIALIZED_VALUE + The value read from params.queue_size was never initialized. + 1810. if (params.queue_size > 0 && + 1811. (unsigned int)tu->queue_size != params.queue_size) { + 1812. > err = realloc_user_queue(tu, params.queue_size); + 1813. if (err < 0) + 1814. goto _end; + +sound/core/timer.c:1836: error: UNINITIALIZED_VALUE + The value read from params.ticks was never initialized. + 1834. } + 1835. tu->filter = params.filter; + 1836. > tu->ticks = params.ticks; + 1837. spin_unlock_irq(&tu->qlock); + 1838. err = 0; + +ipc/sem.c:1751: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1749. struct sem_undo *un; + 1750. + 1751. > list_for_each_entry_rcu(un, &ulp->list_proc, list_proc) { + 1752. if (un->semid == semid) + 1753. return un; + +include/net/sock.h:1754: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1752. __sk_dst_get(struct sock *sk) + 1753. { + 1754. > return rcu_dereference_check(sk->sk_dst_cache, + 1755. lockdep_sock_is_held(sk)); + 1756. } + +net/wireless/trace.h:1752: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1750. ); + 1751. + 1752. > DECLARE_EVENT_CLASS(rdev_pmksa, + 1753. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1754. struct cfg80211_pmksa *pmksa), + +kernel/workqueue.c:1758: error: DEAD_STORE + The value written to &id (type int) is never used. + 1756. { + 1757. struct worker *worker = NULL; + 1758. > int id = -1; + 1759. char id_buf[16]; + 1760. + +include/net/xfrm.h:1762: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1760. + 1761. rcu_read_lock(); + 1762. > nlsk = rcu_dereference(net->xfrm.nlsk); + 1763. if (nlsk) + 1764. ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE); + +drivers/block/loop.c:1783: error: DEAD_STORE + The value written to &err (type int) is never used. + 1781. i = err; + 1782. + 1783. > err = -ENOMEM; + 1784. lo->tag_set.ops = &loop_mq_ops; + 1785. lo->tag_set.nr_hw_queues = 1; + +include/net/sock.h:1764: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1762. + 1763. rcu_read_lock(); + 1764. > dst = rcu_dereference(sk->sk_dst_cache); + 1765. if (dst && !atomic_inc_not_zero(&dst->__refcnt)) + 1766. dst = NULL; + +drivers/gpu/drm/i915/intel_uncore.c:1796: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1794. intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL); + 1795. + 1796. > return ret; + 1797. } + 1798. + +drivers/gpu/drm/drm_dp_mst_topology.c:1784: error: DEAD_STORE + The value written to &len (type int) is never used. + 1782. + 1783. txmsg->dst = port->parent; + 1784. > len = build_power_updown_phy(txmsg, port->port_num, power_up); + 1785. drm_dp_queue_down_tx(mgr, txmsg); + 1786. + +net/wireless/trace.h:1770: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +kernel/cgroup/cgroup.c:1800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1798. */ + 1799. read_lock(&tasklist_lock); + 1800. > do_each_thread(g, p) { + 1801. WARN_ON_ONCE(!list_empty(&p->cg_list) || + 1802. task_css_set(p) != &init_css_set); + +kernel/events/core.c:1791: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1789. event_filter_match(struct perf_event *event) + 1790. { + 1791. > return (event->cpu == -1 || event->cpu == smp_processor_id()) && + 1792. perf_cgroup_match(event) && pmu_filter_match(event); + 1793. } + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +kernel/sched/deadline.c:1832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1830. + 1831. rcu_read_lock(); + 1832. > for_each_domain(cpu, sd) { + 1833. if (sd->flags & SD_WAKE_AFFINE) { + 1834. int best_cpu; + +kernel/sched/deadline.c:1793: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1791. struct sched_domain *sd; + 1792. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1793. > int this_cpu = smp_processor_id(); + 1794. int cpu = task_cpu(task); + 1795. + +kernel/sched/deadline.c:1793: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1791. struct sched_domain *sd; + 1792. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1793. > int this_cpu = smp_processor_id(); + 1794. int cpu = task_cpu(task); + 1795. + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +drivers/usb/core/hub.c:1816: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1802 could be null and is dereferenced at line 1816, column 9. + 1814. info->nports = hdev->maxchild; + 1815. for (i = 0; i < info->nports; i++) { + 1816. > if (hub->ports[i]->child == NULL) + 1817. info->port[i] = 0; + 1818. else + +net/wireless/trace.h:1800: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +kernel/cgroup/cpuset.c:1817: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1813 could be null and is dereferenced at line 1817, column 10. + 1815. switch (type) { + 1816. case FILE_SCHED_RELAX_DOMAIN_LEVEL: + 1817. > return cs->relax_domain_level; + 1818. default: + 1819. BUG(); + +net/xfrm/xfrm_policy.c:1835: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1833. } + 1834. + 1835. > xdst = this_cpu_read(xfrm_last_dst); + 1836. if (xdst && + 1837. xdst->u.dst.dev == dst_orig->dev && + +net/xfrm/xfrm_policy.c:1835: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1833. } + 1834. + 1835. > xdst = this_cpu_read(xfrm_last_dst); + 1836. if (xdst && + 1837. xdst->u.dst.dev == dst_orig->dev && + +net/core/ethtool.c:1826: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1824. return -EFAULT; + 1825. + 1826. > ret = __ethtool_get_sset_count(dev, gstrings.string_set); + 1827. if (ret < 0) + 1828. return ret; + +net/core/ethtool.c:1838: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1836. return -ENOMEM; + 1837. + 1838. > __ethtool_get_strings(dev, gstrings.string_set, data); + 1839. + 1840. ret = -EFAULT; + +net/ipv4/af_inet.c:1823: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1821. struct inet_protosw *q; + 1822. struct list_head *r; + 1823. > int rc = -EINVAL; + 1824. + 1825. sock_skb_cb_check_size(sizeof(struct inet_skb_parm)); + +kernel/sched/core.c:1827: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1825. rcu_read_lock(); + 1826. + 1827. > if (!is_idle_task(rcu_dereference(rq->curr))) + 1828. goto out; + 1829. + +net/wireless/trace.h:1821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +lib/radix-tree.c:1835: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1833. + 1834. radix_tree_for_each_slot(slot, root, &iter, first_index) { + 1835. > results[ret] = rcu_dereference_raw(*slot); + 1836. if (!results[ret]) + 1837. continue; + +net/ipv6/addrconf.c:1829: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1827. + 1828. rcu_read_lock(); + 1829. > list_for_each_entry_rcu(ifp, &idev->addr_list, if_list) + 1830. cnt++; + 1831. rcu_read_unlock(); + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.keycode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +drivers/tty/vt/keyboard.c:1834: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1832. switch (cmd) { + 1833. case KDGETKEYCODE: + 1834. > kc = getkeycode(tmp.scancode); + 1835. if (kc >= 0) + 1836. kc = put_user(kc, &user_kbkc->keycode); + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +net/ipv4/cipso_ipv4.c:1830: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1828. const struct netlbl_lsm_secattr *secattr) + 1829. { + 1830. > int ret_val = -EPERM; + 1831. unsigned char *buf = NULL; + 1832. u32 buf_len; + +net/sunrpc/xprtsock.c:1834: error: DEAD_STORE + The value written to &port (type unsigned short) is never used. + 1832. if (port <= xprt_min_resvport || port > xprt_max_resvport) + 1833. return xprt_max_resvport; + 1834. > return --port; + 1835. } + 1836. static int xs_bind(struct sock_xprt *transport, struct socket *sock) + +net/ipv4/udp.c:1855: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1853. + 1854. /* if we're overly short, let UDP handle it */ + 1855. > encap_rcv = READ_ONCE(up->encap_rcv); + 1856. if (encap_rcv) { + 1857. int ret; + +net/ipv4/udp.c:1910: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1908. + 1909. prefetch(&sk->sk_rmem_alloc); + 1910. > if (rcu_access_pointer(sk->sk_filter) && + 1911. udp_lib_checksum_complete(skb)) + 1912. goto csum_error; + +drivers/usb/host/ehci-sched.c:1888: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 1886. + 1887. /* give urb back to the driver; completion often (re)submits */ + 1888. > dev = urb->dev; + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + +kernel/sys.c:1835: error: DEAD_STORE + The value written to &mm (type mm_struct*) is never used. + 1833. { + 1834. unsigned long mmap_max_addr = TASK_SIZE; + 1835. > struct mm_struct *mm = current->mm; + 1836. int error = -EINVAL, i; + 1837. + +drivers/iommu/dmar.c:1836: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1834. dmar_res_handler_t handler, void *arg) + 1835. { + 1836. > int ret = -ENODEV; + 1837. union acpi_object *obj; + 1838. struct acpi_dmar_header *start; + +drivers/gpu/drm/i915/intel_ddi.c:1839: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1838 could be null and is dereferenced at line 1839, column 46. + 1837. { + 1838. struct intel_digital_port *intel_dig_port = enc_to_dig_port(&encoder->base); + 1839. > struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev); + 1840. enum port port = intel_dig_port->port; + 1841. uint8_t iboost; + +net/core/neighbour.c:1874: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1872. + 1873. rcu_read_lock_bh(); + 1874. > nht = rcu_dereference_bh(tbl->nht); + 1875. ndc.ndtc_hash_rnd = nht->hash_rnd[0]; + 1876. ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1); + +drivers/usb/core/hub.c:1850: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1840 could be null and is dereferenced at line 1850, column 15. + 1848. * will always have maxchild equal to 0. + 1849. */ + 1850. > *ppowner = &(hub->ports[port1 - 1]->port_owner); + 1851. return 0; + 1852. } + +drivers/cdrom/cdrom.c:1856: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1854. return ret; + 1855. + 1856. > s->copyright.cpst = buf[4]; + 1857. s->copyright.rmi = buf[5]; + 1858. + +drivers/cdrom/cdrom.c:1857: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1855. + 1856. s->copyright.cpst = buf[4]; + 1857. > s->copyright.rmi = buf[5]; + 1858. + 1859. return 0; + +net/wireless/trace.h:1838: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +security/selinux/ss/policydb.c:1853: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1851. return rc; + 1852. + 1853. > nel = le32_to_cpu(buf[0]); + 1854. for (i = 0; i < nel; i++) { + 1855. rc = -ENOMEM; + +security/selinux/ss/policydb.c:1864: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1862. goto out; + 1863. + 1864. > rt->source_type = le32_to_cpu(buf[0]); + 1865. rt->target_type = le32_to_cpu(buf[1]); + 1866. if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) { + +security/selinux/ss/policydb.c:1865: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1863. + 1864. rt->source_type = le32_to_cpu(buf[0]); + 1865. > rt->target_type = le32_to_cpu(buf[1]); + 1866. if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) { + 1867. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:1870: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1868. if (rc) + 1869. goto out; + 1870. > rt->target_class = le32_to_cpu(buf[0]); + 1871. } else + 1872. rt->target_class = p->process_class; + +net/ipv6/addrconf.c:1851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1849. + 1850. rcu_read_lock(); + 1851. > hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { + 1852. if (!net_eq(dev_net(ifp->idev->dev), net)) + 1853. continue; + +drivers/iommu/intel-iommu.c:1851: error: DEAD_STORE + The value written to &count (type int) is never used. + 1849. struct intel_iommu *iommu) + 1850. { + 1851. > int num, count = INT_MAX; + 1852. + 1853. assert_spin_locked(&device_domain_lock); + +kernel/sched/core.c:1856: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1854. + 1855. #if defined(CONFIG_SMP) + 1856. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1857. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1858. ttwu_queue_remote(p, cpu, wake_flags); + +kernel/sched/core.c:1856: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1854. + 1855. #if defined(CONFIG_SMP) + 1856. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1857. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1858. ttwu_queue_remote(p, cpu, wake_flags); + +net/wireless/trace.h:1855: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +security/selinux/ss/services.c:1913: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1911. + 1912. /* Convert the user. */ + 1913. > rc = -EINVAL; + 1914. usrdatum = hashtab_search(args->newp->p_users.table, + 1915. sym_name(args->oldp, SYM_USERS, c->user - 1)); + +security/selinux/ss/services.c:1921: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1919. + 1920. /* Convert the role. */ + 1921. > rc = -EINVAL; + 1922. role = hashtab_search(args->newp->p_roles.table, + 1923. sym_name(args->oldp, SYM_ROLES, c->role - 1)); + +security/selinux/ss/services.c:1929: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1927. + 1928. /* Convert the type. */ + 1929. > rc = -EINVAL; + 1930. typdatum = hashtab_search(args->newp->p_types.table, + 1931. sym_name(args->oldp, SYM_TYPES, c->type - 1)); + +security/selinux/ss/services.c:1959: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1957. while (oc && oc->sid[0] != SECINITSID_UNLABELED) + 1958. oc = oc->next; + 1959. > rc = -EINVAL; + 1960. if (!oc) { + 1961. printk(KERN_ERR "SELinux: unable to look up" + +ipc/sem.c:1864: error: DEAD_STORE + The value written to &error (type int) is never used. + 1862. unsigned nsops, const struct timespec64 *timeout) + 1863. { + 1864. > int error = -EINVAL; + 1865. struct sem_array *sma; + 1866. struct sembuf fast_sops[SEMOPM_FAST]; + +ipc/sem.c:2068: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2066. * window between wake_q_add() and wake_up_q(). + 2067. */ + 2068. > error = READ_ONCE(queue.status); + 2069. if (error != -EINTR) { + 2070. /* + +ipc/sem.c:2086: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2084. goto out_unlock_free; + 2085. + 2086. > error = READ_ONCE(queue.status); + 2087. + 2088. /* + +net/ipv4/igmp.c:1872: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1870. return -ENODEV; + 1871. rcu_read_lock(); + 1872. > for_each_pmc_rcu(in_dev, pmc) { + 1873. if (*pmca == pmc->multiaddr) + 1874. break; + +kernel/auditsc.c:1881: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1879. rcu_read_lock(); + 1880. if (!list_empty(list)) { + 1881. > list_for_each_entry_rcu(e, list, list) { + 1882. for (i = 0; i < e->rule.field_count; i++) { + 1883. struct audit_field *f = &e->rule.fields[i]; + +drivers/gpu/drm/drm_dp_mst_topology.c:1909: error: UNINITIALIZED_VALUE + The value read from req_payload.payload_state was never initialized. + 1907. mgr->payloads[i].start_slot = 0; + 1908. } + 1909. > mgr->payloads[i].payload_state = req_payload.payload_state; + 1910. } + 1911. cur_slots += req_payload.num_slots; + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +drivers/i2c/i2c-core-base.c:1893: error: DEAD_STORE + The value written to &orig_jiffies (type unsigned long) is never used. + 1891. + 1892. /* Retry automatically on arbitration loss */ + 1893. > orig_jiffies = jiffies; + 1894. for (ret = 0, try = 0; try <= adap->retries; try++) { + 1895. ret = adap->algo->master_xfer(adap, msgs, num); + +kernel/trace/ring_buffer.c:2000: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1998. struct buffer_page *buffer_tail_page; + 1999. + 2000. > buffer_tail_page = READ_ONCE(cpu_buffer->tail_page); + 2001. /* + 2002. * If the tail had moved passed next, then we need + +net/ipv6/addrconf.c:1888: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1886. idev = __in6_dev_get(dev); + 1887. if (idev) { + 1888. > list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) { + 1889. ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len); + 1890. if (ret) + +drivers/iommu/dmar.c:1895: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1893. */ + 1894. if (!dmaru->include_all && dmaru->devices && dmaru->devices_cnt) { + 1895. > for_each_active_dev_scope(dmaru->devices, + 1896. dmaru->devices_cnt, i, dev) + 1897. return -EBUSY; + +net/ipv4/route.c:1999: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1997. if (res->fi) { + 1998. if (!itag) { + 1999. > rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input); + 2000. if (rt_cache_valid(rth)) { + 2001. skb_dst_set_noref(skb, &rth->dst); + +block/blk-core.c:1978: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1976. + 1977. if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) + 1978. > req->cpu = raw_smp_processor_id(); + 1979. + 1980. plug = current->plug; + +block/blk-core.c:1978: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1976. + 1977. if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) + 1978. > req->cpu = raw_smp_processor_id(); + 1979. + 1980. plug = current->plug; + +net/core/dev.c:1892: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1890. struct packet_type *ptype, *pt_prev = *pt; + 1891. + 1892. > list_for_each_entry_rcu(ptype, ptype_list, list) { + 1893. if (ptype->type != type) + 1894. continue; + +net/wireless/trace.h:1885: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +drivers/usb/core/hub.c:1893: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1889 could be null and is dereferenced at line 1893, column 7. + 1891. + 1892. for (n = 0; n < hdev->maxchild; n++) { + 1893. > if (hub->ports[n]->port_owner == owner) + 1894. hub->ports[n]->port_owner = NULL; + 1895. } + +drivers/cpufreq/cpufreq.c:1897: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1895. unsigned int intermediate_freq = 0; + 1896. unsigned int newfreq = policy->freq_table[index].frequency; + 1897. > int retval = -EINVAL; + 1898. bool notify; + 1899. + +crypto/drbg.c:1904: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1902. struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. > int rc = -EFAULT; + 1905. bool pr = false; + 1906. int coreref = 0; + +crypto/drbg.c:1903: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1901. unsigned char buf[OUTBUFLEN]; + 1902. struct drbg_state *drbg = NULL; + 1903. > int ret = -EFAULT; + 1904. int rc = -EFAULT; + 1905. bool pr = false; + +drivers/usb/core/hub.c:1907: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1906 could be null and is dereferenced at line 1907, column 11. + 1905. return false; + 1906. hub = usb_hub_to_struct_hub(udev->parent); + 1907. > return !!hub->ports[udev->portnum - 1]->port_owner; + 1908. } + 1909. + +net/ipv6/addrconf.c:1910: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1908. idev = __in6_dev_get(dev); + 1909. if (idev) { + 1910. > list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) { + 1911. onlink = ipv6_prefix_equal(addr, &ifa->addr, + 1912. ifa->prefix_len); + +net/ipv6/ip6_fib.c:1926: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1924. if (res) { + 1925. #if RT6_DEBUG >= 2 + 1926. > pr_debug("%s: del failed: rt=%p@%p err=%d\n", + 1927. __func__, rt, + 1928. rcu_access_pointer(rt->rt6i_node), + +net/socket.c:1912: error: UNINITIALIZED_VALUE + The value read from msg.msg_control was never initialized. + 1910. return -EFAULT; + 1911. + 1912. > kmsg->msg_control = (void __force *)msg.msg_control; + 1913. kmsg->msg_controllen = msg.msg_controllen; + 1914. kmsg->msg_flags = msg.msg_flags; + +net/socket.c:1913: error: UNINITIALIZED_VALUE + The value read from msg.msg_controllen was never initialized. + 1911. + 1912. kmsg->msg_control = (void __force *)msg.msg_control; + 1913. > kmsg->msg_controllen = msg.msg_controllen; + 1914. kmsg->msg_flags = msg.msg_flags; + 1915. + +net/socket.c:1914: error: UNINITIALIZED_VALUE + The value read from msg.msg_flags was never initialized. + 1912. kmsg->msg_control = (void __force *)msg.msg_control; + 1913. kmsg->msg_controllen = msg.msg_controllen; + 1914. > kmsg->msg_flags = msg.msg_flags; + 1915. + 1916. kmsg->msg_namelen = msg.msg_namelen; + +net/socket.c:1947: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 1945. kmsg->msg_iocb = NULL; + 1946. + 1947. > return import_iovec(save_addr ? READ : WRITE, + 1948. msg.msg_iov, msg.msg_iovlen, + 1949. UIO_FASTIOV, iov, &kmsg->msg_iter); + +net/socket.c:1927: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 1925. + 1926. if (save_addr) + 1927. > *save_addr = msg.msg_name; + 1928. + 1929. if (msg.msg_name && kmsg->msg_namelen) { + +net/socket.c:1916: error: UNINITIALIZED_VALUE + The value read from msg.msg_namelen was never initialized. + 1914. kmsg->msg_flags = msg.msg_flags; + 1915. + 1916. > kmsg->msg_namelen = msg.msg_namelen; + 1917. if (!msg.msg_name) + 1918. kmsg->msg_namelen = 0; + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +lib/radix-tree.c:1918: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1916. + 1917. radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) { + 1918. > results[ret] = rcu_dereference_raw(*slot); + 1919. if (!results[ret]) + 1920. continue; + +net/xfrm/xfrm_state.c:1912: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1910. + 1911. rcu_read_lock(); + 1912. > list_for_each_entry_rcu(km, &xfrm_km_list, list) + 1913. if (km->notify_policy) + 1914. km->notify_policy(xp, dir, c); + +net/wireless/trace.h:1908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +drivers/usb/core/hub.c:1916: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1912 could be null and is dereferenced at line 1916, column 7. + 1914. + 1915. for (i = 0; i < udev->maxchild; ++i) { + 1916. > if (hub->ports[i]->child) + 1917. recursively_mark_NOTATTACHED(hub->ports[i]->child); + 1918. } + +kernel/sched/rt.c:1947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1945. * Matches WMB in rt_set_overload(). + 1946. */ + 1947. > next = atomic_read_acquire(&rd->rto_loop_next); + 1948. + 1949. if (rd->rto_loop == next) + +security/selinux/ss/policydb.c:1925: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1923. if (rc) + 1924. return rc; + 1925. > nel = le32_to_cpu(buf[0]); + 1926. + 1927. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:1945: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1943. if (rc) + 1944. goto out; + 1945. > len = le32_to_cpu(buf[0]); + 1946. + 1947. /* path component string */ + +security/selinux/ss/policydb.c:1958: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1956. goto out; + 1957. + 1958. > ft->stype = le32_to_cpu(buf[0]); + 1959. ft->ttype = le32_to_cpu(buf[1]); + 1960. ft->tclass = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1959: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1957. + 1958. ft->stype = le32_to_cpu(buf[0]); + 1959. > ft->ttype = le32_to_cpu(buf[1]); + 1960. ft->tclass = le32_to_cpu(buf[2]); + 1961. + +security/selinux/ss/policydb.c:1960: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1958. ft->stype = le32_to_cpu(buf[0]); + 1959. ft->ttype = le32_to_cpu(buf[1]); + 1960. > ft->tclass = le32_to_cpu(buf[2]); + 1961. + 1962. otype->otype = le32_to_cpu(buf[3]); + +security/selinux/ss/policydb.c:1962: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1960. ft->tclass = le32_to_cpu(buf[2]); + 1961. + 1962. > otype->otype = le32_to_cpu(buf[3]); + 1963. + 1964. rc = ebitmap_set_bit(&p->filename_trans_ttypes, ft->ttype, 1); + +net/ipv4/cipso_ipv4.c:1915: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1913. const struct netlbl_lsm_secattr *secattr) + 1914. { + 1915. > int ret_val = -EPERM; + 1916. unsigned char *buf = NULL; + 1917. u32 buf_len; + +net/ipv4/fib_trie.c:1917: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1915. struct fib_alias *fa; + 1916. + 1917. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1918. struct fib_info *fi = fa->fa_info; + 1919. + +arch/x86/events/core.c:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. * transaction. See x86_pmu_add() and x86_pmu_*_txn(). + 1933. */ + 1934. > __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + +arch/x86/events/core.c:1935: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1933. */ + 1934. __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. > __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + 1937. } + +net/xfrm/xfrm_state.c:1922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1920. struct xfrm_mgr *km; + 1921. rcu_read_lock(); + 1922. > list_for_each_entry_rcu(km, &xfrm_km_list, list) + 1923. if (km->notify) + 1924. km->notify(x, c); + +net/core/dev.c:1929: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1927. rcu_read_lock(); + 1928. again: + 1929. > list_for_each_entry_rcu(ptype, ptype_list, list) { + 1930. /* Never send packets back to the socket + 1931. * they originated from - MvS (miquels@drinkel.ow.org) + +net/ipv6/addrconf.c:1929: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1927. + 1928. rcu_read_lock(); + 1929. > hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { + 1930. if (!net_eq(dev_net(ifp->idev->dev), net)) + 1931. continue; + +net/ipv4/tcp_output.c:1964: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1962. goto send_now; + 1963. + 1964. > win_divisor = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_tso_win_divisor); + 1965. if (win_divisor) { + 1966. u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache); + +drivers/video/fbdev/core/fbmem.c:1934: error: DEAD_STORE + The value written to &err (type int) is never used. + 1932. struct fb_modelist *modelist; + 1933. struct fb_videomode *m, mode; + 1934. > int err = 1; + 1935. + 1936. list_for_each_safe(pos, n, &info->modelist) { + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +drivers/tty/n_tty.c:1947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1945. size_t n; + 1946. bool is_eof; + 1947. > size_t head = smp_load_acquire(&ldata->commit_head); + 1948. size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + 1949. + +net/wireless/trace.h:1939: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +drivers/input/mouse/alps.c:1948: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1946. { + 1947. u16 reg_val = 0x181; + 1948. > int ret = -1; + 1949. + 1950. /* enter monitor mode, to write the register */ + +net/xfrm/xfrm_state.c:1952: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1950. + 1951. rcu_read_lock(); + 1952. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 1953. acqret = km->acquire(x, t, pol); + 1954. if (!acqret) + +net/ipv4/fib_trie.c:1959: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1957. struct fib_table *tb; + 1958. + 1959. > hlist_for_each_entry_rcu(tb, head, tb_hlist) + 1960. fib_table_notify(net, tb, nb); + 1961. } + +kernel/rcu/tree.c:1987: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1985. need_gp = !!(rnp->qsmask & rdp->grpmask); + 1986. rdp->cpu_no_qs.b.norm = need_gp; + 1987. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 1988. rdp->core_needs_qs = need_gp; + 1989. zero_cpu_stall_ticks(rdp); + +kernel/rcu/tree.c:1987: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1985. need_gp = !!(rnp->qsmask & rdp->grpmask); + 1986. rdp->cpu_no_qs.b.norm = need_gp; + 1987. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 1988. rdp->core_needs_qs = need_gp; + 1989. zero_cpu_stall_ticks(rdp); + +net/ipv4/udp.c:1963: error: DEAD_STORE + The value written to &dif (type int) is never used. + 1961. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1962. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1963. > int dif = skb->dev->ifindex; + 1964. int sdif = inet_sdif(skb); + 1965. struct hlist_node *node; + +net/ipv4/udp.c:1962: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1960. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 1961. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1962. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 1963. int dif = skb->dev->ifindex; + 1964. int sdif = inet_sdif(skb); + +net/ipv4/udp.c:1974: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1972. start_lookup: + 1973. hslot = &udptable->hash2[hash2]; + 1974. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 1975. } + 1976. + +net/ipv4/udp.c:1964: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 1962. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1963. int dif = skb->dev->ifindex; + 1964. > int sdif = inet_sdif(skb); + 1965. struct hlist_node *node; + 1966. struct sk_buff *nskb; + +net/ipv4/udp.c:1977: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1975. } + 1976. + 1977. > sk_for_each_entry_offset_rcu(sk, node, &hslot->head, offset) { + 1978. if (!__udp_is_mcast_sock(net, sk, uh->dest, daddr, + 1979. uh->source, saddr, dif, sdif, hnum)) + +net/sunrpc/auth_gss/auth_gss.c:1965: error: DEAD_STORE + The value written to &status (type int) is never used. + 1963. struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; + 1964. int savedlen = head->iov_len; + 1965. > int status = -EIO; + 1966. + 1967. if (ctx->gc_proc != RPC_GSS_PROC_DATA) + +drivers/input/input.c:1967: error: UNINITIALIZED_VALUE + The value read from mt_slots was never initialized. + 1965. mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum - + 1966. dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1, + 1967. > mt_slots = clamp(mt_slots, 2, 32); + 1968. } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) { + 1969. mt_slots = 2; + +block/blk-mq.c:1964: error: NULL_DEREFERENCE + pointer `hctx` last assigned on line 1963 could be null and is dereferenced at line 1964, column 25. + 1962. + 1963. hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead); + 1964. > ctx = __blk_mq_get_ctx(hctx->queue, cpu); + 1965. + 1966. spin_lock(&ctx->lock); + +net/wireless/trace.h:1961: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/xfrm/xfrm_state.c:1968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1966. + 1967. rcu_read_lock(); + 1968. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 1969. if (km->new_mapping) + 1970. err = km->new_mapping(x, ipaddr, sport); + +drivers/usb/core/devio.c:1971: error: UNINITIALIZED_VALUE + The value read from ds.context was never initialized. + 1969. return -EFAULT; + 1970. ps->discsignr = ds.signr; + 1971. > ps->disccontext = compat_ptr(ds.context); + 1972. return 0; + 1973. } + +drivers/usb/core/devio.c:1970: error: UNINITIALIZED_VALUE + The value read from ds.signr was never initialized. + 1968. if (copy_from_user(&ds, arg, sizeof(ds))) + 1969. return -EFAULT; + 1970. > ps->discsignr = ds.signr; + 1971. ps->disccontext = compat_ptr(ds.context); + 1972. return 0; + +net/ipv6/ip6_fib.c:1978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1976. for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { + 1977. head = &net->ipv6.fib_table_hash[h]; + 1978. > hlist_for_each_entry_rcu(table, head, tb6_hlist) { + 1979. spin_lock_bh(&table->tb6_lock); + 1980. fib6_clean_tree(net, &table->tb6_root, + +kernel/cgroup/cpuset.c:1974: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1973 could be null and is dereferenced by call to `parent_cs()` at line 1974, column 26. + 1972. { + 1973. struct cpuset *cs = css_cs(css); + 1974. > struct cpuset *parent = parent_cs(cs); + 1975. struct cpuset *tmp_cs; + 1976. struct cgroup_subsys_state *pos_css; + +drivers/usb/core/devio.c:1987: error: UNINITIALIZED_VALUE + The value read from urb32.actual_length was never initialized. + 1985. kurb->buffer = compat_ptr(urb32.buffer); + 1986. kurb->buffer_length = urb32.buffer_length; + 1987. > kurb->actual_length = urb32.actual_length; + 1988. kurb->start_frame = urb32.start_frame; + 1989. kurb->number_of_packets = urb32.number_of_packets; + +drivers/usb/core/devio.c:1985: error: UNINITIALIZED_VALUE + The value read from urb32.buffer was never initialized. + 1983. kurb->status = urb32.status; + 1984. kurb->flags = urb32.flags; + 1985. > kurb->buffer = compat_ptr(urb32.buffer); + 1986. kurb->buffer_length = urb32.buffer_length; + 1987. kurb->actual_length = urb32.actual_length; + +drivers/usb/core/devio.c:1986: error: UNINITIALIZED_VALUE + The value read from urb32.buffer_length was never initialized. + 1984. kurb->flags = urb32.flags; + 1985. kurb->buffer = compat_ptr(urb32.buffer); + 1986. > kurb->buffer_length = urb32.buffer_length; + 1987. kurb->actual_length = urb32.actual_length; + 1988. kurb->start_frame = urb32.start_frame; + +drivers/usb/core/devio.c:1982: error: UNINITIALIZED_VALUE + The value read from urb32.endpoint was never initialized. + 1980. return -EFAULT; + 1981. kurb->type = urb32.type; + 1982. > kurb->endpoint = urb32.endpoint; + 1983. kurb->status = urb32.status; + 1984. kurb->flags = urb32.flags; + +drivers/usb/core/devio.c:1990: error: UNINITIALIZED_VALUE + The value read from urb32.error_count was never initialized. + 1988. kurb->start_frame = urb32.start_frame; + 1989. kurb->number_of_packets = urb32.number_of_packets; + 1990. > kurb->error_count = urb32.error_count; + 1991. kurb->signr = urb32.signr; + 1992. kurb->usercontext = compat_ptr(urb32.usercontext); + +drivers/usb/core/devio.c:1984: error: UNINITIALIZED_VALUE + The value read from urb32.flags was never initialized. + 1982. kurb->endpoint = urb32.endpoint; + 1983. kurb->status = urb32.status; + 1984. > kurb->flags = urb32.flags; + 1985. kurb->buffer = compat_ptr(urb32.buffer); + 1986. kurb->buffer_length = urb32.buffer_length; + +drivers/usb/core/devio.c:1989: error: UNINITIALIZED_VALUE + The value read from urb32.number_of_packets was never initialized. + 1987. kurb->actual_length = urb32.actual_length; + 1988. kurb->start_frame = urb32.start_frame; + 1989. > kurb->number_of_packets = urb32.number_of_packets; + 1990. kurb->error_count = urb32.error_count; + 1991. kurb->signr = urb32.signr; + +drivers/usb/core/devio.c:1991: error: UNINITIALIZED_VALUE + The value read from urb32.signr was never initialized. + 1989. kurb->number_of_packets = urb32.number_of_packets; + 1990. kurb->error_count = urb32.error_count; + 1991. > kurb->signr = urb32.signr; + 1992. kurb->usercontext = compat_ptr(urb32.usercontext); + 1993. return 0; + +drivers/usb/core/devio.c:1988: error: UNINITIALIZED_VALUE + The value read from urb32.start_frame was never initialized. + 1986. kurb->buffer_length = urb32.buffer_length; + 1987. kurb->actual_length = urb32.actual_length; + 1988. > kurb->start_frame = urb32.start_frame; + 1989. kurb->number_of_packets = urb32.number_of_packets; + 1990. kurb->error_count = urb32.error_count; + +drivers/usb/core/devio.c:1983: error: UNINITIALIZED_VALUE + The value read from urb32.status was never initialized. + 1981. kurb->type = urb32.type; + 1982. kurb->endpoint = urb32.endpoint; + 1983. > kurb->status = urb32.status; + 1984. kurb->flags = urb32.flags; + 1985. kurb->buffer = compat_ptr(urb32.buffer); + +drivers/usb/core/devio.c:1981: error: UNINITIALIZED_VALUE + The value read from urb32.type was never initialized. + 1979. if (copy_from_user(&urb32, uurb, sizeof(*uurb))) + 1980. return -EFAULT; + 1981. > kurb->type = urb32.type; + 1982. kurb->endpoint = urb32.endpoint; + 1983. kurb->status = urb32.status; + +drivers/usb/core/devio.c:1992: error: UNINITIALIZED_VALUE + The value read from urb32.usercontext was never initialized. + 1990. kurb->error_count = urb32.error_count; + 1991. kurb->signr = urb32.signr; + 1992. > kurb->usercontext = compat_ptr(urb32.usercontext); + 1993. return 0; + 1994. } + +kernel/sched/core.c:2053: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2051. * their previous state and preserve Program Order. + 2052. */ + 2053. > smp_cond_load_acquire(&p->on_cpu, !VAL); + 2054. + 2055. p->sched_contributes_to_load = !!task_contributes_to_load(p); + +net/ipv4/devinet.c:1998: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1996. cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ + 1997. net->dev_base_seq; + 1998. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 1999. if (idx < s_idx) + 2000. goto cont; + +kernel/module.c:1989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1987. + 1988. mutex_lock(&module_mutex); + 1989. > list_for_each_entry_rcu(mod, &modules, list) { + 1990. if (mod->state == MODULE_STATE_UNFORMED) + 1991. continue; + +net/ipv4/fib_trie.c:1992: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1990. + 1991. /* rcu_read_lock is hold by caller */ + 1992. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1993. int err; + 1994. + +lib/radix-tree.c:1988: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1986. struct radix_tree_node *node, void __rcu **slot) + 1987. { + 1988. > void *old = rcu_dereference_raw(*slot); + 1989. int exceptional = radix_tree_exceptional_entry(old) ? -1 : 0; + 1990. unsigned offset = get_slot_offset(node, slot); + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +drivers/cpufreq/cpufreq.c:1993: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1991. unsigned int relation) + 1992. { + 1993. > int ret = -EINVAL; + 1994. + 1995. down_write(&policy->rwsem); + +lib/vsprintf.c:2056: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2054. /* it's the next argument */ + 2055. spec->type = FORMAT_TYPE_WIDTH; + 2056. > return ++fmt - start; + 2057. } + 2058. + +lib/vsprintf.c:2071: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2069. /* it's the next argument */ + 2070. spec->type = FORMAT_TYPE_PRECISION; + 2071. > return ++fmt - start; + 2072. } + 2073. } + +lib/vsprintf.c:2097: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2095. case 'c': + 2096. spec->type = FORMAT_TYPE_CHAR; + 2097. > return ++fmt - start; + 2098. + 2099. case 's': + +lib/vsprintf.c:2101: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2099. case 's': + 2100. spec->type = FORMAT_TYPE_STR; + 2101. > return ++fmt - start; + 2102. + 2103. case 'p': + +lib/vsprintf.c:2105: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2103. case 'p': + 2104. spec->type = FORMAT_TYPE_PTR; + 2105. > return ++fmt - start; + 2106. + 2107. case '%': + +lib/vsprintf.c:2109: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2107. case '%': + 2108. spec->type = FORMAT_TYPE_PERCENT_CHAR; + 2109. > return ++fmt - start; + 2110. + 2111. /* integer number formats - set up the flags and "break" */ + +lib/vsprintf.c:2163: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2161. } + 2162. + 2163. > return ++fmt - start; + 2164. } + 2165. + +net/wireless/trace.h:1990: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +security/selinux/ss/policydb.c:2005: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2003. if (rc) + 2004. return rc; + 2005. > nel = le32_to_cpu(buf[0]); + 2006. + 2007. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2011: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2009. if (rc) + 2010. goto out; + 2011. > len = le32_to_cpu(buf[0]); + 2012. + 2013. rc = -ENOMEM; + +security/selinux/ss/policydb.c:2045: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2043. goto out; + 2044. + 2045. > nel2 = le32_to_cpu(buf[0]); + 2046. for (j = 0; j < nel2; j++) { + 2047. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:2050: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2048. if (rc) + 2049. goto out; + 2050. > len = le32_to_cpu(buf[0]); + 2051. + 2052. rc = -ENOMEM; + +security/selinux/ss/policydb.c:2065: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2063. goto out; + 2064. + 2065. > newc->v.sclass = le32_to_cpu(buf[0]); + 2066. rc = context_read_and_validate(&newc->context[0], p, fp); + 2067. if (rc) + +drivers/tty/n_tty.c:2007: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2005. return 0; + 2006. + 2007. > n = min(*nr + 1, smp_load_acquire(&ldata->canon_head) - ldata->read_tail); + 2008. + 2009. tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + +net/ipv6/route.c:2013: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2011. + 2012. rcu_read_lock(); + 2013. > fn = rcu_dereference(rt->rt6i_node); + 2014. if (fn && (rt->rt6i_flags & RTF_DEFAULT)) + 2015. fn->fn_sernum = -1; + +drivers/gpu/drm/drm_dp_mst_topology.c:2019: error: DEAD_STORE + The value written to &len (type int) is never used. + 2017. } + 2018. + 2019. > len = build_dpcd_write(txmsg, port->port_num, offset, size, bytes); + 2020. txmsg->dst = mstb; + 2021. + +kernel/module.c:2008: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2006. + 2007. mutex_lock(&module_mutex); + 2008. > list_for_each_entry_rcu(mod, &modules, list) { + 2009. /* + 2010. * Ignore going modules since it's possible that ro + +net/ipv4/tcp_ipv4.c:2004: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2002. { + 2003. struct tcp_iter_state *st = seq->private; + 2004. > struct net *net = seq_file_net(seq); + 2005. void *rc = NULL; + 2006. + +drivers/net/ethernet/broadcom/tg3.c:2017: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2008 could be null and is dereferenced at line 2017, column 6. + 2015. oldflowctrl = tp->link_config.active_flowctrl; + 2016. + 2017. > if (phydev->link) { + 2018. lcl_adv = 0; + 2019. rmt_adv = 0; + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +net/packet/af_packet.c:2015: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2013. + 2014. rcu_read_lock(); + 2015. > filter = rcu_dereference(sk->sk_filter); + 2016. if (filter != NULL) + 2017. res = bpf_prog_run_clear_cb(filter->prog, skb); + +kernel/cgroup/cgroup.c:2022: error: NULL_DEREFERENCE + pointer `ns` last assigned on line 2015 could be null and is dereferenced at line 2022, column 18. + 2020. + 2021. /* Check if the caller has permission to mount. */ + 2022. > if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN)) { + 2023. put_cgroup_ns(ns); + 2024. return ERR_PTR(-EPERM); + +net/wireless/trace.h:2011: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +kernel/workqueue.c:2034: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2032. #endif + 2033. /* ensure we're on the correct CPU */ + 2034. > WARN_ON_ONCE(!(pool->flags & POOL_DISASSOCIATED) && + 2035. raw_smp_processor_id() != pool->cpu); + 2036. + +kernel/auditsc.c:2028: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2026. return; + 2027. + 2028. > uid = from_kuid(&init_user_ns, task_uid(current)); + 2029. oldloginuid = from_kuid(&init_user_ns, koldloginuid); + 2030. loginuid = from_kuid(&init_user_ns, kloginuid), + +net/xfrm/xfrm_state.c:2022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2020. + 2021. rcu_read_lock(); + 2022. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2023. if (km->report) { + 2024. ret = km->report(net, proto, sel, addr); + +net/sunrpc/xprtsock.c:2026: error: DEAD_STORE + The value written to &status (type int) is never used. + 2024. struct rpc_xprt *xprt = &transport->xprt; + 2025. struct socket *sock; + 2026. > int status = -EIO; + 2027. + 2028. status = __sock_create(xprt->xprt_net, AF_LOCAL, + +kernel/trace/trace.c:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. if (atomic_read(&trace_record_taskinfo_disabled) || !tracing_is_on()) + 2028. return true; + 2029. > if (!__this_cpu_read(trace_taskinfo_save)) + 2030. return true; + 2031. return false; + +kernel/cpu.c:2027: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2025. void __init boot_cpu_state_init(void) + 2026. { + 2027. > per_cpu_ptr(&cpuhp_state, smp_processor_id())->state = CPUHP_ONLINE; + 2028. } + +drivers/hid/hid-sony.c:2075: error: DEAD_STORE + The value written to &offset (type int) is never used. + 2073. /* If both delay values are zero the DualShock 4 disables blinking. */ + 2074. buf[offset++] = sc->led_delay_on[3]; + 2075. > buf[offset++] = sc->led_delay_off[3]; + 2076. + 2077. if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) + +net/wireless/trace.h:2029: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/ipv6/route.c:2034: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2032. return !(rt->rt6i_flags & RTF_CACHE) && + 2033. (rt->rt6i_flags & RTF_PCPU || + 2034. > rcu_access_pointer(rt->rt6i_node)); + 2035. } + 2036. + +net/ipv4/tcp_ipv4.c:2037: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2035. struct hlist_nulls_node *node; + 2036. struct tcp_iter_state *st = seq->private; + 2037. > struct net *net = seq_file_net(seq); + 2038. + 2039. ++st->num; + +net/ipv4/igmp.c:2044: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2042. return -ENODEV; + 2043. rcu_read_lock(); + 2044. > for_each_pmc_rcu(in_dev, pmc) { + 2045. if (*pmca == pmc->multiaddr) + 2046. break; + +net/xfrm/xfrm_state.c:2040: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2038. + 2039. rcu_read_lock(); + 2040. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2041. if (km->is_alive && km->is_alive(c)) { + 2042. is_alive = true; + +net/wireless/trace.h:2047: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/ipv4/devinet.c:2057: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2055. + 2056. rcu_read_lock(); + 2057. > for_each_netdev_rcu(net, dev) { + 2058. struct in_device *in_dev; + 2059. + +net/xfrm/xfrm_state.c:2068: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2066. err = -EINVAL; + 2067. rcu_read_lock(); + 2068. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2069. pol = km->compile_policy(sk, optname, data, + 2070. optlen, &err); + +drivers/md/md.c:2058: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2056. + 2057. rcu_read_lock(); + 2058. > rdev_for_each_rcu(rdev, mddev1) { + 2059. if (test_bit(Faulty, &rdev->flags) || + 2060. test_bit(Journal, &rdev->flags) || + +drivers/md/md.c:2063: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2061. rdev->raid_disk == -1) + 2062. continue; + 2063. > rdev_for_each_rcu(rdev2, mddev2) { + 2064. if (test_bit(Faulty, &rdev2->flags) || + 2065. test_bit(Journal, &rdev2->flags) || + +kernel/kprobes.c:2064: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2062. * chained probes and mark them GONE. + 2063. */ + 2064. > list_for_each_entry_rcu(kp, &p->list, list) + 2065. kp->flags |= KPROBE_FLAG_GONE; + 2066. p->post_handler = NULL; + +drivers/usb/core/hub.c:2073: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2068 could be null and is dereferenced at line 2073, column 7. + 2071. /* Free up all the children before we remove this device */ + 2072. for (i = 0; i < udev->maxchild; i++) { + 2073. > if (hub->ports[i]->child) + 2074. usb_disconnect(&hub->ports[i]->child); + 2075. } + +net/wireless/trace.h:2067: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2112: error: UNINITIALIZED_VALUE + The value read from fence.handle was never initialized. + 2110. } + 2111. + 2112. > syncobj = drm_syncobj_find(file, fence.handle); + 2113. if (!syncobj) { + 2114. DRM_DEBUG("Invalid syncobj handle provided\n"); + +drivers/gpu/drm/i915/intel_runtime_pm.c:2082: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 2081 could be null and is dereferenced at line 2082, column 8. + 2080. + 2081. power_well = lookup_power_well(dev_priv, power_well_id); + 2082. > ret = power_well->ops->is_enabled(dev_priv, power_well); + 2083. + 2084. return ret; + +drivers/usb/core/devio.c:2086: error: UNINITIALIZED_VALUE + The value read from ds.context was never initialized. + 2084. return -EFAULT; + 2085. ps->discsignr = ds.signr; + 2086. > ps->disccontext = ds.context; + 2087. return 0; + 2088. } + +drivers/usb/core/devio.c:2085: error: UNINITIALIZED_VALUE + The value read from ds.signr was never initialized. + 2083. if (copy_from_user(&ds, arg, sizeof(ds))) + 2084. return -EFAULT; + 2085. > ps->discsignr = ds.signr; + 2086. ps->disccontext = ds.context; + 2087. return 0; + +net/xfrm/xfrm_user.c:2089: error: DEAD_STORE + The value written to &err (type int) is never used. + 2087. struct xfrm_userpolicy_info *p = &up->pol; + 2088. u8 type = XFRM_POLICY_TYPE_MAIN; + 2089. > int err = -ENOENT; + 2090. struct xfrm_mark m; + 2091. u32 mark = xfrm_mark_get(attrs, &m); + +drivers/net/ethernet/broadcom/tg3.c:2100: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2097 could be null and is dereferenced by call to `phydev_name()` at line 2100, column 32. + 2098. + 2099. /* Attach the MAC to the PHY. */ + 2100. > phydev = phy_connect(tp->dev, phydev_name(phydev), + 2101. tg3_adjust_link, phydev->interface); + 2102. if (IS_ERR(phydev)) { + +net/wireless/trace.h:2087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +drivers/scsi/sd.c:2170: error: DEAD_STORE + The value written to &spintime_expire (type unsigned long) is never used. + 2168. SD_TIMEOUT, SD_MAX_RETRIES, + 2169. NULL); + 2170. > spintime_expire = jiffies + 100 * HZ; + 2171. spintime = 1; + 2172. } + +drivers/scsi/sd.c:2186: error: DEAD_STORE + The value written to &spintime_expire (type unsigned long) is never used. + 2184. sshdr.asc == 0x28) { + 2185. if (!spintime) { + 2186. > spintime_expire = jiffies + 5 * HZ; + 2187. spintime = 1; + 2188. } + +arch/x86/events/intel/core.c:2100: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2098. + 2099. if (unlikely(hwc->idx == INTEL_PMC_IDX_FIXED_BTS)) { + 2100. > if (!__this_cpu_read(cpu_hw_events.enabled)) + 2101. return; + 2102. + +net/ipv4/route.c:2131: error: NULL_DEREFERENCE + pointer `in_dev` last assigned on line 2109 could be null and is dereferenced at line 2131, column 8. + 2129. || + 2130. (!ipv4_is_local_multicast(daddr) && + 2131. > IN_DEV_MFORWARD(in_dev)) + 2132. #endif + 2133. ) { + +kernel/sched/core.c:2132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2130. + 2131. ttwu_do_wakeup(rq, p, 0, rf); + 2132. > ttwu_stat(p, smp_processor_id(), 0); + 2133. out: + 2134. raw_spin_unlock(&p->pi_lock); + +kernel/sched/core.c:2132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2130. + 2131. ttwu_do_wakeup(rq, p, 0, rf); + 2132. > ttwu_stat(p, smp_processor_id(), 0); + 2133. out: + 2134. raw_spin_unlock(&p->pi_lock); + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +include/net/sock.h:2107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2105. if (sock_flag(sk, SOCK_FASYNC)) { + 2106. rcu_read_lock(); + 2107. > sock_wake_async(rcu_dereference(sk->sk_wq), how, band); + 2108. rcu_read_unlock(); + 2109. } + +security/selinux/ss/policydb.c:2118: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2116. if (rc) + 2117. goto out; + 2118. > nel = le32_to_cpu(buf[0]); + 2119. + 2120. l = NULL; + +security/selinux/ss/policydb.c:2138: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2136. goto out; + 2137. + 2138. > c->sid[0] = le32_to_cpu(buf[0]); + 2139. rc = context_read_and_validate(&c->context[0], p, fp); + 2140. if (rc) + +security/selinux/ss/policydb.c:2148: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2146. if (rc) + 2147. goto out; + 2148. > len = le32_to_cpu(buf[0]); + 2149. + 2150. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:2165: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2163. if (rc) + 2164. goto out; + 2165. > c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. c->u.port.high_port = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:2166: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2164. goto out; + 2165. c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. > c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. c->u.port.high_port = le32_to_cpu(buf[2]); + 2168. rc = context_read_and_validate(&c->context[0], p, fp); + +security/selinux/ss/policydb.c:2167: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2165. c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. > c->u.port.high_port = le32_to_cpu(buf[2]); + 2168. rc = context_read_and_validate(&c->context[0], p, fp); + 2169. if (rc) + +security/selinux/ss/policydb.c:2188: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2186. + 2187. rc = -EINVAL; + 2188. > c->v.behavior = le32_to_cpu(buf[0]); + 2189. /* Determined at runtime, not in policy DB. */ + 2190. if (c->v.behavior == SECURITY_FS_USE_MNTPOINT) + +security/selinux/ss/policydb.c:2195: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2193. goto out; + 2194. + 2195. > len = le32_to_cpu(buf[1]); + 2196. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + 2197. if (rc) + +security/selinux/ss/policydb.c:2245: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2243. if (rc) + 2244. goto out; + 2245. > len = le32_to_cpu(buf[0]); + 2246. + 2247. rc = str_read(&c->u.ibendport.dev_name, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:2256: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2254. } + 2255. + 2256. > c->u.ibendport.port = le32_to_cpu(buf[1]); + 2257. + 2258. rc = context_read_and_validate(&c->context[0], + +security/selinux/ss/policydb.c:2176: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2174. if (rc) + 2175. goto out; + 2176. > c->u.node.addr = nodebuf[0]; /* network order */ + 2177. c->u.node.mask = nodebuf[1]; /* network order */ + 2178. rc = context_read_and_validate(&c->context[0], p, fp); + +security/selinux/ss/policydb.c:2177: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2175. goto out; + 2176. c->u.node.addr = nodebuf[0]; /* network order */ + 2177. > c->u.node.mask = nodebuf[1]; /* network order */ + 2178. rc = context_read_and_validate(&c->context[0], p, fp); + 2179. if (rc) + +security/selinux/ss/policydb.c:2211: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2209. goto out; + 2210. for (k = 0; k < 4; k++) + 2211. > c->u.node6.addr[k] = nodebuf[k]; + 2212. for (k = 0; k < 4; k++) + 2213. c->u.node6.mask[k] = nodebuf[k+4]; + +security/selinux/ss/policydb.c:2213: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2211. c->u.node6.addr[k] = nodebuf[k]; + 2212. for (k = 0; k < 4; k++) + 2213. > c->u.node6.mask[k] = nodebuf[k+4]; + 2214. rc = context_read_and_validate(&c->context[0], p, fp); + 2215. if (rc) + +security/selinux/ss/policydb.c:2232: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2230. } + 2231. + 2232. > c->u.ibpkey.low_pkey = le32_to_cpu(nodebuf[2]); + 2233. c->u.ibpkey.high_pkey = le32_to_cpu(nodebuf[3]); + 2234. + +security/selinux/ss/policydb.c:2233: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2231. + 2232. c->u.ibpkey.low_pkey = le32_to_cpu(nodebuf[2]); + 2233. > c->u.ibpkey.high_pkey = le32_to_cpu(nodebuf[3]); + 2234. + 2235. rc = context_read_and_validate(&c->context[0], + +drivers/tty/n_tty.c:2168: error: DEAD_STORE + The value written to &nr (type unsigned long) is never used. + 2166. } + 2167. b++; + 2168. > nr--; + 2169. break; + 2170. } + +kernel/sched/sched.h:2112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2110. struct update_util_data *data; + 2111. + 2112. > data = rcu_dereference_sched(*per_cpu_ptr(&cpufreq_update_util_data, + 2113. cpu_of(rq))); + 2114. if (data) + +net/core/ethtool.c:2131: error: UNINITIALIZED_VALUE + The value read from dump.len was never initialized. + 2129. return ret; + 2130. + 2131. > len = min(tmp.len, dump.len); + 2132. if (!len) + 2133. return -EFAULT; + +kernel/signal.c:2145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2143. info->si_pid = task_pid_vnr(current->parent); + 2144. info->si_uid = from_kuid_munged(current_user_ns(), + 2145. > task_uid(current->parent)); + 2146. rcu_read_unlock(); + 2147. } + +sound/core/pcm_lib.c:2208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2206. } + 2207. frames = size > avail ? avail : size; + 2208. > appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 2209. appl_ofs = appl_ptr % runtime->buffer_size; + 2210. cont = runtime->buffer_size - appl_ofs; + +net/ipv4/fib_trie.c:2126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2124. while (!IS_TRIE(pn)) { + 2125. while (cindex < child_length(pn)) { + 2126. > struct key_vector *n = get_child_rcu(pn, cindex++); + 2127. + 2128. if (!n) + +net/ipv4/fib_trie.c:2146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2144. /* Current node exhausted, pop back up */ + 2145. pkey = pn->key; + 2146. > pn = node_parent_rcu(pn); + 2147. cindex = get_index(pkey, pn) + 1; + 2148. --iter->depth; + +lib/radix-tree.c:2130: error: UNINITIALIZED_VALUE + The value read from pco_ret__ was never initialized. + 2128. if (!bitmap) + 2129. return 0; + 2130. > if (this_cpu_cmpxchg(ida_bitmap, NULL, bitmap)) + 2131. kfree(bitmap); + 2132. } + +lib/radix-tree.c:2126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2124. preempt_enable(); + 2125. + 2126. > if (!this_cpu_read(ida_bitmap)) { + 2127. struct ida_bitmap *bitmap = kmalloc(sizeof(*bitmap), gfp); + 2128. if (!bitmap) + +kernel/printk/printk.c:2120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2118. static inline int can_use_console(void) + 2119. { + 2120. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2121. } + 2122. + +kernel/printk/printk.c:2120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2118. static inline int can_use_console(void) + 2119. { + 2120. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2121. } + 2122. + +net/xfrm/xfrm_state.c:2135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2133. spin_lock_bh(&xfrm_state_afinfo_lock); + 2134. if (likely(xfrm_state_afinfo[afinfo->family] != NULL)) { + 2135. > if (rcu_access_pointer(xfrm_state_afinfo[family]) != afinfo) + 2136. err = -EINVAL; + 2137. else + +arch/x86/events/core.c:2129: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2127. static void refresh_pce(void *ignored) + 2128. { + 2129. > load_mm_cr4(this_cpu_read(cpu_tlbstate.loaded_mm)); + 2130. } + 2131. + +kernel/irq/manage.c:2154: error: MEMORY_LEAK + `chip` is not reachable after line 2154, column 3. + 2152. + 2153. if (data) + 2154. > err = chip->irq_get_irqchip_state(data, which, state); + 2155. + 2156. irq_put_desc_busunlock(desc, flags); + +net/ipv4/cipso_ipv4.c:2138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2136. + 2137. rcu_read_lock(); + 2138. > opt = rcu_dereference(inet_sk(sk)->inet_opt); + 2139. if (opt && opt->opt.cipso) + 2140. res = cipso_v4_getattr(opt->opt.__data + + +net/ipv6/route.c:2156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2154. fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); + 2155. restart: + 2156. > for_each_fib6_node_rt_rcu(fn) { + 2157. if (rt6_check_expired(rt)) + 2158. continue; + +drivers/md/md.c:2144: error: DEAD_STORE + The value written to &bi_rdev (type blk_integrity*) is never used. + 2142. return 0; + 2143. + 2144. > bi_rdev = bdev_get_integrity(rdev->bdev); + 2145. bi_mddev = blk_get_integrity(mddev->gendisk); + 2146. + +drivers/net/ethernet/broadcom/tg3.c:2148: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2144 could be null and is dereferenced at line 2148, column 3. + 2146. if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) { + 2147. tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER; + 2148. > phydev->speed = tp->link_config.speed; + 2149. phydev->duplex = tp->link_config.duplex; + 2150. phydev->autoneg = tp->link_config.autoneg; + +drivers/net/ethernet/broadcom/tg3.c:2154: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2144 could be null and is dereferenced by call to `phy_start()` at line 2154, column 2. + 2152. } + 2153. + 2154. > phy_start(phydev); + 2155. + 2156. phy_start_aneg(phydev); + +kernel/printk/printk.c:2259: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 2257. retry = console_seq != log_next_seq; + 2258. raw_spin_unlock(&logbuf_lock); + 2259. > printk_safe_exit_irqrestore(flags); + 2260. + 2261. if (retry && console_trylock()) + +lib/radix-tree.c:2159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2157. return ERR_PTR(error); + 2158. shift = error; + 2159. > child = rcu_dereference_raw(root->rnode); + 2160. } + 2161. + +lib/radix-tree.c:2192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2190. shift = node->shift; + 2191. } + 2192. > child = rcu_dereference_raw(node->slots[offset]); + 2193. } + 2194. slot = &node->slots[offset]; + +drivers/tty/serial/serial_core.c:2150: error: NULL_DEREFERENCE + pointer `tty_dev` last assigned on line 2149 could be null and is dereferenced by call to `device_may_wakeup()` at line 2150, column 27. + 2148. + 2149. tty_dev = device_find_child(uport->dev, &match, serial_match_port); + 2150. > if (!uport->suspended && device_may_wakeup(tty_dev)) { + 2151. if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) + 2152. disable_irq_wake(uport->irq); + +net/wireless/trace.h:2139: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/ipv4/ipmr.c:2186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2184. struct sock *mroute_sk; + 2185. + 2186. > mroute_sk = rcu_dereference(mrt->mroute_sk); + 2187. if (mroute_sk) { + 2188. nf_reset(skb); + +net/ipv4/route.c:2216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2214. if (fnhe) { + 2215. prth = &fnhe->fnhe_rth_output; + 2216. > rth = rcu_dereference(*prth); + 2217. if (rth && rth->dst.expires && + 2218. time_after(jiffies, rth->dst.expires)) { + +net/ipv4/route.c:2234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2232. } + 2233. prth = raw_cpu_ptr(nh->nh_pcpu_rth_output); + 2234. > rth = rcu_dereference(*prth); + 2235. + 2236. rt_cache: + +kernel/rcu/tree.c:2151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2149. + 2150. /* Someone like call_rcu() requested a force-quiescent-state scan. */ + 2151. > *gfp = READ_ONCE(rsp->gp_flags); + 2152. if (*gfp & RCU_GP_FLAG_FQS) + 2153. return true; + +net/xfrm/xfrm_state.c:2151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2149. return NULL; + 2150. + 2151. > return rcu_dereference(xfrm_state_afinfo[family]); + 2152. } + 2153. + +net/xfrm/xfrm_state.c:2160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2158. return NULL; + 2159. rcu_read_lock(); + 2160. > afinfo = rcu_dereference(xfrm_state_afinfo[family]); + 2161. if (unlikely(!afinfo)) + 2162. rcu_read_unlock(); + +arch/x86/events/intel/core.c:2157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2155. static void intel_pmu_reset(void) + 2156. { + 2157. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 2158. unsigned long flags; + 2159. int idx; + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +arch/x86/events/intel/core.c:2157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2155. static void intel_pmu_reset(void) + 2156. { + 2157. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 2158. unsigned long flags; + 2159. int idx; + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +net/wireless/trace.h:2157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +kernel/fork.c:2166: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2164. leader = top = top->group_leader; + 2165. down: + 2166. > for_each_thread(leader, parent) { + 2167. list_for_each_entry(child, &parent->children, sibling) { + 2168. res = visitor(child, data); + +kernel/signal.c:2340: error: UNINITIALIZED_VALUE + The value read from signr was never initialized. + 2338. spin_unlock_irq(&sighand->siglock); + 2339. + 2340. > ksig->sig = signr; + 2341. return ksig->sig > 0; + 2342. } + +net/ipv4/fib_trie.c:2167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2165. + 2166. pn = t->kv; + 2167. > n = rcu_dereference(pn->tnode[0]); + 2168. if (!n) + 2169. return NULL; + +net/core/dev.c:2215: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2213. for (i = tc, tci = cpu * num_tc; dev_maps && i--; tci++) { + 2214. /* fill in the new device map from the old device map */ + 2215. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2216. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2217. } + +net/core/dev.c:2242: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2240. } else if (dev_maps) { + 2241. /* fill in the new device map from the old device map */ + 2242. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2243. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2244. } + +net/core/dev.c:2249: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2247. for (i = num_tc - tc, tci++; dev_maps && --i; tci++) { + 2248. /* fill in the new device map from the old device map */ + 2249. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2250. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2251. } + +kernel/trace/trace.c:2189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2187. + 2188. preempt_disable(); + 2189. > if (cpu == smp_processor_id() && + 2190. this_cpu_read(trace_buffered_event) != + 2191. per_cpu(trace_buffered_event, cpu)) + +kernel/trace/trace.c:2190: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2188. preempt_disable(); + 2189. if (cpu == smp_processor_id() && + 2190. > this_cpu_read(trace_buffered_event) != + 2191. per_cpu(trace_buffered_event, cpu)) + 2192. WARN_ON_ONCE(1); + +net/ipv4/udp.c:2181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2179. + 2180. result = NULL; + 2181. > sk_for_each_rcu(sk, &hslot->head) { + 2182. if (__udp_is_mcast_sock(net, sk, loc_port, loc_addr, + 2183. rmt_port, rmt_addr, dif, sdif, hnum)) { + +kernel/kprobes.c:2193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2191. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 2192. head = &kprobe_table[i]; + 2193. > hlist_for_each_entry_rcu(p, head, hlist) + 2194. if (within_module_init((unsigned long)p->addr, mod) || + 2195. (checkcore && + +kernel/irq/manage.c:2200: error: MEMORY_LEAK + `chip` is not reachable after line 2200, column 3. + 2198. + 2199. if (data) + 2200. > err = chip->irq_set_irqchip_state(data, which, val); + 2201. + 2202. irq_put_desc_busunlock(desc, flags); + +net/wireless/trace.h:2175: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/xfrm/xfrm_user.c:2219: error: DEAD_STORE + The value written to &err (type int) is never used. + 2217. t->ealgos = ua->ealgos; + 2218. t->calgos = ua->calgos; + 2219. > err = km_query(x, t, xp); + 2220. + 2221. } + +ipc/sem.c:2200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2198. + 2199. rcu_read_lock(); + 2200. > un = list_entry_rcu(ulp->list_proc.next, + 2201. struct sem_undo, list_proc); + 2202. if (&un->list_proc == &ulp->list_proc) { + +net/xfrm/xfrm_state.c:2183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2181. int xfrm_state_mtu(struct xfrm_state *x, int mtu) + 2182. { + 2183. > const struct xfrm_type *type = READ_ONCE(x->type); + 2184. + 2185. if (x->km.state == XFRM_STATE_VALID && + +net/ipv4/fib_trie.c:2201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2199. s->maxdepth = iter.depth; + 2200. + 2201. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) + 2202. ++s->prefixes; + 2203. } else { + +drivers/net/ethernet/intel/e1000/e1000_main.c:2206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2204. struct e1000_rx_ring *ring = &adapter->rx_ring[0]; + 2205. e1000_configure_rx(adapter); + 2206. > adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); + 2207. } + 2208. } + +kernel/rcu/tree.c:2254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2252. if (needgp || cpu_needs_another_gp(rsp, rdp)) { + 2253. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2254. > trace_rcu_grace_period(rsp->name, + 2255. READ_ONCE(rsp->gpnum), + 2256. TPS("newreq")); + +net/ipv4/udp.c:2210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2208. struct sock *sk; + 2209. + 2210. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 2211. if (INET_MATCH(sk, net, acookie, rmt_addr, + 2212. loc_addr, ports, dif, sdif)) + +block/cfq-iosched.c:2213: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced at line 2213, column 12. + 2211. if (cfq_class_idle(cfqq)) { + 2212. rb_key = CFQ_IDLE_DELAY; + 2213. > parent = st->rb_rightmost; + 2214. if (parent && parent != &cfqq->rb_node) { + 2215. __cfqq = rb_entry(parent, struct cfq_queue, rb_node); + +block/cfq-iosched.c:2231: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced by call to `cfq_rb_first()` at line 2231, column 12. + 2229. } else { + 2230. rb_key = -NSEC_PER_SEC; + 2231. > __cfqq = cfq_rb_first(st); + 2232. rb_key += __cfqq ? __cfqq->rb_key : now; + 2233. } + +net/wireless/trace.h:2200: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +drivers/usb/core/devio.c:2212: error: UNINITIALIZED_VALUE + The value read from ioc32.data was never initialized. + 2210. ctrl.ifno = ioc32.ifno; + 2211. ctrl.ioctl_code = ioc32.ioctl_code; + 2212. > ctrl.data = compat_ptr(ioc32.data); + 2213. return proc_ioctl(ps, &ctrl); + 2214. } + +drivers/usb/core/devio.c:2210: error: UNINITIALIZED_VALUE + The value read from ioc32.ifno was never initialized. + 2208. if (copy_from_user(&ioc32, compat_ptr(arg), sizeof(ioc32))) + 2209. return -EFAULT; + 2210. > ctrl.ifno = ioc32.ifno; + 2211. ctrl.ioctl_code = ioc32.ioctl_code; + 2212. ctrl.data = compat_ptr(ioc32.data); + +drivers/usb/core/devio.c:2211: error: UNINITIALIZED_VALUE + The value read from ioc32.ioctl_code was never initialized. + 2209. return -EFAULT; + 2210. ctrl.ifno = ioc32.ifno; + 2211. > ctrl.ioctl_code = ioc32.ioctl_code; + 2212. ctrl.data = compat_ptr(ioc32.data); + 2213. return proc_ioctl(ps, &ctrl); + +kernel/trace/trace_events.c:2239: error: UNINITIALIZED_VALUE + The value read from last_i was never initialized. + 2237. * system. + 2238. */ + 2239. > for (i = last_i; i < len; i++) { + 2240. if (call->class->system == map[i]->system) { + 2241. /* Save the first system if need be */ + +lib/radix-tree.c:2222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2220. void idr_destroy(struct idr *idr) + 2221. { + 2222. > struct radix_tree_node *node = rcu_dereference_raw(idr->idr_rt.rnode); + 2223. if (radix_tree_is_internal_node(node)) + 2224. radix_tree_free_nodes(node); + +net/ipv4/udp.c:2263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2261. skb->sk = sk; + 2262. skb->destructor = sock_efree; + 2263. > dst = READ_ONCE(sk->sk_rx_dst); + 2264. + 2265. if (dst) + +net/wireless/trace.h:2220: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +drivers/usb/host/ehci-sched.c:2270: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 2268. + 2269. /* give urb back to the driver; completion often (re)submits */ + 2270. > dev = urb->dev; + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + +drivers/iommu/intel-iommu.c:2294: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2292. * touches the iova range + 2293. */ + 2294. > tmp = cmpxchg64_local(&pte->val, 0ULL, pteval); + 2295. if (tmp) { + 2296. static int dumps = 5; + +kernel/futex.c:2251: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2249. * optimizing lock_ptr out of the logic below. + 2250. */ + 2251. > lock_ptr = READ_ONCE(q->lock_ptr); + 2252. if (lock_ptr != NULL) { + 2253. spin_lock(lock_ptr); + +net/wireless/trace.h:2244: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/unix/af_unix.c:2365: error: DEAD_STORE + The value written to &sunaddr (type sockaddr_un*) is never used. + 2363. /* Copy address just once */ + 2364. if (state->msg && state->msg->msg_name) { + 2365. > DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + +drivers/gpu/drm/drm_dp_mst_topology.c:2276: error: DEAD_STORE + The value written to &origlen (type int) is never used. + 2274. replylen = msg->curchunk_len + msg->curchunk_hdrlen; + 2275. + 2276. > origlen = replylen; + 2277. replylen -= len; + 2278. curreply = len; + +drivers/usb/core/devio.c:2266: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2264. return -EFAULT; + 2265. + 2266. > intf = usb_ifnum_to_if(ps->dev, dc.interface); + 2267. if (!intf) + 2268. return -EINVAL; + +drivers/usb/core/devio.c:2290: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2288. } + 2289. + 2290. > return claimintf(ps, dc.interface); + 2291. } + 2292. + +kernel/auditsc.c:2265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2263. context->target_pid = task_tgid_nr(t); + 2264. context->target_auid = audit_get_loginuid(t); + 2265. > context->target_uid = task_uid(t); + 2266. context->target_sessionid = audit_get_sessionid(t); + 2267. security_task_getsecid(t, &context->target_sid); + +kernel/trace/trace.c:2274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2272. if ((trace_file->flags & + 2273. (EVENT_FILE_FL_SOFT_DISABLED | EVENT_FILE_FL_FILTERED)) && + 2274. > (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. val = this_cpu_inc_return(trace_buffered_event_cnt); + +kernel/trace/trace.c:2276: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2274. (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. > val = this_cpu_inc_return(trace_buffered_event_cnt); + 2277. if (val == 1) { + 2278. trace_event_setup(entry, type, flags, pc); + +kernel/trace/trace.c:2274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2272. if ((trace_file->flags & + 2273. (EVENT_FILE_FL_SOFT_DISABLED | EVENT_FILE_FL_FILTERED)) && + 2274. > (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. val = this_cpu_inc_return(trace_buffered_event_cnt); + +net/wireless/trace.h:2262: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +kernel/rcu/tree.c:2314: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2312. TPS("fqswait")); + 2313. rsp->gp_state = RCU_GP_WAIT_FQS; + 2314. > ret = swait_event_idle_timeout(rsp->gp_wq, + 2315. rcu_gp_fqs_check_wake(rsp, &gf), j); + 2316. rsp->gp_state = RCU_GP_DOING_FQS; + +kernel/rcu/tree.c:2278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2276. /* Handle grace-period start. */ + 2277. for (;;) { + 2278. > trace_rcu_grace_period(rsp->name, + 2279. READ_ONCE(rsp->gpnum), + 2280. TPS("reqwait")); + +kernel/rcu/tree.c:2291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2289. WRITE_ONCE(rsp->gp_activity, jiffies); + 2290. WARN_ON(signal_pending(current)); + 2291. > trace_rcu_grace_period(rsp->name, + 2292. READ_ONCE(rsp->gpnum), + 2293. TPS("reqwaitsig")); + +kernel/rcu/tree.c:2310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2308. jiffies + 3 * j); + 2309. } + 2310. > trace_rcu_grace_period(rsp->name, + 2311. READ_ONCE(rsp->gpnum), + 2312. TPS("fqswait")); + +kernel/rcu/tree.c:2325: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2323. if (ULONG_CMP_GE(jiffies, rsp->jiffies_force_qs) || + 2324. (gf & RCU_GP_FLAG_FQS)) { + 2325. > trace_rcu_grace_period(rsp->name, + 2326. READ_ONCE(rsp->gpnum), + 2327. TPS("fqsstart")); + +kernel/rcu/tree.c:2330: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2328. rcu_gp_fqs(rsp, first_gp_fqs); + 2329. first_gp_fqs = false; + 2330. > trace_rcu_grace_period(rsp->name, + 2331. READ_ONCE(rsp->gpnum), + 2332. TPS("fqsend")); + +kernel/rcu/tree.c:2349: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2347. WRITE_ONCE(rsp->gp_activity, jiffies); + 2348. WARN_ON(signal_pending(current)); + 2349. > trace_rcu_grace_period(rsp->name, + 2350. READ_ONCE(rsp->gpnum), + 2351. TPS("fqswaitsig")); + +net/ipv6/ip6_fib.c:2274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2272. if (tbl) { + 2273. h = (tbl->tb6_id & (FIB6_TABLE_HASHSZ - 1)) + 1; + 2274. > node = rcu_dereference_bh(hlist_next_rcu(&tbl->tb6_hlist)); + 2275. } else { + 2276. h = 0; + +net/ipv6/ip6_fib.c:2281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2279. + 2280. while (!node && h < FIB6_TABLE_HASHSZ) { + 2281. > node = rcu_dereference_bh( + 2282. hlist_first_rcu(&net->ipv6.fib_table_hash[h++])); + 2283. } + +drivers/input/input.c:2278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2276. rcu_read_lock(); + 2277. + 2278. > list_for_each_entry_rcu(handle, &handler->h_list, h_node) { + 2279. retval = fn(handle, data); + 2280. if (retval) + +security/selinux/ss/policydb.c:2447: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2445. goto bad; + 2446. + 2447. > rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + +security/selinux/ss/policydb.c:2298: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2296. rc = -EINVAL; + 2297. if (le32_to_cpu(buf[0]) != POLICYDB_MAGIC) { + 2298. > printk(KERN_ERR "SELinux: policydb magic number 0x%x does " + 2299. "not match expected magic number 0x%x\n", + 2300. le32_to_cpu(buf[0]), POLICYDB_MAGIC); + +security/selinux/ss/policydb.c:2305: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2303. + 2304. rc = -EINVAL; + 2305. > len = le32_to_cpu(buf[1]); + 2306. if (len != strlen(POLICYDB_STRING)) { + 2307. printk(KERN_ERR "SELinux: policydb string length %d does not " + +security/selinux/ss/policydb.c:2346: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2344. + 2345. rc = -EINVAL; + 2346. > p->policyvers = le32_to_cpu(buf[0]); + 2347. if (p->policyvers < POLICYDB_VERSION_MIN || + 2348. p->policyvers > POLICYDB_VERSION_MAX) { + +security/selinux/ss/policydb.c:2349: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2347. if (p->policyvers < POLICYDB_VERSION_MIN || + 2348. p->policyvers > POLICYDB_VERSION_MAX) { + 2349. > printk(KERN_ERR "SELinux: policydb version %d does not match " + 2350. "my version range %d-%d\n", + 2351. le32_to_cpu(buf[0]), POLICYDB_VERSION_MIN, POLICYDB_VERSION_MAX); + +security/selinux/ss/policydb.c:2392: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2390. if (le32_to_cpu(buf[2]) != info->sym_num || + 2391. le32_to_cpu(buf[3]) != info->ocon_num) { + 2392. > printk(KERN_ERR "SELinux: policydb table sizes (%d,%d) do " + 2393. "not match mine (%d,%d)\n", le32_to_cpu(buf[2]), + 2394. le32_to_cpu(buf[3]), + +security/selinux/ss/policydb.c:2403: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2401. if (rc) + 2402. goto bad; + 2403. > nprim = le32_to_cpu(buf[0]); + 2404. nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + +security/selinux/ss/policydb.c:2404: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2402. goto bad; + 2403. nprim = le32_to_cpu(buf[0]); + 2404. > nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + 2406. rc = read_f[i](p, p->symtab[i].table, fp); + +security/selinux/ss/policydb.c:2432: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2430. if (rc) + 2431. goto bad; + 2432. > nel = le32_to_cpu(buf[0]); + 2433. ltr = NULL; + 2434. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2448: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2446. + 2447. rc = -EINVAL; + 2448. > tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + 2450. tr->new_role = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:2449: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2447. rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. > tr->type = le32_to_cpu(buf[1]); + 2450. tr->new_role = le32_to_cpu(buf[2]); + 2451. if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) { + +security/selinux/ss/policydb.c:2450: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + 2450. > tr->new_role = le32_to_cpu(buf[2]); + 2451. if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) { + 2452. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:2455: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2453. if (rc) + 2454. goto bad; + 2455. > tr->tclass = le32_to_cpu(buf[0]); + 2456. } else + 2457. tr->tclass = p->process_class; + +security/selinux/ss/policydb.c:2471: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2469. if (rc) + 2470. goto bad; + 2471. > nel = le32_to_cpu(buf[0]); + 2472. lra = NULL; + 2473. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2487: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2485. + 2486. rc = -EINVAL; + 2487. > ra->role = le32_to_cpu(buf[0]); + 2488. ra->new_role = le32_to_cpu(buf[1]); + 2489. if (!policydb_role_isvalid(p, ra->role) || + +security/selinux/ss/policydb.c:2488: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2486. rc = -EINVAL; + 2487. ra->role = le32_to_cpu(buf[0]); + 2488. > ra->new_role = le32_to_cpu(buf[1]); + 2489. if (!policydb_role_isvalid(p, ra->role) || + 2490. !policydb_role_isvalid(p, ra->new_role)) + +kernel/auditsc.c:2284: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2282. struct task_struct *tsk = current; + 2283. struct audit_context *ctx = tsk->audit_context; + 2284. > kuid_t uid = current_uid(), t_uid = task_uid(t); + 2285. + 2286. if (auditd_test_task(t) && + +kernel/sysctl.c:2331: error: DEAD_STORE + The value written to &left (type unsigned long) is never used. + 2329. + 2330. if (!err && left) + 2331. > left -= proc_skip_spaces(&p); + 2332. + 2333. out_free: + +drivers/cdrom/cdrom.c:2302: error: UNINITIALIZED_VALUE + The value read from ms_info.addr_format was never initialized. + 2300. return -EFAULT; + 2301. + 2302. > requested_format = ms_info.addr_format; + 2303. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2304. return -EINVAL; + +net/ipv4/udp.c:2300: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2298. if (static_key_false(&udp_encap_needed) && up->encap_type) { + 2299. void (*encap_destroy)(struct sock *sk); + 2300. > encap_destroy = READ_ONCE(up->encap_destroy); + 2301. if (encap_destroy) + 2302. encap_destroy(sk); + +net/ipv4/fib_trie.c:2311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2309. struct fib_table *tb; + 2310. + 2311. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2312. struct trie *t = (struct trie *) tb->tb_data; + 2313. struct trie_stat stat; + +net/ipv6/ip6_fib.c:2308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2306. goto iter_table; + 2307. + 2308. > n = rcu_dereference_bh(((struct rt6_info *)v)->dst.rt6_next); + 2309. if (n) { + 2310. ++*pos; + +drivers/gpu/drm/drm_dp_mst_topology.c:2314: error: DEAD_STORE + The value written to &slot (type int) is never used. + 2312. struct drm_dp_sideband_msg_tx *txmsg; + 2313. struct drm_dp_mst_branch *mstb; + 2314. > int slot = -1; + 2315. mstb = drm_dp_get_mst_branch_device(mgr, + 2316. mgr->down_rep_recv.initial_hdr.lct, + +net/wireless/trace.h:2301: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/ipv4/ipmr.c:2343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2341. nla_nest_end(skb, mp_attr); + 2342. + 2343. > lastuse = READ_ONCE(c->mfc_un.res.lastuse); + 2344. lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0; + 2345. + +net/ipv4/route.c:2314: error: DEAD_STORE + The value written to &err (type int) is never used. + 2312. unsigned int flags = 0; + 2313. struct rtable *rth; + 2314. > int err = -ENETUNREACH; + 2315. + 2316. if (fl4->saddr) { + +kernel/trace/ring_buffer.c:2338: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2336. old_index += write_mask; + 2337. new_index += write_mask; + 2338. > index = local_cmpxchg(&bpage->write, old_index, new_index); + 2339. if (index == old_index) { + 2340. /* update counters */ + +kernel/trace/ring_buffer.c:2324: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2322. addr &= PAGE_MASK; + 2323. + 2324. > bpage = READ_ONCE(cpu_buffer->tail_page); + 2325. + 2326. if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) { + +net/core/neighbour.c:2337: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2335. + 2336. rcu_read_lock_bh(); + 2337. > nht = rcu_dereference_bh(tbl->nht); + 2338. + 2339. for (h = s_h; h < (1 << nht->hash_shift); h++) { + +net/core/neighbour.c:2342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2340. if (h > s_h) + 2341. s_idx = 0; + 2342. > for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; + 2343. n != NULL; + 2344. n = rcu_dereference_bh(n->next)) { + +net/core/neighbour.c:2344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2342. for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; + 2343. n != NULL; + 2344. > n = rcu_dereference_bh(n->next)) { + 2345. if (idx < s_idx || !net_eq(dev_net(n->dev), net)) + 2346. goto next; + +net/ipv6/addrconf.c:2344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2342. goto out; + 2343. + 2344. > for_each_fib6_node_rt_rcu(fn) { + 2345. if (rt->dst.dev->ifindex != dev->ifindex) + 2346. continue; + +net/wireless/trace.h:2326: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +kernel/kprobes.c:2338: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2336. head = &kprobe_table[i]; + 2337. preempt_disable(); + 2338. > hlist_for_each_entry_rcu(p, head, hlist) { + 2339. sym = kallsyms_lookup((unsigned long)p->addr, NULL, + 2340. &offset, &modname, namebuf); + +kernel/kprobes.c:2342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2340. &offset, &modname, namebuf); + 2341. if (kprobe_aggrprobe(p)) { + 2342. > list_for_each_entry_rcu(kp, &p->list, list) + 2343. report_probe(pi, kp, sym, offset, modname, p); + 2344. } else + +drivers/usb/core/hub.c:2345: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2339 could be null and is dereferenced at line 2345, column 10. + 2343. * use that to determine whether it's removable. + 2344. */ + 2345. > switch (hub->ports[udev->portnum - 1]->connect_type) { + 2346. case USB_PORT_CONNECT_TYPE_HOT_PLUG: + 2347. udev->removable = USB_DEVICE_REMOVABLE; + +net/xfrm/xfrm_policy.c:2344: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2342. for (; idx < sp->len; idx++) { + 2343. if (xfrm_state_ok(tmpl, sp->xvec[idx], family)) + 2344. > return ++idx; + 2345. if (sp->xvec[idx]->props.mode != XFRM_MODE_TRANSPORT) { + 2346. if (start == -1) + +drivers/gpu/drm/i915/i915_drv.c:2346: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 2344. * valleyview_enable_rps) so use a 3ms timeout. + 2345. */ + 2346. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2347. 3); + 2348. } + +drivers/gpu/drm/i915/i915_drv.c:2346: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 2344. * valleyview_enable_rps) so use a 3ms timeout. + 2345. */ + 2346. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2347. 3); + 2348. } + +kernel/events/core.c:2342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2340. int cpu) + 2341. { + 2342. > struct task_struct *task = READ_ONCE(ctx->task); + 2343. + 2344. lockdep_assert_held(&ctx->mutex); + +net/wireless/trace.h:2338: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2336. ); + 2337. + 2338. > DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, + 2339. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2340. TP_ARGS(netdev, macaddr), + +kernel/sched/core.c:2343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2341. { + 2342. unsigned long flags; + 2343. > int cpu = get_cpu(); + 2344. + 2345. __sched_fork(clone_flags, p); + +kernel/sched/core.c:2343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2341. { + 2342. unsigned long flags; + 2343. > int cpu = get_cpu(); + 2344. + 2345. __sched_fork(clone_flags, p); + +net/sunrpc/clnt.c:2391: error: DEAD_STORE + The value written to &len (type int) is never used. + 2389. goto out_err; + 2390. } + 2391. > if (--len < 0) + 2392. goto out_overflow; + 2393. switch ((n = ntohl(*p++))) { + +net/sunrpc/clnt.c:2393: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 2391. if (--len < 0) + 2392. goto out_overflow; + 2393. > switch ((n = ntohl(*p++))) { + 2394. case RPC_AUTH_REJECTEDCRED: + 2395. case RPC_AUTH_REJECTEDVERF: + +net/ipv4/fib_trie.c:2355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2353. struct fib_table *tb; + 2354. + 2355. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2356. struct key_vector *n; + 2357. + +include/net/sock.h:2349: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2347. static inline int sk_state_load(const struct sock *sk) + 2348. { + 2349. > return smp_load_acquire(&sk->sk_state); + 2350. } + 2351. + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2358: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2356. ); + 2357. + 2358. > DECLARE_EVENT_CLASS(netdev_evt_only, + 2359. TP_PROTO(struct net_device *netdev), + 2360. TP_ARGS(netdev), + +arch/x86/events/core.c:2374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2372. + 2373. /* IRQs are off, so this synchronizes with smp_store_release */ + 2374. > ldt = READ_ONCE(current->active_mm->context.ldt); + 2375. if (!ldt || idx >= ldt->nr_entries) + 2376. return 0; + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2375: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/ipv4/fib_trie.c:2395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2393. /* walk rest of this hash chain */ + 2394. h = tb->tb_id & (FIB_TABLE_HASHSZ - 1); + 2395. > while ((tb_node = rcu_dereference(hlist_next_rcu(&tb->tb_hlist)))) { + 2396. tb = hlist_entry(tb_node, struct fib_table, tb_hlist); + 2397. n = fib_trie_get_first(iter, (struct trie *) tb->tb_data); + +net/ipv4/fib_trie.c:2405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2403. while (++h < FIB_TABLE_HASHSZ) { + 2404. struct hlist_head *head = &net->ipv4.fib_table_hash[h]; + 2405. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2406. n = fib_trie_get_first(iter, (struct trie *) tb->tb_data); + 2407. if (n) + +kernel/rcu/tree.c:2394: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2392. } + 2393. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2394. > trace_rcu_grace_period(rsp->name, READ_ONCE(rsp->gpnum), + 2395. TPS("newreq")); + 2396. + +net/sunrpc/xprtsock.c:2398: error: DEAD_STORE + The value written to &status (type int) is never used. + 2396. struct socket *sock = transport->sock; + 2397. struct rpc_xprt *xprt = &transport->xprt; + 2398. > int status = -EIO; + 2399. + 2400. if (!sock) { + +net/wireless/trace.h:2392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2390. ); + 2391. + 2392. > DECLARE_EVENT_CLASS(netdev_frame_event, + 2393. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2394. TP_ARGS(netdev, buf, len), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2407: error: DEAD_STORE + The value written to &ctrl (type unsigned int) is never used. + 2405. u16 phy_data; + 2406. + 2407. > ctrl = er32(CTRL); + 2408. status = er32(STATUS); + 2409. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2468: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 2466. hw->forced_speed_duplex == e1000_10_half)) { + 2467. ew32(IMC, 0xffffffff); + 2468. > ret_val = + 2469. e1000_polarity_reversal_workaround(hw); + 2470. icr = er32(ICR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2416: error: DEAD_STORE + The value written to &rxcw (type unsigned int) is never used. + 2414. if ((hw->media_type == e1000_media_type_fiber) || + 2415. (hw->media_type == e1000_media_type_internal_serdes)) { + 2416. > rxcw = er32(RXCW); + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2419: error: DEAD_STORE + The value written to &signal (type unsigned int) is never used. + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + 2419. > signal = + 2420. (hw->mac_type > + 2421. e1000_82544) ? E1000_CTRL_SWDPIN1 : 0; + +include/linux/netdevice.h:2413: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2411. + 2412. net = dev_net(dev); + 2413. > lh = rcu_dereference(list_next_rcu(&dev->dev_list)); + 2414. return lh == &net->dev_base_head ? NULL : net_device_entry(lh); + 2415. } + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +kernel/kprobes.c:2431: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2429. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 2430. head = &kprobe_table[i]; + 2431. > hlist_for_each_entry_rcu(p, head, hlist) + 2432. if (!kprobe_disabled(p)) + 2433. arm_kprobe(p); + +drivers/gpu/drm/i915/intel_ddi.c:2429: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2417 could be null and is dereferenced at line 2429, column 2. + 2427. * enabling the port. + 2428. */ + 2429. > I915_WRITE(DDI_BUF_CTL(port), + 2430. dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE); + 2431. + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2418: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +drivers/md/md.c:2449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2447. if (ret == 0) + 2448. md_cluster_ops->metadata_update_cancel(mddev); + 2449. > bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2450. BIT(MD_SB_CHANGE_DEVS) | + 2451. BIT(MD_SB_CHANGE_CLEAN)); + +drivers/md/md.c:2598: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2596. + 2597. if (mddev->in_sync != sync_req || + 2598. > !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2599. BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN))) + 2600. /* have to write it out again */ + +net/wireless/trace.h:2434: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2432. ); + 2433. + 2434. > DECLARE_EVENT_CLASS(netdev_mac_evt, + 2435. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2436. TP_ARGS(netdev, mac), + +kernel/trace/trace.c:2448: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2446. preempt_disable_notrace(); + 2447. + 2448. > export = rcu_dereference_raw_notrace(ftrace_exports_list); + 2449. while (export) { + 2450. trace_process_export(export, event); + +kernel/trace/trace.c:2451: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2449. while (export) { + 2450. trace_process_export(export, event); + 2451. > export = rcu_dereference_raw_notrace(export->next); + 2452. } + 2453. + +kernel/kprobes.c:2462: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2460. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 2461. head = &kprobe_table[i]; + 2462. > hlist_for_each_entry_rcu(p, head, hlist) { + 2463. if (!arch_trampoline_kprobe(p) && !kprobe_disabled(p)) + 2464. disarm_kprobe(p, false); + +drivers/net/ethernet/intel/e1000/e1000_main.c:2461: error: DEAD_STORE + The value written to &txb2b (type _Bool) is never used. + 2459. if (!netif_carrier_ok(netdev)) { + 2460. u32 ctrl; + 2461. > bool txb2b = true; + 2462. /* update snapshot of PHY registers on LSC */ + 2463. e1000_get_speed_and_duplex(hw, + +drivers/net/ethernet/intel/e1000/e1000_main.c:2535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2533. + 2534. if (!netif_carrier_ok(netdev)) { + 2535. > if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { + 2536. /* We've lost link, so the controller stops DMA, + 2537. * but we've got queued Tx work that's never going + +net/core/neighbour.c:2453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2451. + 2452. rcu_read_lock_bh(); + 2453. > nht = rcu_dereference_bh(tbl->nht); + 2454. + 2455. read_lock(&tbl->lock); /* avoid resizes */ + +net/core/neighbour.c:2459: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2457. struct neighbour *n; + 2458. + 2459. > for (n = rcu_dereference_bh(nht->hash_buckets[chain]); + 2460. n != NULL; + 2461. n = rcu_dereference_bh(n->next)) + +net/core/neighbour.c:2461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2459. for (n = rcu_dereference_bh(nht->hash_buckets[chain]); + 2460. n != NULL; + 2461. > n = rcu_dereference_bh(n->next)) + 2462. cb(n, cookie); + 2463. } + +net/ipv4/tcp.c:2472: error: UNINITIALIZED_VALUE + The value read from opt.max_window was never initialized. + 2470. tp->snd_wl1 = opt.snd_wl1; + 2471. tp->snd_wnd = opt.snd_wnd; + 2472. > tp->max_window = opt.max_window; + 2473. + 2474. tp->rcv_wnd = opt.rcv_wnd; + +net/ipv4/tcp.c:2474: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wnd was never initialized. + 2472. tp->max_window = opt.max_window; + 2473. + 2474. > tp->rcv_wnd = opt.rcv_wnd; + 2475. tp->rcv_wup = opt.rcv_wup; + 2476. + +net/ipv4/tcp.c:2467: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wup was never initialized. + 2465. return -EINVAL; + 2466. + 2467. > if (after(opt.rcv_wup, tp->rcv_nxt)) + 2468. return -EINVAL; + 2469. + +net/ipv4/tcp.c:2475: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wup was never initialized. + 2473. + 2474. tp->rcv_wnd = opt.rcv_wnd; + 2475. > tp->rcv_wup = opt.rcv_wup; + 2476. + 2477. return 0; + +net/ipv4/tcp.c:2464: error: UNINITIALIZED_VALUE + The value read from opt.snd_wl1 was never initialized. + 2462. return -EINVAL; + 2463. + 2464. > if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd)) + 2465. return -EINVAL; + 2466. + +net/ipv4/tcp.c:2470: error: UNINITIALIZED_VALUE + The value read from opt.snd_wl1 was never initialized. + 2468. return -EINVAL; + 2469. + 2470. > tp->snd_wl1 = opt.snd_wl1; + 2471. tp->snd_wnd = opt.snd_wnd; + 2472. tp->max_window = opt.max_window; + +net/ipv4/tcp.c:2471: error: UNINITIALIZED_VALUE + The value read from opt.snd_wnd was never initialized. + 2469. + 2470. tp->snd_wl1 = opt.snd_wl1; + 2471. > tp->snd_wnd = opt.snd_wnd; + 2472. tp->max_window = opt.max_window; + 2473. + +net/wireless/reg.c:2457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2455. rcu_read_lock(); + 2456. + 2457. > cfg80211_regd = rcu_dereference(cfg80211_regdomain); + 2458. wiphy1_regd = rcu_dereference(wiphy1->regd); + 2459. if (!wiphy1_regd) + +net/wireless/reg.c:2458: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2456. + 2457. cfg80211_regd = rcu_dereference(cfg80211_regdomain); + 2458. > wiphy1_regd = rcu_dereference(wiphy1->regd); + 2459. if (!wiphy1_regd) + 2460. wiphy1_regd = cfg80211_regd; + +net/wireless/reg.c:2462: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2460. wiphy1_regd = cfg80211_regd; + 2461. + 2462. > wiphy2_regd = rcu_dereference(wiphy2->regd); + 2463. if (!wiphy2_regd) + 2464. wiphy2_regd = cfg80211_regd; + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2459: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +drivers/net/ethernet/intel/e100.c:2464: error: DEAD_STORE + The value written to &nic (type nic*) is never used. + 2462. static int e100_get_regs_len(struct net_device *netdev) + 2463. { + 2464. > struct nic *nic = netdev_priv(netdev); + 2465. return 1 + E100_PHY_REGS + sizeof(nic->mem->dump_buf); + 2466. } + +net/ipv4/fib_trie.c:2473: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2471. struct key_vector *n = v; + 2472. + 2473. > if (IS_TRIE(node_parent_rcu(n))) + 2474. fib_table_print(seq, iter->tb); + 2475. + +net/ipv4/fib_trie.c:2491: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2489. seq_printf(seq, " |-- %pI4\n", &val); + 2490. + 2491. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) { + 2492. char buf1[32], buf2[32]; + 2493. + +include/linux/netdevice.h:2476: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2474. static inline int dev_recursion_level(void) + 2475. { + 2476. > return this_cpu_read(xmit_recursion); + 2477. } + 2478. + +include/linux/netdevice.h:2476: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2474. static inline int dev_recursion_level(void) + 2475. { + 2476. > return this_cpu_read(xmit_recursion); + 2477. } + 2478. + +net/core/dev.c:2479: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2477. rcu_read_lock(); + 2478. if (!(txq->state & QUEUE_STATE_ANY_XOFF)) { + 2479. > struct Qdisc *q = rcu_dereference(txq->qdisc); + 2480. + 2481. __netif_schedule(q); + +net/ipv4/tcp.c:2495: error: UNINITIALIZED_VALUE + The value read from opt.opt_val was never initialized. + 2493. switch (opt.opt_code) { + 2494. case TCPOPT_MSS: + 2495. > tp->rx_opt.mss_clamp = opt.opt_val; + 2496. tcp_mtup_init(sk); + 2497. break; + +net/wireless/trace.h:2483: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/core/dev.c:2493: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2491. + 2492. rcu_read_lock(); + 2493. > q = rcu_dereference(dev_queue->qdisc); + 2494. __netif_schedule(q); + 2495. rcu_read_unlock(); + +net/netlink/af_netlink.c:2526: error: UNINITIALIZED_VALUE + The value read from nlk was never initialized. + 2524. } while (sock_net(&nlk->sk) != seq_file_net(seq)); + 2525. + 2526. > return nlk; + 2527. } + 2528. + +net/core/dev.c:2515: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2513. get_kfree_skb_cb(skb)->reason = reason; + 2514. local_irq_save(flags); + 2515. > skb->next = __this_cpu_read(softnet_data.completion_queue); + 2516. __this_cpu_write(softnet_data.completion_queue, skb); + 2517. raise_softirq_irqoff(NET_TX_SOFTIRQ); + +net/core/dev.c:2515: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2513. get_kfree_skb_cb(skb)->reason = reason; + 2514. local_irq_save(flags); + 2515. > skb->next = __this_cpu_read(softnet_data.completion_queue); + 2516. __this_cpu_write(softnet_data.completion_queue, skb); + 2517. raise_softirq_irqoff(NET_TX_SOFTIRQ); + +net/wireless/trace.h:2505: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +drivers/base/regmap/regmap.c:2559: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2557. map->unlock(map->lock_arg); + 2558. + 2559. > return ret; + 2560. } + 2561. EXPORT_SYMBOL_GPL(regmap_raw_read); + +kernel/events/core.c:2536: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2534. * so we need to check again lest we try to stop another CPU's event. + 2535. */ + 2536. > if (READ_ONCE(event->oncpu) != smp_processor_id()) + 2537. return -EAGAIN; + 2538. + +net/wireless/trace.h:2523: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/netfilter/nf_conntrack_netlink.c:2582: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2580. struct nf_conntrack_helper *helper; + 2581. + 2582. > helper = rcu_dereference(help->helper); + 2583. if (helper && + 2584. nla_put_string(skb, CTA_EXPECT_HELP_NAME, helper->name)) + +drivers/iommu/intel-iommu.c:2543: error: DEAD_STORE + The value written to &req_id (type unsigned short) is never used. + 2541. return NULL; + 2542. + 2543. > req_id = ((u16)bus << 8) | devfn; + 2544. + 2545. if (dev_is_pci(dev)) { + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/core/neighbour.c:2550: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2548. struct neigh_hash_table *nht = state->nht; + 2549. struct neighbour *n = NULL; + 2550. > int bucket = state->bucket; + 2551. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + +net/core/neighbour.c:2554: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + 2553. for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) { + 2554. > n = rcu_dereference_bh(nht->hash_buckets[bucket]); + 2555. + 2556. while (n) { + +net/core/neighbour.c:2572: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2570. break; + 2571. next: + 2572. > n = rcu_dereference_bh(n->next); + 2573. } + 2574. + +net/wireless/trace.h:2546: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm), + 2548. TP_ARGS(wdev, freq, sig_mbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm), + 2548. TP_ARGS(wdev, freq, sig_mbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm), + 2548. TP_ARGS(wdev, freq, sig_mbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm), + 2548. TP_ARGS(wdev, freq, sig_mbm), + +kernel/workqueue.c:2560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2558. } + 2559. + 2560. > for_each_pwq(pwq, wq) { + 2561. struct worker_pool *pool = pwq->pool; + 2562. + +drivers/gpu/drm/i915/intel_ddi.c:2597: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 2595 could be null and is dereferenced at line 2597, column 7. + 2595. intel_dig_port = enc_to_dig_port(&encoder->base); + 2596. + 2597. > if (intel_dig_port->infoframe_enabled(&encoder->base, pipe_config)) + 2598. pipe_config->has_infoframe = true; + 2599. + +drivers/net/ethernet/broadcom/tg3.c:2607: error: UNINITIALIZED_VALUE + The value read from phy9_orig was never initialized. + 2605. tg3_phy_toggle_auxctl_smdsp(tp, false); + 2606. + 2607. > tg3_writephy(tp, MII_CTRL1000, phy9_orig); + 2608. + 2609. err = tg3_readphy(tp, MII_TG3_EXT_CTRL, ®32); + +kernel/events/core.c:2576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2574. * fall through with ret==-ENXIO. + 2575. */ + 2576. > ret = cpu_function_call(READ_ONCE(event->oncpu), + 2577. __perf_event_stop, &sd); + 2578. } while (ret == -EAGAIN); + +drivers/iommu/amd_iommu.c:2568: error: DEAD_STORE + The value written to &npages (type int) is never used. + 2566. struct dma_ops_domain *dma_dom; + 2567. unsigned long startaddr; + 2568. > int npages = 2; + 2569. + 2570. domain = get_domain(dev); + +kernel/rcu/tree.c:2583: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2581. */ + 2582. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */ + 2583. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 2584. raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + 2585. return; + +kernel/rcu/tree.c:2583: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2581. */ + 2582. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */ + 2583. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 2584. raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + 2585. return; + +net/wireless/trace.h:2563: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +block/blk-core.c:2572: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2570. int cpu; + 2571. + 2572. > cpu = part_stat_lock(); + 2573. part = req->part; + 2574. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +block/blk-core.c:2572: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2570. int cpu; + 2571. + 2572. > cpu = part_stat_lock(); + 2573. part = req->part; + 2574. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +kernel/trace/trace.c:2603: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2601. preempt_disable_notrace(); + 2602. + 2603. > use_stack = __this_cpu_inc_return(ftrace_stack_reserve); + 2604. /* + 2605. * We don't need any atomic variables, just a barrier. + +net/ipv4/ipmr.c:2592: error: DEAD_STORE + The value written to &rtm (type rtmsg*) is never used. + 2590. goto errout; + 2591. + 2592. > rtm = nlmsg_data(nlh); + 2593. + 2594. src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0; + +block/blk-core.c:2592: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2590. int cpu; + 2591. + 2592. > cpu = part_stat_lock(); + 2593. part = req->part; + 2594. + +block/blk-core.c:2592: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2590. int cpu; + 2591. + 2592. > cpu = part_stat_lock(); + 2593. part = req->part; + 2594. + +net/wireless/trace.h:2580: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/ipv4/igmp.c:2596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2594. + 2595. rcu_read_lock(); + 2596. > for_each_pmc_rcu(inet, pmc) { + 2597. if (pmc->multi.imr_multiaddr.s_addr == loc_addr && + 2598. (pmc->multi.imr_ifindex == dif || + +net/ipv4/igmp.c:2605: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2603. if (!pmc) + 2604. goto unlock; + 2605. > psl = rcu_dereference(pmc->sflist); + 2606. ret = (pmc->sfmode == MCAST_EXCLUDE); + 2607. if (!psl) + +net/core/neighbour.c:2596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2594. return n; + 2595. } + 2596. > n = rcu_dereference_bh(n->next); + 2597. + 2598. while (1) { + +net/core/neighbour.c:2614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2612. break; + 2613. next: + 2614. > n = rcu_dereference_bh(n->next); + 2615. } + 2616. + +net/core/neighbour.c:2623: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2621. break; + 2622. + 2623. > n = rcu_dereference_bh(nht->hash_buckets[state->bucket]); + 2624. } + 2625. + +drivers/iommu/amd_iommu.c:2588: error: DEAD_STORE + The value written to &dma_mask (type unsigned long long) is never used. + 2586. unsigned long attrs) + 2587. { + 2588. > u64 dma_mask = dev->coherent_dma_mask; + 2589. struct protection_domain *domain; + 2590. struct dma_ops_domain *dma_dom; + +drivers/gpu/drm/i915/intel_runtime_pm.c:2614: error: NULL_DEREFERENCE + pointer `well` last assigned on line 2613 could be null and is dereferenced by call to `intel_power_well_enable()` at line 2614, column 2. + 2612. + 2613. well = lookup_power_well(dev_priv, SKL_DISP_PW_1); + 2614. > intel_power_well_enable(dev_priv, well); + 2615. + 2616. well = lookup_power_well(dev_priv, SKL_DISP_PW_MISC_IO); + +net/core/sock.c:2602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2600. + 2601. rcu_read_lock(); + 2602. > wq = rcu_dereference(sk->sk_wq); + 2603. if (skwq_has_sleeper(wq)) + 2604. wake_up_interruptible_all(&wq->wait); + +net/wireless/trace.h:2599: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +drivers/cdrom/cdrom.c:2618: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 2616. return -EFAULT; + 2617. + 2618. > requested = q.cdsc_format; + 2619. if (requested != CDROM_MSF && requested != CDROM_LBA) + 2620. return -EINVAL; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +net/core/sock.c:2613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2611. + 2612. rcu_read_lock(); + 2613. > wq = rcu_dereference(sk->sk_wq); + 2614. if (skwq_has_sleeper(wq)) + 2615. wake_up_interruptible_poll(&wq->wait, POLLERR); + +drivers/net/ethernet/intel/e100.c:2631: error: DEAD_STORE + The value written to &err (type int) is never used. + 2629. + 2630. /* save speed, duplex & autoneg settings */ + 2631. > err = mii_ethtool_gset(&nic->mii, &cmd); + 2632. + 2633. if (netif_running(netdev)) + +drivers/net/ethernet/intel/e100.c:2640: error: DEAD_STORE + The value written to &err (type int) is never used. + 2638. + 2639. /* restore speed, duplex & autoneg settings */ + 2640. > err = mii_ethtool_sset(&nic->mii, &cmd); + 2641. + 2642. if (netif_running(netdev)) + +net/core/sock.c:2625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2623. + 2624. rcu_read_lock(); + 2625. > wq = rcu_dereference(sk->sk_wq); + 2626. if (skwq_has_sleeper(wq)) + 2627. wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI | + +net/wireless/trace.h:2620: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +block/blk-core.c:2638: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2636. return; + 2637. + 2638. > cpu = part_stat_lock(); + 2639. + 2640. if (!new_io) { + +block/blk-core.c:2638: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2636. return; + 2637. + 2638. > cpu = part_stat_lock(); + 2639. + 2640. if (!new_io) { + +net/core/sock.c:2643: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2641. */ + 2642. if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) { + 2643. > wq = rcu_dereference(sk->sk_wq); + 2644. if (skwq_has_sleeper(wq)) + 2645. wake_up_interruptible_sync_poll(&wq->wait, POLLOUT | + +net/sunrpc/clnt.c:2673: error: NULL_DEREFERENCE + pointer `xprt` last assigned on line 2643 could be null and is dereferenced at line 2673, column 2. + 2671. xprt_put(xprt); + 2672. xprt_switch_put(xps); + 2673. > pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n", + 2674. status, xprt->address_strings[RPC_DISPLAY_ADDR]); + 2675. return status; + +net/ipv4/ipmr.c:2650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2648. if (t < s_t) + 2649. goto next_table; + 2650. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) { + 2651. if (e < s_e) + 2652. goto next_entry; + +net/wireless/trace.h:2635: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +drivers/gpu/drm/i915/intel_sdvo.c:2693: error: UNINITIALIZED_VALUE + The value read from bytes[_] was never initialized. + 2691. intel_sdvo->controlled_output = 0; + 2692. memcpy(bytes, &intel_sdvo->caps.output_flags, 2); + 2693. > DRM_DEBUG_KMS("%s: Unknown SDVO output type (0x%02x%02x)\n", + 2694. SDVO_NAME(intel_sdvo), + 2695. bytes[0], bytes[1]); + +kernel/trace/ring_buffer.c:2661: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2659. + 2660. /* Don't let the compiler play games with cpu_buffer->tail_page */ + 2661. > tail_page = info->tail_page = READ_ONCE(cpu_buffer->tail_page); + 2662. write = local_add_return(info->length, &tail_page->write); + 2663. + +net/core/neighbour.c:2652: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2650. struct neigh_table *tbl = state->tbl; + 2651. struct pneigh_entry *pn = NULL; + 2652. > int bucket = state->bucket; + 2653. + 2654. state->flags |= NEIGH_SEQ_IS_PNEIGH; + +drivers/tty/tty_io.c:2652: error: DEAD_STORE + The value written to &retval (type int) is never used. + 2650. struct tty_struct *tty = file_tty(file); + 2651. struct tty_ldisc *ld; + 2652. > int retval = -ENOIOCTLCMD; + 2653. + 2654. if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl")) + +net/ipv4/fib_trie.c:2664: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2662. prefix = htonl(l->key); + 2663. + 2664. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 2665. const struct fib_info *fi = fa->fa_info; + 2666. __be32 mask = inet_make_mask(KEYLENGTH - fa->fa_slen); + +net/ipv6/mcast.c:2656: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2654. + 2655. state->idev = NULL; + 2656. > for_each_netdev_rcu(net, state->dev) { + 2657. struct inet6_dev *idev; + 2658. idev = __in6_dev_get(state->dev); + +net/wireless/trace.h:2651: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/ipv4/igmp.c:2663: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2661. int rv = 0; + 2662. + 2663. > mc_hash = rcu_dereference(in_dev->mc_hash); + 2664. if (mc_hash) { + 2665. u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); + +net/ipv4/igmp.c:2667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2665. u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); + 2666. + 2667. > for (im = rcu_dereference(mc_hash[hash]); + 2668. im != NULL; + 2669. im = rcu_dereference(im->next_hash)) { + +net/ipv4/igmp.c:2669: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2667. for (im = rcu_dereference(mc_hash[hash]); + 2668. im != NULL; + 2669. > im = rcu_dereference(im->next_hash)) { + 2670. if (im->multiaddr == mc_addr) + 2671. break; + +net/ipv4/igmp.c:2674: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2672. } + 2673. } else { + 2674. > for_each_pmc_rcu(in_dev, im) { + 2675. if (im->multiaddr == mc_addr) + 2676. break; + +drivers/usb/core/hub.c:2706: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 2704. return -EBUSY; + 2705. + 2706. > if (hub_port_warm_reset_required(hub, port1, portstatus)) + 2707. return -ENOTCONN; + 2708. + +drivers/cdrom/cdrom.c:2670: error: UNINITIALIZED_VALUE + The value read from entry.cdte_format was never initialized. + 2668. return -EFAULT; + 2669. + 2670. > requested_format = entry.cdte_format; + 2671. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2672. return -EINVAL; + +drivers/gpu/drm/i915/intel_runtime_pm.c:2682: error: NULL_DEREFERENCE + pointer `well` last assigned on line 2681 could be null and is dereferenced by call to `intel_power_well_enable()` at line 2682, column 2. + 2680. + 2681. well = lookup_power_well(dev_priv, SKL_DISP_PW_1); + 2682. > intel_power_well_enable(dev_priv, well); + 2683. + 2684. mutex_unlock(&power_domains->lock); + +block/blk-core.c:2668: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 2668, column 31. + 2666. { + 2667. struct request *rq; + 2668. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 2669. + 2670. WARN_ON_ONCE(q->mq_ops); + +net/wireless/trace.h:2667: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +kernel/cgroup/cgroup.c:2685: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2684 could be null and is dereferenced at line 2685, column 7. + 2683. percpu_up_write(&cgroup_threadgroup_rwsem); + 2684. for_each_subsys(ss, ssid) + 2685. > if (ss->post_attach) + 2686. ss->post_attach(); + 2687. } + +drivers/md/md.c:2683: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2681. char *sep = ","; + 2682. size_t len = 0; + 2683. > unsigned long flags = READ_ONCE(rdev->flags); + 2684. + 2685. if (test_bit(Faulty, &flags) || + +drivers/ata/libata-eh.c:2838: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2836. rc = ata_do_reset(link, reset, classes, deadline, true); + 2837. if (rc && rc != -EAGAIN) { + 2838. > failed_link = link; + 2839. goto fail; + 2840. } + +drivers/ata/libata-eh.c:2858: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2856. break; + 2857. default: + 2858. > failed_link = slave; + 2859. rc = tmp; + 2860. goto fail; + +drivers/ata/libata-eh.c:2872: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2870. ata_link_err(link, + 2871. "follow-up softreset required but no softreset available\n"); + 2872. > failed_link = link; + 2873. rc = -EINVAL; + 2874. goto fail; + +drivers/ata/libata-eh.c:2880: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2878. rc = ata_do_reset(link, reset, classes, deadline, true); + 2879. if (rc) { + 2880. > failed_link = link; + 2881. goto fail; + 2882. } + +drivers/ata/libata-eh.c:2987: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2985. "link online but %d devices misclassified, retrying\n", + 2986. nr_unknown); + 2987. > failed_link = link; + 2988. rc = -EAGAIN; + 2989. goto fail; + +net/wireless/trace.h:2682: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +kernel/printk/printk.c:2690: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2688. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2689. { + 2690. > int pending = __this_cpu_xchg(printk_pending, 0); + 2691. + 2692. if (pending & PRINTK_PENDING_OUTPUT) { + +kernel/printk/printk.c:2690: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 2688. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2689. { + 2690. > int pending = __this_cpu_xchg(printk_pending, 0); + 2691. + 2692. if (pending & PRINTK_PENDING_OUTPUT) { + +net/netfilter/nf_conntrack_netlink.c:2702: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2700. for (; cb->args[0] < nf_ct_expect_hsize; cb->args[0]++) { + 2701. restart: + 2702. > hlist_for_each_entry_rcu(exp, &nf_ct_expect_hash[cb->args[0]], + 2703. hnode) { + 2704. if (l3proto && exp->tuple.src.l3num != l3proto) + +net/sunrpc/clnt.c:2708: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2706. + 2707. rcu_read_lock(); + 2708. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 2709. xprt = xprt_iter_xprt(&clnt->cl_xpi); + 2710. if (xps == NULL || xprt == NULL) { + +net/wireless/trace.h:2697: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2695. ); + 2696. + 2697. > DECLARE_EVENT_CLASS(cfg80211_rx_evt, + 2698. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2699. TP_ARGS(netdev, addr), + +drivers/tty/tty_io.c:2721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2719. read_lock(&tasklist_lock); + 2720. /* Kill the entire session */ + 2721. > do_each_pid_task(session, PIDTYPE_SID, p) { + 2722. tty_notice(tty, "SAK: killed process %d (%s): by session\n", + 2723. task_pid_nr(p), p->comm); + +drivers/tty/tty_io.c:2728: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2726. + 2727. /* Now kill any processes that happen to have the tty open */ + 2728. > do_each_thread(g, p) { + 2729. if (p->signal->tty == tty) { + 2730. tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n", + +net/socket.c:2727: error: UNINITIALIZED_VALUE + The value read from ifc32.ifcbuf was never initialized. + 2725. ifc.ifc_len = len; + 2726. ifr = ifc.ifc_req = (void __user *)(uifc + 1); + 2727. > ifr32 = compat_ptr(ifc32.ifcbuf); + 2728. for (i = 0; i < ifc32.ifc_len; i += sizeof(struct compat_ifreq)) { + 2729. if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq))) + +net/socket.c:2746: error: UNINITIALIZED_VALUE + The value read from ifc32.ifcbuf was never initialized. + 2744. + 2745. ifr = ifc.ifc_req; + 2746. > ifr32 = compat_ptr(ifc32.ifcbuf); + 2747. for (i = 0, j = 0; + 2748. i + sizeof(struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len; + +net/ipv4/tcp_output.c:2713: error: NULL_DEREFERENCE + pointer `next_skb` last assigned on line 2709 could be null and is dereferenced at line 2713, column 18. + 2711. + 2712. skb_size = skb->len; + 2713. > next_skb_size = next_skb->len; + 2714. + 2715. BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1); + +net/ipv4/igmp.c:2715: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2713. + 2714. state->in_dev = NULL; + 2715. > for_each_netdev_rcu(net, state->dev) { + 2716. struct in_device *in_dev; + 2717. + +net/ipv4/igmp.c:2721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2719. if (!in_dev) + 2720. continue; + 2721. > im = rcu_dereference(in_dev->mc_list); + 2722. if (im) { + 2723. state->in_dev = in_dev; + +sound/pci/hda/hda_codec.c:2712: error: DEAD_STORE + The value written to &end_time (type unsigned long) is never used. + 2710. unsigned int power_state) + 2711. { + 2712. > unsigned long end_time = jiffies + msecs_to_jiffies(500); + 2713. unsigned int state, actual_state; + 2714. + +sound/pci/hda/hda_codec.c:2728: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2726. msleep(1); + 2727. } + 2728. > return state; + 2729. } + 2730. + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +drivers/net/ethernet/intel/e100.c:2732: error: DEAD_STORE + The value written to &i (type int) is never used. + 2730. data[i++] = nic->rx_tco_frames; + 2731. data[i++] = nic->rx_short_frame_errors; + 2732. > data[i++] = nic->rx_over_length_errors; + 2733. } + 2734. + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2721: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +kernel/rcu/tree.c:2747: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2745. */ + 2746. local_irq_save(flags); + 2747. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2748. bl = rdp->blimit; + 2749. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +kernel/rcu/tree.c:2747: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2745. */ + 2746. local_irq_save(flags); + 2747. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2748. bl = rdp->blimit; + 2749. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +net/core/neighbour.c:2733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2731. + 2732. rcu_read_lock_bh(); + 2733. > state->nht = rcu_dereference_bh(tbl->nht); + 2734. + 2735. return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN; + +net/ipv6/addrconf.c:2730: error: DEAD_STORE + The value written to &err (type int) is never used. + 2728. struct in6_ifreq ireq; + 2729. struct net_device *dev; + 2730. > int err = -EINVAL; + 2731. + 2732. rtnl_lock(); + +net/ipv6/addrconf.c:2738: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2736. goto err_exit; + 2737. + 2738. > dev = __dev_get_by_index(net, ireq.ifr6_ifindex); + 2739. + 2740. err = -ENODEV; + +net/core/dev.c:2741: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2739. + 2740. rcu_read_lock(); + 2741. > list_for_each_entry_rcu(ptype, &offload_base, list) { + 2742. if (ptype->type == type && ptype->callbacks.gso_segment) { + 2743. segs = ptype->callbacks.gso_segment(skb, features); + +net/ipv4/igmp.c:2734: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2732. struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); + 2733. + 2734. > im = rcu_dereference(im->next_rcu); + 2735. while (!im) { + 2736. state->dev = next_net_device_rcu(state->dev); + +net/ipv4/igmp.c:2744: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2742. if (!state->in_dev) + 2743. continue; + 2744. > im = rcu_dereference(state->in_dev->mc_list); + 2745. } + 2746. return im; + +kernel/trace/trace.c:2754: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2752. */ + 2753. preempt_disable(); + 2754. > if (__this_cpu_read(user_stack_count)) + 2755. goto out; + 2756. + +drivers/scsi/scsi_lib.c:2772: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2770. } + 2771. + 2772. > envp[idx++] = NULL; + 2773. + 2774. kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); + +drivers/md/dm.c:2767: error: UNINITIALIZED_VALUE + The value read from front_pad was never initialized. + 2765. } + 2766. + 2767. > pools->bs = bioset_create(pool_size, front_pad, BIOSET_NEED_RESCUER); + 2768. if (!pools->bs) + 2769. goto out; + +net/netfilter/nf_conntrack_netlink.c:2754: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2752. last = (struct nf_conntrack_expect *)cb->args[1]; + 2753. restart: + 2754. > hlist_for_each_entry_rcu(exp, &help->expectations, lnode) { + 2755. if (l3proto && exp->tuple.src.l3num != l3proto) + 2756. continue; + +net/wireless/trace.h:2739: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +drivers/usb/core/hub.c:2867: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 2865. up_read(&ehci_cf_port_reset_rwsem); + 2866. + 2867. > return status; + 2868. } + 2869. + +kernel/sched/fair.c:2753: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2751. cfs_rq->runnable_weight -= se->runnable_weight; + 2752. + 2753. > sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + +kernel/sched/fair.c:2754: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2752. + 2753. sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. > sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + 2756. } + +kernel/workqueue.c:2774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2772. mutex_lock(&wq->mutex); + 2773. + 2774. > for_each_pwq(pwq, wq) { + 2775. bool drained; + 2776. + +net/wireless/trace.h:2760: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +sound/pci/hda/hda_codec.c:2798: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2796. } + 2797. + 2798. > return state; + 2799. } + 2800. + +kernel/sched/fair.c:2768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2766. dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) + 2767. { + 2768. > sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + +kernel/sched/fair.c:2769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2767. { + 2768. sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. > sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + 2771. #else + +sound/core/pcm_native.c:2782: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2780. return -EFAULT; + 2781. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2782. > result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + +sound/core/pcm_native.c:2784: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2782. result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. > result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + 2785. __put_user(result, &_xferi->result); + 2786. return result < 0 ? result : 0; + +net/ipv6/mcast.c:2786: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2784. state->idev = NULL; + 2785. state->im = NULL; + 2786. > for_each_netdev_rcu(net, state->dev) { + 2787. struct inet6_dev *idev; + 2788. idev = __in6_dev_get(state->dev); + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/sunrpc/clnt.c:2782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2780. { + 2781. rcu_read_lock(); + 2782. > xprt_switch_put(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 2783. rcu_read_unlock(); + 2784. } + +drivers/gpu/drm/i915/intel_sdvo.c:2807: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2805. sdvo_state->tv.overscan_h = response; + 2806. + 2807. > intel_sdvo_connector->max_hscan = data_value[0]; + 2808. intel_sdvo_connector->left = + 2809. drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]); + +drivers/gpu/drm/i915/intel_sdvo.c:2809: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2807. intel_sdvo_connector->max_hscan = data_value[0]; + 2808. intel_sdvo_connector->left = + 2809. > drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]); + 2810. if (!intel_sdvo_connector->left) + 2811. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2817: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2815. + 2816. intel_sdvo_connector->right = + 2817. > drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]); + 2818. if (!intel_sdvo_connector->right) + 2819. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2823: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2821. drm_object_attach_property(&connector->base, + 2822. intel_sdvo_connector->right, 0); + 2823. > DRM_DEBUG_KMS("h_overscan: max %d, " + 2824. "default %d, current %d\n", + 2825. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2841: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2839. sdvo_state->tv.overscan_v = response; + 2840. + 2841. > intel_sdvo_connector->max_vscan = data_value[0]; + 2842. intel_sdvo_connector->top = + 2843. drm_property_create_range(dev, 0, + +drivers/gpu/drm/i915/intel_sdvo.c:2843: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2841. intel_sdvo_connector->max_vscan = data_value[0]; + 2842. intel_sdvo_connector->top = + 2843. > drm_property_create_range(dev, 0, + 2844. "top_margin", 0, data_value[0]); + 2845. if (!intel_sdvo_connector->top) + +drivers/gpu/drm/i915/intel_sdvo.c:2852: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2850. + 2851. intel_sdvo_connector->bottom = + 2852. > drm_property_create_range(dev, 0, + 2853. "bottom_margin", 0, data_value[0]); + 2854. if (!intel_sdvo_connector->bottom) + +drivers/gpu/drm/i915/intel_sdvo.c:2859: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2857. drm_object_attach_property(&connector->base, + 2858. intel_sdvo_connector->bottom, 0); + 2859. > DRM_DEBUG_KMS("v_overscan: max %d, " + 2860. "default %d, current %d\n", + 2861. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2864: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2862. } + 2863. + 2864. > ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2865. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2866. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + +drivers/gpu/drm/i915/intel_sdvo.c:2865: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2863. + 2864. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2865. > ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2866. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2867. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + +drivers/gpu/drm/i915/intel_sdvo.c:2866: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2864. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2865. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2866. > ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2867. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2868. ENHANCEMENT(&conn_state->tv, hue, HUE); + +drivers/gpu/drm/i915/intel_sdvo.c:2867: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2865. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2866. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2867. > ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2868. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2869. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2868: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2866. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2867. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2868. > ENHANCEMENT(&conn_state->tv, hue, HUE); + 2869. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2870. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2869: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2867. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2868. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2869. > ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2870. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2871. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2870: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2868. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2869. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2870. > ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2871. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2872. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + +drivers/gpu/drm/i915/intel_sdvo.c:2871: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2869. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2870. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2871. > ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2872. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + +drivers/gpu/drm/i915/intel_sdvo.c:2872: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2870. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2871. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2872. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2874. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2873: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2871. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2872. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2873. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2874. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2875. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2874: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2872. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2874. > _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2875. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2876. + +drivers/gpu/drm/i915/intel_sdvo.c:2875: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2874. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2875. > _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2876. + 2877. if (enhancements.dot_crawl) { + +net/wireless/trace.h:2782: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +drivers/gpu/drm/i915/i915_gem_gtt.c:2815: error: UNINITIALIZED_VALUE + The value read from hole_end was never initialized. + 2813. /* Clear any non-preallocated blocks */ + 2814. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2815. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2816. hole_start, hole_end); + 2817. ggtt->base.clear_range(&ggtt->base, hole_start, + +drivers/gpu/drm/i915/i915_gem_gtt.c:2815: error: UNINITIALIZED_VALUE + The value read from hole_start was never initialized. + 2813. /* Clear any non-preallocated blocks */ + 2814. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2815. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2816. hole_start, hole_end); + 2817. ggtt->base.clear_range(&ggtt->base, hole_start, + +net/ipv4/igmp.c:2805: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2803. #endif + 2804. + 2805. > if (rcu_access_pointer(state->in_dev->mc_list) == im) { + 2806. seq_printf(seq, "%d\t%-10s: %5d %7s\n", + 2807. state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier); + +net/sunrpc/clnt.c:2790: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2788. { + 2789. rcu_read_lock(); + 2790. > rpc_xprt_switch_add_xprt(rcu_dereference(clnt->cl_xpi.xpi_xpswitch), + 2791. xprt); + 2792. rcu_read_unlock(); + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +sound/core/pcm_native.c:2810: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2808. return PTR_ERR(bufs); + 2809. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2810. > result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + +sound/core/pcm_native.c:2812: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2810. result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. > result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + 2813. kfree(bufs); + 2814. __put_user(result, &_xfern->result); + +net/sunrpc/clnt.c:2803: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2801. + 2802. rcu_read_lock(); + 2803. > xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch); + 2804. ret = rpc_xprt_switch_has_addr(xps, sap); + 2805. rcu_read_unlock(); + +net/wireless/trace.h:2803: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +kernel/events/core.c:2837: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2835. goto unlock; + 2836. + 2837. > parent = rcu_dereference(ctx->parent_ctx); + 2838. next_parent = rcu_dereference(next_ctx->parent_ctx); + 2839. + +kernel/events/core.c:2838: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2836. + 2837. parent = rcu_dereference(ctx->parent_ctx); + 2838. > next_parent = rcu_dereference(next_ctx->parent_ctx); + 2839. + 2840. /* If neither context have a parent context; they cannot be clones. */ + +drivers/iommu/intel-iommu.c:2833: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2831. * is passed in. + 2832. */ + 2833. > for_each_active_dev_scope(rmrr->devices, + 2834. rmrr->devices_cnt, i, tmp) + 2835. if (tmp == dev) { + +net/wireless/trace.h:2821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +drivers/cdrom/cdrom.c:2838: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2836. track_information ti; + 2837. __u32 last_track; + 2838. > int ret = -1, ti_size; + 2839. + 2840. if (!CDROM_CAN(CDC_GENERIC_PACKET)) + +lib/vsprintf.c:2855: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2853. */ + 2854. if (isspace(*fmt)) { + 2855. > fmt = skip_spaces(++fmt); + 2856. str = skip_spaces(str); + 2857. } + +lib/vsprintf.c:3060: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3058. while (next - str > field_width) { + 3059. if (is_sign) + 3060. > val.s = div_s64(val.s, base); + 3061. else + 3062. val.u = div_u64(val.u, base); + +lib/vsprintf.c:3062: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3060. val.s = div_s64(val.s, base); + 3061. else + 3062. > val.u = div_u64(val.u, base); + 3063. --next; + 3064. } + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +drivers/input/mouse/alps.c:2895: error: DEAD_STORE + The value written to &protocol (type alps_protocol_info const *) is never used. + 2893. protocol = &alps_v8_protocol_data; + 2894. } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0xc8) { + 2895. > protocol = &alps_v9_protocol_data; + 2896. psmouse_warn(psmouse, + 2897. "Unsupported ALPS V9 touchpad: E7=%3ph, EC=%3ph\n", + +kernel/printk/printk.c:2857: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2855. + 2856. rcu_read_lock(); + 2857. > list_for_each_entry_rcu(dumper, &dump_list, list) { + 2858. if (dumper->max_reason && reason > dumper->max_reason) + 2859. continue; + +net/ipv4/igmp.c:2860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2858. state->idev = NULL; + 2859. state->im = NULL; + 2860. > for_each_netdev_rcu(net, state->dev) { + 2861. struct in_device *idev; + 2862. idev = __in_dev_get_rcu(state->dev); + +net/ipv4/igmp.c:2865: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2863. if (unlikely(!idev)) + 2864. continue; + 2865. > im = rcu_dereference(idev->mc_list); + 2866. if (likely(im)) { + 2867. spin_lock_bh(&im->lock); + +drivers/ata/libata-core.c:2922: error: UNINITIALIZED_VALUE + The value read from classes[_] was never initialized. + 2920. ata_for_each_dev(dev, &ap->link, ALL_REVERSE) { + 2921. if (tries[dev->devno]) + 2922. > dev->class = classes[dev->devno]; + 2923. + 2924. if (!ata_dev_enabled(dev)) + +net/ipv6/route.c:2900: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2898. + 2899. if (fn) { + 2900. > for_each_fib6_node_rt_rcu(fn) { + 2901. if (cfg->fc_flags & RTF_CACHE) { + 2902. rt_cache = rt6_find_cached_rt(rt, &cfg->fc_dst, + +net/ipv4/igmp.c:2897: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2895. if (!state->idev) + 2896. continue; + 2897. > state->im = rcu_dereference(state->idev->mc_list); + 2898. } + 2899. if (!state->im) + +net/wireless/trace.h:2884: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2882. ); + 2883. + 2884. > DECLARE_EVENT_CLASS(wiphy_id_evt, + 2885. TP_PROTO(struct wiphy *wiphy, u64 id), + 2886. TP_ARGS(wiphy, id), + +drivers/gpu/drm/drm_atomic_helper.c:2905: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2903. + 2904. if (ret) + 2905. > DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret); + 2906. + 2907. drm_modeset_drop_locks(&ctx); + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +net/ipv4/tcp.c:2908: error: UNINITIALIZED_VALUE + The value read from stats[_] was never initialized. + 2906. + 2907. info->tcpi_busy_time = total; + 2908. > info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED]; + 2909. info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED]; + 2910. } + +net/ipv4/tcp.c:2909: error: UNINITIALIZED_VALUE + The value read from stats[_] was never initialized. + 2907. info->tcpi_busy_time = total; + 2908. info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED]; + 2909. > info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED]; + 2910. } + 2911. + +drivers/gpu/drm/i915/intel_sdvo.c:2904: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2902. uint16_t response, data_value[2]; + 2903. + 2904. > ENHANCEMENT(&connector->state->tv, brightness, BRIGHTNESS); + 2905. + 2906. return true; + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +kernel/cgroup/cgroup.c:2912: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2907 could be null and is dereferenced at line 2912, column 39. + 2910. WARN_ON_ONCE(css && percpu_ref_is_dying(&css->refcnt)); + 2911. + 2912. > if (!(cgroup_ss_mask(dsct) & (1 << ss->id))) + 2913. continue; + 2914. + +kernel/sched/fair.c:2905: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2903. struct task_group *tg = cfs_rq->tg; + 2904. + 2905. > tg_shares = READ_ONCE(tg->shares); + 2906. + 2907. load = max(scale_load_down(cfs_rq->load.weight), cfs_rq->avg.load_avg); + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +drivers/tty/serial/8250/8250_port.c:2920: error: DEAD_STORE + The value written to &i (type int) is never used. + 2918. if (bytes < conf_type->rxtrig_bytes[i]) + 2919. /* Use the nearest lower value */ + 2920. > return (--i) << UART_FCR_R_TRIG_SHIFT; + 2921. } + 2922. + +kernel/rcu/tree.c:2921: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2919. + 2920. /* Funnel through hierarchy to reduce memory contention. */ + 2921. > rnp = __this_cpu_read(rsp->rda->mynode); + 2922. for (; rnp != NULL; rnp = rnp->parent) { + 2923. ret = (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) || + +kernel/rcu/tree.c:2921: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2919. + 2920. /* Funnel through hierarchy to reduce memory contention. */ + 2921. > rnp = __this_cpu_read(rsp->rda->mynode); + 2922. for (; rnp != NULL; rnp = rnp->parent) { + 2923. ret = (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) || + +net/ipv4/tcp.c:2929: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2927. + 2928. /* Report meaningful fields for all TCP states, including listeners */ + 2929. > rate = READ_ONCE(sk->sk_pacing_rate); + 2930. rate64 = rate != ~0U ? rate : ~0ULL; + 2931. info->tcpi_pacing_rate = rate64; + +net/ipv4/tcp.c:2933: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2931. info->tcpi_pacing_rate = rate64; + 2932. + 2933. > rate = READ_ONCE(sk->sk_max_pacing_rate); + 2934. rate64 = rate != ~0U ? rate : ~0ULL; + 2935. info->tcpi_max_pacing_rate = rate64; + +net/netfilter/nf_conntrack_netlink.c:2920: error: NULL_DEREFERENCE + pointer `m_help` last assigned on line 2918 could be null and is dereferenced at line 2920, column 16. + 2918. m_help = nfct_help(exp->master); + 2919. + 2920. > return strcmp(m_help->helper->name, name) == 0; + 2921. } + 2922. + +kernel/sched/core.c:2925: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2923. raw_spin_lock_irqsave(&p->pi_lock, flags); + 2924. dest_cpu = p->sched_class->select_task_rq(p, task_cpu(p), SD_BALANCE_EXEC, 0); + 2925. > if (dest_cpu == smp_processor_id()) + 2926. goto unlock; + 2927. + +net/unix/af_unix.c:2920: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2918. static int __init af_unix_init(void) + 2919. { + 2920. > int rc = -1; + 2921. + 2922. BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb)); + +net/core/rtnetlink.c:2957: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2955. */ + 2956. rcu_read_lock(); + 2957. > for_each_netdev_rcu(net, dev) { + 2958. min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size, + 2959. if_nlmsg_size(dev, + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +net/ipv6/addrconf.c:2954: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2952. + 2953. rtnl_lock(); + 2954. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2955. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2956. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +net/ipv6/addrconf.c:2954: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2952. + 2953. rtnl_lock(); + 2954. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2955. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2956. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +block/blk-mq.c:2968: error: NULL_DEREFERENCE + pointer `rq` last assigned on line 2955 could be null and is dereferenced by call to `__blk_mq_poll()` at line 2968, column 9. + 2966. } + 2967. + 2968. > return __blk_mq_poll(hctx, rq); + 2969. } + 2970. + +kernel/cgroup/cgroup.c:2966: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2953 could be null and is dereferenced at line 2966, column 9. + 2964. } else if (!css_visible(css)) { + 2965. css_clear_dir(css); + 2966. > if (ss->css_reset) + 2967. ss->css_reset(css); + 2968. } + +drivers/gpu/drm/i915/intel_runtime_pm.c:2957: error: NULL_DEREFERENCE + pointer `cmn` last assigned on line 2951 could be null and is dereferenced at line 2957, column 6. + 2955. + 2956. /* If the display might be already active skip this */ + 2957. > if (cmn->ops->is_enabled(dev_priv, cmn) && + 2958. disp2d->ops->is_enabled(dev_priv, disp2d) && + 2959. I915_READ(DPIO_CTL) & DPIO_CMNRST) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2958: error: NULL_DEREFERENCE + pointer `disp2d` last assigned on line 2953 could be null and is dereferenced at line 2958, column 6. + 2956. /* If the display might be already active skip this */ + 2957. if (cmn->ops->is_enabled(dev_priv, cmn) && + 2958. > disp2d->ops->is_enabled(dev_priv, disp2d) && + 2959. I915_READ(DPIO_CTL) & DPIO_CMNRST) + 2960. return; + +net/core/neighbour.c:2956: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2954. + 2955. rcu_read_lock(); + 2956. > for_each_netdev_rcu(net, dev) { + 2957. struct neigh_parms *dst_p = + 2958. neigh_get_dev_parms_rcu(dev, family); + +net/ipv6/addrconf.c:2973: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2971. + 2972. rtnl_lock(); + 2973. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2974. ireq.ifr6_prefixlen); + 2975. rtnl_unlock(); + +net/ipv6/addrconf.c:2973: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2971. + 2972. rtnl_lock(); + 2973. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2974. ireq.ifr6_prefixlen); + 2975. rtnl_unlock(); + +kernel/events/core.c:2968: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2966. int ctxn; + 2967. + 2968. > if (__this_cpu_read(perf_sched_cb_usages)) + 2969. perf_pmu_sched_task(task, next, false); + 2970. + +net/core/rtnetlink.c:2987: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2985. continue; + 2986. + 2987. > dumpit = READ_ONCE(handlers[type].dumpit); + 2988. if (!dumpit) + 2989. continue; + +drivers/iommu/intel-iommu.c:2984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2982. } + 2983. + 2984. > for_each_active_iommu(iommu, drhd) + 2985. for_each_active_dev_scope(drhd->devices, drhd->devices_cnt, i, dev) { + 2986. struct acpi_device_physical_node *pn; + +drivers/iommu/intel-iommu.c:2985: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2983. + 2984. for_each_active_iommu(iommu, drhd) + 2985. > for_each_active_dev_scope(drhd->devices, drhd->devices_cnt, i, dev) { + 2986. struct acpi_device_physical_node *pn; + 2987. struct acpi_device *adev; + +drivers/gpu/drm/drm_dp_mst_topology.c:3016: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3014. int ret; + 3015. + 3016. > ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + +drivers/gpu/drm/drm_dp_mst_topology.c:3018: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3016. ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. > ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + +drivers/gpu/drm/drm_dp_mst_topology.c:3020: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. > ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + 3021. seq_printf(m, "mst ctrl: %*ph\n", 1, buf); + 3022. + +drivers/gpu/drm/drm_dp_mst_topology.c:3024: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3022. + 3023. /* dump the standard OUI branch header */ + 3024. > ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE); + 3025. seq_printf(m, "branch oui: %*phN devid: ", 3, buf); + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + +drivers/gpu/drm/i915/i915_debugfs.c:2976: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 2974 could be null and is dereferenced at line 2976, column 36. + 2974. struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base); + 2975. + 2976. > seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]); + 2977. seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio)); + 2978. if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) + +net/wireless/trace.h:2970: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2968. ); + 2969. + 2970. > DECLARE_EVENT_CLASS(cfg80211_bss_evt, + 2971. TP_PROTO(struct cfg80211_bss *pub), + 2972. TP_ARGS(pub), + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +kernel/rcu/tree.c:2992: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2990. struct rcu_state *rsp; + 2991. + 2992. > if (cpu_is_offline(smp_processor_id())) + 2993. return; + 2994. trace_rcu_utilization(TPS("Start RCU core")); + +kernel/rcu/tree.c:2992: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2990. struct rcu_state *rsp; + 2991. + 2992. > if (cpu_is_offline(smp_processor_id())) + 2993. return; + 2994. trace_rcu_utilization(TPS("Start RCU core")); + +net/wireless/trace.h:2989: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +drivers/cdrom/cdrom.c:3026: error: UNINITIALIZED_VALUE + The value read from ra.nframes was never initialized. + 3024. return -EINVAL; + 3025. + 3026. > return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes); + 3027. } + 3028. + +kernel/sched/core.c:3014: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3012. void scheduler_tick(void) + 3013. { + 3014. > int cpu = smp_processor_id(); + 3015. struct rq *rq = cpu_rq(cpu); + 3016. struct task_struct *curr = rq->curr; + +kernel/sched/core.c:3014: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3012. void scheduler_tick(void) + 3013. { + 3014. > int cpu = smp_processor_id(); + 3015. struct rq *rq = cpu_rq(cpu); + 3016. struct task_struct *curr = rq->curr; + +net/wireless/trace.h:3013: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +kernel/rcu/tree.c:3020: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3018. static void invoke_rcu_core(void) + 3019. { + 3020. > if (cpu_online(smp_processor_id())) + 3021. raise_softirq(RCU_SOFTIRQ); + 3022. } + +kernel/rcu/tree.c:3020: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3018. static void invoke_rcu_core(void) + 3019. { + 3020. > if (cpu_online(smp_processor_id())) + 3021. raise_softirq(RCU_SOFTIRQ); + 3022. } + +net/ipv4/tcp.c:3048: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3046. tp->total_retrans, TCP_NLA_PAD); + 3047. + 3048. > rate = READ_ONCE(sk->sk_pacing_rate); + 3049. rate64 = rate != ~0U ? rate : ~0ULL; + 3050. nla_put_u64_64bit(stats, TCP_NLA_PACING_RATE, rate64, TCP_NLA_PAD); + +net/ipv4/tcp_input.c:3134: error: UNINITIALIZED_VALUE + The value read from last_ackt was never initialized. + 3132. if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) { + 3133. seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt); + 3134. > ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt); + 3135. } + 3136. if (sack->first_sackt) { + +kernel/rcu/tree.c:3040: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3038. + 3039. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 3040. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 3041. return; + 3042. + +kernel/rcu/tree.c:3040: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3038. + 3039. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 3040. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 3041. return; + 3042. + +drivers/cdrom/cdrom.c:3037: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 3035. if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q))) + 3036. return -EFAULT; + 3037. > requested = q.cdsc_format; + 3038. if (!((requested == CDROM_MSF) || + 3039. (requested == CDROM_LBA))) + +drivers/gpu/drm/i915/i915_gem_gtt.c:3071: error: UNINITIALIZED_VALUE + The value read from entry was never initialized. + 3069. + 3070. kref_get(&entry->ref); + 3071. > return entry; + 3072. } + 3073. + +drivers/gpu/drm/drm_atomic_helper.c:3067: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 3065. drm_modeset_acquire_fini(&ctx); + 3066. + 3067. > return err; + 3068. } + 3069. EXPORT_SYMBOL(drm_atomic_helper_resume); + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +drivers/cdrom/cdrom.c:3066: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame0 was never initialized. + 3064. cgc->cmd[3] = msf.cdmsf_min0; + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. > cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + +drivers/cdrom/cdrom.c:3069: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame1 was never initialized. + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + 3069. > cgc->cmd[8] = msf.cdmsf_frame1; + 3070. cgc->data_direction = CGC_DATA_NONE; + 3071. return cdo->generic_packet(cdi, cgc); + +drivers/cdrom/cdrom.c:3064: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min0 was never initialized. + 3062. return -EFAULT; + 3063. cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF; + 3064. > cgc->cmd[3] = msf.cdmsf_min0; + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + +drivers/cdrom/cdrom.c:3067: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min1 was never initialized. + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. > cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + 3069. cgc->cmd[8] = msf.cdmsf_frame1; + +drivers/cdrom/cdrom.c:3065: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec0 was never initialized. + 3063. cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF; + 3064. cgc->cmd[3] = msf.cdmsf_min0; + 3065. > cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + +drivers/cdrom/cdrom.c:3068: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec1 was never initialized. + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. > cgc->cmd[7] = msf.cdmsf_sec1; + 3069. cgc->cmd[8] = msf.cdmsf_frame1; + 3070. cgc->data_direction = CGC_DATA_NONE; + +drivers/gpu/drm/drm_dp_mst_topology.c:3069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3067. for (;;) { + 3068. mutex_lock(&mgr->destroy_connector_lock); + 3069. > port = list_first_entry_or_null(&mgr->destroy_connector_list, struct drm_dp_mst_port, next); + 3070. if (!port) { + 3071. mutex_unlock(&mgr->destroy_connector_lock); + +net/ipv4/ipmr.c:3069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3067. rcu_read_lock(); + 3068. it->cache = &mrt->mfc_cache_list; + 3069. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) + 3070. if (pos-- == 0) + 3071. return mfc; + +net/ipv4/tcp.c:3190: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3188. + 3189. rcu_read_lock(); + 3190. > ctx = rcu_dereference(icsk->icsk_accept_queue.fastopenq.ctx); + 3191. if (ctx) + 3192. memcpy(key, ctx->key, sizeof(key)); + +drivers/gpu/drm/drm_edid.c:3129: error: UNINITIALIZED_VALUE + The value read from clock2 was never initialized. + 3127. newmode->clock = clock1; + 3128. else + 3129. > newmode->clock = clock2; + 3130. + 3131. list_add_tail(&newmode->head, &list); + +net/wireless/trace.h:3077: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +drivers/net/ethernet/intel/e1000/e1000_main.c:3107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3105. * made room available. + 3106. */ + 3107. > if (likely(E1000_DESC_UNUSED(tx_ring) < size)) + 3108. return -EBUSY; + 3109. + +net/wireless/trace.h:3092: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +drivers/cdrom/cdrom.c:3142: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3140. a CDROMVOLREAD, return these values */ + 3141. if (cmd == CDROMVOLREAD) { + 3142. > volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + +drivers/cdrom/cdrom.c:3143: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3141. if (cmd == CDROMVOLREAD) { + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. > volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + +drivers/cdrom/cdrom.c:3144: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. > volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + +drivers/cdrom/cdrom.c:3145: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. > volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + 3147. sizeof(volctrl))) + +net/core/filter.c:3111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3109. return -E2BIG; + 3110. + 3111. > cgrp = READ_ONCE(array->ptrs[idx]); + 3112. if (unlikely(!cgrp)) + 3113. return -EAGAIN; + +drivers/clk/clk.c:3115: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3113. { + 3114. struct clk_notifier *cn = NULL; + 3115. > int ret = -EINVAL; + 3116. + 3117. if (!clk || !nb) + +net/wireless/trace.h:3115: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +drivers/net/ethernet/intel/e1000/e1000_main.c:3119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3117. struct e1000_tx_ring *tx_ring, int size) + 3118. { + 3119. > if (likely(E1000_DESC_UNUSED(tx_ring) >= size)) + 3120. return 0; + 3121. return __e1000_maybe_stop_tx(netdev, size); + +kernel/printk/printk.c:3122: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3120. { + 3121. printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3122. > log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3123. print_tainted(), init_utsname()->release, + 3124. (int)strcspn(init_utsname()->version, " "), + +kernel/printk/printk.c:3121: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3119. void dump_stack_print_info(const char *log_lvl) + 3120. { + 3121. > printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3122. log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3123. print_tainted(), init_utsname()->release, + +drivers/usb/core/hub.c:3131: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3130 could be null and is dereferenced at line 3131, column 30. + 3129. { + 3130. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3131. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3132. int port1 = udev->portnum; + 3133. int status; + +drivers/net/ethernet/nvidia/forcedeth.c:3189: error: UNINITIALIZED_VALUE + The value read from mask[_] was never initialized. + 3187. writel(addr[0], base + NvRegMulticastAddrA); + 3188. writel(addr[1], base + NvRegMulticastAddrB); + 3189. > writel(mask[0], base + NvRegMulticastMaskA); + 3190. writel(mask[1], base + NvRegMulticastMaskB); + 3191. writel(pff, base + NvRegPacketFilterFlags); + +drivers/net/ethernet/nvidia/forcedeth.c:3190: error: UNINITIALIZED_VALUE + The value read from mask[_] was never initialized. + 3188. writel(addr[1], base + NvRegMulticastAddrB); + 3189. writel(mask[0], base + NvRegMulticastMaskA); + 3190. > writel(mask[1], base + NvRegMulticastMaskB); + 3191. writel(pff, base + NvRegPacketFilterFlags); + 3192. nv_start_rx(dev); + +net/wireless/trace.h:3138: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +kernel/signal.c:3177: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3175. sigaddset(&mask, sig); + 3176. flush_sigqueue_mask(&mask, &p->signal->shared_pending); + 3177. > for_each_thread(p, t) + 3178. flush_sigqueue_mask(&mask, &t->pending); + 3179. } + +kernel/events/core.c:3169: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3167. perf_event_switch(task, prev, true); + 3168. + 3169. > if (__this_cpu_read(perf_sched_cb_usages)) + 3170. perf_pmu_sched_task(prev, task, true); + 3171. } + +security/selinux/hooks.c:3149: error: MEMORY_LEAK + `return` is not reachable after line 3149, column 3. + 3147. + 3148. if (cap_capable(cred, &init_user_ns, CAP_MAC_ADMIN, cap_audit)) + 3149. > return false; + 3150. if (cred_has_capability(cred, CAP_MAC_ADMIN, cap_audit, true)) + 3151. return false; + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/ipv6/route.c:3168: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3166. + 3167. rcu_read_lock(); + 3168. > for_each_fib6_node_rt_rcu(&table->tb6_root) { + 3169. if (dev == rt->dst.dev && + 3170. ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) && + +net/wireless/trace.h:3158: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +kernel/cgroup/cgroup.c:3177: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 3176 could be null and is dereferenced at line 3177, column 28. + 3175. { + 3176. struct cgroup *parent = cgroup_parent(cgrp); + 3177. > struct cgroup *dom_cgrp = parent->dom_cgrp; + 3178. int ret; + 3179. + +net/core/rtnetlink.c:3238: error: NULL_DEREFERENCE + pointer `br_dev` last assigned on line 3237 could be null and is dereferenced at line 3238, column 38. + 3236. (dev->priv_flags & IFF_BRIDGE_PORT)) { + 3237. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + 3238. > const struct net_device_ops *ops = br_dev->netdev_ops; + 3239. + 3240. err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, + +drivers/tty/serial/8250/8250_port.c:3256: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 3254. + 3255. if (locked) + 3256. > spin_unlock_irqrestore(&port->lock, flags); + 3257. serial8250_rpm_put(up); + 3258. } + +net/ipv6/route.c:3215: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3213. restart: + 3214. rcu_read_lock(); + 3215. > for_each_fib6_node_rt_rcu(&table->tb6_root) { + 3216. if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) && + 3217. (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) { + +net/ipv4/ipmr.c:3249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3247. + 3248. /* Notify on table MFC entries */ + 3249. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) + 3250. call_ipmr_mfc_entry_notifier(nb, net, + 3251. FIB_EVENT_ENTRY_ADD, mfc, + +drivers/iommu/intel-iommu.c:3241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3239. * endfor + 3240. */ + 3241. > for_each_drhd_unit(drhd) { + 3242. /* + 3243. * lock not needed as this is only incremented in the single + +drivers/iommu/intel-iommu.c:3266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3264. } + 3265. + 3266. > for_each_active_iommu(iommu, drhd) { + 3267. g_iommus[iommu->seq_id] = iommu; + 3268. + +drivers/iommu/intel-iommu.c:3331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3329. * flush_context function will loop forever and the boot hangs. + 3330. */ + 3331. > for_each_active_iommu(iommu, drhd) { + 3332. iommu_flush_write_buffer(iommu); + 3333. iommu_set_root_entry(iommu); + +drivers/iommu/intel-iommu.c:3392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3390. for_each_rmrr_units(rmrr) { + 3391. /* some BIOS lists non-exist devices in DMAR table. */ + 3392. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 3393. i, dev) { + 3394. ret = iommu_prepare_rmrr_dev(rmrr, dev); + +drivers/iommu/intel-iommu.c:3411: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3409. * enable translation + 3410. */ + 3411. > for_each_iommu(iommu, drhd) { + 3412. if (drhd->ignored) { + 3413. /* + +drivers/iommu/intel-iommu.c:3444: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3442. + 3443. free_iommu: + 3444. > for_each_active_iommu(iommu, drhd) { + 3445. disable_dmar_iommu(iommu); + 3446. free_dmar_iommu(iommu); + +net/ipv6/route.c:3242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3240. for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { + 3241. head = &net->ipv6.fib_table_hash[h]; + 3242. > hlist_for_each_entry_rcu(table, head, tb6_hlist) { + 3243. if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER) + 3244. __rt6_purge_dflt_routers(table); + +kernel/cgroup/cgroup.c:3248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3246. { + 3247. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3248. > int descendants = READ_ONCE(cgrp->max_descendants); + 3249. + 3250. if (descendants == INT_MAX) + +kernel/signal.c:3277: error: UNINITIALIZED_VALUE + The value read from uss32.ss_flags was never initialized. + 3275. return -EFAULT; + 3276. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3277. > uss.ss_flags = uss32.ss_flags; + 3278. uss.ss_size = uss32.ss_size; + 3279. } + +kernel/signal.c:3278: error: UNINITIALIZED_VALUE + The value read from uss32.ss_size was never initialized. + 3276. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3277. uss.ss_flags = uss32.ss_flags; + 3278. > uss.ss_size = uss32.ss_size; + 3279. } + 3280. ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, + +kernel/signal.c:3276: error: UNINITIALIZED_VALUE + The value read from uss32.ss_sp was never initialized. + 3274. if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t))) + 3275. return -EFAULT; + 3276. > uss.ss_sp = compat_ptr(uss32.ss_sp); + 3277. uss.ss_flags = uss32.ss_flags; + 3278. uss.ss_size = uss32.ss_size; + +drivers/gpu/drm/i915/i915_gem.c:3289: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 3287. * new request is submitted. + 3288. */ + 3289. > wait_for(intel_engines_are_idle(dev_priv), 10); + 3290. if (READ_ONCE(dev_priv->gt.active_requests)) + 3291. return; + +drivers/gpu/drm/i915/i915_gem.c:3314: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 3312. goto out_unlock; + 3313. + 3314. > if (wait_for(intel_engines_are_idle(dev_priv), 10)) + 3315. DRM_ERROR("Timeout waiting for engines to idle\n"); + 3316. + +kernel/events/core.c:3302: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3300. perf_pmu_disable(ctx->pmu); + 3301. + 3302. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 3303. if (event->state != PERF_EVENT_STATE_ACTIVE) + 3304. continue; + +net/socket.c:3300: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3288 could be null and is dereferenced at line 3300, column 2. + 3298. } + 3299. + 3300. > (*newsock)->ops = sock->ops; + 3301. __module_get((*newsock)->ops->owner); + 3302. + +kernel/sched/core.c:3295: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3293. int cpu; + 3294. + 3295. > cpu = smp_processor_id(); + 3296. rq = cpu_rq(cpu); + 3297. prev = rq->curr; + +kernel/sched/core.c:3295: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3293. int cpu; + 3294. + 3295. > cpu = smp_processor_id(); + 3296. rq = cpu_rq(cpu); + 3297. prev = rq->curr; + +kernel/cgroup/cgroup.c:3291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3289. { + 3290. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3291. > int depth = READ_ONCE(cgrp->max_depth); + 3292. + 3293. if (depth == INT_MAX) + +net/core/rtnetlink.c:3302: error: DEAD_STORE + The value written to &err (type int) is never used. + 3300. struct nlattr *tb[NDA_MAX+1]; + 3301. struct net_device *dev; + 3302. > int err = -EINVAL; + 3303. __u8 *addr; + 3304. u16 vid; + +drivers/net/ethernet/nvidia/forcedeth.c:3317: error: DEAD_STORE + The value written to &newdup (type int) is never used. + 3315. int adv_lpa, adv_pause, lpa_pause; + 3316. int newls = np->linkspeed; + 3317. > int newdup = np->duplex; + 3318. int mii_status; + 3319. u32 bmcr; + +drivers/net/ethernet/nvidia/forcedeth.c:3316: error: DEAD_STORE + The value written to &newls (type int) is never used. + 3314. int lpa = 0; + 3315. int adv_lpa, adv_pause, lpa_pause; + 3316. > int newls = np->linkspeed; + 3317. int newdup = np->duplex; + 3318. int mii_status; + +net/core/dev.c:3329: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3327. + 3328. rcu_read_lock(); + 3329. > dev_maps = rcu_dereference(dev->xps_maps); + 3330. if (dev_maps) { + 3331. unsigned int tci = skb->sender_cpu - 1; + +net/core/dev.c:3338: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3336. } + 3337. + 3338. > map = rcu_dereference(dev_maps->cpu_map[tci]); + 3339. if (map) { + 3340. if (map->len == 1) + +kernel/rcu/tree.c:3342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3340. * and cond_synchronize_rcu(). + 3341. */ + 3342. > return smp_load_acquire(&rcu_state_p->gpnum); + 3343. } + 3344. EXPORT_SYMBOL_GPL(get_state_synchronize_rcu); + +drivers/scsi/scsi_lib.c:3356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3354. + 3355. rcu_read_lock(); + 3356. > vpd_pg83 = rcu_dereference(sdev->vpd_pg83); + 3357. if (!vpd_pg83) { + 3358. rcu_read_unlock(); + +net/core/dev.c:3371: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3369. if (queue_index != new_index && sk && + 3370. sk_fullsock(sk) && + 3371. > rcu_access_pointer(sk->sk_dst_cache)) + 3372. sk_tx_queue_set(sk, new_index); + 3373. + +kernel/rcu/tree.c:3368: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3366. * actions the caller might carry out after we return. + 3367. */ + 3368. > newstate = smp_load_acquire(&rcu_state_p->completed); + 3369. if (ULONG_CMP_GE(oldstate, newstate)) + 3370. synchronize_rcu(); + +drivers/iommu/amd_iommu.c:3408: error: UNINITIALIZED_VALUE + The value read from pte was never initialized. + 3406. } + 3407. + 3408. > return pte; + 3409. } + 3410. + +net/core/dev.c:3390: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3388. + 3389. if (sender_cpu >= (u32)NR_CPUS) + 3390. > skb->sender_cpu = raw_smp_processor_id() + 1; + 3391. #endif + 3392. + +kernel/rcu/tree.c:3394: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3392. * and cond_synchronize_sched(). + 3393. */ + 3394. > return smp_load_acquire(&rcu_sched_state.gpnum); + 3395. } + 3396. EXPORT_SYMBOL_GPL(get_state_synchronize_sched); + +net/ipv4/tcp_input.c:3404: error: DEAD_STORE + The value written to &half (type unsigned int) is never used. + 3402. if (now != challenge_timestamp) { + 3403. u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit; + 3404. > u32 half = (ack_limit + 1) >> 1; + 3405. + 3406. challenge_timestamp = now; + +net/ipv4/tcp_input.c:3409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3407. WRITE_ONCE(challenge_count, half + prandom_u32_max(ack_limit)); + 3408. } + 3409. > count = READ_ONCE(challenge_count); + 3410. if (count > 0) { + 3411. WRITE_ONCE(challenge_count, count - 1); + +kernel/trace/trace.c:3404: error: DEAD_STORE + The value written to &name (type char const *) is never used. + 3402. unsigned long entries; + 3403. unsigned long total; + 3404. > const char *name = "preemption"; + 3405. + 3406. name = type->name; + +drivers/usb/core/hub.c:3400: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3399 could be null and is dereferenced at line 3400, column 30. + 3398. { + 3399. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3400. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3401. int port1 = udev->portnum; + 3402. int status; + +kernel/events/core.c:3412: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3410. __this_cpu_inc(perf_throttled_seq); + 3411. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3412. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3413. + 3414. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3411: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 3409. + 3410. __this_cpu_inc(perf_throttled_seq); + 3411. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3412. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3413. + +kernel/events/core.c:3412: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3410. __this_cpu_inc(perf_throttled_seq); + 3411. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3412. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3413. + 3414. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3411: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 3409. + 3410. __this_cpu_inc(perf_throttled_seq); + 3411. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3412. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3413. + +kernel/rcu/tree.c:3420: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3418. * actions the caller might carry out after we return. + 3419. */ + 3420. > newstate = smp_load_acquire(&rcu_sched_state.completed); + 3421. if (ULONG_CMP_GE(oldstate, newstate)) + 3422. synchronize_sched(); + +kernel/rcu/tree.c:3449: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3447. if (rcu_scheduler_fully_active && + 3448. rdp->core_needs_qs && rdp->cpu_no_qs.b.norm && + 3449. > rdp->rcu_qs_ctr_snap == __this_cpu_read(rcu_dynticks.rcu_qs_ctr)) { + 3450. rdp->n_rp_core_needs_qs++; + 3451. } else if (rdp->core_needs_qs && !rdp->cpu_no_qs.b.norm) { + +net/core/dev.c:3475: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3473. + 3474. txq = netdev_pick_tx(dev, skb, accel_priv); + 3475. > q = rcu_dereference_bh(txq->qdisc); + 3476. + 3477. trace_net_dev_queue(skb); + +net/core/dev.c:3496: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3494. */ + 3495. if (dev->flags & IFF_UP) { + 3496. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3497. + 3498. if (txq->xmit_lock_owner != cpu) { + +net/core/dev.c:3499: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3497. + 3498. if (txq->xmit_lock_owner != cpu) { + 3499. > if (unlikely(__this_cpu_read(xmit_recursion) > + 3500. XMIT_RECURSION_LIMIT)) + 3501. goto recursion_alert; + +net/core/dev.c:3496: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3494. */ + 3495. if (dev->flags & IFF_UP) { + 3496. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3497. + 3498. if (txq->xmit_lock_owner != cpu) { + +drivers/gpu/drm/i915/i915_gem.c:3470: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 3468. static int wait_for_engines(struct drm_i915_private *i915) + 3469. { + 3470. > if (wait_for(intel_engines_are_idle(i915), 50)) { + 3471. DRM_ERROR("Failed to idle engines, declaring wedged!\n"); + 3472. i915_gem_set_wedged(i915); + +drivers/net/ethernet/intel/e1000e/netdev.c:3483: error: UNINITIALIZED_VALUE + The value read from rss_key[_] was never initialized. + 3481. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 3482. for (i = 0; i < 10; i++) + 3483. > ew32(RSSRK(i), rss_key[i]); + 3484. + 3485. /* Direct all traffic to queue 0 */ + +kernel/sched/fair.c:3496: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3494. + 3495. /* Update parent cfs_rq utilization */ + 3496. > add_positive(&cfs_rq->avg.util_avg, delta); + 3497. cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX; + 3498. } + +kernel/events/core.c:3488: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3486. + 3487. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3488. > int local_cpu = smp_processor_id(); + 3489. + 3490. event_pkg = topology_physical_package_id(event_cpu); + +kernel/events/core.c:3488: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3486. + 3487. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3488. > int local_cpu = smp_processor_id(); + 3489. + 3490. event_pkg = topology_physical_package_id(event_cpu); + +drivers/iommu/intel-iommu.c:3507: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3505. rcu_read_lock(); + 3506. for_each_rmrr_units(rmrr) { + 3507. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 3508. i, i_dev) { + 3509. if (i_dev != dev) + +drivers/scsi/scsi_lib.c:3505: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3503. + 3504. rcu_read_lock(); + 3505. > vpd_pg83 = rcu_dereference(sdev->vpd_pg83); + 3506. if (!vpd_pg83) { + 3507. rcu_read_unlock(); + +kernel/sched/fair.c:3551: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3549. se->avg.load_sum = runnable_sum; + 3550. se->avg.load_avg = load_avg; + 3551. > add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3552. add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3553. + +kernel/sched/fair.c:3552: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3550. se->avg.load_avg = load_avg; + 3551. add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3552. > add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3553. + 3554. runnable_load_sum = (s64)se_runnable(se) * runnable_sum; + +kernel/sched/fair.c:3563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3561. + 3562. if (se->on_rq) { + 3563. > add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3564. add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3565. } + +kernel/sched/fair.c:3564: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3562. if (se->on_rq) { + 3563. add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3564. > add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3565. } + 3566. } + +drivers/usb/core/hub.c:3596: error: DEAD_STORE + The value written to &status (type int) is never used. + 3594. /* Enable hub to send remote wakeup for all ports. */ + 3595. for (port1 = 1; port1 <= hdev->maxchild; port1++) { + 3596. > status = set_port_feature(hdev, + 3597. port1 | + 3598. USB_PORT_FEAT_REMOTE_WAKE_CONNECT | + +include/linux/netdevice.h:3562: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3560. bool ok = spin_trylock(&txq->_xmit_lock); + 3561. if (likely(ok)) + 3562. > txq->xmit_lock_owner = smp_processor_id(); + 3563. return ok; + 3564. } + +include/linux/netdevice.h:3562: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3560. bool ok = spin_trylock(&txq->_xmit_lock); + 3561. if (likely(ok)) + 3562. > txq->xmit_lock_owner = smp_processor_id(); + 3563. return ok; + 3564. } + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3571: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3569. u32 flash_linear_addr; + 3570. u32 flash_data = 0; + 3571. > s32 ret_val = -E1000_ERR_NVM; + 3572. u8 count = 0; + 3573. + +drivers/video/fbdev/core/fbcon.c:3591: error: DEAD_STORE + The value written to &pending (type int) is never used. + 3589. + 3590. if (info->queue.func) + 3591. > pending = cancel_work_sync(&info->queue); + 3592. DPRINTK("fbcon: %s pending work\n", (pending ? "canceled" : + 3593. "no")); + +kernel/events/core.c:3603: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3601. /* If this is a per-CPU event, it must be for this CPU */ + 3602. if (!(event->attach_state & PERF_ATTACH_TASK) && + 3603. > event->cpu != smp_processor_id()) { + 3604. ret = -EINVAL; + 3605. goto out; + +kernel/events/core.c:3613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3611. * oncpu == -1). + 3612. */ + 3613. > if (event->oncpu == smp_processor_id()) + 3614. event->pmu->read(event); + 3615. + +net/ipv6/addrconf.c:3627: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3625. spin_lock_bh(&addrconf_hash_lock); + 3626. restart: + 3627. > hlist_for_each_entry_rcu(ifa, h, addr_lst) { + 3628. if (ifa->idev == idev) { + 3629. addrconf_del_dad_work(ifa); + +drivers/gpu/drm/i915/i915_debugfs.c:3600: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 3599 could be null and is dereferenced at line 3600, column 8. + 3598. + 3599. intel_dig_port = enc_to_dig_port(&intel_encoder->base); + 3600. > if (!intel_dig_port->dp.can_mst) + 3601. continue; + 3602. + +net/wireless/reg.c:3593: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3591. rcu_read_lock(); + 3592. + 3593. > regd = rcu_dereference(cfg80211_regdomain); + 3594. wiphy_regd = rcu_dereference(wiphy->regd); + 3595. if (!wiphy_regd) { + +net/wireless/reg.c:3594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3592. + 3593. regd = rcu_dereference(cfg80211_regdomain); + 3594. > wiphy_regd = rcu_dereference(wiphy->regd); + 3595. if (!wiphy_regd) { + 3596. if (regd->dfs_region == NL80211_DFS_ETSI) + +net/core/dev.c:3614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3612. + 3613. rxqueue = dev->_rx + rxq_index; + 3614. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3615. if (!flow_table) + 3616. goto out; + +include/linux/netdevice.h:3605: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3603. + 3604. spin_lock(&dev->tx_global_lock); + 3605. > cpu = smp_processor_id(); + 3606. for (i = 0; i < dev->num_tx_queues; i++) { + 3607. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3605: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3603. + 3604. spin_lock(&dev->tx_global_lock); + 3605. > cpu = smp_processor_id(); + 3606. for (i = 0; i < dev->num_tx_queues; i++) { + 3607. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +kernel/workqueue.c:3618: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3616. link_pwq(pwq); + 3617. + 3618. > old_pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]); + 3619. rcu_assign_pointer(wq->numa_pwq_tbl[node], pwq); + 3620. return old_pwq; + +drivers/gpu/drm/i915/i915_debugfs.c:3657: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3648 could be null and is dereferenced at line 3657, column 5. + 3655. */ + 3656. if (val == 1) + 3657. > intel_dp->compliance.test_active = 1; + 3658. else + 3659. intel_dp->compliance.test_active = 0; + +drivers/gpu/drm/i915/i915_debugfs.c:3659: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3648 could be null and is dereferenced at line 3659, column 5. + 3657. intel_dp->compliance.test_active = 1; + 3658. else + 3659. > intel_dp->compliance.test_active = 0; + 3660. } + 3661. } + +kernel/events/core.c:3635: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3633. static int perf_event_read(struct perf_event *event, bool group) + 3634. { + 3635. > enum perf_event_state state = READ_ONCE(event->state); + 3636. int event_cpu, ret = 0; + 3637. + +kernel/events/core.c:3654: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3652. smp_rmb(); + 3653. + 3654. > event_cpu = READ_ONCE(event->oncpu); + 3655. if ((unsigned)event_cpu >= nr_cpu_ids) + 3656. return 0; + +net/core/rtnetlink.c:3662: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3660. + 3661. rcu_read_lock(); + 3662. > for_each_netdev_rcu(net, dev) { + 3663. const struct net_device_ops *ops = dev->netdev_ops; + 3664. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3646: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3644. union ich8_hws_flash_ctrl hsflctl; + 3645. u32 flash_linear_addr; + 3646. > s32 ret_val = -E1000_ERR_NVM; + 3647. u8 count = 0; + 3648. + +net/core/dev.c:3668: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3666. /* Avoid computing hash if RFS/RPS is not active for this rxqueue */ + 3667. + 3668. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3669. map = rcu_dereference(rxqueue->rps_map); + 3670. if (!flow_table && !map) + +net/core/dev.c:3669: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3667. + 3668. flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3669. > map = rcu_dereference(rxqueue->rps_map); + 3670. if (!flow_table && !map) + 3671. goto done; + +net/core/dev.c:3678: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3676. goto done; + 3677. + 3678. > sock_flow_table = rcu_dereference(rps_sock_flow_table); + 3679. if (flow_table && sock_flow_table) { + 3680. struct rps_dev_flow *rflow; + +kernel/sched/fair.c:3676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3674. + 3675. r = removed_load; + 3676. > sub_positive(&sa->load_avg, r); + 3677. sub_positive(&sa->load_sum, r * divider); + 3678. + +kernel/sched/fair.c:3677: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3675. r = removed_load; + 3676. sub_positive(&sa->load_avg, r); + 3677. > sub_positive(&sa->load_sum, r * divider); + 3678. + 3679. r = removed_util; + +kernel/sched/fair.c:3680: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3678. + 3679. r = removed_util; + 3680. > sub_positive(&sa->util_avg, r); + 3681. sub_positive(&sa->util_sum, r * divider); + 3682. + +kernel/sched/fair.c:3681: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3679. r = removed_util; + 3680. sub_positive(&sa->util_avg, r); + 3681. > sub_positive(&sa->util_sum, r * divider); + 3682. + 3683. add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum); + +drivers/gpu/drm/drm_edid.c:3710: error: UNINITIALIZED_VALUE + The value read from hdmi_len was never initialized. + 3708. */ + 3709. if (hdmi) + 3710. > modes += do_hdmi_vsdb_modes(connector, hdmi, hdmi_len, video, + 3711. video_len); + 3712. + +drivers/gpu/drm/i915/i915_debugfs.c:3692: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3691 could be null and is dereferenced at line 3692, column 8. + 3690. if (encoder && connector->status == connector_status_connected) { + 3691. intel_dp = enc_to_intel_dp(&encoder->base); + 3692. > if (intel_dp->compliance.test_active) + 3693. seq_puts(m, "1"); + 3694. else + +include/linux/netdevice.h:3677: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3675. + 3676. local_bh_disable(); + 3677. > cpu = smp_processor_id(); + 3678. for (i = 0; i < dev->num_tx_queues; i++) { + 3679. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3677: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3675. + 3676. local_bh_disable(); + 3677. > cpu = smp_processor_id(); + 3678. for (i = 0; i < dev->num_tx_queues; i++) { + 3679. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +drivers/gpu/drm/i915/intel_dp.c:3762: error: UNINITIALIZED_VALUE + The value read from sink_rates[_] was never initialized. + 3760. + 3761. for (i = 0; i < ARRAY_SIZE(sink_rates); i++) { + 3762. > int val = le16_to_cpu(sink_rates[i]); + 3763. + 3764. if (val == 0) + +drivers/ata/libata-scsi.c:3691: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3689. struct scsi_cmnd *scmd = qc->scsicmd; + 3690. const u8 *cdb = scmd->cmnd; + 3691. > u16 sect, fp = (u16)-1; + 3692. u8 sa, options, bp = 0xff; + 3693. u64 block; + +drivers/ata/libata-core.c:3726: error: DEAD_STORE + The value written to &nodev_deadline (type unsigned long) is never used. + 3724. + 3725. if (time_after(nodev_deadline, deadline)) + 3726. > nodev_deadline = deadline; + 3727. + 3728. while (1) { + +drivers/ata/libata-core.c:3729: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 3727. + 3728. while (1) { + 3729. > unsigned long now = jiffies; + 3730. int ready, tmp; + 3731. + +drivers/ata/libata-core.c:3766: error: DEAD_STORE + The value written to &warned (type int) is never used. + 3764. "link is slow to respond, please be patient " + 3765. "(ready=%d)\n", tmp); + 3766. > warned = 1; + 3767. } + 3768. + +drivers/pci/quirks.c:3736: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 3734. iowrite32(val, mmio_base + PCH_PP_CONTROL); + 3735. + 3736. > timeout = jiffies + msecs_to_jiffies(IGD_OPERATION_TIMEOUT); + 3737. do { + 3738. val = ioread32(mmio_base + PCH_PP_STATUS); + +net/core/rtnetlink.c:3724: error: DEAD_STORE + The value written to &err (type int) is never used. + 3722. struct net *net = dev_net(dev); + 3723. struct sk_buff *skb; + 3724. > int err = -EOPNOTSUPP; + 3725. + 3726. if (!dev->netdev_ops->ndo_bridge_getlink) + +drivers/gpu/drm/i915/i915_drv.h:3723: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3721. static inline u32 i915_reset_count(struct i915_gpu_error *error) + 3722. { + 3723. > return READ_ONCE(error->reset_count); + 3724. } + 3725. + +drivers/gpu/drm/i915/i915_debugfs.c:3743: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3742 could be null and is dereferenced at line 3743, column 8. + 3741. if (encoder && connector->status == connector_status_connected) { + 3742. intel_dp = enc_to_intel_dp(&encoder->base); + 3743. > if (intel_dp->compliance.test_type == + 3744. DP_TEST_LINK_EDID_READ) + 3745. seq_printf(m, "%lx", + +drivers/gpu/drm/i915/i915_drv.h:3729: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3727. struct intel_engine_cs *engine) + 3728. { + 3729. > return READ_ONCE(error->reset_engine_count[engine->id]); + 3730. } + 3731. + +net/core/dev.c:3760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3758. + 3759. rcu_read_lock(); + 3760. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3761. if (flow_table && flow_id <= flow_table->mask) { + 3762. rflow = &flow_table->flows[flow_id]; + +net/core/dev.c:3763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3761. if (flow_table && flow_id <= flow_table->mask) { + 3762. rflow = &flow_table->flows[flow_id]; + 3763. > cpu = READ_ONCE(rflow->cpu); + 3764. if (rflow->filter == filter_id && cpu < nr_cpu_ids && + 3765. ((int)(per_cpu(softnet_data, cpu).input_queue_head - + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3823: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3821. + 3822. /* Convert offset to bytes. */ + 3823. > act_offset = (i + new_bank_offset) << 1; + 3824. + 3825. usleep_range(100, 200); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3869: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3867. * to 1's. We can write 1's to 0's without an erase + 3868. */ + 3869. > act_offset = (old_bank_offset + E1000_ICH_NVM_SIG_WORD) * 2 + 1; + 3870. + 3871. /* offset in words but we read dword */ + +kernel/sched/fair.c:3759: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3757. { + 3758. dequeue_load_avg(cfs_rq, se); + 3759. > sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3760. sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3761. + +kernel/sched/fair.c:3760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3758. dequeue_load_avg(cfs_rq, se); + 3759. sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3760. > sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3761. + 3762. add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum); + +drivers/ata/libata-scsi.c:3778: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3776. u64 block; + 3777. u32 n_block; + 3778. > u16 fp = (u16)-1; + 3779. + 3780. if (unlikely(scmd->cmd_len < 16)) { + +drivers/gpu/drm/i915/i915_debugfs.c:3801: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3800 could be null and is dereferenced at line 3801, column 27. + 3799. if (encoder && connector->status == connector_status_connected) { + 3800. intel_dp = enc_to_intel_dp(&encoder->base); + 3801. > seq_printf(m, "%02lx", intel_dp->compliance.test_type); + 3802. } else + 3803. seq_puts(m, "0"); + +kernel/cgroup/cgroup.c:3839: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3837. */ + 3838. if (!pos) { + 3839. > next = list_entry_rcu(parent->children.next, struct cgroup_subsys_state, sibling); + 3840. } else if (likely(!(pos->flags & CSS_RELEASED))) { + 3841. next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + +kernel/cgroup/cgroup.c:3841: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3839. next = list_entry_rcu(parent->children.next, struct cgroup_subsys_state, sibling); + 3840. } else if (likely(!(pos->flags & CSS_RELEASED))) { + 3841. > next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + 3842. } else { + 3843. list_for_each_entry_rcu(next, &parent->children, sibling) + +kernel/cgroup/cgroup.c:3843: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3841. next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + 3842. } else { + 3843. > list_for_each_entry_rcu(next, &parent->children, sibling) + 3844. if (next->serial_nr > pos->serial_nr) + 3845. break; + +net/core/dev.c:3826: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3824. + 3825. rcu_read_lock(); + 3826. > fl = rcu_dereference(sd->flow_limit); + 3827. if (fl) { + 3828. new_flow = skb_get_hash(skb) & (fl->num_buckets - 1); + +drivers/ata/libata-core.c:3828: error: DEAD_STORE + The value written to &deadline (type unsigned long) is never used. + 3826. t = ata_deadline(jiffies, params[2]); + 3827. if (time_before(t, deadline)) + 3828. > deadline = t; + 3829. + 3830. if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) + +drivers/ata/libata-core.c:3834: error: DEAD_STORE + The value written to &last (type unsigned int) is never used. + 3832. cur &= 0xf; + 3833. + 3834. > last = cur; + 3835. last_jiffies = jiffies; + 3836. + +drivers/ata/libata-core.c:3835: error: DEAD_STORE + The value written to &last_jiffies (type unsigned long) is never used. + 3833. + 3834. last = cur; + 3835. > last_jiffies = jiffies; + 3836. + 3837. while (1) { + +net/packet/af_packet.c:3874: error: DEAD_STORE + The value written to &val (type int) is never used. + 3872. break; + 3873. case PACKET_AUXDATA: + 3874. > val = po->auxdata; + 3875. break; + 3876. case PACKET_ORIGDEV: + +net/packet/af_packet.c:3877: error: DEAD_STORE + The value written to &val (type int) is never used. + 3875. break; + 3876. case PACKET_ORIGDEV: + 3877. > val = po->origdev; + 3878. break; + 3879. case PACKET_VNET_HDR: + +net/packet/af_packet.c:3880: error: DEAD_STORE + The value written to &val (type int) is never used. + 3878. break; + 3879. case PACKET_VNET_HDR: + 3880. > val = po->has_vnet_hdr; + 3881. break; + 3882. case PACKET_VERSION: + +net/packet/af_packet.c:3883: error: DEAD_STORE + The value written to &val (type int) is never used. + 3881. break; + 3882. case PACKET_VERSION: + 3883. > val = po->tp_version; + 3884. break; + 3885. case PACKET_HDRLEN: + +net/packet/af_packet.c:3894: error: DEAD_STORE + The value written to &val (type int) is never used. + 3892. switch (val) { + 3893. case TPACKET_V1: + 3894. > val = sizeof(struct tpacket_hdr); + 3895. break; + 3896. case TPACKET_V2: + +net/packet/af_packet.c:3897: error: DEAD_STORE + The value written to &val (type int) is never used. + 3895. break; + 3896. case TPACKET_V2: + 3897. > val = sizeof(struct tpacket2_hdr); + 3898. break; + 3899. case TPACKET_V3: + +net/packet/af_packet.c:3900: error: DEAD_STORE + The value written to &val (type int) is never used. + 3898. break; + 3899. case TPACKET_V3: + 3900. > val = sizeof(struct tpacket3_hdr); + 3901. break; + 3902. default: + +net/packet/af_packet.c:3907: error: DEAD_STORE + The value written to &val (type int) is never used. + 3905. break; + 3906. case PACKET_RESERVE: + 3907. > val = po->tp_reserve; + 3908. break; + 3909. case PACKET_LOSS: + +net/packet/af_packet.c:3910: error: DEAD_STORE + The value written to &val (type int) is never used. + 3908. break; + 3909. case PACKET_LOSS: + 3910. > val = po->tp_loss; + 3911. break; + 3912. case PACKET_TIMESTAMP: + +net/packet/af_packet.c:3913: error: DEAD_STORE + The value written to &val (type int) is never used. + 3911. break; + 3912. case PACKET_TIMESTAMP: + 3913. > val = po->tp_tstamp; + 3914. break; + 3915. case PACKET_FANOUT: + +net/packet/af_packet.c:3916: error: DEAD_STORE + The value written to &val (type int) is never used. + 3914. break; + 3915. case PACKET_FANOUT: + 3916. > val = (po->fanout ? + 3917. ((u32)po->fanout->id | + 3918. ((u32)po->fanout->type << 16) | + +net/packet/af_packet.c:3932: error: DEAD_STORE + The value written to &val (type int) is never used. + 3930. break; + 3931. case PACKET_TX_HAS_OFF: + 3932. > val = po->tp_tx_has_off; + 3933. break; + 3934. case PACKET_QDISC_BYPASS: + +net/packet/af_packet.c:3935: error: DEAD_STORE + The value written to &val (type int) is never used. + 3933. break; + 3934. case PACKET_QDISC_BYPASS: + 3935. > val = packet_use_direct_xmit(po); + 3936. break; + 3937. default: + +drivers/net/ethernet/intel/e1000/e1000_main.c:3856: error: DEAD_STORE + The value written to &hw (type e1000_hw*) is never used. + 3854. struct e1000_tx_ring *tx_ring) + 3855. { + 3856. > struct e1000_hw *hw = &adapter->hw; + 3857. struct net_device *netdev = adapter->netdev; + 3858. struct e1000_tx_desc *tx_desc, *eop_desc; + +drivers/net/ethernet/intel/e1000/e1000_main.c:3906: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3904. + 3905. #define TX_WAKE_THRESHOLD 32 + 3906. > if (unlikely(count && netif_carrier_ok(netdev) && + 3907. E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) { + 3908. /* Make sure that anybody stopping the queue after this + +net/ipv6/route.c:3897: error: DEAD_STORE + The value written to &err (type int) is never used. + 3895. int remaining; + 3896. int attrlen; + 3897. > int err = 1, last_err = 0; + 3898. + 3899. remaining = cfg->fc_mp_len; + +kernel/rcu/tree.c:3913: error: DEAD_STORE + The value written to &nbits (type int) is never used. + 3911. rnp->expmaskinitnext |= mask; + 3912. oldmask ^= rnp->expmaskinitnext; + 3913. > nbits = bitmap_weight(&oldmask, BITS_PER_LONG); + 3914. /* Allow lockless access for expedited grace periods. */ + 3915. smp_store_release(&rsp->ncpus, rsp->ncpus + nbits); /* ^^^ */ + +kernel/module.c:3903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3901. unsigned int i, best = 0; + 3902. unsigned long nextval; + 3903. > struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms); + 3904. + 3905. /* At worse, next value is at end of module */ + +kernel/workqueue.c:4040: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4038. + 4039. mutex_lock(&wq->mutex); + 4040. > for_each_pwq(pwq, wq) + 4041. pwq_adjust_max_active(pwq); + 4042. mutex_unlock(&wq->mutex); + +kernel/module.c:3974: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3972. + 3973. preempt_disable(); + 3974. > list_for_each_entry_rcu(mod, &modules, list) { + 3975. if (mod->state == MODULE_STATE_UNFORMED) + 3976. continue; + +drivers/iommu/intel-iommu.c:3977: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3975. int i; + 3976. + 3977. > for_each_drhd_unit(drhd) { + 3978. if (!drhd->include_all) { + 3979. for_each_active_dev_scope(drhd->devices, + +drivers/iommu/intel-iommu.c:3979: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3977. for_each_drhd_unit(drhd) { + 3978. if (!drhd->include_all) { + 3979. > for_each_active_dev_scope(drhd->devices, + 3980. drhd->devices_cnt, i, dev) + 3981. break; + +drivers/iommu/intel-iommu.c:3988: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3986. } + 3987. + 3988. > for_each_active_drhd_unit(drhd) { + 3989. if (drhd->include_all) + 3990. continue; + +drivers/iommu/intel-iommu.c:3992: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3990. continue; + 3991. + 3992. > for_each_active_dev_scope(drhd->devices, + 3993. drhd->devices_cnt, i, dev) + 3994. if (!dev_is_pci(dev) || !IS_GFX_DEVICE(to_pci_dev(dev))) + +drivers/iommu/intel-iommu.c:4005: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4003. } else { + 4004. drhd->ignored = 1; + 4005. > for_each_active_dev_scope(drhd->devices, + 4006. drhd->devices_cnt, i, dev) + 4007. dev->archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO; + +net/packet/af_packet.c:3980: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3978. + 3979. rcu_read_lock(); + 3980. > sk_for_each_rcu(sk, &net->packet.sklist) { + 3981. struct packet_sock *po = pkt_sk(sk); + 3982. + +net/core/dev.c:3990: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3988. + 3989. txq = netdev_pick_tx(dev, skb, NULL); + 3990. > cpu = smp_processor_id(); + 3991. HARD_TX_LOCK(dev, txq, cpu); + 3992. if (!netif_xmit_stopped(txq)) { + +net/core/dev.c:3990: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3988. + 3989. txq = netdev_pick_tx(dev, skb, NULL); + 3990. > cpu = smp_processor_id(); + 3991. HARD_TX_LOCK(dev, txq, cpu); + 3992. if (!netif_xmit_stopped(txq)) { + +drivers/tty/vt/vt.c:3993: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3991. console_lock(); + 3992. for (i = k = 0; i < 16; i++) { + 3993. > default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + +drivers/tty/vt/vt.c:3994: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3992. for (i = k = 0; i < 16; i++) { + 3993. default_red[i] = colormap[k++]; + 3994. > default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + 3996. } + +drivers/tty/vt/vt.c:3995: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3993. default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. > default_blu[i] = colormap[k++]; + 3996. } + 3997. for (i = 0; i < MAX_NR_CONSOLES; i++) { + +kernel/module.c:3999: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3997. + 3998. preempt_disable(); + 3999. > list_for_each_entry_rcu(mod, &modules, list) { + 4000. if (mod->state == MODULE_STATE_UNFORMED) + 4001. continue; + +net/core/rtnetlink.c:4099: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4097. + 4098. rcu_read_lock(); + 4099. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 4100. if (af_ops->fill_stats_af) { + 4101. struct nlattr *af; + +kernel/sched/core.c:4008: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4006. + 4007. rcu_read_lock(); + 4008. > pcred = __task_cred(p); + 4009. match = (uid_eq(cred->euid, pcred->euid) || + 4010. uid_eq(cred->euid, pcred->uid)); + +drivers/iommu/intel-iommu.c:4018: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4016. struct intel_iommu *iommu = NULL; + 4017. + 4018. > for_each_active_iommu(iommu, drhd) + 4019. if (iommu->qi) + 4020. dmar_reenable_qi(iommu); + +drivers/iommu/intel-iommu.c:4022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4020. dmar_reenable_qi(iommu); + 4021. + 4022. > for_each_iommu(iommu, drhd) { + 4023. if (drhd->ignored) { + 4024. /* + +kernel/module.c:4027: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4025. + 4026. preempt_disable(); + 4027. > list_for_each_entry_rcu(mod, &modules, list) { + 4028. struct mod_kallsyms *kallsyms; + 4029. + +kernel/module.c:4032: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4030. if (mod->state == MODULE_STATE_UNFORMED) + 4031. continue; + 4032. > kallsyms = rcu_dereference_sched(mod->kallsyms); + 4033. if (symnum < kallsyms->num_symtab) { + 4034. *value = kallsyms->symtab[symnum].st_value; + +drivers/gpu/drm/i915/i915_gem.c:4038: error: DEAD_STORE + The value written to &recent_enough (type unsigned long) is never used. + 4036. struct drm_i915_private *dev_priv = to_i915(dev); + 4037. struct drm_i915_file_private *file_priv = file->driver_priv; + 4038. > unsigned long recent_enough = jiffies - DRM_I915_THROTTLE_JIFFIES; + 4039. struct drm_i915_gem_request *request, *target = NULL; + 4040. long ret; + +net/core/dev.c:4048: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4046. preempt_disable(); + 4047. rcu_read_lock(); + 4048. > ret = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb); + 4049. rcu_read_unlock(); + 4050. preempt_enable(); + +net/core/dev.c:4070: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4068. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4069. if (cpu < 0) + 4070. > cpu = smp_processor_id(); + 4071. + 4072. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4081: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4079. unsigned int qtail; + 4080. + 4081. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4082. put_cpu(); + 4083. } + +net/core/dev.c:4070: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4068. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4069. if (cpu < 0) + 4070. > cpu = smp_processor_id(); + 4071. + 4072. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4081: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4079. unsigned int qtail; + 4080. + 4081. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4082. put_cpu(); + 4083. } + +drivers/iommu/intel-iommu.c:4052: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4050. struct intel_iommu *iommu; + 4051. + 4052. > for_each_active_iommu(iommu, drhd) { + 4053. iommu->flush.flush_context(iommu, 0, 0, 0, + 4054. DMA_CCMD_GLOBAL_INVL); + +kernel/module.c:4051: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4049. { + 4050. unsigned int i; + 4051. > struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms); + 4052. + 4053. for (i = 0; i < kallsyms->num_symtab; i++) + +drivers/tty/vt/vt.c:4060: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4058. { + 4059. struct console_font font; + 4060. > int rc = -EINVAL; + 4061. int c; + 4062. + +drivers/tty/vt/vt.c:4101: error: UNINITIALIZED_VALUE + The value read from font.charcount was never initialized. + 4099. op->height = font.height; + 4100. op->width = font.width; + 4101. > op->charcount = font.charcount; + 4102. + 4103. if (op->data && copy_to_user(op->data, font.data, c)) + +drivers/tty/vt/vt.c:4099: error: UNINITIALIZED_VALUE + The value read from font.height was never initialized. + 4097. goto out; + 4098. + 4099. > op->height = font.height; + 4100. op->width = font.width; + 4101. op->charcount = font.charcount; + +drivers/tty/vt/vt.c:4100: error: UNINITIALIZED_VALUE + The value read from font.width was never initialized. + 4098. + 4099. op->height = font.height; + 4100. > op->width = font.width; + 4101. op->charcount = font.charcount; + 4102. + +drivers/iommu/intel-iommu.c:4066: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4064. unsigned long flag; + 4065. + 4066. > for_each_active_iommu(iommu, drhd) { + 4067. iommu->iommu_state = kzalloc(sizeof(u32) * MAX_SR_DMAR_REGS, + 4068. GFP_ATOMIC); + +drivers/iommu/intel-iommu.c:4075: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4073. iommu_flush_all(); + 4074. + 4075. > for_each_active_iommu(iommu, drhd) { + 4076. iommu_disable_translation(iommu); + 4077. + +drivers/iommu/intel-iommu.c:4094: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4092. + 4093. nomem: + 4094. > for_each_active_iommu(iommu, drhd) + 4095. kfree(iommu->iommu_state); + 4096. + +kernel/module.c:4073: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4071. ret = mod_find_symname(mod, colon+1); + 4072. } else { + 4073. > list_for_each_entry_rcu(mod, &modules, list) { + 4074. if (mod->state == MODULE_STATE_UNFORMED) + 4075. continue; + +kernel/workqueue.c:4076: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4074. /* sanity checks */ + 4075. mutex_lock(&wq->mutex); + 4076. > for_each_pwq(pwq, wq) { + 4077. int i; + 4078. + +kernel/workqueue.c:4123: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4121. */ + 4122. for_each_node(node) { + 4123. > pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]); + 4124. RCU_INIT_POINTER(wq->numa_pwq_tbl[node], NULL); + 4125. put_pwq_unlocked(pwq); + +drivers/gpu/drm/i915/intel_pm.c:4109: error: DEAD_STORE + The value written to &src_h (type unsigned int) is never used. + 4107. if (fb->format->format == DRM_FORMAT_NV12 && !y) { + 4108. src_w /= 2; + 4109. > src_h /= 2; + 4110. } + 4111. + +drivers/iommu/intel-iommu.c:4114: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4112. } + 4113. + 4114. > for_each_active_iommu(iommu, drhd) { + 4115. + 4116. raw_spin_lock_irqsave(&iommu->register_lock, flag); + +drivers/iommu/intel-iommu.c:4130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4128. } + 4129. + 4130. > for_each_active_iommu(iommu, drhd) + 4131. kfree(iommu->iommu_state); + 4132. } + +net/ipv6/addrconf.c:4116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4114. + 4115. for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) { + 4116. > hlist_for_each_entry_rcu(ifa, &inet6_addr_lst[state->bucket], + 4117. addr_lst) { + 4118. if (!net_eq(dev_net(ifa->idev->dev), net)) + +net/core/dev.c:4118: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4116. preempt_disable(); + 4117. err = netif_rx_internal(skb); + 4118. > if (local_softirq_pending()) + 4119. do_softirq(); + 4120. preempt_enable(); + +drivers/tty/vt/vt.c:4114: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4112. { + 4113. struct console_font font; + 4114. > int rc = -EINVAL; + 4115. int size; + 4116. + +net/ipv6/addrconf.c:4142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4140. struct net *net = seq_file_net(seq); + 4141. + 4142. > hlist_for_each_entry_continue_rcu(ifa, addr_lst) { + 4143. if (!net_eq(dev_net(ifa->idev->dev), net)) + 4144. continue; + +net/ipv6/addrconf.c:4151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4149. while (++state->bucket < IN6_ADDR_HSIZE) { + 4150. state->offset = 0; + 4151. > hlist_for_each_entry_rcu(ifa, + 4152. &inet6_addr_lst[state->bucket], addr_lst) { + 4153. if (!net_eq(dev_net(ifa->idev->dev), net)) + +kernel/events/core.c:4149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4147. * owner->perf_event_mutex. + 4148. */ + 4149. > owner = READ_ONCE(event->owner); + 4150. if (owner) { + 4151. /* + +net/core/rtnetlink.c:4191: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4189. + 4190. rcu_read_lock(); + 4191. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 4192. if (af_ops->get_stats_af_size) { + 4193. size += nla_total_size( + +kernel/workqueue.c:4164: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4162. wq->saved_max_active = max_active; + 4163. + 4164. > for_each_pwq(pwq, wq) + 4165. pwq_adjust_max_active(pwq); + 4166. + +drivers/net/ethernet/intel/e1000/e1000_main.c:4331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4329. rx_ring->next_to_clean = i; + 4330. + 4331. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4332. if (cleaned_count) + 4333. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +kernel/sched/fair.c:4188: error: NULL_DEREFERENCE + pointer `se` last assigned on line 4187 could be null and is dereferenced at line 4188, column 27. + 4186. + 4187. se = __pick_first_entity(cfs_rq); + 4188. > delta = curr->vruntime - se->vruntime; + 4189. + 4190. if (delta < 0) + +drivers/iommu/intel-iommu.c:4193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4191. struct acpi_dmar_atsr *tmp; + 4192. + 4193. > list_for_each_entry_rcu(atsru, &dmar_atsr_units, list) { + 4194. tmp = (struct acpi_dmar_atsr *)atsru->hdr; + 4195. if (atsr->segment != tmp->segment) + +drivers/usb/core/hub.c:4197: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 4195 could be null and is dereferenced by call to `hub_port_disable()` at line 4197, column 9. + 4195. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 4196. + 4197. > return hub_port_disable(hub, udev->portnum, 0); + 4198. } + 4199. + +net/core/dev.c:4198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4196. { + 4197. #ifdef CONFIG_NET_CLS_ACT + 4198. > struct mini_Qdisc *miniq = rcu_dereference_bh(skb->dev->miniq_ingress); + 4199. struct tcf_result cl_res; + 4200. + +kernel/events/core.c:4247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4245. * comment with perf_event_ctx_lock_nested(). + 4246. */ + 4247. > ctx = READ_ONCE(child->ctx); + 4248. /* + 4249. * Since child_mutex nests inside ctx::mutex, we must jump + +kernel/events/core.c:4272: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4270. * and we can continue doing so. + 4271. */ + 4272. > tmp = list_first_entry_or_null(&event->child_list, + 4273. struct perf_event, child_list); + 4274. if (tmp == child) { + +net/packet/af_packet.c:4208: error: DEAD_STORE + The value written to &err (type int) is never used. + 4206. struct sk_buff_head *rb_queue; + 4207. __be16 num; + 4208. > int err = -EINVAL; + 4209. /* Added to avoid minimal code churn */ + 4210. struct tpacket_req *req = &req_u->req; + +kernel/workqueue.c:4212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4210. + 4211. if (cpu == WORK_CPU_UNBOUND) + 4212. > cpu = smp_processor_id(); + 4213. + 4214. if (!(wq->flags & WQ_UNBOUND)) + +kernel/workqueue.c:4212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4210. + 4211. if (cpu == WORK_CPU_UNBOUND) + 4212. > cpu = smp_processor_id(); + 4213. + 4214. if (!(wq->flags & WQ_UNBOUND)) + +drivers/usb/core/hub.c:4250: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4248. } + 4249. + 4250. > dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n", + 4251. total_time, stable_time, portstatus); + 4252. + +drivers/usb/core/hub.c:4255: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4253. if (stable_time < HUB_DEBOUNCE_STABLE) + 4254. return -ETIMEDOUT; + 4255. > return portstatus; + 4256. } + 4257. + +drivers/gpu/drm/i915/i915_gem.c:4252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4250. + 4251. /* Translate the exclusive fence to the READ *and* WRITE engine */ + 4252. > args->busy = busy_check_writer(rcu_dereference(obj->resv->fence_excl)); + 4253. + 4254. /* Translate shared fences to READ set of engines */ + +drivers/gpu/drm/i915/i915_gem.c:4255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4253. + 4254. /* Translate shared fences to READ set of engines */ + 4255. > list = rcu_dereference(obj->resv->fence); + 4256. if (list) { + 4257. unsigned int shared_count = list->shared_count, i; + +drivers/gpu/drm/i915/i915_gem.c:4261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4259. for (i = 0; i < shared_count; ++i) { + 4260. struct dma_fence *fence = + 4261. > rcu_dereference(list->shared[i]); + 4262. + 4263. args->busy |= busy_check_reader(fence); + +drivers/gpu/drm/i915/intel_display.c:4243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4241. struct drm_crtc_commit *commit; + 4242. spin_lock(&crtc->commit_lock); + 4243. > commit = list_first_entry_or_null(&crtc->commit_list, + 4244. struct drm_crtc_commit, commit_entry); + 4245. cleanup_done = commit ? + +net/core/filter.c:4266: error: DEAD_STORE + The value written to &insn (type bpf_insn*) is never used. + 4264. struct bpf_prog *prog, u32 *target_size) + 4265. { + 4266. > struct bpf_insn *insn = insn_buf; + 4267. + 4268. switch (si->off) { + +net/core/filter.c:4270: error: NULL_DEREFERENCE + pointer `insn` last assigned on line 4270 could be null and is dereferenced at line 4270, column 13. + 4268. switch (si->off) { + 4269. case offsetof(struct __sk_buff, ifindex): + 4270. > *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, dev), + 4271. si->dst_reg, si->src_reg, + 4272. offsetof(struct sk_buff, dev)); + +drivers/iommu/intel-iommu.c:4281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4279. + 4280. if (!atsru->include_all && atsru->devices && atsru->devices_cnt) { + 4281. > for_each_active_dev_scope(atsru->devices, atsru->devices_cnt, + 4282. i, dev) + 4283. return -EBUSY; + +net/ipv6/addrconf.c:4290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4288. for (i = 0; i < IN6_ADDR_HSIZE; i++) { + 4289. restart: + 4290. > hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) { + 4291. unsigned long age; + 4292. + +drivers/gpu/drm/i915/intel_display.c:4315: error: UNINITIALIZED_VALUE + The value read from divsel was never initialized. + 4313. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4314. + 4315. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4316. clock, + 4317. auxdiv, + +drivers/gpu/drm/i915/intel_display.c:4315: error: UNINITIALIZED_VALUE + The value read from phaseinc was never initialized. + 4313. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4314. + 4315. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4316. clock, + 4317. auxdiv, + +drivers/net/ethernet/marvell/sky2.c:4282: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 4280. static int sky2_vpd_wait(const struct sky2_hw *hw, int cap, u16 busy) + 4281. { + 4282. > unsigned long start = jiffies; + 4283. + 4284. while ( (sky2_pci_read16(hw, cap + PCI_VPD_ADDR) & PCI_VPD_ADDR_F) == busy) { + +net/ipv4/tcp_input.c:4341: error: UNINITIALIZED_VALUE + The value read from fragstolen was never initialized. + 4339. __skb_queue_tail(&sk->sk_receive_queue, skb); + 4340. else + 4341. > kfree_skb_partial(skb, fragstolen); + 4342. + 4343. if (unlikely(fin)) { + +kernel/cgroup/cgroup.c:4320: error: NULL_DEREFERENCE + pointer `com_cgrp` last assigned on line 4321 could be null and is dereferenced by call to `cgroup_is_descendant()` at line 4320, column 10. + 4318. + 4319. /* find the common ancestor */ + 4320. > while (!cgroup_is_descendant(dst_cgrp, com_cgrp)) + 4321. com_cgrp = cgroup_parent(com_cgrp); + 4322. + +net/core/rtnetlink.c:4345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4343. + 4344. rcu_read_lock(); + 4345. > handlers = rcu_dereference(rtnl_msg_handlers[family]); + 4346. if (!handlers) { + 4347. family = PF_UNSPEC; + +net/core/rtnetlink.c:4348: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4346. if (!handlers) { + 4347. family = PF_UNSPEC; + 4348. > handlers = rcu_dereference(rtnl_msg_handlers[family]); + 4349. } + 4350. + +net/core/rtnetlink.c:4356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4354. u16 min_dump_alloc = 0; + 4355. + 4356. > dumpit = READ_ONCE(handlers[type].dumpit); + 4357. if (!dumpit) { + 4358. family = PF_UNSPEC; + +net/core/rtnetlink.c:4359: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4357. if (!dumpit) { + 4358. family = PF_UNSPEC; + 4359. > handlers = rcu_dereference(rtnl_msg_handlers[PF_UNSPEC]); + 4360. if (!handlers) + 4361. goto err_unlock; + +net/core/rtnetlink.c:4363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4361. goto err_unlock; + 4362. + 4363. > dumpit = READ_ONCE(handlers[type].dumpit); + 4364. if (!dumpit) + 4365. goto err_unlock; + +net/core/rtnetlink.c:4387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4385. } + 4386. + 4387. > doit = READ_ONCE(handlers[type].doit); + 4388. if (!doit) { + 4389. family = PF_UNSPEC; + +net/core/rtnetlink.c:4390: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4388. if (!doit) { + 4389. family = PF_UNSPEC; + 4390. > handlers = rcu_dereference(rtnl_msg_handlers[family]); + 4391. } + 4392. + +net/core/rtnetlink.c:4393: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4391. } + 4392. + 4393. > flags = READ_ONCE(handlers[type].flags); + 4394. if (flags & RTNL_FLAG_DOIT_UNLOCKED) { + 4395. refcount_inc(&rtnl_msg_handlers_ref[family]); + +net/core/rtnetlink.c:4396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4394. if (flags & RTNL_FLAG_DOIT_UNLOCKED) { + 4395. refcount_inc(&rtnl_msg_handlers_ref[family]); + 4396. > doit = READ_ONCE(handlers[type].doit); + 4397. rcu_read_unlock(); + 4398. if (doit) + +net/core/rtnetlink.c:4409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4407. handlers = rtnl_dereference(rtnl_msg_handlers[family]); + 4408. if (handlers) { + 4409. > doit = READ_ONCE(handlers[type].doit); + 4410. if (doit) + 4411. err = doit(skb, nlh, extack); + +kernel/module.c:4352: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4350. /* Most callers should already have preempt disabled, but make sure */ + 4351. preempt_disable(); + 4352. > list_for_each_entry_rcu(mod, &modules, list) { + 4353. if (mod->state == MODULE_STATE_UNFORMED) + 4354. continue; + +net/core/dev.c:4393: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4391. goto skip_taps; + 4392. + 4393. > list_for_each_entry_rcu(ptype, &ptype_all, list) { + 4394. if (pt_prev) + 4395. ret = deliver_skb(skb, pt_prev, orig_dev); + +net/core/dev.c:4399: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4397. } + 4398. + 4399. > list_for_each_entry_rcu(ptype, &skb->dev->ptype_all, list) { + 4400. if (pt_prev) + 4401. ret = deliver_skb(skb, pt_prev, orig_dev); + +net/core/dev.c:4432: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4430. } + 4431. + 4432. > rx_handler = rcu_dereference(skb->dev->rx_handler); + 4433. if (rx_handler) { + 4434. if (pt_prev) { + +drivers/net/ethernet/intel/e1000e/netdev.c:4374: error: DEAD_STORE + The value written to &temp (type unsigned long long) is never used. + 4372. temp = time_delta; + 4373. /* VMWare users have seen incvalue of zero, don't div / 0 */ + 4374. > rem = incvalue ? do_div(temp, incvalue) : (time_delta != 0); + 4375. + 4376. systim = systim_next; + +drivers/net/ethernet/intel/e1000/e1000_main.c:4504: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4502. rx_ring->next_to_clean = i; + 4503. + 4504. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4505. if (cleaned_count) + 4506. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +drivers/gpu/drm/i915/i915_gem.c:4442: error: NULL_DEREFERENCE + pointer `obj->base.filp` last assigned on line 4431 could be null and is dereferenced at line 4442, column 12. + 4440. } + 4441. + 4442. > mapping = obj->base.filp->f_mapping; + 4443. mapping_set_gfp_mask(mapping, mask); + 4444. GEM_BUG_ON(!(mapping_gfp_mask(mapping) & __GFP_RECLAIM)); + +drivers/iommu/intel-iommu.c:4434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4432. + 4433. rcu_read_lock(); + 4434. > list_for_each_entry_rcu(atsru, &dmar_atsr_units, list) { + 4435. atsr = container_of(atsru->hdr, struct acpi_dmar_atsr, header); + 4436. if (atsr->segment != pci_domain_nr(dev->bus)) + +drivers/iommu/intel-iommu.c:4439: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4437. continue; + 4438. + 4439. > for_each_dev_scope(atsru->devices, atsru->devices_cnt, i, tmp) + 4440. if (tmp == &bridge->dev) + 4441. goto out; + +kernel/workqueue.c:4447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4445. pr_info("Showing busy workqueues and worker pools:\n"); + 4446. + 4447. > list_for_each_entry_rcu(wq, &workqueues, list) { + 4448. struct pool_workqueue *pwq; + 4449. bool idle = true; + +kernel/workqueue.c:4451: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4449. bool idle = true; + 4450. + 4451. > for_each_pwq(pwq, wq) { + 4452. if (pwq->nr_active || !list_empty(&pwq->delayed_works)) { + 4453. idle = false; + +kernel/workqueue.c:4462: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4460. pr_info("workqueue %s: flags=0x%x\n", wq->name, wq->flags); + 4461. + 4462. > for_each_pwq(pwq, wq) { + 4463. spin_lock_irqsave(&pwq->pool->lock, flags); + 4464. if (pwq->nr_active || !list_empty(&pwq->delayed_works)) + +drivers/md/md.c:4478: error: DEAD_STORE + The value written to &namelen (type unsigned long) is never used. + 4476. mddev->metadata_type[namelen] = 0; + 4477. if (namelen && mddev->metadata_type[namelen-1] == '\n') + 4478. > mddev->metadata_type[--namelen] = 0; + 4479. mddev->persistent = 0; + 4480. mddev->external = 1; + +drivers/iommu/intel-iommu.c:4584: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4582. + 4583. rcu_read_lock(); + 4584. > for_each_active_iommu(iommu, drhd) + 4585. iommu_flush_iotlb_psi(iommu, si_domain, + 4586. iova->pfn_lo, iova_size(iova), + +net/ipv6/addrconf.c:4548: error: DEAD_STORE + The value written to &preferred_lft (type unsigned int) is never used. + 4546. struct inet6_ifaddr *ifa; + 4547. struct net_device *dev; + 4548. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4549. u32 ifa_flags; + 4550. int err; + +net/ipv6/addrconf.c:4548: error: DEAD_STORE + The value written to &valid_lft (type unsigned int) is never used. + 4546. struct inet6_ifaddr *ifa; + 4547. struct net_device *dev; + 4548. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4549. u32 ifa_flags; + 4550. int err; + +drivers/ata/libata-scsi.c:4613: error: UNINITIALIZED_VALUE + The value read from dev was never initialized. + 4611. if (dev != last_failed_dev) { + 4612. msleep(100); + 4613. > last_failed_dev = dev; + 4614. goto repeat; + 4615. } + +kernel/workqueue.c:4637: error: DEAD_STORE + The value written to &worker_flags (type unsigned int) is never used. + 4635. WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND)); + 4636. worker_flags |= WORKER_REBOUND; + 4637. > worker_flags &= ~WORKER_UNBOUND; + 4638. WRITE_ONCE(worker->flags, worker_flags); + 4639. } + +net/core/dev.c:4601: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4599. preempt_disable(); + 4600. rcu_read_lock(); + 4601. > ret = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb); + 4602. rcu_read_unlock(); + 4603. preempt_enable(); + +drivers/gpu/drm/i915/intel_display.c:4595: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4593. u32 temp; + 4594. + 4595. > temp = I915_READ(dslreg); + 4596. udelay(500); + 4597. if (wait_for(I915_READ(dslreg) != temp, 5)) { + +drivers/gpu/drm/i915/intel_display.c:4597: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 4595. temp = I915_READ(dslreg); + 4596. udelay(500); + 4597. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4598. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4599. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4598: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 4596. udelay(500); + 4597. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4598. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4599. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4600. } + +kernel/sched/core.c:4659: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4657. if (!check_same_owner(p)) { + 4658. rcu_read_lock(); + 4659. > if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) { + 4660. rcu_read_unlock(); + 4661. goto out_free_new_mask; + +drivers/iommu/intel-iommu.c:4638: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4636. struct dmar_drhd_unit *drhd; + 4637. + 4638. > for_each_iommu(iommu, drhd) + 4639. iommu_disable_translation(iommu); + 4640. } + +kernel/events/core.c:4726: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4724. + 4725. rcu_read_lock(); + 4726. > rb = rcu_dereference(event->rb); + 4727. if (!rb || !rb->nr_pages) { + 4728. rcu_read_unlock(); + +net/core/dev.c:4714: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4712. + 4713. rcu_read_lock(); + 4714. > list_for_each_entry_rcu(ptype, head, list) { + 4715. if (ptype->type != type || !ptype->callbacks.gro_complete) + 4716. continue; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4705: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4703. volatile u32 temp; + 4704. + 4705. > temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4706: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4704. + 4705. temp = er32(CRCERRS); + 4706. > temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4707: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4705. temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. > temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4708: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. > temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4709: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. > temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4710: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. > temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4711: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. > temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4712: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. > temp = er32(COLC); + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4713: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. > temp = er32(DC); + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4714: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + 4714. > temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4715: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + 4715. > temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4716: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. > temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4717: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. > temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4718: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. > temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4719: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. > temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + 4721. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4720: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. > temp = er32(FCRUC); + 4721. + 4722. temp = er32(PRC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4722: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4720. temp = er32(FCRUC); + 4721. + 4722. > temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4723: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4721. + 4722. temp = er32(PRC64); + 4723. > temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4724: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4722. temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. > temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4725: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. > temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4726: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. > temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + 4728. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4727: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. > temp = er32(PRC1522); + 4728. + 4729. temp = er32(GPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4729: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4727. temp = er32(PRC1522); + 4728. + 4729. > temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4730: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4728. + 4729. temp = er32(GPRC); + 4730. > temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4731: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4729. temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. > temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4732: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. > temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4733: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. > temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4734: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. > temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4735: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. > temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4736: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. > temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4737: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. > temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4738: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. > temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4739: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. > temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4740: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. > temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4741: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. > temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4742: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. > temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4743: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. > temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4744: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. > temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4745: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. > temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. temp = er32(TPT); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4746: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. > temp = er32(TPR); + 4747. temp = er32(TPT); + 4748. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4747: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. > temp = er32(TPT); + 4748. + 4749. temp = er32(PTC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4749: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4747. temp = er32(TPT); + 4748. + 4749. > temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4750: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4748. + 4749. temp = er32(PTC64); + 4750. > temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4751: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4749. temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. > temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4752: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. > temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4753: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. > temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + 4755. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4754: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. > temp = er32(PTC1522); + 4755. + 4756. temp = er32(MPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4756: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4754. temp = er32(PTC1522); + 4755. + 4756. > temp = er32(MPTC); + 4757. temp = er32(BPTC); + 4758. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4757: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4755. + 4756. temp = er32(MPTC); + 4757. > temp = er32(BPTC); + 4758. + 4759. if (hw->mac_type < e1000_82543) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4762: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4760. return; + 4761. + 4762. > temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4763: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4761. + 4762. temp = er32(ALGNERRC); + 4763. > temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4764: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4762. temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. > temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4765: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. > temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4766: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. > temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + 4768. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4767: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. > temp = er32(TSCTFC); + 4768. + 4769. if (hw->mac_type <= e1000_82544) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4772: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4770. return; + 4771. + 4772. > temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4773: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4771. + 4772. temp = er32(MGTPRC); + 4773. > temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + 4775. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4774: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4772. temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. > temp = er32(MGTPTC); + 4775. } + 4776. + +drivers/pci/quirks.c:4781: error: DEAD_STORE + The value written to &i (type int) is never used. + 4779. pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &cap[i++]); + 4780. pcie_capability_read_word(pdev, PCI_EXP_LNKCTL2, &cap[i++]); + 4781. > pcie_capability_read_word(pdev, PCI_EXP_SLTCTL2, &cap[i++]); + 4782. hlist_add_head(&state->next, &pdev->saved_cap_space); + 4783. } + +kernel/workqueue.c:4717: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4715. + 4716. /* unbinding per-cpu workers should happen on the local CPU */ + 4717. > if (WARN_ON(cpu != smp_processor_id())) + 4718. return -1; + 4719. + +drivers/iommu/intel-iommu.c:4774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4772. */ + 4773. if (intel_iommu_tboot_noforce) { + 4774. > for_each_iommu(iommu, drhd) + 4775. iommu_disable_protect_mem_regions(iommu); + 4776. } + +drivers/iommu/intel-iommu.c:4818: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4816. init_iommu_pm_ops(); + 4817. + 4818. > for_each_active_iommu(iommu, drhd) { + 4819. iommu_device_sysfs_add(&iommu->iommu, NULL, + 4820. intel_iommu_groups, + +kernel/workqueue.c:4818: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4816. list_for_each_entry(wq, &workqueues, list) { + 4817. mutex_lock(&wq->mutex); + 4818. > for_each_pwq(pwq, wq) + 4819. pwq_adjust_max_active(pwq); + 4820. mutex_unlock(&wq->mutex); + +net/core/dev.c:4849: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4847. + 4848. rcu_read_lock(); + 4849. > list_for_each_entry_rcu(ptype, head, list) { + 4850. if (ptype->type != type || !ptype->callbacks.gro_receive) + 4851. continue; + +kernel/events/core.c:4841: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4839. + 4840. rcu_read_lock(); + 4841. > rb = rcu_dereference(event->rb); + 4842. if (!rb) + 4843. goto unlock; + +net/ipv6/addrconf.c:4855: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4853. idx = 0; + 4854. head = &net->dev_index_head[h]; + 4855. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 4856. if (idx < s_idx) + 4857. goto cont; + +kernel/workqueue.c:4857: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4855. */ + 4856. rcu_read_lock_sched(); + 4857. > for_each_pwq(pwq, wq) { + 4858. WARN_ON_ONCE(pwq->nr_active < 0); + 4859. if (pwq->nr_active) { + +kernel/events/core.c:4874: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4872. + 4873. rcu_read_lock(); + 4874. > rb = rcu_dereference(event->rb); + 4875. if (!rb) + 4876. goto unlock; + +kernel/workqueue.c:4896: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4894. list_for_each_entry(wq, &workqueues, list) { + 4895. mutex_lock(&wq->mutex); + 4896. > for_each_pwq(pwq, wq) + 4897. pwq_adjust_max_active(pwq); + 4898. mutex_unlock(&wq->mutex); + +kernel/events/core.c:4930: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4928. + 4929. rcu_read_lock(); + 4930. > rb = rcu_dereference(event->rb); + 4931. if (!rb) + 4932. goto unlock; + +drivers/gpu/drm/i915/intel_dp.c:4947: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 4944 could be null and is dereferenced by call to `intel_dp_mst_encoder_cleanup()` at line 4947, column 2. + 4945. struct intel_dp *intel_dp = &intel_dig_port->dp; + 4946. + 4947. > intel_dp_mst_encoder_cleanup(intel_dig_port); + 4948. if (intel_dp_is_edp(intel_dp)) { + 4949. cancel_delayed_work_sync(&intel_dp->panel_vdd_work); + +net/core/dev.c:4950: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4948. struct packet_offload *ptype; + 4949. + 4950. > list_for_each_entry_rcu(ptype, offload_head, list) { + 4951. if (ptype->type != type || !ptype->callbacks.gro_receive) + 4952. continue; + +net/core/dev.c:4964: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4962. struct packet_offload *ptype; + 4963. + 4964. > list_for_each_entry_rcu(ptype, offload_head, list) { + 4965. if (ptype->type != type || !ptype->callbacks.gro_complete) + 4966. continue; + +kernel/events/core.c:5016: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5014. + 5015. rcu_read_lock(); + 5016. > rb = rcu_dereference(event->rb); + 5017. if (rb) { + 5018. list_for_each_entry_rcu(event, &rb->event_list, rb_entry) + +kernel/events/core.c:5018: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5016. rb = rcu_dereference(event->rb); + 5017. if (rb) { + 5018. > list_for_each_entry_rcu(event, &rb->event_list, rb_entry) + 5019. wake_up_all(&event->waitq); + 5020. } + +drivers/gpu/drm/i915/intel_dp.c:5030: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5026 could be null and is dereferenced at line 5030, column 18. + 5028. + 5029. if (!HAS_DDI(dev_priv)) + 5030. > intel_dp->DP = I915_READ(intel_dp->output_reg); + 5031. + 5032. if (lspcon->active) + +drivers/gpu/drm/i915/intel_dp.c:5035: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5026 could be null and is dereferenced at line 5035, column 2. + 5033. lspcon_resume(lspcon); + 5034. + 5035. > intel_dp->reset_link_params = true; + 5036. + 5037. pps_lock(intel_dp); + +kernel/events/core.c:5029: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5027. + 5028. rcu_read_lock(); + 5029. > rb = rcu_dereference(event->rb); + 5030. if (rb) { + 5031. if (!atomic_inc_not_zero(&rb->refcount)) + +kernel/cgroup/cgroup.c:5087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5085. + 5086. /* initiate massacre of all css's */ + 5087. > for_each_css(css, ssid, cgrp) + 5088. kill_css(css); + 5089. + +drivers/iommu/intel-iommu.c:5096: error: DEAD_STORE + The value written to &iommu (type intel_iommu*) is never used. + 5094. + 5095. for_each_domain_iommu(iommu_id, dmar_domain) { + 5096. > iommu = g_iommus[iommu_id]; + 5097. + 5098. iommu_flush_iotlb_psi(g_iommus[iommu_id], dmar_domain, + +kernel/events/core.c:5130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5128. again: + 5129. rcu_read_lock(); + 5130. > list_for_each_entry_rcu(event, &rb->event_list, rb_entry) { + 5131. if (!atomic_long_inc_not_zero(&event->refcount)) { + 5132. /* + +drivers/ata/libata-core.c:5105: error: NULL_DEREFERENCE + pointer `qc` last assigned on line 5104 could be null and is dereferenced at line 5105, column 2. + 5103. + 5104. qc = __ata_qc_from_tag(ap, tag); + 5105. > qc->tag = tag; + 5106. qc->scsicmd = NULL; + 5107. qc->ap = ap; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:5143: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 5141. * stability + 5142. */ + 5143. > ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); + 5144. if (!link) + 5145. return 0; + +drivers/iommu/intel-iommu.c:5180: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5178. rcu_read_lock(); + 5179. for_each_rmrr_units(rmrr) { + 5180. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 5181. i, i_dev) { + 5182. if (i_dev != device) + +kernel/sched/core.c:5191: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5189. rcu_read_lock(); + 5190. if (pid_alive(p)) + 5191. > ppid = task_pid_nr(rcu_dereference(p->real_parent)); + 5192. rcu_read_unlock(); + 5193. printk(KERN_CONT "%5lu %5d %6d 0x%08lx\n", free, + +kernel/events/core.c:5236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5234. goto aux_unlock; + 5235. + 5236. > aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5237. aux_size = READ_ONCE(rb->user_page->aux_size); + 5238. + +kernel/events/core.c:5237: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5235. + 5236. aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5237. > aux_size = READ_ONCE(rb->user_page->aux_size); + 5238. + 5239. if (aux_offset < perf_data_size(rb) + PAGE_SIZE) + +kernel/cgroup/cgroup.c:5209: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5208 could be null and is dereferenced at line 5209, column 3. + 5207. + 5208. for_each_subsys(ss, i) { + 5209. > WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id, + 5210. "invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p id:name=%d:%s\n", + 5211. i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free, + +kernel/sched/core.c:5237: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5235. #endif + 5236. rcu_read_lock(); + 5237. > for_each_process_thread(g, p) { + 5238. /* + 5239. * reset the NMI-timeout, listing all files on a slow + +kernel/trace/trace.c:5256: error: DEAD_STORE + The value written to &ret (type int) is never used. + 5254. unsigned long size, int cpu_id) + 5255. { + 5256. > int ret = size; + 5257. + 5258. mutex_lock(&trace_types_lock); + +net/core/dev.c:5291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5289. + 5290. do { + 5291. > val = READ_ONCE(n->state); + 5292. if (unlikely(val & NAPIF_STATE_DISABLE)) + 5293. return false; + +net/core/dev.c:5356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5354. + 5355. do { + 5356. > val = READ_ONCE(n->state); + 5357. + 5358. WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED)); + +drivers/net/ethernet/nvidia/forcedeth.c:5512: error: DEAD_STORE + The value written to &miistat (type unsigned int) is never used. + 5510. { + 5511. u32 miistat; + 5512. > miistat = readl(base + NvRegMIIStatus); + 5513. writel(NVREG_MIISTAT_MASK_ALL, base + NvRegMIIStatus); + 5514. } + +net/core/dev.c:5385: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5383. struct napi_struct *napi; + 5384. + 5385. > hlist_for_each_entry_rcu(napi, &napi_hash[hash], napi_hash_node) + 5386. if (napi->napi_id == napi_id) + 5387. return napi; + +net/ipv6/addrconf.c:5405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5403. idx = 0; + 5404. head = &net->dev_index_head[h]; + 5405. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 5406. if (idx < s_idx) + 5407. goto cont; + +drivers/net/ethernet/broadcom/tg3.c:5434: error: UNINITIALIZED_VALUE + The value read from aninfo.txconfig was never initialized. + 5432. udelay(40); + 5433. + 5434. > *txflags = aninfo.txconfig; + 5435. *rxflags = aninfo.flags; + 5436. + +net/core/dev.c:5449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5447. local_bh_disable(); + 5448. if (!napi_poll) { + 5449. > unsigned long val = READ_ONCE(napi->state); + 5450. + 5451. /* If multiple threads are competing for this napi, + +kernel/sched/core.c:5432: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5430. struct mm_struct *mm = current->active_mm; + 5431. + 5432. > BUG_ON(cpu_online(smp_processor_id())); + 5433. + 5434. if (mm != &init_mm) { + +kernel/sched/core.c:5432: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5430. struct mm_struct *mm = current->active_mm; + 5431. + 5432. > BUG_ON(cpu_online(smp_processor_id())); + 5433. + 5434. if (mm != &init_mm) { + +drivers/gpu/drm/i915/intel_dp.c:5460: error: DEAD_STORE + The value written to &intel_crtc (type intel_crtc*) is never used. + 5458. struct intel_digital_port *dig_port = NULL; + 5459. struct intel_dp *intel_dp = dev_priv->drrs.dp; + 5460. > struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc); + 5461. enum drrs_refresh_rate_type index = DRRS_HIGH_RR; + 5462. + +kernel/cgroup/cgroup.c:5485: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5482 could be null and is dereferenced at line 5485, column 7. + 5483. if (j >= i) + 5484. break; + 5485. > if (ss->cancel_fork) + 5486. ss->cancel_fork(child); + 5487. } + +kernel/cgroup/cgroup.c:5505: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5504 could be null and is dereferenced at line 5505, column 7. + 5503. + 5504. for_each_subsys(ss, i) + 5505. > if (ss->cancel_fork) + 5506. ss->cancel_fork(child); + 5507. } + +kernel/sched/fair.c:5517: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5515. return; + 5516. + 5517. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), 0); + 5518. } + 5519. + +net/ipv6/addrconf.c:5541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5539. * to do it again + 5540. */ + 5541. > if (!rcu_access_pointer(ifp->rt->rt6i_node)) + 5542. ip6_ins_rt(ifp->rt); + 5543. if (ifp->idev->cnf.forwarding) + +kernel/sched/fair.c:5543: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5541. void cpu_load_update_nohz_stop(void) + 5542. { + 5543. > unsigned long curr_jiffies = READ_ONCE(jiffies); + 5544. struct rq *this_rq = this_rq(); + 5545. unsigned long load; + +kernel/sched/fair.c:5567: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5565. #ifdef CONFIG_NO_HZ_COMMON + 5566. /* See the mess around cpu_load_update_nohz(). */ + 5567. > this_rq->last_load_update_tick = READ_ONCE(jiffies); + 5568. #endif + 5569. cpu_load_update(this_rq, load, 1); + +kernel/sched/fair.c:5580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5578. + 5579. if (tick_nohz_tick_stopped()) + 5580. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), load); + 5581. else + 5582. cpu_load_update_periodic(this_rq, load); + +drivers/gpu/drm/i915/intel_pm.c:5635: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 5633. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5634. + 5635. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5636. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5637. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +kernel/events/core.c:5644: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5642. + 5643. if (sample_type & PERF_SAMPLE_CPU) { + 5644. > data->cpu_entry.cpu = raw_smp_processor_id(); + 5645. data->cpu_entry.reserved = 0; + 5646. } + +kernel/events/core.c:5644: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5642. + 5643. if (sample_type & PERF_SAMPLE_CPU) { + 5644. > data->cpu_entry.cpu = raw_smp_processor_id(); + 5645. data->cpu_entry.reserved = 0; + 5646. } + +drivers/usb/core/hub.c:5647: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5632 could be null and is dereferenced at line 5647, column 13. + 5645. } + 5646. + 5647. > port_dev = hub->ports[udev->portnum - 1]; + 5648. + 5649. /* + +kernel/cgroup/cgroup.c:5638: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5637 could be null and is dereferenced at line 5638, column 22. + 5636. + 5637. for_each_subsys(ss, i) { + 5638. > if (strcmp(token, ss->name) && + 5639. strcmp(token, ss->legacy_name)) + 5640. continue; + +kernel/sched/fair.c:5631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5629. { + 5630. struct rq *rq = cpu_rq(cpu); + 5631. > unsigned long nr_running = READ_ONCE(rq->cfs.h_nr_running); + 5632. unsigned long load_avg = weighted_cpuload(rq); + 5633. + +kernel/workqueue.c:5657: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5655. + 5656. list_for_each_entry(wq, &workqueues, list) + 5657. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5658. + 5659. mutex_unlock(&wq_pool_mutex); + +kernel/workqueue.c:5657: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5655. + 5656. list_for_each_entry(wq, &workqueues, list) + 5657. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5658. + 5659. mutex_unlock(&wq_pool_mutex); + +kernel/cgroup/cgroup.c:5677: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5675. * protected for this access. See css_release_work_fn() for details. + 5676. */ + 5677. > cgrp = rcu_dereference(*(void __rcu __force **)&kn->priv); + 5678. if (cgrp) + 5679. css = cgroup_css(cgrp, ss); + +net/core/dev.c:5672: error: DEAD_STORE + The value written to &time_limit (type unsigned long) is never used. + 5670. { + 5671. struct softnet_data *sd = this_cpu_ptr(&softnet_data); + 5672. > unsigned long time_limit = jiffies + + 5673. usecs_to_jiffies(netdev_budget_usecs); + 5674. int budget = netdev_budget; + +net/wireless/nl80211.c:5684: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5682. * even possible. + 5683. */ + 5684. > if (unlikely(!rcu_access_pointer(cfg80211_regdomain))) + 5685. return -EINPROGRESS; + 5686. + +kernel/sched/fair.c:5678: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5676. unsigned int master = current->wakee_flips; + 5677. unsigned int slave = p->wakee_flips; + 5678. > int factor = this_cpu_read(sd_llc_size); + 5679. + 5680. if (master < slave) + +kernel/sched/fair.c:5678: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5676. unsigned int master = current->wakee_flips; + 5677. unsigned int slave = p->wakee_flips; + 5678. > int factor = this_cpu_read(sd_llc_size); + 5679. + 5680. if (master < slave) + +drivers/md/md.c:5708: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5706. + 5707. rcu_read_lock(); + 5708. > rdev_for_each_rcu(rdev, mddev) { + 5709. if (test_bit(Journal, &rdev->flags) && + 5710. !test_bit(Faulty, &rdev->flags)) + +net/wireless/nl80211.c:5776: error: UNINITIALIZED_VALUE + The value read from cur_params.auto_open_plinks was never initialized. + 5774. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5775. cur_params.element_ttl) || + 5776. > nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5777. cur_params.auto_open_plinks) || + 5778. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + +net/wireless/nl80211.c:5814: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshAwakeWindowDuration was never initialized. + 5812. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5813. cur_params.power_mode) || + 5814. > nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5815. cur_params.dot11MeshAwakeWindowDuration) || + 5816. nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + +net/wireless/nl80211.c:5764: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshConfirmTimeout was never initialized. + 5762. nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5763. cur_params.dot11MeshRetryTimeout) || + 5764. > nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5765. cur_params.dot11MeshConfirmTimeout) || + 5766. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + +net/wireless/nl80211.c:5800: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshForwarding was never initialized. + 5798. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5799. cur_params.dot11MeshGateAnnouncementProtocol) || + 5800. > nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5801. cur_params.dot11MeshForwarding) || + 5802. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + +net/wireless/nl80211.c:5798: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshGateAnnouncementProtocol was never initialized. + 5796. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5797. cur_params.dot11MeshHWMPRannInterval) || + 5798. > nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5799. cur_params.dot11MeshGateAnnouncementProtocol) || + 5800. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + +net/wireless/nl80211.c:5796: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRannInterval was never initialized. + 5794. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5795. cur_params.dot11MeshHWMPRootMode) || + 5796. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5797. cur_params.dot11MeshHWMPRannInterval) || + 5798. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + +net/wireless/nl80211.c:5794: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRootMode was never initialized. + 5792. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5793. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5794. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5795. cur_params.dot11MeshHWMPRootMode) || + 5796. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + +net/wireless/nl80211.c:5786: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathTimeout was never initialized. + 5784. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5785. cur_params.min_discovery_timeout) || + 5786. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5787. cur_params.dot11MeshHWMPactivePathTimeout) || + 5788. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + +net/wireless/nl80211.c:5806: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathToRootTimeout was never initialized. + 5804. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5805. cur_params.ht_opmode) || + 5806. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5807. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5808. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + +net/wireless/nl80211.c:5810: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPconfirmationInterval was never initialized. + 5808. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5809. cur_params.dot11MeshHWMProotInterval) || + 5810. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5811. cur_params.dot11MeshHWMPconfirmationInterval) || + 5812. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + +net/wireless/nl80211.c:5780: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPmaxPREQretries was never initialized. + 5778. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5779. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5780. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5781. cur_params.dot11MeshHWMPmaxPREQretries) || + 5782. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + +net/wireless/nl80211.c:5792: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPnetDiameterTraversalTime was never initialized. + 5790. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5791. cur_params.dot11MeshHWMPperrMinInterval) || + 5792. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5793. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5794. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + +net/wireless/nl80211.c:5790: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPperrMinInterval was never initialized. + 5788. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5789. cur_params.dot11MeshHWMPpreqMinInterval) || + 5790. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5791. cur_params.dot11MeshHWMPperrMinInterval) || + 5792. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + +net/wireless/nl80211.c:5788: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPpreqMinInterval was never initialized. + 5786. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5787. cur_params.dot11MeshHWMPactivePathTimeout) || + 5788. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5789. cur_params.dot11MeshHWMPpreqMinInterval) || + 5790. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + +net/wireless/nl80211.c:5808: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMProotInterval was never initialized. + 5806. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5807. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5808. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5809. cur_params.dot11MeshHWMProotInterval) || + 5810. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + +net/wireless/nl80211.c:5766: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHoldingTimeout was never initialized. + 5764. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5765. cur_params.dot11MeshConfirmTimeout) || + 5766. > nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5767. cur_params.dot11MeshHoldingTimeout) || + 5768. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + +net/wireless/nl80211.c:5768: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxPeerLinks was never initialized. + 5766. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5767. cur_params.dot11MeshHoldingTimeout) || + 5768. > nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5769. cur_params.dot11MeshMaxPeerLinks) || + 5770. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + +net/wireless/nl80211.c:5770: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxRetries was never initialized. + 5768. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5769. cur_params.dot11MeshMaxPeerLinks) || + 5770. > nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5771. cur_params.dot11MeshMaxRetries) || + 5772. nla_put_u8(msg, NL80211_MESHCONF_TTL, + +net/wireless/nl80211.c:5778: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshNbrOffsetMaxNeighbor was never initialized. + 5776. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5777. cur_params.auto_open_plinks) || + 5778. > nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5779. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5780. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + +net/wireless/nl80211.c:5762: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshRetryTimeout was never initialized. + 5760. goto nla_put_failure; + 5761. if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || + 5762. > nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5763. cur_params.dot11MeshRetryTimeout) || + 5764. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + +net/wireless/nl80211.c:5772: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshTTL was never initialized. + 5770. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5771. cur_params.dot11MeshMaxRetries) || + 5772. > nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5773. cur_params.dot11MeshTTL) || + 5774. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + +net/wireless/nl80211.c:5774: error: UNINITIALIZED_VALUE + The value read from cur_params.element_ttl was never initialized. + 5772. nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5773. cur_params.dot11MeshTTL) || + 5774. > nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5775. cur_params.element_ttl) || + 5776. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + +net/wireless/nl80211.c:5804: error: UNINITIALIZED_VALUE + The value read from cur_params.ht_opmode was never initialized. + 5802. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5803. cur_params.rssi_threshold) || + 5804. > nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5805. cur_params.ht_opmode) || + 5806. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + +net/wireless/nl80211.c:5784: error: UNINITIALIZED_VALUE + The value read from cur_params.min_discovery_timeout was never initialized. + 5782. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5783. cur_params.path_refresh_time) || + 5784. > nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5785. cur_params.min_discovery_timeout) || + 5786. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + +net/wireless/nl80211.c:5782: error: UNINITIALIZED_VALUE + The value read from cur_params.path_refresh_time was never initialized. + 5780. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5781. cur_params.dot11MeshHWMPmaxPREQretries) || + 5782. > nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5783. cur_params.path_refresh_time) || + 5784. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + +net/wireless/nl80211.c:5816: error: UNINITIALIZED_VALUE + The value read from cur_params.plink_timeout was never initialized. + 5814. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5815. cur_params.dot11MeshAwakeWindowDuration) || + 5816. > nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + 5817. cur_params.plink_timeout)) + 5818. goto nla_put_failure; + +net/wireless/nl80211.c:5812: error: UNINITIALIZED_VALUE + The value read from cur_params.power_mode was never initialized. + 5810. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5811. cur_params.dot11MeshHWMPconfirmationInterval) || + 5812. > nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5813. cur_params.power_mode) || + 5814. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + +net/wireless/nl80211.c:5802: error: UNINITIALIZED_VALUE + The value read from cur_params.rssi_threshold was never initialized. + 5800. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5801. cur_params.dot11MeshForwarding) || + 5802. > nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5803. cur_params.rssi_threshold) || + 5804. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + +kernel/sched/fair.c:5750: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5748. int prev_cpu, int sync) + 5749. { + 5750. > int this_cpu = smp_processor_id(); + 5751. bool affine = false; + 5752. + +kernel/sched/fair.c:5750: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5748. int prev_cpu, int sync) + 5749. { + 5750. > int this_cpu = smp_processor_id(); + 5751. bool affine = false; + 5752. + +drivers/usb/core/hub.c:5768: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5764 could be null and is dereferenced at line 5768, column 9. + 5766. if (port1 < 1 || port1 > hdev->maxchild) + 5767. return NULL; + 5768. > return hub->ports[port1 - 1]->child; + 5769. } + 5770. EXPORT_SYMBOL_GPL(usb_hub_find_child); + +kernel/sched/core.c:5789: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5787. static int __init migration_init(void) + 5788. { + 5789. > sched_rq_cpu_starting(smp_processor_id()); + 5790. return 0; + 5791. } + +kernel/sched/core.c:5789: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5787. static int __init migration_init(void) + 5788. { + 5789. > sched_rq_cpu_starting(smp_processor_id()); + 5790. return 0; + 5791. } + +drivers/net/ethernet/broadcom/tg3.c:5984: error: UNINITIALIZED_VALUE + The value read from local_adv was never initialized. + 5982. fiber_setup_done: + 5983. if (current_link_up && current_duplex == DUPLEX_FULL) + 5984. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5985. + 5986. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +drivers/net/ethernet/broadcom/tg3.c:5984: error: UNINITIALIZED_VALUE + The value read from remote_adv was never initialized. + 5982. fiber_setup_done: + 5983. if (current_link_up && current_duplex == DUPLEX_FULL) + 5984. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5985. + 5986. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +kernel/sched/core.c:5845: error: DEAD_STORE + The value written to &ptr (type unsigned long) is never used. + 5843. + 5844. root_task_group.cfs_rq = (struct cfs_rq **)ptr; + 5845. > ptr += nr_cpu_ids * sizeof(void **); + 5846. + 5847. #endif /* CONFIG_FAIR_GROUP_SCHED */ + +kernel/sched/core.c:5976: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5974. * when this runqueue becomes "idle". + 5975. */ + 5976. > init_idle(current, smp_processor_id()); + 5977. + 5978. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:5982: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5980. #ifdef CONFIG_SMP + 5981. idle_thread_set_boot_cpu(); + 5982. > set_cpu_rq_start_time(smp_processor_id()); + 5983. #endif + 5984. init_sched_fair_class(); + +kernel/sched/core.c:5976: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5974. * when this runqueue becomes "idle". + 5975. */ + 5976. > init_idle(current, smp_processor_id()); + 5977. + 5978. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:5982: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5980. #ifdef CONFIG_SMP + 5981. idle_thread_set_boot_cpu(); + 5982. > set_cpu_rq_start_time(smp_processor_id()); + 5983. #endif + 5984. init_sched_fair_class(); + +net/core/dev.c:5868: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5866. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 5867. + 5868. > upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 5869. + 5870. if (&upper->list == &dev->adj_list.upper) + +net/core/dev.c:5886: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5884. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 5885. + 5886. > upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 5887. + 5888. if (&upper->list == &dev->adj_list.upper) + +kernel/cgroup/cgroup.c:5903: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5902 could be null and is dereferenced at line 5903, column 33. + 5901. + 5902. for_each_subsys(ss, ssid) + 5903. > ret += show_delegatable_files(ss->dfl_cftypes, buf + ret, + 5904. PAGE_SIZE - ret, + 5905. cgroup_subsys_name[ssid]); + +security/selinux/hooks.c:5908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5906. + 5907. rcu_read_lock(); + 5908. > __tsec = __task_cred(p)->security; + 5909. + 5910. if (current != p) { + +drivers/gpu/drm/i915/intel_pm.c:5954: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5952. I915_WRITE(MEMMODECTL, rgvmodectl); + 5953. + 5954. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5955. DRM_ERROR("stuck trying to change perf mode\n"); + 5956. mdelay(1); + +drivers/gpu/drm/i915/intel_pm.c:5954: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5952. I915_WRITE(MEMMODECTL, rgvmodectl); + 5953. + 5954. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5955. DRM_ERROR("stuck trying to change perf mode\n"); + 5956. mdelay(1); + +security/selinux/hooks.c:6040: error: DEAD_STORE + The value written to &error (type int) is never used. + 6038. + 6039. /* Only allow single threaded processes to change context */ + 6040. > error = -EPERM; + 6041. if (!current_is_single_threaded()) { + 6042. error = security_bounded_transition(tsec->sid, sid); + +net/core/dev.c:5968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5966. WARN_ON_ONCE(!rcu_read_lock_held()); + 5967. + 5968. > lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 5969. + 5970. if (&lower->list == &dev->adj_list.lower) + +kernel/sched/fair.c:5998: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5996. weight = sd->span_weight; + 5997. sd = NULL; + 5998. > for_each_domain(cpu, tmp) { + 5999. if (weight <= tmp->span_weight) + 6000. break; + +kernel/sched/fair.c:6016: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6014. struct sched_domain_shared *sds; + 6015. + 6016. > sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6017. if (sds) + 6018. WRITE_ONCE(sds->has_idle_cores, val); + +kernel/sched/fair.c:6025: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6023. struct sched_domain_shared *sds; + 6024. + 6025. > sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6026. if (sds) + 6027. return READ_ONCE(sds->has_idle_cores); + +kernel/sched/fair.c:6027: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6025. sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6026. if (sds) + 6027. > return READ_ONCE(sds->has_idle_cores); + 6028. + 6029. return def; + +net/core/dev.c:6053: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6051. struct netdev_adjacent *lower; + 6052. + 6053. > lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 6054. if (&lower->list == &dev->adj_list.lower) + 6055. return NULL; + +kernel/sched/core.c:6075: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6073. + 6074. read_lock(&tasklist_lock); + 6075. > for_each_process_thread(g, p) { + 6076. /* + 6077. * Only normalize user tasks: + +net/core/dev.c:6103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6101. struct netdev_adjacent *lower; + 6102. + 6103. > lower = list_first_or_null_rcu(&dev->adj_list.lower, + 6104. struct netdev_adjacent, list); + 6105. if (lower) + +net/core/dev.c:6122: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6120. struct netdev_adjacent *upper; + 6121. + 6122. > upper = list_first_or_null_rcu(&dev->adj_list.upper, + 6123. struct netdev_adjacent, list); + 6124. if (upper && likely(upper->master)) + +kernel/sched/fair.c:6147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6145. int cpu, nr = INT_MAX; + 6146. + 6147. > this_sd = rcu_dereference(*this_cpu_ptr(&sd_llc)); + 6148. if (!this_sd) + 6149. return -1; + +drivers/md/md.c:6154: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6152. nr = working = insync = failed = spare = 0; + 6153. rcu_read_lock(); + 6154. > rdev_for_each_rcu(rdev, mddev) { + 6155. nr++; + 6156. if (test_bit(Faulty, &rdev->flags)) + +kernel/sched/fair.c:6205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6203. return prev; + 6204. + 6205. > sd = rcu_dereference(per_cpu(sd_llc, target)); + 6206. if (!sd) + 6207. return target; + +kernel/events/core.c:6215: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6213. struct perf_event *event; + 6214. + 6215. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 6216. if (!all) { + 6217. if (event->state < PERF_EVENT_STATE_INACTIVE) + +kernel/events/core.c:6232: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6230. struct perf_event *event; + 6231. + 6232. > list_for_each_entry_rcu(event, &pel->list, sb_list) { + 6233. /* + 6234. * Skip events that are not fully formed yet; ensure that + +kernel/events/core.c:6238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6236. * complete enough. See perf_install_in_context(). + 6237. */ + 6238. > if (!smp_load_acquire(&event->ctx)) + 6239. continue; + 6240. + +kernel/sched/core.c:6240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6238. * to prevent lockdep warnings. + 6239. */ + 6240. > tg = container_of(task_css_check(tsk, cpu_cgrp_id, true), + 6241. struct task_group, css); + 6242. tg = autogroup_task_group(tsk, tg); + +drivers/md/md.c:6247: error: UNINITIALIZED_VALUE + The value read from info.number was never initialized. + 6245. + 6246. rcu_read_lock(); + 6247. > rdev = md_find_rdev_nr_rcu(mddev, info.number); + 6248. if (rdev) { + 6249. info.major = MAJOR(rdev->bdev->bd_dev); + +net/wireless/nl80211.c:6292: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6290. + 6291. if (!regdom) + 6292. > regdom = rcu_dereference(cfg80211_regdomain); + 6293. + 6294. if (nl80211_put_regdom(regdom, msg)) + +kernel/events/core.c:6278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6276. + 6277. for_each_task_context_nr(ctxn) { + 6278. > ctx = rcu_dereference(current->perf_event_ctxp[ctxn]); + 6279. if (ctx) + 6280. perf_iterate_ctx(ctx, output, data, false); + +kernel/sched/fair.c:6333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6331. + 6332. rcu_read_lock(); + 6333. > for_each_domain(cpu, tmp) { + 6334. if (!(tmp->flags & SD_LOAD_BALANCE)) + 6335. break; + +kernel/sched/fair.c:6321: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6319. { + 6320. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6321. > int cpu = smp_processor_id(); + 6322. int new_cpu = prev_cpu; + 6323. int want_affine = 0; + +kernel/sched/fair.c:6321: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6319. { + 6320. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6321. > int cpu = smp_processor_id(); + 6322. int new_cpu = prev_cpu; + 6323. int want_affine = 0; + +kernel/sched/core.c:6326: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6324 could be null and is dereferenced by call to `sched_offline_group()` at line 6326, column 2. + 6324. struct task_group *tg = css_tg(css); + 6325. + 6326. > sched_offline_group(tg); + 6327. } + 6328. + +drivers/net/ethernet/intel/e1000e/netdev.c:6429: error: DEAD_STORE + The value written to &retval (type int) is never used. + 6427. lpi_ctrl |= I82579_LPI_CTRL_1000_ENABLE; + 6428. + 6429. > retval = e1e_wphy_locked(hw, I82579_LPI_CTRL, + 6430. lpi_ctrl); + 6431. } + +kernel/events/core.c:6368: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6366. * its rb pointer. + 6367. */ + 6368. > if (rcu_dereference(parent->rb) == rb) + 6369. ro->err = __perf_event_stop(&sd); + 6370. } + +kernel/events/core.c:6398: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6396. restart: + 6397. rcu_read_lock(); + 6398. > list_for_each_entry_rcu(iter, &event->rb->event_list, rb_entry) { + 6399. /* + 6400. * For per-CPU events, we need to make sure that neither they + +kernel/events/core.c:6407: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6405. cpu = iter->cpu; + 6406. if (cpu == -1) + 6407. > cpu = READ_ONCE(iter->oncpu); + 6408. + 6409. if (cpu == -1) + +kernel/sched/core.c:6412: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6410 could be null and is dereferenced at line 6412, column 15. + 6410. struct task_group *tg = css_tg(css); + 6411. + 6412. > return (u64) scale_load_down(tg->shares); + 6413. } + 6414. + +drivers/net/ethernet/broadcom/tg3.c:6613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6611. if (unlikely(netif_tx_queue_stopped(txq) && + 6612. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6613. > __netif_tx_lock(txq, smp_processor_id()); + 6614. if (netif_tx_queue_stopped(txq) && + 6615. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +drivers/net/ethernet/broadcom/tg3.c:6613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6611. if (unlikely(netif_tx_queue_stopped(txq) && + 6612. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6613. > __netif_tx_lock(txq, smp_processor_id()); + 6614. if (netif_tx_queue_stopped(txq) && + 6615. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +kernel/sched/core.c:6753: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6752 could be null and is dereferenced at line 6753, column 15. + 6751. { + 6752. struct task_group *tg = css_tg(css); + 6753. > u64 weight = scale_load_down(tg->shares); + 6754. + 6755. return DIV_ROUND_CLOSEST_ULL(weight * CGROUP_WEIGHT_DFL, 1024); + +kernel/events/core.c:7031: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7029. rcu_read_lock(); + 7030. for_each_task_context_nr(ctxn) { + 7031. > ctx = rcu_dereference(current->perf_event_ctxp[ctxn]); + 7032. if (!ctx) + 7033. continue; + +drivers/ata/libata-core.c:7084: error: DEAD_STORE + The value written to &deadline (type unsigned long) is never used. + 7082. * eat away the timeout. + 7083. */ + 7084. > deadline = ata_deadline(jiffies, timeout); + 7085. + 7086. while ((tmp & mask) == val && time_before(jiffies, deadline)) { + +drivers/ata/libata-core.c:7108: error: DEAD_STORE + The value written to &lpm_timeout (type unsigned long) is never used. + 7106. bool sata_lpm_ignore_phy_events(struct ata_link *link) + 7107. { + 7108. > unsigned long lpm_timeout = link->last_lpm_change + + 7109. msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY); + 7110. + +kernel/events/core.c:7316: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7314. u64 seq; + 7315. + 7316. > seq = __this_cpu_read(perf_throttled_seq); + 7317. if (seq != hwc->interrupts_seq) { + 7318. hwc->interrupts_seq = seq; + +kernel/events/core.c:7325: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7323. && hwc->interrupts >= max_samples_per_tick)) { + 7324. __this_cpu_inc(perf_throttled_count); + 7325. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7326. hwc->interrupts = MAX_INTERRUPTS; + 7327. perf_log_throttle(event, 0); + +kernel/events/core.c:7316: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7314. u64 seq; + 7315. + 7316. > seq = __this_cpu_read(perf_throttled_seq); + 7317. if (seq != hwc->interrupts_seq) { + 7318. hwc->interrupts_seq = seq; + +kernel/events/core.c:7325: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7323. && hwc->interrupts >= max_samples_per_tick)) { + 7324. __this_cpu_inc(perf_throttled_count); + 7325. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7326. hwc->interrupts = MAX_INTERRUPTS; + 7327. perf_log_throttle(event, 0); + +drivers/gpu/drm/i915/intel_display.c:7425: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7423. if (INTEL_GEN(dev_priv) >= 4) { + 7424. if (plane_config->tiling) + 7425. > offset = I915_READ(DSPTILEOFF(plane)); + 7426. else + 7427. offset = I915_READ(DSPLINOFF(plane)); + +drivers/gpu/drm/i915/intel_display.c:7427: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7425. offset = I915_READ(DSPTILEOFF(plane)); + 7426. else + 7427. > offset = I915_READ(DSPLINOFF(plane)); + 7428. base = I915_READ(DSPSURF(plane)) & 0xfffff000; + 7429. } else { + +net/wireless/nl80211.c:7460: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7448 could be null and is dereferenced at line 7460, column 11. + 7458. */ + 7459. if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) { + 7460. > while (!sched_scan_req->reqid) + 7461. sched_scan_req->reqid = rdev->wiphy.cookie_counter++; + 7462. } + +net/wireless/nl80211.c:7464: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7448 could be null and is dereferenced by call to `rdev_sched_scan_start()` at line 7464, column 8. + 7462. } + 7463. + 7464. > err = rdev_sched_scan_start(rdev, dev, sched_scan_req); + 7465. if (err) + 7466. goto out_free; + +net/wireless/nl80211.c:7500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7498. } + 7499. + 7500. > req = list_first_or_null_rcu(&rdev->sched_scan_req_list, + 7501. struct cfg80211_sched_scan_request, + 7502. list); + +kernel/sched/fair.c:7555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7553. * we read them once before doing sanity checks on them. + 7554. */ + 7555. > age_stamp = READ_ONCE(rq->age_stamp); + 7556. avg = READ_ONCE(rq->rt_avg); + 7557. delta = __rq_clock_broken(rq) - age_stamp; + +kernel/sched/fair.c:7556: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7554. */ + 7555. age_stamp = READ_ONCE(rq->age_stamp); + 7556. > avg = READ_ONCE(rq->rt_avg); + 7557. delta = __rq_clock_broken(rq) - age_stamp; + 7558. + +kernel/events/core.c:7556: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7554. struct swevent_hlist *hlist; + 7555. + 7556. > hlist = rcu_dereference(swhash->swevent_hlist); + 7557. if (!hlist) + 7558. return NULL; + +kernel/events/core.c:7598: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7596. goto end; + 7597. + 7598. > hlist_for_each_entry_rcu(event, head, hlist_entry) { + 7599. if (perf_swevent_match(event, type, event_id, data, regs)) + 7600. perf_swevent_event(event, nr, data, regs); + +drivers/md/md.c:7713: error: DEAD_STORE + The value written to &l (type long long) is never used. + 7711. } + 7712. spin_unlock(&all_mddevs_lock); + 7713. > if (!l--) + 7714. return (void*)2;/* tail */ + 7715. return NULL; + +net/wireless/nl80211.c:7772: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7770. rcu_read_lock(); + 7771. /* indicate whether we have probe response data or not */ + 7772. > if (rcu_access_pointer(res->proberesp_ies) && + 7773. nla_put_flag(msg, NL80211_BSS_PRESP_DATA)) + 7774. goto fail_unlock_rcu; + +net/wireless/nl80211.c:7779: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7777. * but is always valid + 7778. */ + 7779. > ies = rcu_dereference(res->ies); + 7780. if (ies) { + 7781. if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf, + +net/wireless/nl80211.c:7790: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7788. + 7789. /* and this pointer is always (unless driver didn't know) beacon data */ + 7790. > ies = rcu_dereference(res->beacon_ies); + 7791. if (ies && ies->from_beacon) { + 7792. if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf, + +drivers/md/md.c:7791: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7789. sectors = 0; + 7790. rcu_read_lock(); + 7791. > rdev_for_each_rcu(rdev, mddev) { + 7792. char b[BDEVNAME_SIZE]; + 7793. seq_printf(seq, " %s[%d]", + +drivers/gpu/drm/i915/intel_display.c:7776: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 7774. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7775. + 7776. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7777. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7778. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7784: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 7782. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7783. + 7784. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7785. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7786. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7776: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7774. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7775. + 7776. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7777. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7778. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7784: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7782. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7783. + 7784. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7785. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7786. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7776: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7774. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7775. + 7776. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7777. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7778. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7784: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7782. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7783. + 7784. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7785. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7786. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7776: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7774. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7775. + 7776. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7777. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7778. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7784: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7782. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7783. + 7784. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7785. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7786. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +net/core/dev.c:7870: error: DEAD_STORE + The value written to &rebroadcast_time (type unsigned long) is never used. + 7868. linkwatch_forget_dev(dev); + 7869. + 7870. > rebroadcast_time = warning_time = jiffies; + 7871. refcnt = netdev_refcnt_read(dev); + 7872. + +net/core/dev.c:7908: error: DEAD_STORE + The value written to &warning_time (type unsigned long) is never used. + 7906. pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n", + 7907. dev->name, refcnt); + 7908. > warning_time = jiffies; + 7909. } + 7910. } + +drivers/net/ethernet/broadcom/tg3.c:8145: error: DEAD_STORE + The value written to &i (type int) is never used. + 8143. + 8144. dma_error: + 8145. > tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, --i); + 8146. tnapi->tx_buffers[tnapi->tx_prod].skb = NULL; + 8147. drop: + +kernel/events/core.c:7913: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7911. perf_trace_buf_update(record, event_type); + 7912. + 7913. > hlist_for_each_entry_rcu(event, head, hlist_entry) { + 7914. if (perf_tp_event_match(event, &data, regs)) + 7915. perf_swevent_event(event, count, &data, regs); + +kernel/events/core.c:7927: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7925. + 7926. rcu_read_lock(); + 7927. > ctx = rcu_dereference(task->perf_event_ctxp[perf_sw_context]); + 7928. if (!ctx) + 7929. goto unlock; + +kernel/events/core.c:7931: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7929. goto unlock; + 7930. + 7931. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 7932. if (event->attr.type != PERF_TYPE_TRACEPOINT) + 7933. continue; + +net/core/dev.c:7975: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7973. BUG_ON(!list_empty(&dev->ptype_all)); + 7974. BUG_ON(!list_empty(&dev->ptype_specific)); + 7975. > WARN_ON(rcu_access_pointer(dev->ip_ptr)); + 7976. WARN_ON(rcu_access_pointer(dev->ip6_ptr)); + 7977. WARN_ON(dev->dn_ptr); + +net/core/dev.c:7976: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7974. BUG_ON(!list_empty(&dev->ptype_specific)); + 7975. WARN_ON(rcu_access_pointer(dev->ip_ptr)); + 7976. > WARN_ON(rcu_access_pointer(dev->ip6_ptr)); + 7977. WARN_ON(dev->dn_ptr); + 7978. + +drivers/md/md.c:7978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7976. idle = 1; + 7977. rcu_read_lock(); + 7978. > rdev_for_each_rcu(rdev, mddev) { + 7979. struct gendisk *disk = rdev->bdev->bd_contains->bd_disk; + 7980. curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + + +kernel/trace/trace.c:8208: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8206. break; + 8207. case DUMP_ORIG: + 8208. > iter.cpu_file = raw_smp_processor_id(); + 8209. break; + 8210. case DUMP_NONE: + +kernel/trace/trace.c:8208: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8206. break; + 8207. case DUMP_ORIG: + 8208. > iter.cpu_file = raw_smp_processor_id(); + 8209. break; + 8210. case DUMP_NONE: + +kernel/events/core.c:8241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8239. { + 8240. struct perf_addr_filters_head *ifh = perf_event_addr_filters(event); + 8241. > struct task_struct *task = READ_ONCE(event->ctx->task); + 8242. struct perf_addr_filter *filter; + 8243. struct mm_struct *mm = NULL; + +net/core/dev.c:8396: error: DEAD_STORE + The value written to &err (type int) is never used. + 8394. + 8395. /* And unlink it from device chain */ + 8396. > err = -ENODEV; + 8397. unlist_netdevice(dev); + 8398. + +drivers/gpu/drm/i915/intel_display.c:8471: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 8469. plane_config->base = base; + 8470. + 8471. > offset = I915_READ(PLANE_OFFSET(pipe, 0)); + 8472. + 8473. val = I915_READ(PLANE_SIZE(pipe, 0)); + +net/core/dev.c:8472: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8470. + 8471. local_irq_disable(); + 8472. > cpu = smp_processor_id(); + 8473. sd = &per_cpu(softnet_data, cpu); + 8474. oldsd = &per_cpu(softnet_data, oldcpu); + +net/core/dev.c:8472: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8470. + 8471. local_irq_disable(); + 8472. > cpu = smp_processor_id(); + 8473. sd = &per_cpu(softnet_data, cpu); + 8474. oldsd = &per_cpu(softnet_data, oldcpu); + +drivers/gpu/drm/i915/intel_display.c:8561: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 8559. base = I915_READ(DSPSURF(pipe)) & 0xfffff000; + 8560. if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) { + 8561. > offset = I915_READ(DSPOFFSET(pipe)); + 8562. } else { + 8563. if (plane_config->tiling) + +drivers/gpu/drm/i915/intel_display.c:8564: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 8562. } else { + 8563. if (plane_config->tiling) + 8564. > offset = I915_READ(DSPTILEOFF(pipe)); + 8565. else + 8566. offset = I915_READ(DSPLINOFF(pipe)); + +drivers/gpu/drm/i915/intel_display.c:8566: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 8564. offset = I915_READ(DSPTILEOFF(pipe)); + 8565. else + 8566. > offset = I915_READ(DSPLINOFF(pipe)); + 8567. } + 8568. plane_config->base = base; + +drivers/gpu/drm/i915/intel_display.c:8764: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8762. I915_WRITE(LCPLL_CTL, val); + 8763. + 8764. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8765. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8766. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8783: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8781. ndelay(100); + 8782. + 8783. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8784. 1)) + 8785. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +drivers/gpu/drm/i915/intel_display.c:8764: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8762. I915_WRITE(LCPLL_CTL, val); + 8763. + 8764. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8765. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8766. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8764: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8762. I915_WRITE(LCPLL_CTL, val); + 8763. + 8764. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8765. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8766. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8764: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8762. I915_WRITE(LCPLL_CTL, val); + 8763. + 8764. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8765. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8766. DRM_ERROR("Switching to FCLK failed\n"); + +kernel/sched/fair.c:8759: error: DEAD_STORE + The value written to &next_balance (type unsigned long) is never used. + 8757. static int idle_balance(struct rq *this_rq, struct rq_flags *rf) + 8758. { + 8759. > unsigned long next_balance = jiffies + HZ; + 8760. int this_cpu = this_rq->cpu; + 8761. struct sched_domain *sd; + +kernel/sched/fair.c:8788: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8786. !this_rq->rd->overload) { + 8787. rcu_read_lock(); + 8788. > sd = rcu_dereference_check_sched_domain(this_rq->sd); + 8789. if (sd) + 8790. update_next_balance(sd, &next_balance); + +kernel/sched/fair.c:8800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8798. update_blocked_averages(this_cpu); + 8799. rcu_read_lock(); + 8800. > for_each_domain(this_cpu, sd) { + 8801. int continue_balancing = 1; + 8802. u64 t0, domain_cost; + +drivers/gpu/drm/i915/intel_display.c:8840: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8838. I915_WRITE(LCPLL_CTL, val); + 8839. + 8840. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8841. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8842. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8840: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8838. I915_WRITE(LCPLL_CTL, val); + 8839. + 8840. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8841. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8842. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8840: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8838. I915_WRITE(LCPLL_CTL, val); + 8839. + 8840. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8841. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8842. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8840: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8838. I915_WRITE(LCPLL_CTL, val); + 8839. + 8840. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8841. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8842. DRM_ERROR("Switching back to LCPLL failed\n"); + +kernel/events/core.c:8852: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8850. static int perf_pmu_commit_txn(struct pmu *pmu) + 8851. { + 8852. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8853. + 8854. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8852: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8850. static int perf_pmu_commit_txn(struct pmu *pmu) + 8851. { + 8852. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8853. + 8854. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8865: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8863. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8864. { + 8865. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8866. + 8867. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8865: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8863. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8864. { + 8865. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8866. + 8867. __this_cpu_write(nop_txn_flags, 0); + +kernel/sched/fair.c:8910: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8908. /* Search for an sd spanning us and the target CPU. */ + 8909. rcu_read_lock(); + 8910. > for_each_domain(target_cpu, sd) { + 8911. if ((sd->flags & SD_LOAD_BALANCE) && + 8912. cpumask_test_cpu(busiest_cpu, sched_domain_span(sd))) + +kernel/sched/fair.c:8893: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8891. + 8892. /* make sure the requested cpu hasn't gone down in the meantime */ + 8893. > if (unlikely(busiest_cpu != smp_processor_id() || + 8894. !busiest_rq->active_balance)) + 8895. goto out_unlock; + +drivers/md/md.c:8956: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8954. "unacknowledged_bad_blocks"); + 8955. sysfs_notify_dirent_safe(rdev->sysfs_state); + 8956. > set_mask_bits(&mddev->sb_flags, 0, + 8957. BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING)); + 8958. md_wakeup_thread(rdev->mddev->thread); + +kernel/sched/fair.c:8960: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8958. static inline int on_null_domain(struct rq *rq) + 8959. { + 8960. > return unlikely(!rcu_dereference_sched(rq->sd)); + 8961. } + 8962. + +kernel/sched/fair.c:9034: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9032. + 9033. rcu_read_lock(); + 9034. > sd = rcu_dereference(per_cpu(sd_llc, cpu)); + 9035. + 9036. if (!sd || !sd->nohz_idle) + +kernel/sched/fair.c:9031: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9029. { + 9030. struct sched_domain *sd; + 9031. > int cpu = smp_processor_id(); + 9032. + 9033. rcu_read_lock(); + +kernel/sched/fair.c:9031: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9029. { + 9030. struct sched_domain *sd; + 9031. > int cpu = smp_processor_id(); + 9032. + 9033. rcu_read_lock(); + +kernel/sched/fair.c:9051: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9049. + 9050. rcu_read_lock(); + 9051. > sd = rcu_dereference(per_cpu(sd_llc, cpu)); + 9052. + 9053. if (!sd || sd->nohz_idle) + +kernel/sched/fair.c:9048: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9046. { + 9047. struct sched_domain *sd; + 9048. > int cpu = smp_processor_id(); + 9049. + 9050. rcu_read_lock(); + +kernel/sched/fair.c:9048: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9046. { + 9047. struct sched_domain *sd; + 9048. > int cpu = smp_processor_id(); + 9049. + 9050. rcu_read_lock(); + +drivers/md/md.c:9103: error: DEAD_STORE + The value written to &ret (type int) is never used. + 9101. if (rdev2->raid_disk == -1 && role != 0xffff) { + 9102. rdev2->saved_raid_disk = role; + 9103. > ret = remove_and_add_spares(mddev, rdev2); + 9104. pr_info("Activated spare: %s\n", + 9105. bdevname(rdev2->bdev,b)); + +kernel/sched/fair.c:9112: error: DEAD_STORE + The value written to &continue_balancing (type int) is never used. + 9110. static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle) + 9111. { + 9112. > int continue_balancing = 1; + 9113. int cpu = rq->cpu; + 9114. unsigned long interval; + +kernel/sched/fair.c:9125: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9123. + 9124. rcu_read_lock(); + 9125. > for_each_domain(cpu, sd) { + 9126. /* + 9127. * Decay the newidle max times here because this is a regular + +drivers/md/md.c:9184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9182. + 9183. /* Find the rdev */ + 9184. > rdev_for_each_rcu(rdev, mddev) { + 9185. if (rdev->desc_nr == nr) + 9186. break; + +drivers/md/md.c:9201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9199. + 9200. /* Read all rdev's to update recovery_offset */ + 9201. > rdev_for_each_rcu(rdev, mddev) + 9202. read_rdev(mddev, rdev); + 9203. } + +kernel/events/core.c:9256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9254. } + 9255. + 9256. > list_for_each_entry_rcu(pmu, &pmus, entry) { + 9257. ret = perf_try_init_event(pmu, event); + 9258. if (!ret) + +drivers/gpu/drm/i915/intel_display.c:9248: error: NULL_DEREFERENCE + pointer `obj` last assigned on line 9244 could be null and is dereferenced at line 9248, column 10. + 9246. + 9247. if (INTEL_INFO(dev_priv)->cursor_needs_physical) + 9248. > base = obj->phys_handle->busaddr; + 9249. else + 9250. base = intel_plane_ggtt_offset(plane_state); + +kernel/sched/fair.c:9290: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 9288. static inline bool nohz_kick_needed(struct rq *rq) + 9289. { + 9290. > unsigned long now = jiffies; + 9291. struct sched_domain_shared *sds; + 9292. struct sched_domain *sd; + +drivers/gpu/drm/i915/intel_pm.c:9327: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 9325. goto out; + 9326. } + 9327. > ret = _wait_for(COND, timeout_base_ms * 1000, 10); + 9328. if (!ret) + 9329. goto out; + +drivers/gpu/drm/i915/intel_pm.c:9344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9342. WARN_ON_ONCE(timeout_base_ms > 3); + 9343. preempt_disable(); + 9344. > ret = wait_for_atomic(COND, 50); + 9345. preempt_enable(); + 9346. + +drivers/gpu/drm/i915/intel_pm.c:9344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9342. WARN_ON_ONCE(timeout_base_ms > 3); + 9343. preempt_disable(); + 9344. > ret = wait_for_atomic(COND, 50); + 9345. preempt_enable(); + 9346. + +drivers/gpu/drm/i915/intel_pm.c:9344: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 9342. WARN_ON_ONCE(timeout_base_ms > 3); + 9343. preempt_disable(); + 9344. > ret = wait_for_atomic(COND, 50); + 9345. preempt_enable(); + 9346. + +drivers/gpu/drm/i915/intel_pm.c:9327: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 9325. goto out; + 9326. } + 9327. > ret = _wait_for(COND, timeout_base_ms * 1000, 10); + 9328. if (!ret) + 9329. goto out; + +drivers/gpu/drm/i915/intel_pm.c:9460: error: DEAD_STORE + The value written to &loop (type int) is never used. + 9458. _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH)); + 9459. upper = I915_READ_FW(reg); + 9460. > } while (upper != tmp && --loop); + 9461. + 9462. /* Everywhere else we always use VLV_COUNTER_CONTROL with the + +kernel/events/core.c:9835: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9833. again: + 9834. rcu_read_lock(); + 9835. > gctx = READ_ONCE(group_leader->ctx); + 9836. if (!atomic_inc_not_zero(&gctx->refcount)) { + 9837. rcu_read_unlock(); + +drivers/net/ethernet/broadcom/tg3.c:10770: error: DEAD_STORE + The value written to &off (type unsigned int) is never used. + 10768. + 10769. tg3_ape_scratchpad_read(tp, (u32 *) ocir, off, len); + 10770. > off += len; + 10771. + 10772. if (ocir->signature != TG3_OCIR_SIG_MAGIC || + +kernel/events/core.c:11150: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11148. perf_pmu_register(&perf_task_clock, NULL, -1); + 11149. perf_tp_register(); + 11150. > perf_event_init_cpu(smp_processor_id()); + 11151. register_reboot_notifier(&perf_reboot_notifier); + 11152. + +kernel/events/core.c:11150: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11148. perf_pmu_register(&perf_task_clock, NULL, -1); + 11149. perf_tp_register(); + 11150. > perf_event_init_cpu(smp_processor_id()); + 11151. register_reboot_notifier(&perf_reboot_notifier); + 11152. + +drivers/net/ethernet/broadcom/tg3.c:12186: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 12185 could be null and is dereferenced by call to `phy_ethtool_ksettings_set()` at line 12186, column 10. + 12184. return -EAGAIN; + 12185. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 12186. > return phy_ethtool_ksettings_set(phydev, cmd); + 12187. } + 12188. + +drivers/gpu/drm/i915/intel_display.c:12394: error: UNINITIALIZED_VALUE + The value read from put_domains[_] was never initialized. + 12392. + 12393. if (put_domains[i]) + 12394. > modeset_put_power_domains(dev_priv, put_domains[i]); + 12395. + 12396. intel_modeset_verify_crtc(crtc, state, old_crtc_state, new_crtc_state); + +drivers/net/ethernet/broadcom/tg3.c:12969: error: UNINITIALIZED_VALUE + The value read from data[_] was never initialized. + 12967. err = -EIO; + 12968. for (i = 0; i < NVRAM_SELFBOOT_DATA_SIZE; i++) { + 12969. > u8 hw8 = hweight8(data[i]); + 12970. + 12971. if ((hw8 & 0x1) && parity[i]) + +net/wireless/nl80211.c:14305: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 14303. struct sk_buff *msg; + 14304. void *hdr; + 14305. > u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid); + 14306. + 14307. if (!nlportid) + +drivers/gpu/drm/i915/intel_display.c:15195: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 15193. + 15194. if (ret) + 15195. > DRM_ERROR("Restoring old state failed with %i\n", ret); + 15196. if (state) + 15197. drm_atomic_state_put(state); + +net/wireless/nl80211.c:15181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15179. rcu_read_lock(); + 15180. + 15181. > list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) { + 15182. struct cfg80211_sched_scan_request *sched_scan_req; + 15183. + +net/wireless/nl80211.c:15184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15182. struct cfg80211_sched_scan_request *sched_scan_req; + 15183. + 15184. > list_for_each_entry_rcu(sched_scan_req, + 15185. &rdev->sched_scan_req_list, + 15186. list) { + +net/wireless/nl80211.c:15193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15191. } + 15192. + 15193. > list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) { + 15194. cfg80211_mlme_unregister_socket(wdev, notify->portid); + 15195. + +Summary of the reports + + UNINITIALIZED_VALUE: 4642 + DEAD_STORE: 853 + NULL_DEREFERENCE: 210 + MEMORY_LEAK: 15 + RESOURCE_LEAK: 9 \ No newline at end of file diff --git a/infer/results/v416/infer0131/analysisconfig b/infer/results/v416/infer0131/analysisconfig new file mode 100644 index 0000000..c143574 --- /dev/null +++ b/infer/results/v416/infer0131/analysisconfig @@ -0,0 +1,6 @@ +KERNEL_HEAD_SHA="0adb32858b0b" +KERNEL_CONFIG="defconfig" +INFERCONFIG_LOCATION="../infer/results/v416/inferconfig" +KERNEL_REPOSITORY="stable" +DONT_RUN_ANALYZE=1 + diff --git a/infer/results/v416/infer0131/bugs.txt b/infer/results/v416/infer0131/bugs.txt new file mode 100644 index 0000000..eab1f15 --- /dev/null +++ b/infer/results/v416/infer0131/bugs.txt @@ -0,0 +1,18144 @@ +Found 2267 issues + +arch/x86/lib/msr.c:11: error: DEAD_STORE + The value written to &msrs is never used. + 9. struct msr *msrs_alloc(void) + 10. { + 11. > struct msr *msrs = NULL; + 12. + 13. msrs = alloc_percpu(struct msr); + +arch/x86/pci/init.c:12: error: DEAD_STORE + The value written to &type is never used. + 10. { + 11. #ifdef CONFIG_PCI_DIRECT + 12. > int type = 0; + 13. + 14. type = pci_direct_probe(); + +tools/include/asm-generic/bitops/fls.h:36: error: DEAD_STORE + The value written to &x is never used. + 34. } + 35. if (!(x & 0x80000000u)) { + 36. > x <<= 1; + 37. r -= 1; + 38. } + +block/blk-merge.c:50: error: DEAD_STORE + The value written to &tmp is never used. + 48. + 49. tmp = bio->bi_iter.bi_sector + split_sectors - alignment; + 50. > tmp = sector_div(tmp, granularity); + 51. + 52. if (split_sectors > tmp) + +tools/lib/subcmd/help.c:20: error: NULL_DEREFERENCE + pointer `ent` last assigned on line 18 could be null and is dereferenced at line 20, column 2. + 18. struct cmdname *ent = malloc(sizeof(*ent) + len + 1); + 19. + 20. > ent->len = len; + 21. memcpy(ent->name, name, len); + 22. ent->name[len] = 0; + +drivers/clk/clk-fractional-divider.c:23: error: DEAD_STORE + The value written to &flags is never used. + 21. { + 22. struct clk_fractional_divider *fd = to_clk_fd(hw); + 23. > unsigned long flags = 0; + 24. unsigned long m, n; + 25. u32 val; + +sound/hda/trace.h:19: error: DEAD_STORE + The value written to &p is never used. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +tools/lib/subcmd/sigchain.c:30: error: MEMORY_LEAK + memory dynamically allocated by call to `xrealloc()` at line 26, column 2 is not reachable after line 30, column 2. + 28. if (s->old[s->n] == SIG_ERR) + 29. return -1; + 30. > s->n++; + 31. return 0; + 32. } + +tools/lib/subcmd/sigchain.c:29: error: MEMORY_LEAK + memory dynamically allocated to `return` by call to `xrealloc()` at line 26, column 2 is not reachable after line 29, column 3. + 27. s->old[s->n] = signal(sig, f); + 28. if (s->old[s->n] == SIG_ERR) + 29. > return -1; + 30. s->n++; + 31. return 0; + +lib/assoc_array.c:101: error: DEAD_STORE + The value written to &cursor is never used. + 99. if (assoc_array_ptr_is_shortcut(parent)) { + 100. shortcut = assoc_array_ptr_to_shortcut(parent); + 101. > cursor = parent; + 102. parent = READ_ONCE(shortcut->back_pointer); /* Address dependency. */ + 103. slot = shortcut->parent_slot; + +net/ipv6/ip6_offload.c:25: error: DEAD_STORE + The value written to &ops is never used. + 23. static int ipv6_gso_pull_exthdrs(struct sk_buff *skb, int proto) + 24. { + 25. > const struct net_offload *ops = NULL; + 26. + 27. for (;;) { + +tools/include/tools/be_byteshift.h:26: error: DEAD_STORE + The value written to &p is never used. + 24. { + 25. *p++ = val >> 8; + 26. > *p++ = val; + 27. } + 28. + +tools/include/tools/le_byteshift.h:26: error: DEAD_STORE + The value written to &p is never used. + 24. { + 25. *p++ = val; + 26. > *p++ = val >> 8; + 27. } + 28. + +drivers/dma-buf/seqno-fence.c:28: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 26 could be null and is dereferenced at line 28, column 9. + 26. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 27. + 28. > return seqno_fence->ops->get_driver_name(fence); + 29. } + 30. + +drivers/pci/proc.c:100: error: DEAD_STORE + The value written to &buf is never used. + 98. pci_user_read_config_byte(dev, pos, &val); + 99. __put_user(val, buf); + 100. > buf++; + 101. pos++; + 102. cnt--; + +drivers/pci/proc.c:102: error: DEAD_STORE + The value written to &cnt is never used. + 100. buf++; + 101. pos++; + 102. > cnt--; + 103. } + 104. + +lib/ratelimit.c:42: error: DEAD_STORE + The value written to &flags is never used. + 40. * the entity that is holding the lock already: + 41. */ + 42. > if (!raw_spin_trylock_irqsave(&rs->lock, flags)) + 43. return 0; + 44. + +block/partitions/amiga.c:36: error: DEAD_STORE + The value written to &blksize is never used. + 34. struct PartitionBlock *pb; + 35. int start_sect, nr_sects, blk, part, res = 0; + 36. > int blksize = 1; /* Multiplier for disk block size */ + 37. int slot = 1; + 38. char b[BDEVNAME_SIZE]; + +drivers/ras/ras.c:31: error: DEAD_STORE + The value written to &rc is never used. + 29. static int __init ras_init(void) + 30. { + 31. > int rc = 0; + 32. + 33. ras_debugfs_init(); + +drivers/scsi/scsi_trace.c:33: error: DEAD_STORE + The value written to &txlen is never used. + 31. { + 32. const char *ret = trace_seq_buffer_ptr(p); + 33. > sector_t lba = 0, txlen = 0; + 34. + 35. lba |= ((cdb[1] & 0x1F) << 16); + +tools/objtool/warn.h:48: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 48, column 3. + 46. + 47. if (func) + 48. > sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. sprintf(str, "%s+0x%lx", name, name_off); + +tools/objtool/warn.h:50: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 50, column 3. + 48. sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. > sprintf(str, "%s+0x%lx", name, name_off); + 51. + 52. return str; + +drivers/dma-buf/seqno-fence.c:35: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 33 could be null and is dereferenced at line 35, column 9. + 33. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 34. + 35. > return seqno_fence->ops->get_timeline_name(fence); + 36. } + 37. + +drivers/edac/edac_pci.c:40: error: DEAD_STORE + The value written to &pci is never used. + 38. edac_dbg(1, "\n"); + 39. + 40. > pci = edac_align_ptr(&p, sizeof(*pci), 1); + 41. pvt = edac_align_ptr(&p, 1, sz_pvt); + 42. size = ((unsigned long)pvt) + sz_pvt; + +kernel/power/process.c:44: error: DEAD_STORE + The value written to &end_time is never used. + 42. start = ktime_get_boottime(); + 43. + 44. > end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs); + 45. + 46. if (!user_only) + +kernel/power/process.c:40: error: DEAD_STORE + The value written to &sleep_usecs is never used. + 38. unsigned int elapsed_msecs; + 39. bool wakeup = false; + 40. > int sleep_usecs = USEC_PER_MSEC; + 41. + 42. start = ktime_get_boottime(); + +kernel/power/process.c:81: error: DEAD_STORE + The value written to &sleep_usecs is never used. + 79. usleep_range(sleep_usecs / 2, sleep_usecs); + 80. if (sleep_usecs < 8 * USEC_PER_MSEC) + 81. > sleep_usecs *= 2; + 82. } + 83. + +sound/hda/trace.h:31: error: DEAD_STORE + The value written to &p is never used. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +drivers/scsi/scsi_logging.c:36: error: DEAD_STORE + The value written to &idx is never used. + 34. struct scsi_log_buf *buf; + 35. unsigned long map_bits = sizeof(buf->buffer) / SCSI_LOG_BUFSIZE; + 36. > unsigned long idx = 0; + 37. + 38. preempt_disable(); + +drivers/base/module.c:62: error: DEAD_STORE + The value written to &no_warn is never used. + 60. + 61. /* Don't check return codes; these calls are idempotent */ + 62. > no_warn = sysfs_create_link(&drv->p->kobj, &mk->kobj, "module"); + 63. driver_name = make_driver_name(drv); + 64. if (driver_name) { + +drivers/base/module.c:66: error: DEAD_STORE + The value written to &no_warn is never used. + 64. if (driver_name) { + 65. module_create_drivers_dir(mk); + 66. > no_warn = sysfs_create_link(mk->drivers_dir, &drv->p->kobj, + 67. driver_name); + 68. kfree(driver_name); + +lib/decompress_unlz4.c:41: error: DEAD_STORE + The value written to &chunksize is never used. + 39. { + 40. int ret = -1; + 41. > size_t chunksize = 0; + 42. size_t uncomp_chunksize = LZ4_DEFAULT_UNCOMPRESSED_CHUNK_SIZE; + 43. u8 *inp; + +lib/mpi/mpicoder.c:41: error: DEAD_STORE + The value written to &val is never used. + 39. unsigned nbits, nlimbs; + 40. mpi_limb_t a; + 41. > MPI val = NULL; + 42. + 43. while (nbytes > 0 && buffer[0] == 0) { + +lib/mpi/mpi-pow.c:56: error: DEAD_STORE + The value written to &esign is never used. + 54. msize = mod->nlimbs; + 55. size = 2 * msize; + 56. > esign = exp->sign; + 57. msign = mod->sign; + 58. + +drivers/dma-buf/seqno-fence.c:42: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 40 could be null and is dereferenced at line 42, column 9. + 40. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 41. + 42. > return seqno_fence->ops->enable_signaling(fence); + 43. } + 44. + +tools/objtool/builtin-orc.c:47: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 66, column 22) -> ShellExec(execvp at line 180, column 2). + 45. + 46. if (!strncmp(argv[0], "gen", 3)) { + 47. > argc = parse_options(argc, argv, check_options, orc_usage, 0); + 48. if (argc != 1) + 49. usage_with_options(orc_usage, check_options); + +tools/objtool/builtin-orc.c:49: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 66, column 22) -> ShellExec(execvp at line 180, column 2). + 47. argc = parse_options(argc, argv, check_options, orc_usage, 0); + 48. if (argc != 1) + 49. > usage_with_options(orc_usage, check_options); + 50. + 51. objname = argv[0]; + +tools/objtool/builtin-orc.c:58: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 66, column 22) -> ShellExec(execvp at line 180, column 2). + 56. if (!strcmp(argv[0], "dump")) { + 57. if (argc != 2) + 58. > usage_with_options(orc_usage, check_options); + 59. + 60. objname = argv[1]; + +tools/objtool/builtin-orc.c:65: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 66, column 22) -> ShellExec(execvp at line 180, column 2). + 63. } + 64. + 65. > usage_with_options(orc_usage, check_options); + 66. + 67. return 0; + +net/ipv6/netfilter/nf_log_ipv6.c:49: error: DEAD_STORE + The value written to &hdrlen is never used. + 47. const struct ipv6hdr *ih; + 48. unsigned int ptr; + 49. > unsigned int hdrlen = 0; + 50. unsigned int logflags; + 51. + +drivers/video/backlight/backlight.c:46: error: DEAD_STORE + The value written to &fb_blank is never used. + 44. struct fb_event *evdata = data; + 45. int node = evdata->info->node; + 46. > int fb_blank = 0; + 47. + 48. /* If we aren't interested in this event, skip it immediately ... */ + +drivers/clocksource/acpi_pm.c:43: error: DEAD_STORE + The value written to &v1 is never used. + 41. u32 acpi_pm_read_verified(void) + 42. { + 43. > u32 v1 = 0, v2 = 0, v3 = 0; + 44. + 45. /* + +drivers/clocksource/acpi_pm.c:43: error: DEAD_STORE + The value written to &v2 is never used. + 41. u32 acpi_pm_read_verified(void) + 42. { + 43. > u32 v1 = 0, v2 = 0, v3 = 0; + 44. + 45. /* + +drivers/clocksource/acpi_pm.c:43: error: DEAD_STORE + The value written to &v3 is never used. + 41. u32 acpi_pm_read_verified(void) + 42. { + 43. > u32 v1 = 0, v2 = 0, v3 = 0; + 44. + 45. /* + +drivers/clk/clk-gate.c:46: error: DEAD_STORE + The value written to &flags is never used. + 44. struct clk_gate *gate = to_clk_gate(hw); + 45. int set = gate->flags & CLK_GATE_SET_TO_DISABLE ? 1 : 0; + 46. > unsigned long uninitialized_var(flags); + 47. u32 reg; + 48. + +drivers/usb/core/driver.c:52: error: DEAD_STORE + The value written to &fields is never used. + 50. unsigned int bInterfaceClass = 0; + 51. u32 refVendor, refProduct; + 52. > int fields = 0; + 53. int retval = 0; + 54. + +drivers/usb/core/driver.c:53: error: DEAD_STORE + The value written to &retval is never used. + 51. u32 refVendor, refProduct; + 52. int fields = 0; + 53. > int retval = 0; + 54. + 55. fields = sscanf(buf, "%x %x %x %x %x", &idVendor, &idProduct, + +sound/hda/trace.h:43: error: DEAD_STORE + The value written to &p is never used. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +net/ipv4/tcp_ulp.c:46: error: DEAD_STORE + The value written to &ulp is never used. + 44. static const struct tcp_ulp_ops *__tcp_ulp_find_autoload(const char *name) + 45. { + 46. > const struct tcp_ulp_ops *ulp = NULL; + 47. + 48. rcu_read_lock(); + +security/keys/process_keys.c:67: error: DEAD_STORE + The value written to &ret is never used. + 65. + 66. mutex_lock(&key_user_keyring_mutex); + 67. > ret = 0; + 68. + 69. if (!user->uid_keyring) { + +drivers/dma-buf/seqno-fence.c:49: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 47 could be null and is dereferenced at line 49, column 9. + 47. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 48. + 49. > return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence); + 50. } + 51. + +drivers/usb/core/otg_whitelist.h:47: error: DEAD_STORE + The value written to &id is never used. + 45. static int is_targeted(struct usb_device *dev) + 46. { + 47. > struct usb_device_id *id = whitelist_table; + 48. + 49. /* HNP test device is _never_ targeted (see OTG spec 6.6.6) */ + +drivers/thermal/thermal_helpers.c:50: error: DEAD_STORE + The value written to &pos is never used. + 48. struct thermal_cooling_device *cdev, int trip) + 49. { + 50. > struct thermal_instance *pos = NULL; + 51. struct thermal_instance *target_instance = NULL; + 52. + +drivers/base/syscore.c:50: error: DEAD_STORE + The value written to &ret is never used. + 48. { + 49. struct syscore_ops *ops; + 50. > int ret = 0; + 51. + 52. trace_suspend_resume(TPS("syscore_suspend"), 0, true); + +kernel/power/user.c:79: error: DEAD_STORE + The value written to &nr_calls is never used. + 77. error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls); + 78. if (error) + 79. > __pm_notifier_call_chain(PM_POST_HIBERNATION, --nr_calls, NULL); + 80. } else { + 81. /* + +security/selinux/ss/status.c:50: error: DEAD_STORE + The value written to &result is never used. + 48. { + 49. struct selinux_kernel_status *status; + 50. > struct page *result = NULL; + 51. + 52. mutex_lock(&selinux_status_lock); + +tools/objtool/builtin-check.c:54: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 66, column 22) -> ShellExec(execvp at line 180, column 2). + 52. + 53. if (argc != 1) + 54. > usage_with_options(check_usage, check_options); + 55. + 56. objname = argv[0]; + +drivers/edac/edac_device.c:78: error: DEAD_STORE + The value written to &dev_ctl is never used. + 76. */ + 77. p = NULL; + 78. > dev_ctl = edac_align_ptr(&p, sizeof(*dev_ctl), 1); + 79. + 80. /* Calc the 'end' offset past end of ONE ctl_info structure + +kernel/futex_compat.c:103: error: DEAD_STORE + The value written to &uentry is never used. + 101. if (rc) + 102. return; + 103. > uentry = next_uentry; + 104. entry = next_entry; + 105. pi = next_pi; + +drivers/dma-buf/seqno-fence.c:56: error: NULL_DEREFERENCE + pointer `f` last assigned on line 54 could be null and is dereferenced at line 56, column 14. + 54. struct seqno_fence *f = to_seqno_fence(fence); + 55. + 56. > dma_buf_put(f->sync_buf); + 57. if (f->ops->release) + 58. f->ops->release(fence); + +drivers/gpu/drm/drm_encoder_slave.c:60: error: DEAD_STORE + The value written to &err is never used. + 58. struct i2c_client *client; + 59. struct drm_i2c_encoder_driver *encoder_drv; + 60. > int err = 0; + 61. + 62. request_module("%s%s", I2C_MODULE_PREFIX, info->type); + +drivers/video/fbdev/core/sysimgblt.c:57: error: DEAD_STORE + The value written to &color is never used. + 55. /* Draw the penguin */ + 56. u32 *dst, *dst2; + 57. > u32 color = 0, val, shift; + 58. int i, n, bpp = p->var.bits_per_pixel; + 59. u32 null_bits = 32 - bpp; + +drivers/hid/hid-generic.c:57: error: DEAD_STORE + The value written to &ret is never used. + 55. int ret; + 56. + 57. > ret = driver_attach(&hid_generic.driver); + 58. } + 59. + +net/ipv6/anycast.c:56: error: DEAD_STORE + The value written to &dev is never used. + 54. { + 55. struct ipv6_pinfo *np = inet6_sk(sk); + 56. > struct net_device *dev = NULL; + 57. struct inet6_dev *idev; + 58. struct ipv6_ac_socklist *pac; + +net/ipv6/inet6_hashtables.c:63: error: DEAD_STORE + The value written to &ports is never used. + 61. struct sock *sk; + 62. const struct hlist_nulls_node *node; + 63. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 64. /* Optimize here for direct hit, only listening connections can + 65. * have wildcards anyways. + +crypto/cmac.c:63: error: DEAD_STORE + The value written to &err is never used. + 61. (alignmask | (__alignof__(__be64) - 1)) + 1); + 62. u64 _const[2]; + 63. > int i, err = 0; + 64. u8 msb_mask, gfmask; + 65. + +drivers/dma-buf/dma-fence-array.c:61: error: NULL_DEREFERENCE + pointer `array` last assigned on line 57 could be null and is dereferenced at line 61, column 18. + 59. unsigned i; + 60. + 61. > for (i = 0; i < array->num_fences; ++i) { + 62. cb[i].array = array; + 63. /* + +sound/hda/trace.h:55: error: DEAD_STORE + The value written to &p is never used. + 53. ); + 54. + 55. > DECLARE_EVENT_CLASS(hdac_stream, + 56. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 57. + +lib/decompress_unlzo.c:60: error: DEAD_STORE + The value written to &level is never used. + 58. u8 *parse = input; + 59. u8 *end = input + in_len; + 60. > u8 level = 0; + 61. u16 version; + 62. + +lib/decompress_unlzo.c:82: error: DEAD_STORE + The value written to &level is never used. + 80. parse += 7; + 81. if (version >= 0x0940) + 82. > level = *parse++; + 83. if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) + 84. parse += 8; /* flags + filter info */ + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:61: error: DEAD_STORE + The value written to &level is never used. + 59. struct intel_dp *intel_dp = enc_to_intel_dp(&connector->encoder->base); + 60. uint8_t read_val[2] = { 0x0 }; + 61. > uint16_t level = 0; + 62. + 63. if (drm_dp_dpcd_read(&intel_dp->aux, DP_EDP_BACKLIGHT_BRIGHTNESS_MSB, + +kernel/time/tick-sched.c:88: error: DEAD_STORE + The value written to &ticks is never used. + 86. incr * ticks); + 87. } + 88. > do_timer(++ticks); + 89. + 90. /* Keep the tick_next_period variable up to date */ + +net/sunrpc/cache.c:60: error: DEAD_STORE + The value written to &new is never used. + 58. struct cache_head *key, int hash) + 59. { + 60. > struct cache_head *new = NULL, *freeme = NULL, *tmp = NULL; + 61. struct hlist_head *head; + 62. + +net/sunrpc/cache.c:60: error: DEAD_STORE + The value written to &tmp is never used. + 58. struct cache_head *key, int hash) + 59. { + 60. > struct cache_head *new = NULL, *freeme = NULL, *tmp = NULL; + 61. struct hlist_head *head; + 62. + +arch/x86/pci/amd_bus.c:128: error: DEAD_STORE + The value written to &info is never used. + 126. link = (reg >> 8) & 0x03; + 127. + 128. > info = alloc_pci_root_info(min_bus, max_bus, node, link); + 129. } + 130. + +net/dns_resolver/dns_key.c:66: error: DEAD_STORE + The value written to &result_len is never used. + 64. unsigned long derrno; + 65. int ret; + 66. > int datalen = prep->datalen, result_len = 0; + 67. const char *data = prep->data, *end, *opt; + 68. + +block/badblocks.c:76: error: DEAD_STORE + The value written to §ors is never used. + 74. target += (1<shift) - 1; + 75. target >>= bb->shift; + 76. > sectors = target - s; + 77. } + 78. /* 'target' is now the first block after the bad range */ + +sound/core/vmaster.c:70: error: DEAD_STORE + The value written to &err is never used. + 68. return -ENOMEM; + 69. uctl->id = slave->slave.id; + 70. > err = slave->slave.get(&slave->slave, uctl); + 71. for (ch = 0; ch < slave->info.count; ch++) + 72. slave->vals[ch] = uctl->value.integer.value[ch]; + +drivers/dma-buf/seqno-fence.c:68: error: NULL_DEREFERENCE + pointer `f` last assigned on line 66 could be null and is dereferenced at line 68, column 9. + 66. struct seqno_fence *f = to_seqno_fence(fence); + 67. + 68. > return f->ops->wait(fence, intr, timeout); + 69. } + 70. + +drivers/char/agp/isoch.c:140: error: DEAD_STORE + The value written to &mcapndx is never used. + 138. dev = cur->dev; + 139. + 140. > mcapndx = cur->capndx; + 141. + 142. pci_read_config_dword(dev, cur->capndx+AGPNISTAT, &mnistat); + +drivers/char/agp/isoch.c:253: error: DEAD_STORE + The value written to &mcapndx is never used. + 251. dev = cur->dev; + 252. + 253. > mcapndx = cur->capndx; + 254. + 255. master[cdev].rq += (cdev == ndevs - 1) + +tools/lib/subcmd/pager.c:92: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 66, column 22) -> ShellExec(execvp at line 180, column 2). + 90. pager_process.preexec_cb = pager_preexec; + 91. + 92. > if (start_command(&pager_process)) + 93. return; + 94. + +tools/lib/subcmd/pager.c:92: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 74, column 11) -> ShellExec(execvp at line 180, column 2). + 90. pager_process.preexec_cb = pager_preexec; + 91. + 92. > if (start_command(&pager_process)) + 93. return; + 94. + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &timeout__ is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &wait__ is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +drivers/clk/clk-mux.c:70: error: DEAD_STORE + The value written to &flags is never used. + 68. struct clk_mux *mux = to_clk_mux(hw); + 69. u32 val; + 70. > unsigned long flags = 0; + 71. + 72. if (mux->table) { + +lib/bug.c:69: error: DEAD_STORE + The value written to &bug is never used. + 67. { + 68. struct module *mod; + 69. > struct bug_entry *bug = NULL; + 70. + 71. rcu_read_lock_sched(); + +kernel/sched/cpupri.c:71: error: DEAD_STORE + The value written to &idx is never used. + 69. struct cpumask *lowest_mask) + 70. { + 71. > int idx = 0; + 72. int task_pri = convert_prio(p->prio); + 73. + +net/ipv6/xfrm6_mode_transport.c:77: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 74 could be null and is dereferenced at line 77, column 8. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +net/ipv4/syncookies.c:73: error: DEAD_STORE + The value written to &options is never used. + 71. struct inet_request_sock *ireq; + 72. u32 ts, ts_now = tcp_time_stamp_raw(); + 73. > u32 options = 0; + 74. + 75. ireq = inet_rsk(req); + +arch/x86/ia32/sys_ia32.c:73: error: DEAD_STORE + The value written to &gid is never used. + 71. { + 72. typeof(ubuf->st_uid) uid = 0; + 73. > typeof(ubuf->st_gid) gid = 0; + 74. SET_UID(uid, from_kuid_munged(current_user_ns(), stat->uid)); + 75. SET_GID(gid, from_kgid_munged(current_user_ns(), stat->gid)); + +arch/x86/ia32/sys_ia32.c:72: error: DEAD_STORE + The value written to &uid is never used. + 70. static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat) + 71. { + 72. > typeof(ubuf->st_uid) uid = 0; + 73. typeof(ubuf->st_gid) gid = 0; + 74. SET_UID(uid, from_kuid_munged(current_user_ns(), stat->uid)); + +drivers/scsi/scsi_pm.c:74: error: DEAD_STORE + The value written to &err is never used. + 72. { + 73. const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; + 74. > int err = 0; + 75. + 76. err = cb(dev, pm); + +kernel/irq/chip.c:74: error: DEAD_STORE + The value written to &ret is never used. + 72. unsigned long flags; + 73. struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL); + 74. > int ret = 0; + 75. + 76. if (!desc) + +crypto/sha256_generic.c:230: error: DEAD_STORE + The value written to &a is never used. + 228. + 229. /* clear any sensitive info... */ + 230. > a = b = c = d = e = f = g = h = t1 = t2 = 0; + 231. memzero_explicit(W, 64 * sizeof(u32)); + 232. } + +arch/x86/platform/efi/efi_64.c:104: error: DEAD_STORE + The value written to &vaddr is never used. + 102. for (pgd = 0; pgd < n_pgds; pgd++) { + 103. addr_pgd = (unsigned long)(pgd * PGDIR_SIZE); + 104. > vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. save_pgd[pgd] = *pgd_efi; + +arch/x86/platform/efi/efi_64.c:106: error: NULL_DEREFERENCE + pointer `save_pgd` last assigned on line 92 could be null and is dereferenced at line 106, column 3. + 104. vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. > save_pgd[pgd] = *pgd_efi; + 107. + 108. p4d = p4d_alloc(&init_mm, pgd_efi, addr_pgd); + +tools/objtool/orc_dump.c:102: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 102, column 3. + 100. elf = elf_begin(fd, ELF_C_READ_MMAP, NULL); + 101. if (!elf) { + 102. > WARN_ELF("elf_begin"); + 103. return -1; + 104. } + +tools/objtool/orc_dump.c:107: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 107, column 3. + 105. + 106. if (elf_getshdrnum(elf, &nr_sections)) { + 107. > WARN_ELF("elf_getshdrnum"); + 108. return -1; + 109. } + +tools/objtool/orc_dump.c:112: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 112, column 3. + 110. + 111. if (elf_getshdrstrndx(elf, &shstrtab_idx)) { + 112. > WARN_ELF("elf_getshdrstrndx"); + 113. return -1; + 114. } + +tools/objtool/orc_dump.c:119: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 119, column 4. + 117. scn = elf_getscn(elf, i); + 118. if (!scn) { + 119. > WARN_ELF("elf_getscn"); + 120. return -1; + 121. } + +tools/objtool/orc_dump.c:124: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 124, column 4. + 122. + 123. if (!gelf_getshdr(scn, &sh)) { + 124. > WARN_ELF("gelf_getshdr"); + 125. return -1; + 126. } + +tools/objtool/orc_dump.c:130: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 130, column 4. + 128. name = elf_strptr(elf, shstrtab_idx, sh.sh_name); + 129. if (!name) { + 130. > WARN_ELF("elf_strptr"); + 131. return -1; + 132. } + +tools/objtool/orc_dump.c:136: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 136, column 4. + 134. data = elf_getdata(scn, NULL); + 135. if (!data) { + 136. > WARN_ELF("elf_getdata"); + 137. return -1; + 138. } + +drivers/gpu/drm/drm_property.c:78: error: DEAD_STORE + The value written to &property is never used. + 76. const char *name, int num_values) + 77. { + 78. > struct drm_property *property = NULL; + 79. int ret; + 80. + +drivers/video/fbdev/core/cfbimgblt.c:82: error: DEAD_STORE + The value written to &color is never used. + 80. /* Draw the penguin */ + 81. u32 __iomem *dst, *dst2; + 82. > u32 color = 0, val, shift; + 83. int i, n, bpp = p->var.bits_per_pixel; + 84. u32 null_bits = 32 - bpp; + +drivers/power/supply/power_supply_sysfs.c:79: error: DEAD_STORE + The value written to &ret is never used. + 77. struct device_attribute *attr, + 78. char *buf) { + 79. > ssize_t ret = 0; + 80. struct power_supply *psy = dev_get_drvdata(dev); + 81. const ptrdiff_t off = attr - power_supply_attrs; + +kernel/cgroup/stat.c:96: error: NULL_DEREFERENCE + pointer `pos` last assigned on line 92 could be null and is dereferenced by call to `cgroup_cpu_stat()` at line 96, column 11. + 94. /* walk down to the first leaf */ + 95. while (true) { + 96. > cstat = cgroup_cpu_stat(pos, cpu); + 97. if (cstat->updated_children == pos) + 98. break; + +drivers/net/ethernet/intel/e1000e/phy.c:80: error: DEAD_STORE + The value written to &ret_val is never used. + 78. { + 79. struct e1000_phy_info *phy = &hw->phy; + 80. > s32 ret_val = 0; + 81. u16 phy_id; + 82. u16 retry_count = 0; + +drivers/gpu/drm/drm_global.c:80: error: DEAD_STORE + The value written to &ret is never used. + 78. int drm_global_item_ref(struct drm_global_reference *ref) + 79. { + 80. > int ret = 0; + 81. struct drm_global_item *item = &glob[ref->global_type]; + 82. + +drivers/pps/kapi.c:88: error: DEAD_STORE + The value written to &err is never used. + 86. pr_err("%s: unsupported default parameters\n", + 87. info->name); + 88. > err = -EINVAL; + 89. goto pps_register_source_exit; + 90. } + +drivers/pps/kapi.c:94: error: DEAD_STORE + The value written to &err is never used. + 92. pr_err("%s: unspecified time format\n", + 93. info->name); + 94. > err = -EINVAL; + 95. goto pps_register_source_exit; + 96. } + +drivers/pps/kapi.c:101: error: DEAD_STORE + The value written to &err is never used. + 99. pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL); + 100. if (pps == NULL) { + 101. > err = -ENOMEM; + 102. goto pps_register_source_exit; + 103. } + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:90: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 84 could be null and is dereferenced at line 90, column 6. + 88. + 89. /* Write the MSB and/or LSB */ + 90. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) { + 91. vals[0] = (level & 0xFF00) >> 8; + 92. vals[1] = (level & 0xFF); + +drivers/pnp/driver.c:85: error: DEAD_STORE + The value written to &dev_id is never used. + 83. struct pnp_driver *pnp_drv; + 84. struct pnp_dev *pnp_dev; + 85. > const struct pnp_device_id *dev_id = NULL; + 86. pnp_dev = to_pnp_dev(dev); + 87. pnp_drv = to_pnp_driver(dev->driver); + +net/core/net-sysfs.c:87: error: DEAD_STORE + The value written to &ret is never used. + 85. struct net *net = dev_net(netdev); + 86. unsigned long new; + 87. > int ret = -EINVAL; + 88. + 89. if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) + +net/ipv4/ping.c:87: error: DEAD_STORE + The value written to &sk2 is never used. + 85. struct hlist_nulls_head *hlist; + 86. struct inet_sock *isk, *isk2; + 87. > struct sock *sk2 = NULL; + 88. + 89. isk = inet_sk(sk); + +net/ipv6/xfrm6_input.c:88: error: DEAD_STORE + The value written to &i is never used. + 86. struct net *net = dev_net(skb->dev); + 87. struct xfrm_state *x = NULL; + 88. > int i = 0; + 89. + 90. if (secpath_set(skb)) { + +drivers/i2c/algos/i2c-algo-bit.c:94: error: DEAD_STORE + The value written to &start is never used. + 92. goto done; + 93. + 94. > start = jiffies; + 95. while (!getscl(adap)) { + 96. /* This hw knows how to read the clock line, so we wait + +drivers/usb/core/usb-acpi.c:100: error: DEAD_STORE + The value written to &status is never used. + 98. * no connectable, the port would be not used. + 99. */ + 100. > status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer); + 101. upc = buffer.pointer; + 102. if (!upc || (upc->type != ACPI_TYPE_PACKAGE) + +net/netlabel/netlabel_calipso.c:88: error: DEAD_STORE + The value written to &doi_def is never used. + 86. { + 87. int ret_val; + 88. > struct calipso_doi *doi_def = NULL; + 89. + 90. doi_def = kmalloc(sizeof(*doi_def), GFP_KERNEL); + +sound/hda/hdac_controller.c:88: error: DEAD_STORE + The value written to &timeout is never used. + 86. unsigned long timeout; + 87. + 88. > timeout = jiffies + msecs_to_jiffies(100); + 89. while ((snd_hdac_chip_readb(bus, RIRBCTL) & AZX_RBCTL_DMA_EN) + 90. && time_before(jiffies, timeout)) + +sound/hda/hdac_controller.c:93: error: DEAD_STORE + The value written to &timeout is never used. + 91. udelay(10); + 92. + 93. > timeout = jiffies + msecs_to_jiffies(100); + 94. while ((snd_hdac_chip_readb(bus, CORBCTL) & AZX_CORBCTL_RUN) + 95. && time_before(jiffies, timeout)) + +crypto/rsa.c:91: error: DEAD_STORE + The value written to &ret is never used. + 89. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 90. MPI m, c = mpi_alloc(0); + 91. > int ret = 0; + 92. int sign; + 93. + +drivers/gpu/drm/drm_probe_helper.c:92: error: DEAD_STORE + The value written to &ret is never used. + 90. struct drm_device *dev = connector->dev; + 91. uint32_t *ids = connector->encoder_ids; + 92. > enum drm_mode_status ret = MODE_OK; + 93. unsigned int i; + 94. + +lib/zlib_inflate/inffast.c:257: error: DEAD_STORE + The value written to &from is never used. + 255. PUP(out) = PUP(from); + 256. if (len > 1) + 257. > PUP(out) = PUP(from); + 258. } + 259. } + +lib/zlib_inflate/inffast.c:304: error: DEAD_STORE + The value written to &from is never used. + 302. } + 303. if (len & 1) + 304. > PUP(out) = PUP(from); + 305. } + 306. } + +crypto/ccm.c:96: error: DEAD_STORE + The value written to &err is never used. + 94. struct crypto_skcipher *ctr = ctx->ctr; + 95. struct crypto_ahash *mac = ctx->mac; + 96. > int err = 0; + 97. + 98. crypto_skcipher_clear_flags(ctr, CRYPTO_TFM_REQ_MASK); + +drivers/dma-buf/dma-fence-array.c:95: error: NULL_DEREFERENCE + pointer `array` last assigned on line 92 could be null and is dereferenced at line 95, column 18. + 93. unsigned i; + 94. + 95. > for (i = 0; i < array->num_fences; ++i) + 96. dma_fence_put(array->fences[i]); + 97. + +drivers/edac/edac_mc.c:92: error: DEAD_STORE + The value written to &ret is never used. + 90. static int edac_report_get(char *buffer, const struct kernel_param *kp) + 91. { + 92. > int ret = 0; + 93. + 94. switch (edac_report) { + +net/netfilter/nf_nat_sip.c:112: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 99 could be null and is dereferenced at line 112, column 13. + 110. ct->tuplehash[dir].tuple.dst.u.udp.port == port) { + 111. newaddr = ct->tuplehash[!dir].tuple.src.u3; + 112. > newport = ct_sip_info->forced_dport ? : + 113. ct->tuplehash[!dir].tuple.src.u.udp.port; + 114. } else + +drivers/clk/clk-fractional-divider.c:98: error: DEAD_STORE + The value written to &flags is never used. + 96. { + 97. struct clk_fractional_divider *fd = to_clk_fd(hw); + 98. > unsigned long flags = 0; + 99. unsigned long m, n; + 100. u32 val; + +drivers/video/fbdev/core/fbmem.c:97: error: DEAD_STORE + The value written to &depth is never used. + 95. struct fb_fix_screeninfo *fix) + 96. { + 97. > int depth = 0; + 98. + 99. if (fix->visual == FB_VISUAL_MONO01 || + +security/keys/request_key.c:99: error: DEAD_STORE + The value written to &cred is never used. + 97. { + 98. static char const request_key[] = "/sbin/request-key"; + 99. > const struct cred *cred = current_cred(); + 100. key_serial_t prkey, sskey; + 101. struct key *key = cons->key, *authkey = cons->authkey, *keyring, + +drivers/clk/clk.c:98: error: DEAD_STORE + The value written to &ret is never used. + 96. static int clk_pm_runtime_get(struct clk_core *core) + 97. { + 98. > int ret = 0; + 99. + 100. if (!core->dev) + +drivers/firmware/efi/vars.c:101: error: DEAD_STORE + The value written to &desclength is never used. + 99. { + 100. u16 filepathlength; + 101. > int i, desclength = 0, namelen; + 102. + 103. namelen = ucs2_strnlen(var_name, EFI_VAR_NAME_LEN); + +drivers/scsi/scsi_logging.c:115: error: DEAD_STORE + The value written to &off is never used. + 113. if (!WARN_ON(off >= logbuf_len)) { + 114. va_start(args, fmt); + 115. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 116. va_end(args); + 117. } + +net/sched/ematch.c:98: error: DEAD_STORE + The value written to &e is never used. + 96. static struct tcf_ematch_ops *tcf_em_lookup(u16 kind) + 97. { + 98. > struct tcf_ematch_ops *e = NULL; + 99. + 100. read_lock(&ematch_mod_lock); + +drivers/pci/pci-driver.c:105: error: DEAD_STORE + The value written to &fields is never used. + 103. subdevice = PCI_ANY_ID, class = 0, class_mask = 0; + 104. unsigned long driver_data = 0; + 105. > int fields = 0; + 106. int retval = 0; + 107. + +drivers/pcmcia/ds.c:105: error: DEAD_STORE + The value written to &fields is never used. + 103. __u8 func_id, function, device_no; + 104. __u32 prod_id_hash[4] = {0, 0, 0, 0}; + 105. > int fields = 0; + 106. int retval = 0; + 107. + +drivers/pcmcia/ds.c:106: error: DEAD_STORE + The value written to &retval is never used. + 104. __u32 prod_id_hash[4] = {0, 0, 0, 0}; + 105. int fields = 0; + 106. > int retval = 0; + 107. + 108. fields = sscanf(buf, "%hx %hx %hx %hhx %hhx %hhx %x %x %x %x", + +crypto/jitterentropy-kcapi.c:100: error: DEAD_STORE + The value written to &tmp is never used. + 98. void jent_get_nstime(__u64 *out) + 99. { + 100. > __u64 tmp = 0; + 101. + 102. tmp = random_get_entropy(); + +net/sched/sch_mq.c:103: error: DEAD_STORE + The value written to &qlen is never used. + 101. struct Qdisc *qdisc; + 102. unsigned int ntx; + 103. > __u32 qlen = 0; + 104. + 105. sch->q.qlen = 0; + +drivers/char/agp/frontend.c:112: error: DEAD_STORE + The value written to &num_segments is never used. + 110. pg_count = size / 4096; + 111. seg = *(client->segments); + 112. > num_segments = client->num_segments; + 113. + 114. for (i = 0; i < client->num_segments; i++) { + +drivers/gpu/drm/drm_rect.c:101: error: DEAD_STORE + The value written to &scale is never used. + 99. static int drm_calc_scale(int src, int dst) + 100. { + 101. > int scale = 0; + 102. + 103. if (WARN_ON(src < 0 || dst < 0)) + +drivers/gpu/drm/i915/intel_dp_mst.c:110: error: NULL_DEREFERENCE + pointer `old_conn_state` last assigned on line 109 could be null and is dereferenced at line 110, column 13. + 108. + 109. old_conn_state = drm_atomic_get_old_connector_state(state, connector); + 110. > old_crtc = old_conn_state->crtc; + 111. if (!old_crtc) + 112. return ret; + +kernel/sched/cpuacct.c:104: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 102 could be null and is dereferenced at line 104, column 14. + 102. struct cpuacct *ca = css_ca(css); + 103. + 104. > free_percpu(ca->cpustat); + 105. free_percpu(ca->cpuusage); + 106. kfree(ca); + +drivers/video/fbdev/core/fbcvt.c:103: error: DEAD_STORE + The value written to &hblank is never used. + 101. static u32 fb_cvt_hblank(struct fb_cvt_data *cvt) + 102. { + 103. > u32 hblank = 0; + 104. + 105. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) + +drivers/edac/edac_module.c:104: error: DEAD_STORE + The value written to &err is never used. + 102. static int __init edac_init(void) + 103. { + 104. > int err = 0; + 105. + 106. edac_printk(KERN_INFO, EDAC_MC, EDAC_VERSION "\n"); + +drivers/tty/serial/8250/8250_pci.c:106: error: DEAD_STORE + The value written to &bar is never used. + 104. struct uart_8250_port *port, int idx) + 105. { + 106. > unsigned int bar = 0, offset = board->first_offset; + 107. bar = FL_GET_BASE(board->flags); + 108. + +net/ipv4/netfilter/nf_reject_ipv4.c:128: error: DEAD_STORE + The value written to &niph is never used. + 126. + 127. skb_reserve(nskb, LL_MAX_HEADER); + 128. > niph = nf_reject_iphdr_put(nskb, oldskb, IPPROTO_TCP, + 129. ip4_dst_hoplimit(skb_dst(nskb))); + 130. nf_reject_ip_tcphdr_put(nskb, oldskb, oth); + +net/ipv4/netfilter/nf_reject_ipv4.c:135: error: DEAD_STORE + The value written to &niph is never used. + 133. goto free_nskb; + 134. + 135. > niph = ip_hdr(nskb); + 136. + 137. /* "Never happens" */ + +drivers/input/ff-core.c:109: error: DEAD_STORE + The value written to &ret is never used. + 107. struct ff_device *ff = dev->ff; + 108. struct ff_effect *old; + 109. > int ret = 0; + 110. int id; + 111. + +security/keys/proc.c:122: error: DEAD_STORE + The value written to &key is never used. + 120. break; + 121. } + 122. > key = NULL; + 123. } + 124. + +drivers/leds/led-core.c:109: error: DEAD_STORE + The value written to &ret is never used. + 107. struct led_classdev *led_cdev = + 108. container_of(ws, struct led_classdev, set_brightness_work); + 109. > int ret = 0; + 110. + 111. if (test_and_clear_bit(LED_BLINK_DISABLE, &led_cdev->work_flags)) { + +drivers/pnp/support.c:126: error: DEAD_STORE + The value written to &len is never used. + 124. case IORESOURCE_IO: + 125. port = &option->u.port; + 126. > len += scnprintf(buf + len, sizeof(buf) - len, "io min %#llx " + 127. "max %#llx align %lld size %lld flags %#x", + 128. (unsigned long long) port->min, + +drivers/pnp/support.c:135: error: DEAD_STORE + The value written to &len is never used. + 133. case IORESOURCE_MEM: + 134. mem = &option->u.mem; + 135. > len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx " + 136. "max %#llx align %lld size %lld flags %#x", + 137. (unsigned long long) mem->min, + +drivers/pnp/support.c:158: error: DEAD_STORE + The value written to &len is never used. + 156. irq->flags); + 157. if (irq->flags & IORESOURCE_IRQ_OPTIONAL) + 158. > len += scnprintf(buf + len, sizeof(buf) - len, + 159. " (optional)"); + 160. break; + +drivers/pnp/support.c:174: error: DEAD_STORE + The value written to &len is never used. + 172. " %d", i); + 173. } + 174. > len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) " + 175. "flags %#x", dma->map, dma->flags); + 176. break; + +kernel/cgroup/freezer.c:108: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 107 could be null and is dereferenced by call to `parent_freezer()` at line 108, column 27. + 106. { + 107. struct freezer *freezer = css_freezer(css); + 108. > struct freezer *parent = parent_freezer(freezer); + 109. + 110. mutex_lock(&freezer_mutex); + +crypto/asymmetric_keys/x509_public_key.c:108: error: DEAD_STORE + The value written to &ret is never used. + 106. int x509_check_for_self_signed(struct x509_certificate *cert) + 107. { + 108. > int ret = 0; + 109. + 110. pr_devel("==>%s()\n", __func__); + +drivers/leds/led-triggers.c:109: error: DEAD_STORE + The value written to &event is never used. + 107. { + 108. unsigned long flags; + 109. > char *event = NULL; + 110. char *envp[2]; + 111. const char *name; + +net/ipv6/netfilter/nf_defrag_ipv6_hooks.c:110: error: DEAD_STORE + The value written to &ret is never used. + 108. static int __init nf_defrag_init(void) + 109. { + 110. > int ret = 0; + 111. + 112. ret = nf_ct_frag6_init(); + +kernel/sched/cpuacct.c:129: error: DEAD_STORE + The value written to &i is never used. + 127. + 128. if (index == CPUACCT_STAT_NSTATS) { + 129. > int i = 0; + 130. + 131. data = 0; + +lib/kobject_uevent.c:113: error: DEAD_STORE + The value written to &env is never used. + 111. struct kobj_uevent_env **ret_env) + 112. { + 113. > struct kobj_uevent_env *env = NULL; + 114. const char *next, *buf_end, *key; + 115. int key_len; + +lib/oid_registry.c:129: error: DEAD_STORE + The value written to &num is never used. + 127. + 128. while (v < end) { + 129. > num = 0; + 130. n = *v++; + 131. if (!(n & 0x80)) { + +drivers/clk/clk-multiplier.c:116: error: DEAD_STORE + The value written to &flags is never used. + 114. struct clk_multiplier *mult = to_clk_multiplier(hw); + 115. unsigned long factor = __get_mult(mult, rate, parent_rate); + 116. > unsigned long flags = 0; + 117. unsigned long val; + 118. + +drivers/pci/proc.c:173: error: DEAD_STORE + The value written to &buf is never used. + 171. __get_user(val, buf); + 172. pci_user_write_config_byte(dev, pos, val); + 173. > buf++; + 174. pos++; + 175. cnt--; + +drivers/pci/proc.c:175: error: DEAD_STORE + The value written to &cnt is never used. + 173. buf++; + 174. pos++; + 175. > cnt--; + 176. } + 177. + +drivers/video/fbdev/core/sysimgblt.c:115: error: DEAD_STORE + The value written to &color is never used. + 113. u32 start_index, u32 pitch_index) + 114. { + 115. > u32 shift, color = 0, bpp = p->var.bits_per_pixel; + 116. u32 *dst, *dst2; + 117. u32 val, pitch = p->fix.line_length; + +security/lsm_audit.c:114: error: DEAD_STORE + The value written to &ret is never used. + 112. struct common_audit_data *ad, u8 *proto) + 113. { + 114. > int offset, ret = 0; + 115. struct ipv6hdr *ip6; + 116. u8 nexthdr; + +net/ipv6/xfrm6_mode_tunnel.c:116: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 114 could be null and is dereferenced at line 116, column 6. + 114. struct xfrm_offload *xo = xfrm_offload(skb); + 115. + 116. > if (xo->flags & XFRM_GSO_SEGMENT) + 117. skb->transport_header = skb->network_header + sizeof(struct ipv6hdr); + 118. + +net/sched/act_api.c:115: error: DEAD_STORE + The value written to &err is never used. + 113. struct netlink_callback *cb) + 114. { + 115. > int err = 0, index = -1, s_i = 0, n_i = 0; + 116. u32 act_flags = cb->args[2]; + 117. unsigned long jiffy_since = cb->args[3]; + +net/sched/act_api.c:121: error: DEAD_STORE + The value written to &id is never used. + 119. struct idr *idr = &idrinfo->action_idr; + 120. struct tc_action *p; + 121. > unsigned long id = 1; + 122. + 123. spin_lock_bh(&idrinfo->lock); + +net/sched/act_api.c:115: error: DEAD_STORE + The value written to &s_i is never used. + 113. struct netlink_callback *cb) + 114. { + 115. > int err = 0, index = -1, s_i = 0, n_i = 0; + 116. u32 act_flags = cb->args[2]; + 117. unsigned long jiffy_since = cb->args[3]; + +lib/decompress_unlzo.c:118: error: DEAD_STORE + The value written to &r is never used. + 116. void (*error) (char *x)) + 117. { + 118. > u8 r = 0; + 119. long skip = 0; + 120. u32 src_len, dst_len; + +arch/x86/include/asm/syscall.h:138: error: DEAD_STORE + The value written to &args is never used. + 136. case 5: + 137. if (!n--) break; + 138. > *args++ = regs->bp; + 139. case 6: + 140. if (!n--) break; + +arch/x86/include/asm/syscall.h:165: error: DEAD_STORE + The value written to &args is never used. + 163. case 5: + 164. if (!n--) break; + 165. > *args++ = regs->r9; + 166. case 6: + 167. if (!n--) break; + +arch/x86/include/asm/syscall.h:140: error: DEAD_STORE + The value written to &n is never used. + 138. *args++ = regs->bp; + 139. case 6: + 140. > if (!n--) break; + 141. default: + 142. BUG(); + +arch/x86/include/asm/syscall.h:167: error: DEAD_STORE + The value written to &n is never used. + 165. *args++ = regs->r9; + 166. case 6: + 167. > if (!n--) break; + 168. default: + 169. BUG(); + +drivers/hid/hidraw.c:118: error: DEAD_STORE + The value written to &ret is never used. + 116. struct hid_device *dev; + 117. __u8 *buf; + 118. > int ret = 0; + 119. + 120. if (!hidraw_table[minor] || !hidraw_table[minor]->exist) { + +drivers/clk/clk-mux.c:125: error: DEAD_STORE + The value written to &width is never used. + 123. struct clk_hw *hw; + 124. struct clk_init_data init; + 125. > u8 width = 0; + 126. int ret; + 127. + +init/do_mounts.c:120: error: DEAD_STORE + The value written to &dev is never used. + 118. dev_t res = 0; + 119. struct uuidcmp cmp; + 120. > struct device *dev = NULL; + 121. struct gendisk *disk; + 122. struct hd_struct *part; + +security/selinux/selinuxfs.c:120: error: DEAD_STORE + The value written to &page is never used. + 118. + 119. { + 120. > char *page = NULL; + 121. ssize_t length; + 122. int new_value; + +net/ipv6/ah6.c:122: error: DEAD_STORE + The value written to &optlen is never used. + 120. int len = ipv6_optlen(opthdr); + 121. int off = 0; + 122. > int optlen = 0; + 123. + 124. off += 2; + +drivers/gpu/drm/i915/intel_dsi.c:136: error: DEAD_STORE + The value written to &data is never used. + 134. + 135. header = packet.header; + 136. > data = packet.payload; + 137. + 138. if (msg->flags & MIPI_DSI_MSG_USE_LPM) { + +drivers/md/dm-raid1.c:122: error: DEAD_STORE + The value written to &should_wake is never used. + 120. { + 121. unsigned long flags; + 122. > int should_wake = 0; + 123. struct bio_list *bl; + 124. + +sound/core/info.c:130: error: DEAD_STORE + The value written to &offset is never used. + 128. mutex_lock(&entry->access); + 129. if (entry->c.ops->llseek) { + 130. > offset = entry->c.ops->llseek(entry, + 131. data->file_private_data, + 132. file, offset, orig); + +block/blk-mq.h:129: error: DEAD_STORE + The value written to &new_val is never used. + 127. if (state == MQ_RQ_IN_FLIGHT) { + 128. WARN_ON_ONCE((old_val & MQ_RQ_STATE_MASK) != MQ_RQ_IDLE); + 129. > new_val += MQ_RQ_GEN_INC; + 130. } + 131. + +drivers/scsi/scsi_logging.c:128: error: DEAD_STORE + The value written to &off is never used. + 126. va_list args; + 127. char *logbuf; + 128. > size_t off = 0, logbuf_len; + 129. + 130. if (!scmd || !scmd->cmnd) + +drivers/scsi/scsi_logging.c:140: error: DEAD_STORE + The value written to &off is never used. + 138. if (off < logbuf_len) { + 139. va_start(args, fmt); + 140. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 141. va_end(args); + 142. } + +kernel/taskstats.c:134: error: DEAD_STORE + The value written to &rc is never used. + 132. genlmsg_end(skb, reply); + 133. + 134. > rc = 0; + 135. down_read(&listeners->sem); + 136. list_for_each_entry(s, &listeners->list, list) { + +net/ipv6/xfrm6_policy.c:165: error: DEAD_STORE + The value written to &exthdr is never used. + 163. offset += ipv6_optlen(exthdr); + 164. nexthdr = exthdr->nexthdr; + 165. > exthdr = (struct ipv6_opt_hdr *)(nh + offset); + 166. break; + 167. + +security/selinux/ss/services.c:128: error: DEAD_STORE + The value written to &out_map is never used. + 126. u16 *out_map_size) + 127. { + 128. > struct selinux_mapping *out_map = NULL; + 129. size_t size = sizeof(struct selinux_mapping); + 130. u16 i, j; + +drivers/input/ff-memless.c:127: error: DEAD_STORE + The value written to &now is never used. + 125. { + 126. struct ml_effect_state *state; + 127. > unsigned long now = jiffies; + 128. unsigned long earliest = 0; + 129. unsigned long next_at; + +net/sched/cls_api.c:135: error: DEAD_STORE + The value written to &err is never used. + 133. return ERR_PTR(-ENOBUFS); + 134. + 135. > err = -ENOENT; + 136. tp->ops = tcf_proto_lookup_ops(kind); + 137. if (!tp->ops) { + +crypto/rsa.c:130: error: DEAD_STORE + The value written to &ret is never used. + 128. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 129. MPI c, m = mpi_alloc(0); + 130. > int ret = 0; + 131. int sign; + 132. + +drivers/gpu/drm/drm_mode_object.c:130: error: DEAD_STORE + The value written to &obj is never used. + 128. uint32_t id, uint32_t type) + 129. { + 130. > struct drm_mode_object *obj = NULL; + 131. + 132. mutex_lock(&dev->mode_config.idr_mutex); + +drivers/usb/storage/sierra_ms.c:135: error: DEAD_STORE + The value written to &result is never used. + 133. + 134. retries = 3; + 135. > result = 0; + 136. udev = us->pusb_dev; + 137. + +drivers/usb/storage/sierra_ms.c:197: error: DEAD_STORE + The value written to &result is never used. + 195. } + 196. complete: + 197. > result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); + 198. + 199. return 0; + +drivers/usb/storage/sierra_ms.c:134: error: DEAD_STORE + The value written to &retries is never used. + 132. struct Scsi_Host *sh; + 133. + 134. > retries = 3; + 135. result = 0; + 136. udev = us->pusb_dev; + +net/ipv6/inet6_hashtables.c:139: error: DEAD_STORE + The value written to &phash is never used. + 137. struct sock *sk, *result = NULL; + 138. int score, hiscore = 0; + 139. > u32 phash = 0; + 140. + 141. inet_lhash2_for_each_icsk_rcu(icsk, &ilb2->head) { + +drivers/char/hw_random/via-rng.c:177: error: DEAD_STORE + The value written to &hi is never used. + 175. /* perhaps-unnecessary sanity check; remove after testing if + 176. unneeded */ + 177. > rdmsr(MSR_VIA_RNG, lo, hi); + 178. if ((lo & VIA_RNG_ENABLE) == 0) { + 179. pr_err(PFX "cannot enable VIA C3 RNG, aborting\n"); + +kernel/cgroup/freezer.c:136: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 132 could be null and is dereferenced at line 136, column 6. + 134. mutex_lock(&freezer_mutex); + 135. + 136. > if (freezer->state & CGROUP_FREEZING) + 137. atomic_dec(&system_freezing_cnt); + 138. + +init/initramfs.c:137: error: NULL_DEREFERENCE + pointer `de` last assigned on line 133 could be null and is dereferenced at line 137, column 2. + 135. panic("can't allocate dir_entry buffer"); + 136. INIT_LIST_HEAD(&de->list); + 137. > de->name = kstrdup(name, GFP_KERNEL); + 138. de->mtime = mtime; + 139. list_add(&de->list, &dir_list); + +net/ipv6/reassembly.c:134: error: DEAD_STORE + The value written to &dev is never used. + 132. struct inet_frags *frags) + 133. { + 134. > struct net_device *dev = NULL; + 135. + 136. spin_lock(&fq->q.lock); + +net/ipv6/netfilter/nf_reject_ipv6.c:140: error: DEAD_STORE + The value written to &dst is never used. + 138. const struct ipv6hdr *oip6h = ipv6_hdr(oldskb); + 139. struct ipv6hdr *ip6h; + 140. > struct dst_entry *dst = NULL; + 141. struct flowi6 fl6; + 142. + +net/ipv6/netfilter/nf_reject_ipv6.c:187: error: DEAD_STORE + The value written to &ip6h is never used. + 185. + 186. skb_reserve(nskb, hh_len + dst->header_len); + 187. > ip6h = nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP, + 188. ip6_dst_hoplimit(dst)); + 189. nf_reject_ip6_tcphdr_put(nskb, oldskb, otcph, otcplen); + +crypto/jitterentropy.c:138: error: DEAD_STORE + The value written to &i is never used. + 136. __u64 time = 0; + 137. __u64 shuffle = 0; + 138. > unsigned int i = 0; + 139. unsigned int mask = (1< struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + 140. struct nlattr *nla_b; + +net/netlabel/netlabel_cipso_v4.c:137: error: DEAD_STORE + The value written to &ret_val is never used. + 135. struct netlbl_audit *audit_info) + 136. { + 137. > int ret_val = -EINVAL; + 138. struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + +drivers/tty/sysrq.c:147: error: NULL_DEREFERENCE + pointer `killer` last assigned on line 137 could be null and is dereferenced at line 147, column 2. + 145. panic_on_oops = 1; /* force panic */ + 146. wmb(); + 147. > *killer = 1; + 148. } + 149. static struct sysrq_key_op sysrq_crash_op = { + +net/ipv4/tcp_ulp.c:139: error: DEAD_STORE + The value written to &err is never used. + 137. struct inet_connection_sock *icsk = inet_csk(sk); + 138. const struct tcp_ulp_ops *ulp_ops; + 139. > int err = 0; + 140. + 141. if (icsk->icsk_ulp_ops) + +sound/core/timer.c:137: error: DEAD_STORE + The value written to &timer is never used. + 135. static struct snd_timer *snd_timer_find(struct snd_timer_id *tid) + 136. { + 137. > struct snd_timer *timer = NULL; + 138. + 139. list_for_each_entry(timer, &snd_timer_list, device_list) { + +drivers/net/ethernet/intel/e1000e/phy.c:139: error: DEAD_STORE + The value written to &mdic is never used. + 137. { + 138. struct e1000_phy_info *phy = &hw->phy; + 139. > u32 i, mdic = 0; + 140. + 141. if (offset > MAX_PHY_REG_ADDRESS) { + +drivers/pci/pcie/aer/aerdrv_errprint.c:140: error: DEAD_STORE + The value written to &errmsg is never used. + 138. { + 139. int i, status; + 140. > const char *errmsg = NULL; + 141. status = (info->status & ~info->mask); + 142. + +drivers/video/fbdev/core/cfbimgblt.c:143: error: DEAD_STORE + The value written to &color is never used. + 141. u32 pitch_index) + 142. { + 143. > u32 shift, color = 0, bpp = p->var.bits_per_pixel; + 144. u32 __iomem *dst, *dst2; + 145. u32 val, pitch = p->fix.line_length; + +net/ipv6/mcast_snoop.c:143: error: DEAD_STORE + The value written to &skb_chk is never used. + 141. + 142. { + 143. > struct sk_buff *skb_chk = NULL; + 144. unsigned int transport_len; + 145. unsigned int len = skb_transport_offset(skb) + sizeof(struct mld_msg); + +drivers/net/ethernet/intel/e1000e/nvm.c:143: error: DEAD_STORE + The value written to ® is never used. + 141. { + 142. u32 attempts = 100000; + 143. > u32 i, reg = 0; + 144. + 145. for (i = 0; i < attempts; i++) { + +security/selinux/ibpkey.c:144: error: DEAD_STORE + The value written to &new is never used. + 142. int ret; + 143. struct sel_ib_pkey *pkey; + 144. > struct sel_ib_pkey *new = NULL; + 145. unsigned long flags; + 146. + +net/ipv6/ipv6_sockglue.c:569: error: DEAD_STORE + The value written to &dev is never used. + 567. case IPV6_UNICAST_IF: + 568. { + 569. > struct net_device *dev = NULL; + 570. int ifindex; + 571. + +net/ipv6/ipv6_sockglue.c:821: error: DEAD_STORE + The value written to &retv is never used. + 819. goto e_inval; + 820. + 821. > retv = -EINVAL; + 822. + 823. /* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */ + +drivers/char/hpet.c:167: error: DEAD_STORE + The value written to &m is never used. + 165. + 166. t = devp->hd_ireqfreq; + 167. > m = read_counter(&devp->hd_timer->hpet_compare); + 168. mc = read_counter(&hpet->hpet_mc); + 169. /* The time for the next interrupt would logically be t + m, + +net/netfilter/nf_queue.c:146: error: DEAD_STORE + The value written to &status is never used. + 144. unsigned int index, unsigned int queuenum) + 145. { + 146. > int status = -ENOENT; + 147. struct nf_queue_entry *entry = NULL; + 148. const struct nf_queue_handler *qh; + +drivers/gpu/drm/drm_modes.c:252: error: DEAD_STORE + The value written to &vback_porch is never used. + 250. vsyncandback_porch = tmp1; + 251. /* 10. Find number of lines in back porch */ + 252. > vback_porch = vsyncandback_porch - vsync; + 253. drm_mode->vtotal = vdisplay_rnd + 2 * vmargin + + 254. vsyncandback_porch + CVT_MIN_V_PORCH; + +security/selinux/ss/ebitmap.c:148: error: DEAD_STORE + The value written to &e_prev is never used. + 146. int rc; + 147. struct ebitmap_node *e_iter = NULL; + 148. > struct ebitmap_node *e_prev = NULL; + 149. u32 offset = 0, idx; + 150. unsigned long bitmap; + +arch/x86/pci/mmconfig-shared.c:146: error: DEAD_STORE + The value written to &len is never used. + 144. static const char *__init pci_mmcfg_intel_945(void) + 145. { + 146. > u32 pciexbar, mask = 0, len = 0; + 147. + 148. raw_pci_ops->read(0, 0, PCI_DEVFN(0, 0), 0x48, 4, &pciexbar); + +arch/x86/pci/mmconfig-shared.c:146: error: DEAD_STORE + The value written to &mask is never used. + 144. static const char *__init pci_mmcfg_intel_945(void) + 145. { + 146. > u32 pciexbar, mask = 0, len = 0; + 147. + 148. raw_pci_ops->read(0, 0, PCI_DEVFN(0, 0), 0x48, 4, &pciexbar); + +drivers/connector/cn_queue.c:160: error: DEAD_STORE + The value written to &dev is never used. + 158. + 159. kfree(dev); + 160. > dev = NULL; + 161. } + +drivers/hid/hid-ntrig.c:162: error: DEAD_STORE + The value written to &ret is never used. + 160. + 161. if (ret == 8) { + 162. > ret = ntrig_version_string(&data[2], buf); + 163. + 164. hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n", + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &timeout__ is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &wait__ is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +arch/x86/platform/efi/efi_64.c:183: error: DEAD_STORE + The value written to &p4d is never used. + 181. } + 182. + 183. > p4d = (p4d_t *)pgd_page_vaddr(*pgd); + 184. p4d_free(&init_mm, p4d); + 185. } + +drivers/usb/host/ohci-hcd.c:157: error: DEAD_STORE + The value written to &retval is never used. + 155. int i, size = 0; + 156. unsigned long flags; + 157. > int retval = 0; + 158. + 159. /* every endpoint has a ed, locate and maybe (re)initialize it */ + +crypto/jitterentropy-kcapi.c:153: error: DEAD_STORE + The value written to &ret is never used. + 151. { + 152. struct jitterentropy *rng = crypto_rng_ctx(tfm); + 153. > int ret = 0; + 154. + 155. spin_lock(&rng->jent_lock); + +drivers/usb/host/pci-quirks.c:150: error: DEAD_STORE + The value written to &rev is never used. + 148. static int amd_chipset_sb_type_init(struct amd_chipset_info *pinfo) + 149. { + 150. > u8 rev = 0; + 151. pinfo->sb_type.gen = AMD_CHIPSET_UNKNOWN; + 152. + +net/sunrpc/auth_gss/gss_rpc_xdr.c:158: error: DEAD_STORE + The value written to &p is never used. + 156. if (unlikely(p == NULL)) + 157. return -ENOSPC; + 158. > count = be32_to_cpup(p++); + 159. memset(&dummy, 0, sizeof(dummy)); + 160. for (i = 0; i < count; i++) { + +security/selinux/netport.c:152: error: DEAD_STORE + The value written to &new is never used. + 150. int ret = -ENOMEM; + 151. struct sel_netport *port; + 152. > struct sel_netport *new = NULL; + 153. + 154. spin_lock_bh(&sel_netport_lock); + +net/core/dst.c:153: error: DEAD_STORE + The value written to &dst is never used. + 151. struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head); + 152. + 153. > dst = dst_destroy(dst); + 154. } + 155. + +net/core/netpoll.c:151: error: DEAD_STORE + The value written to &work is never used. + 149. static void poll_one_napi(struct napi_struct *napi) + 150. { + 151. > int work = 0; + 152. + 153. /* net_rx_action's ->poll() invocations and our's are + +kernel/capability.c:152: error: DEAD_STORE + The value written to &ret is never used. + 150. SYSCALL_DEFINE2(capget, cap_user_header_t, header, cap_user_data_t, dataptr) + 151. { + 152. > int ret = 0; + 153. pid_t pid; + 154. unsigned tocopy; + +sound/core/sound.c:153: error: DEAD_STORE + The value written to &mptr is never used. + 151. { + 152. unsigned int minor = iminor(inode); + 153. > struct snd_minor *mptr = NULL; + 154. const struct file_operations *new_fops; + 155. int err = 0; + +security/keys/request_key_auth.c:156: error: DEAD_STORE + The value written to &authkey is never used. + 154. struct request_key_auth *rka, *irka; + 155. const struct cred *cred = current->cred; + 156. > struct key *authkey = NULL; + 157. char desc[20]; + 158. int ret = -ENOMEM; + +drivers/gpu/drm/drm_drv.c:158: error: NULL_DEREFERENCE + pointer `slot` last assigned on line 157 could be null and is dereferenced at line 158, column 10. + 156. + 157. slot = drm_minor_get_slot(dev, type); + 158. > minor = *slot; + 159. if (!minor) + 160. return; + +drivers/gpu/drm/drm_framebuffer.c:184: error: NULL_DEREFERENCE + pointer `info` last assigned on line 172 could be null and is dereferenced at line 184, column 18. + 182. } + 183. + 184. > for (i = 0; i < info->num_planes; i++) { + 185. unsigned int width = fb_plane_width(r->width, info, i); + 186. unsigned int height = fb_plane_height(r->height, info, i); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:166: error: DEAD_STORE + The value written to &ret_val is never used. + 164. * at the end of this routine. + 165. */ + 166. > ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data); + 167. + 168. /* Disabled the PHY transmitter */ + +kernel/trace/blktrace.c:184: error: DEAD_STORE + The value written to &blkcg is never used. + 182. + 183. if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CGROUP)) + 184. > blkcg = NULL; + 185. #ifdef CONFIG_BLK_CGROUP + 186. trace_note(bt, 0, BLK_TN_MESSAGE, buf, n, + +crypto/ccm.c:161: error: DEAD_STORE + The value written to &len is never used. + 159. static int format_adata(u8 *adata, unsigned int a) + 160. { + 161. > int len = 0; + 162. + 163. /* add control info for associated data + +drivers/pcmcia/pcmcia_resource.c:168: error: DEAD_STORE + The value written to &ret is never used. + 166. config_t *c; + 167. int addr; + 168. > int ret = 0; + 169. + 170. s = p_dev->socket; + +lib/ioremap.c:170: error: DEAD_STORE + The value written to &start is never used. + 168. BUG_ON(addr >= end); + 169. + 170. > start = addr; + 171. phys_addr -= addr; + 172. pgd = pgd_offset_k(addr); + +drivers/firmware/efi/runtime-map.c:162: error: DEAD_STORE + The value written to &ret is never used. + 160. int __init efi_runtime_map_init(struct kobject *efi_kobj) + 161. { + 162. > int i, j, ret = 0; + 163. struct efi_runtime_map_entry *entry; + 164. efi_memory_desc_t *md; + +net/wireless/reg.c:162: error: DEAD_STORE + The value written to ®d is never used. + 160. enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy) + 161. { + 162. > const struct ieee80211_regdomain *regd = NULL; + 163. const struct ieee80211_regdomain *wiphy_regd = NULL; + 164. + +net/wireless/reg.c:163: error: DEAD_STORE + The value written to &wiphy_regd is never used. + 161. { + 162. const struct ieee80211_regdomain *regd = NULL; + 163. > const struct ieee80211_regdomain *wiphy_regd = NULL; + 164. + 165. regd = get_cfg80211_regdom(); + +crypto/asymmetric_keys/x509_public_key.c:167: error: DEAD_STORE + The value written to &desc is never used. + 165. const char *q; + 166. size_t srlen, sulen; + 167. > char *desc = NULL, *p; + 168. int ret; + 169. + +net/ipv6/inet6_hashtables.c:176: error: DEAD_STORE + The value written to &phash is never used. + 174. int score, hiscore = 0; + 175. unsigned int hash2; + 176. > u32 phash = 0; + 177. + 178. if (ilb->count <= 10 || !hashinfo->lhash2) + +crypto/rsa.c:168: error: DEAD_STORE + The value written to &ret is never used. + 166. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 167. MPI m, s = mpi_alloc(0); + 168. > int ret = 0; + 169. int sign; + 170. + +drivers/gpu/drm/drm_mode_object.c:167: error: DEAD_STORE + The value written to &obj is never used. + 165. uint32_t id, uint32_t type) + 166. { + 167. > struct drm_mode_object *obj = NULL; + 168. + 169. obj = __drm_mode_object_find(dev, file_priv, id, type); + +drivers/net/ethernet/intel/e1000e/netdev.c:165: error: DEAD_STORE + The value written to &n is never used. + 163. static void e1000_regdump(struct e1000_hw *hw, struct e1000_reg_info *reginfo) + 164. { + 165. > int n = 0; + 166. char rname[16]; + 167. u32 regs[8]; + +net/ipv6/udp.c:172: error: DEAD_STORE + The value written to &hash is never used. + 170. struct sock *sk, *result; + 171. int score, badness; + 172. > u32 hash = 0; + 173. + 174. result = NULL; + +arch/x86/lib/delay.c:175: error: DEAD_STORE + The value written to &xloops is never used. + 173. :"1" (xloops), "0" (lpj * (HZ / 4))); + 174. + 175. > __delay(++xloops); + 176. } + 177. EXPORT_SYMBOL(__const_udelay); + +drivers/pci/pci-driver.c:172: error: DEAD_STORE + The value written to &fields is never used. + 170. __u32 vendor, device, subvendor = PCI_ANY_ID, + 171. subdevice = PCI_ANY_ID, class = 0, class_mask = 0; + 172. > int fields = 0; + 173. size_t retval = -ENODEV; + 174. + +drivers/firmware/efi/esrt.c:177: error: DEAD_STORE + The value written to &rc is never used. + 175. + 176. if (esrt->fw_resource_version == 1) { + 177. > int rc = 0; + 178. + 179. entry->esre.esre1 = esre; + +kernel/audit_fsnotify.c:175: error: DEAD_STORE + The value written to &inode is never used. + 173. { + 174. struct audit_fsnotify_mark *audit_mark; + 175. > const struct inode *inode = NULL; + 176. + 177. audit_mark = container_of(inode_mark, struct audit_fsnotify_mark, mark); + +kernel/sched/cpuacct.c:174: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 169 could be null and is dereferenced by call to `cpuacct_cpuusage_read()` at line 174, column 20. + 172. + 173. for_each_possible_cpu(i) + 174. > totalcpuusage += cpuacct_cpuusage_read(ca, i, index); + 175. + 176. return totalcpuusage; + +net/sunrpc/auth_gss/gss_mech_switch.c:169: error: DEAD_STORE + The value written to &gm is never used. + 167. struct gss_api_mech * gss_mech_get_by_name(const char *name) + 168. { + 169. > struct gss_api_mech *gm = NULL; + 170. + 171. gm = _gss_mech_get_by_name(name); + +net/netfilter/core.c:173: error: DEAD_STORE + The value written to &i is never used. + 171. struct nf_hook_ops **orig_ops; + 172. int prio = INT_MIN; + 173. > size_t i = 0; + 174. + 175. orig_ops = nf_hook_entries_get_hook_ops(hooks); + +lib/rhashtable.c:173: error: DEAD_STORE + The value written to &tbl is never used. + 171. gfp_t gfp) + 172. { + 173. > struct bucket_table *tbl = NULL; + 174. size_t size, max_locks; + 175. int i; + +net/sched/act_api.c:178: error: DEAD_STORE + The value written to &id is never used. + 176. struct idr *idr = &idrinfo->action_idr; + 177. struct tc_action *p; + 178. > unsigned long id = 1; + 179. + 180. nest = nla_nest_start(skb, 0); + +kernel/time/time.c:174: error: DEAD_STORE + The value written to &error is never used. + 172. { + 173. static int firsttime = 1; + 174. > int error = 0; + 175. + 176. if (tv && !timespec64_valid(tv)) + +drivers/ata/libata-scsi.c:197: error: DEAD_STORE + The value written to &now is never used. + 195. + 196. link = dev->link; + 197. > now = jiffies; + 198. if (ap->pflags & ATA_PFLAG_EH_IN_PROGRESS && + 199. link->eh_context.unloaded_mask & (1 << dev->devno) && + +drivers/pcmcia/yenta_socket.c:176: error: DEAD_STORE + The value written to &offset is never used. + 174. struct pci_dev *dev = to_pci_dev(yentadev); + 175. struct yenta_socket *socket = pci_get_drvdata(dev); + 176. > int offset = 0, i; + 177. + 178. offset = snprintf(buf, PAGE_SIZE, "CB registers:"); + +net/ipv4/inet_connection_sock.c:176: error: DEAD_STORE + The value written to &port is never used. + 174. { + 175. struct inet_hashinfo *hinfo = sk->sk_prot->h.hashinfo; + 176. > int port = 0; + 177. struct inet_bind_hashbucket *head; + 178. struct net *net = sock_net(sk); + +net/ipv4/ping.c:177: error: DEAD_STORE + The value written to &sk is never used. + 175. { + 176. struct hlist_nulls_head *hslot = ping_hashslot(&ping_table, net, ident); + 177. > struct sock *sk = NULL; + 178. struct inet_sock *isk; + 179. struct hlist_nulls_node *hnode; + +net/sched/sch_mq.c:179: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 177 could be null and is dereferenced at line 179, column 9. + 177. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 178. + 179. > return dev_queue->qdisc_sleeping; + 180. } + 181. + +drivers/clocksource/acpi_pm.c:179: error: DEAD_STORE + The value written to &j is never used. + 177. { + 178. u64 value1, value2; + 179. > unsigned int i, j = 0; + 180. + 181. if (!pmtmr_ioport) + +arch/x86/events/intel/pt.c:229: error: DEAD_STORE + The value written to &attrs is never used. + 227. } + 228. + 229. > attrs = NULL; + 230. + 231. for (i = 0; i < PT_CPUID_LEAVES; i++) { + +drivers/firmware/dmi-id.c:206: error: DEAD_STORE + The value written to &i is never used. + 204. ADD_DMI_ATTR(chassis_serial, DMI_CHASSIS_SERIAL); + 205. ADD_DMI_ATTR(chassis_asset_tag, DMI_CHASSIS_ASSET_TAG); + 206. > sys_dmi_attributes[i++] = &sys_dmi_modalias_attr.attr; + 207. } + 208. + +drivers/gpu/drm/i915/intel_hdmi.c:189: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 183 could be null and is dereferenced at line 189, column 37. + 187. return false; + 188. + 189. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 190. return false; + 191. + +net/sunrpc/auth_gss/auth_gss.c:183: error: DEAD_STORE + The value written to &ctx is never used. + 181. { + 182. struct gss_cred *gss_cred = container_of(cred, struct gss_cred, gc_base); + 183. > struct gss_cl_ctx *ctx = NULL; + 184. + 185. rcu_read_lock(); + +drivers/gpu/drm/i915/intel_cdclk.c:221: error: DEAD_STORE + The value written to &tmp is never used. + 219. const unsigned int *vco_table; + 220. unsigned int vco; + 221. > uint8_t tmp = 0; + 222. + 223. /* FIXME other chipsets? */ + +drivers/tty/serial/serial_core.c:185: error: DEAD_STORE + The value written to &retval is never used. + 183. struct uart_port *uport = uart_port_check(state); + 184. unsigned long page; + 185. > int retval = 0; + 186. + 187. if (uport->type == PORT_UNKNOWN) + +crypto/jitterentropy-kcapi.c:186: error: DEAD_STORE + The value written to &ret is never used. + 184. static int __init jent_mod_init(void) + 185. { + 186. > int ret = 0; + 187. + 188. ret = jent_entropy_init(); + +drivers/video/fbdev/core/sysimgblt.c:194: error: DEAD_STORE + The value written to &tab is never used. + 192. const char *s = image->data, *src; + 193. u32 *dst; + 194. > const u32 *tab = NULL; + 195. int i, j, k; + 196. + +net/sunrpc/svcsock.c:197: error: DEAD_STORE + The value written to &len is never used. + 195. unsigned int flags = MSG_MORE | MSG_SENDPAGE_NOTLAST; + 196. int slen; + 197. > int len = 0; + 198. + 199. slen = xdr->len; + +drivers/hid/hidraw.c:192: error: DEAD_STORE + The value written to &ret is never used. + 190. struct hid_device *dev; + 191. __u8 *buf; + 192. > int ret = 0, len; + 193. unsigned char report_number; + 194. + +scripts/mod/file2alias.c:196: error: DEAD_STORE + The value written to &bcdDevice_lo is never used. + 194. DEF_FIELD(symval, usb_device_id, idVendor); + 195. DEF_FIELD(symval, usb_device_id, idProduct); + 196. > DEF_FIELD(symval, usb_device_id, bcdDevice_lo); + 197. DEF_FIELD(symval, usb_device_id, bDeviceClass); + 198. DEF_FIELD(symval, usb_device_id, bDeviceSubClass); + +arch/x86/events/amd/iommu.c:193: error: DEAD_STORE + The value written to &shift is never used. + 191. unsigned long flags; + 192. int max_banks, max_cntrs; + 193. > int shift = 0; + 194. + 195. max_banks = perf_iommu->max_banks; + +block/partitions/efi.c:190: error: DEAD_STORE + The value written to &sz is never used. + 188. static int is_pmbr_valid(legacy_mbr *mbr, sector_t total_sectors) + 189. { + 190. > uint32_t sz = 0; + 191. int i, part = 0, ret = 0; /* invalid by default */ + 192. + +drivers/video/fbdev/core/fbcvt.c:192: error: DEAD_STORE + The value written to &aspect is never used. + 190. u32 xres = cvt->xres; + 191. u32 yres = cvt->yres; + 192. > u32 aspect = -1; + 193. + 194. if (xres == (yres * 4)/3 && !((yres * 4) % 3)) + +security/selinux/hooks.c:199: error: NULL_DEREFERENCE + pointer `tsec` last assigned on line 195 could be null and is dereferenced at line 199, column 15. + 197. panic("SELinux: Failed to initialize initial task.\n"); + 198. + 199. > tsec->osid = tsec->sid = SECINITSID_KERNEL; + 200. cred->security = tsec; + 201. } + +net/sched/sch_mq.c:198: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 194 could be null and is dereferenced at line 198, column 18. + 196. tcm->tcm_parent = TC_H_ROOT; + 197. tcm->tcm_handle |= TC_H_MIN(cl); + 198. > tcm->tcm_info = dev_queue->qdisc_sleeping->handle; + 199. return 0; + 200. } + +arch/x86/events/core.c:195: error: DEAD_STORE + The value written to &ret is never used. + 193. { + 194. u64 val, val_fail = -1, val_new= ~0; + 195. > int i, reg, reg_fail = -1, ret = 0; + 196. int bios_fail = 0; + 197. int reg_safe = -1; + +crypto/crypto_null.c:194: error: DEAD_STORE + The value written to &ret is never used. + 192. static int __init crypto_null_mod_init(void) + 193. { + 194. > int ret = 0; + 195. + 196. ret = crypto_register_algs(null_algs, ARRAY_SIZE(null_algs)); + +drivers/gpu/vga/vgaarb.c:199: error: DEAD_STORE + The value written to &flags is never used. + 197. struct vga_device *conflict; + 198. unsigned int pci_bits; + 199. > u32 flags = 0; + 200. + 201. /* Account for "normal" resources to lock. If we decode the legacy, + +tools/lib/subcmd/help.c:210: error: NULL_DEREFERENCE + pointer `path` last assigned on line 208 could be null and is dereferenced by call to `strchr()` at line 210, column 17. + 208. path = paths = strdup(env_path); + 209. while (1) { + 210. > if ((colon = strchr(path, ':'))) + 211. *colon = 0; + 212. if (!exec_path || strcmp(path, exec_path)) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:200: error: DEAD_STORE + The value written to &mac_reg is never used. + 198. s32 ret_val = 0; + 199. u16 retry_count; + 200. > u32 mac_reg = 0; + 201. + 202. for (retry_count = 0; retry_count < 2; retry_count++) { + +drivers/tty/vt/vc_screen.c:206: error: DEAD_STORE + The value written to &org is never used. + 204. long attr, read; + 205. int col, maxcol, viewed; + 206. > unsigned short *org = NULL; + 207. ssize_t ret; + 208. char *con_buf; + +kernel/sched/cpuacct.c:209: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 199 could be null and is dereferenced by call to `cpuacct_cpuusage_write()` at line 209, column 3. + 207. + 208. for_each_possible_cpu(cpu) + 209. > cpuacct_cpuusage_write(ca, cpu, 0); + 210. + 211. return 0; + +kernel/irq/irqdesc.c:201: error: DEAD_STORE + The value written to &ret is never used. + 199. { + 200. struct irq_desc *desc = container_of(kobj, struct irq_desc, kobj); + 201. > ssize_t ret = 0; + 202. + 203. raw_spin_lock_irq(&desc->lock); + +kernel/kallsyms.c:201: error: DEAD_STORE + The value written to &symbol_start is never used. + 199. unsigned long *offset) + 200. { + 201. > unsigned long symbol_start = 0, symbol_end = 0; + 202. unsigned long i, low, high, mid; + 203. + +kernel/kthread.c:219: error: NULL_DEREFERENCE + pointer `done` last assigned on line 211 could be null and is dereferenced by call to `complete()` at line 219, column 3. + 217. if (!self) { + 218. create->result = ERR_PTR(-ENOMEM); + 219. > complete(done); + 220. do_exit(-ENOMEM); + 221. } + +net/ipv6/udp.c:209: error: DEAD_STORE + The value written to &hash is never used. + 207. bool exact_dif = udp6_lib_exact_dif_match(net, skb); + 208. int score, badness; + 209. > u32 hash = 0; + 210. + 211. if (hslot->count > 10) { + +lib/kobject.c:200: error: DEAD_STORE + The value written to &error is never used. + 198. static int kobject_add_internal(struct kobject *kobj) + 199. { + 200. > int error = 0; + 201. struct kobject *parent; + 202. + +drivers/net/ethernet/intel/e1000e/phy.c:202: error: DEAD_STORE + The value written to &mdic is never used. + 200. { + 201. struct e1000_phy_info *phy = &hw->phy; + 202. > u32 i, mdic = 0; + 203. + 204. if (offset > MAX_PHY_REG_ADDRESS) { + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: DEAD_STORE + The value written to &timeout__ is never used. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: DEAD_STORE + The value written to &wait__ is never used. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +security/selinux/netnode.c:204: error: DEAD_STORE + The value written to &new is never used. + 202. int ret = -ENOMEM; + 203. struct sel_netnode *node; + 204. > struct sel_netnode *new = NULL; + 205. + 206. spin_lock_bh(&sel_netnode_lock); + +crypto/jitterentropy.c:206: error: DEAD_STORE + The value written to &j is never used. + 204. { + 205. unsigned int i; + 206. > __u64 j = 0; + 207. __u64 new = 0; + 208. #define MAX_FOLD_LOOP_BIT 4 + +crypto/rsa.c:207: error: DEAD_STORE + The value written to &ret is never used. + 205. const struct rsa_mpi_key *pkey = rsa_get_key(tfm); + 206. MPI s, m = mpi_alloc(0); + 207. > int ret = 0; + 208. int sign; + 209. + +crypto/rsa.c:218: error: DEAD_STORE + The value written to &ret is never used. + 216. } + 217. + 218. > ret = -ENOMEM; + 219. s = mpi_read_raw_from_sgl(req->src, req->src_len); + 220. if (!s) { + +net/sched/sch_mq.c:207: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 205 could be null and is dereferenced at line 207, column 8. + 205. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 206. + 207. > sch = dev_queue->qdisc_sleeping; + 208. if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || + 209. gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) + +drivers/ptp/ptp_clock.c:207: error: DEAD_STORE + The value written to &err is never used. + 205. { + 206. struct ptp_clock *ptp; + 207. > int err = 0, index, major = MAJOR(ptp_devt); + 208. + 209. if (info->n_alarm > PTP_MAX_ALARMS) + +kernel/cgroup/freezer.c:221: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 220 could be null and is dereferenced at line 221, column 6. + 219. + 220. freezer = task_freezer(task); + 221. > if (freezer->state & CGROUP_FREEZING) + 222. freeze_task(task); + 223. + +net/ipv6/addrlabel.c:206: error: DEAD_STORE + The value written to &p is never used. + 204. int replace) + 205. { + 206. > struct ip6addrlbl_entry *last = NULL, *p = NULL; + 207. struct hlist_node *n; + 208. int ret = 0; + +drivers/gpu/drm/i915/intel_dp_mst.c:245: error: DEAD_STORE + The value written to &ret is never used. + 243. I915_WRITE(DP_TP_STATUS(port), temp); + 244. + 245. > ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); + 246. } + 247. + +net/sched/sch_api.c:206: error: DEAD_STORE + The value written to &q is never used. + 204. static struct Qdisc_ops *qdisc_lookup_default(const char *name) + 205. { + 206. > struct Qdisc_ops *q = NULL; + 207. + 208. for (q = qdisc_base; q; q = q->next) { + +security/keys/request_key.c:225: error: DEAD_STORE + The value written to &authkey is never used. + 223. kfree(cons); + 224. ret = PTR_ERR(authkey); + 225. > authkey = NULL; + 226. } else { + 227. cons->authkey = key_get(authkey); + +drivers/gpu/drm/i915/intel_sideband.c:208: error: DEAD_STORE + The value written to &value is never used. + 206. enum intel_sbi_destination destination) + 207. { + 208. > u32 value = 0; + 209. WARN_ON(!mutex_is_locked(&dev_priv->sb_lock)); + 210. + +drivers/tty/n_tty.c:209: error: DEAD_STORE + The value written to &n is never used. + 207. { + 208. struct n_tty_data *ldata = tty->disc_data; + 209. > ssize_t n = 0; + 210. + 211. if (!ldata->icanon) + +drivers/pci/pcie/aspm.c:256: error: DEAD_STORE + The value written to &start_jiffies is never used. + 254. + 255. /* Wait for link training end. Break out after waiting for timeout */ + 256. > start_jiffies = jiffies; + 257. for (;;) { + 258. pcie_capability_read_word(parent, PCI_EXP_LNKSTA, ®16); + +drivers/clk/clk.c:210: error: DEAD_STORE + The value written to &ret is never used. + 208. static bool clk_core_is_enabled(struct clk_core *core) + 209. { + 210. > bool ret = false; + 211. + 212. /* + +drivers/usb/core/devio.c:210: error: DEAD_STORE + The value written to &usbm is never used. + 208. static int usbdev_mmap(struct file *file, struct vm_area_struct *vma) + 209. { + 210. > struct usb_memory *usbm = NULL; + 211. struct usb_dev_state *ps = file->private_data; + 212. size_t size = vma->vm_end - vma->vm_start; + +drivers/rtc/rtc-dev.c:212: error: DEAD_STORE + The value written to &err is never used. + 210. unsigned int cmd, unsigned long arg) + 211. { + 212. > int err = 0; + 213. struct rtc_device *rtc = file->private_data; + 214. const struct rtc_class_ops *ops = rtc->ops; + +crypto/algboss.c:213: error: DEAD_STORE + The value written to &type is never used. + 211. { + 212. struct crypto_test_param *param = data; + 213. > u32 type = param->type; + 214. int err = 0; + 215. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: DEAD_STORE + The value written to &timeout__ is never used. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: DEAD_STORE + The value written to &wait__ is never used. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/net/ethernet/intel/e1000e/82571.c:215: error: DEAD_STORE + The value written to &force_clear_smbi is never used. + 213. u32 swsm = 0; + 214. u32 swsm2 = 0; + 215. > bool force_clear_smbi = false; + 216. + 217. /* Set media type and media-dependent function pointers */ + +drivers/net/ethernet/intel/e1000e/82571.c:213: error: DEAD_STORE + The value written to &swsm is never used. + 211. { + 212. struct e1000_mac_info *mac = &hw->mac; + 213. > u32 swsm = 0; + 214. u32 swsm2 = 0; + 215. bool force_clear_smbi = false; + +drivers/net/ethernet/intel/e1000e/82571.c:214: error: DEAD_STORE + The value written to &swsm2 is never used. + 212. struct e1000_mac_info *mac = &hw->mac; + 213. u32 swsm = 0; + 214. > u32 swsm2 = 0; + 215. bool force_clear_smbi = false; + 216. + +drivers/pci/pcie/portdrv_core.c:213: error: DEAD_STORE + The value written to &cap_mask is never used. + 211. { + 212. int services = 0; + 213. > int cap_mask = 0; + 214. + 215. if (pcie_ports_disabled) + +init/do_mounts.c:214: error: DEAD_STORE + The value written to &res is never used. + 212. char s[32]; + 213. char *p; + 214. > dev_t res = 0; + 215. int part; + 216. + +net/core/net-procfs.c:212: error: DEAD_STORE + The value written to &pt is never used. + 210. static void *ptype_get_idx(loff_t pos) + 211. { + 212. > struct packet_type *pt = NULL; + 213. loff_t i = 0; + 214. int t; + +security/lsm_audit.c:324: error: DEAD_STORE + The value written to &len is never used. + 322. struct sock *sk = a->u.net->sk; + 323. struct unix_sock *u; + 324. > int len = 0; + 325. char *p = NULL; + 326. + +security/lsm_audit.c:325: error: DEAD_STORE + The value written to &p is never used. + 323. struct unix_sock *u; + 324. int len = 0; + 325. > char *p = NULL; + 326. + 327. switch (sk->sk_family) { + +drivers/net/ethernet/intel/e1000e/netdev.c:236: error: DEAD_STORE + The value written to &i is never used. + 234. } *u1; + 235. u32 staterr; + 236. > int i = 0; + 237. + 238. if (!netif_msg_hw(adapter)) + +drivers/video/fbdev/core/fbcvt.c:261: error: DEAD_STORE + The value written to &cnt is never used. + 259. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. > cnt -= read; + 262. offset += read; + 263. } + +drivers/video/fbdev/core/fbcvt.c:262: error: DEAD_STORE + The value written to &offset is never used. + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. cnt -= read; + 262. > offset += read; + 263. } + 264. } + +drivers/video/fbdev/core/fbcvt.c:217: error: DEAD_STORE + The value written to &read is never used. + 215. { + 216. u32 pixcount, pixcount_mod; + 217. > int cnt = 255, offset = 0, read = 0; + 218. u8 *buf = kzalloc(256, GFP_KERNEL); + 219. + +block/blk-map.c:220: error: DEAD_STORE + The value written to &do_copy is never used. + 218. int reading = rq_data_dir(rq) == READ; + 219. unsigned long addr = (unsigned long) kbuf; + 220. > int do_copy = 0; + 221. struct bio *bio, *orig_bio; + 222. int ret; + +drivers/ata/libata-sff.c:223: error: DEAD_STORE + The value written to &timeout is never used. + 221. status = ata_sff_busy_wait(ap, ATA_BUSY, 300); + 222. timer_start = jiffies; + 223. > timeout = ata_deadline(timer_start, tmout_pat); + 224. while (status != 0xff && (status & ATA_BUSY) && + 225. time_before(jiffies, timeout)) { + +drivers/ata/libata-sff.c:235: error: DEAD_STORE + The value written to &timeout is never used. + 233. status); + 234. + 235. > timeout = ata_deadline(timer_start, tmout); + 236. while (status != 0xff && (status & ATA_BUSY) && + 237. time_before(jiffies, timeout)) { + +drivers/video/fbdev/core/cfbimgblt.c:224: error: DEAD_STORE + The value written to &tab is never used. + 222. const char *s = image->data, *src; + 223. u32 __iomem *dst; + 224. > const u32 *tab = NULL; + 225. int i, j, k; + 226. + +drivers/gpu/drm/i915/intel_atomic.c:221: error: DEAD_STORE + The value written to &plane is never used. + 219. struct intel_crtc_state *crtc_state) + 220. { + 221. > struct drm_plane *plane = NULL; + 222. struct intel_plane *intel_plane; + 223. struct intel_plane_state *plane_state = NULL; + +drivers/gpu/drm/i915/intel_atomic.c:223: error: DEAD_STORE + The value written to &plane_state is never used. + 221. struct drm_plane *plane = NULL; + 222. struct intel_plane *intel_plane; + 223. > struct intel_plane_state *plane_state = NULL; + 224. struct intel_crtc_scaler_state *scaler_state = + 225. &crtc_state->scaler_state; + +net/wireless/trace.h:217: error: DEAD_STORE + The value written to &p is never used. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +drivers/gpu/drm/drm_color_mgmt.c:228: error: DEAD_STORE + The value written to &ret is never used. + 226. int size; + 227. struct drm_modeset_acquire_ctx ctx; + 228. > int ret = 0; + 229. + 230. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/gpu/drm/drm_context.c:224: error: DEAD_STORE + The value written to &map is never used. + 222. { + 223. struct drm_ctx_priv_map *request = data; + 224. > struct drm_local_map *map = NULL; + 225. struct drm_map_list *r_list = NULL; + 226. + +drivers/gpu/drm/drm_context.c:225: error: DEAD_STORE + The value written to &r_list is never used. + 223. struct drm_ctx_priv_map *request = data; + 224. struct drm_local_map *map = NULL; + 225. > struct drm_map_list *r_list = NULL; + 226. + 227. if (!drm_core_check_feature(dev, DRIVER_KMS_LEGACY_CONTEXT) && + +drivers/scsi/scsi_logging.c:249: error: DEAD_STORE + The value written to &off is never used. + 247. if (cmd->cmd_len > 16) { + 248. /* Print opcode in one line and use separate lines for CDB */ + 249. > off += scnprintf(logbuf + off, logbuf_len - off, "\n"); + 250. dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf); + 251. scsi_log_release_buffer(logbuf); + +drivers/gpu/drm/drm_irq.c:226: error: DEAD_STORE + The value written to &ret is never used. + 224. { + 225. struct drm_control *ctl = data; + 226. > int ret = 0, irq; + 227. + 228. /* if we haven't irq we fallback for compatibility reasons - + +net/sched/act_api.c:224: error: DEAD_STORE + The value written to &p is never used. + 222. static struct tc_action *tcf_idr_lookup(u32 index, struct tcf_idrinfo *idrinfo) + 223. { + 224. > struct tc_action *p = NULL; + 225. + 226. spin_lock_bh(&idrinfo->lock); + +net/xfrm/xfrm_input.c:232: error: DEAD_STORE + The value written to &family is never used. + 230. struct xfrm_mode *inner_mode; + 231. u32 mark = skb->mark; + 232. > unsigned int family = AF_UNSPEC; + 233. int decaps = 0; + 234. int async = 0; + +net/ipv4/ip_tunnel.c:233: error: DEAD_STORE + The value written to &t is never used. + 231. __be16 flags = parms->i_flags; + 232. int link = parms->link; + 233. > struct ip_tunnel *t = NULL; + 234. struct hlist_head *head = ip_bucket(itn, parms); + 235. + +net/sunrpc/auth_generic.c:231: error: DEAD_STORE + The value written to &ret is never used. + 229. gc_base)->acred; + 230. struct rpc_cred *tcred; + 231. > int ret = 0; + 232. + 233. + +arch/x86/events/intel/bts.c:232: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 229 could be null and is dereferenced at line 232, column 7. + 230. u64 config = 0; + 231. + 232. > if (!buf->snapshot) + 233. config |= ARCH_PERFMON_EVENTSEL_INT; + 234. if (!event->attr.exclude_kernel) + +drivers/scsi/scsi_pm.c:230: error: DEAD_STORE + The value written to &err is never used. + 228. const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL; + 229. struct scsi_device *sdev = to_scsi_device(dev); + 230. > int err = 0; + 231. + 232. err = blk_pre_runtime_suspend(sdev->request_queue); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:233: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 230 could be null and is dereferenced at line 233, column 6. + 231. struct intel_panel *panel = &connector->panel; + 232. + 233. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) + 234. panel->backlight.max = 0xFFFF; + 235. else + +lib/rhashtable.c:261: error: DEAD_STORE + The value written to &head is never used. + 259. + 260. spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING); + 261. > head = rht_dereference_bucket(new_tbl->buckets[new_hash], + 262. new_tbl, new_hash); + 263. + +security/keys/key.c:233: error: DEAD_STORE + The value written to &user is never used. + 231. struct key_restriction *restrict_link) + 232. { + 233. > struct key_user *user = NULL; + 234. struct key *key; + 235. size_t desclen, quotalen; + +net/ipv4/raw.c:235: error: DEAD_STORE + The value written to &err is never used. + 233. const int type = icmp_hdr(skb)->type; + 234. const int code = icmp_hdr(skb)->code; + 235. > int err = 0; + 236. int harderr = 0; + 237. + +drivers/video/backlight/backlight.c:234: error: DEAD_STORE + The value written to &rc is never used. + 232. struct device_attribute *attr, char *buf) + 233. { + 234. > int rc = -ENXIO; + 235. struct backlight_device *bd = to_backlight_device(dev); + 236. + +sound/hda/hdac_controller.c:239: error: DEAD_STORE + The value written to &loopcounter is never used. + 237. timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. > for (loopcounter = 0;; loopcounter++) { + 240. spin_lock_irq(&bus->reg_lock); + 241. if (!bus->rirb.cmds[addr]) { + +sound/hda/hdac_controller.c:239: error: DEAD_STORE + The value written to &loopcounter is never used. + 237. timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. > for (loopcounter = 0;; loopcounter++) { + 240. spin_lock_irq(&bus->reg_lock); + 241. if (!bus->rirb.cmds[addr]) { + +sound/hda/hdac_controller.c:237: error: DEAD_STORE + The value written to &timeout is never used. + 235. unsigned long loopcounter; + 236. + 237. > timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. for (loopcounter = 0;; loopcounter++) { + +security/selinux/ss/mls.c:366: error: DEAD_STORE + The value written to &p is never used. + 364. goto out; + 365. } + 366. > *scontext = ++p; + 367. rc = 0; + 368. out: + +drivers/gpu/drm/i915/intel_hdmi.c:248: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 240 could be null and is dereferenced at line 248, column 37. + 246. return false; + 247. + 248. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 249. return false; + 250. + +drivers/video/fbdev/core/bitblit.c:252: error: DEAD_STORE + The value written to &mode is never used. + 250. if (softback_lines) { + 251. if (y + softback_lines >= vc->vc_rows) { + 252. > mode = CM_ERASE; + 253. ops->cursor_flash = 0; + 254. return; + +drivers/video/fbdev/core/sysimgblt.c:242: error: DEAD_STORE + The value written to &pitch_index is never used. + 240. void sys_imageblit(struct fb_info *p, const struct fb_image *image) + 241. { + 242. > u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0; + 243. u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel; + 244. u32 width = image->width; + +drivers/base/cpu.c:245: error: DEAD_STORE + The value written to &n is never used. + 243. struct device_attribute *attr, char *buf) + 244. { + 245. > int n = 0, len = PAGE_SIZE-2; + 246. cpumask_var_t offline; + 247. + +net/ipv6/addrlabel.c:247: error: DEAD_STORE + The value written to &ret is never used. + 245. { + 246. struct ip6addrlbl_entry *newp; + 247. > int ret = 0; + 248. + 249. ADDRLABEL(KERN_DEBUG "%s(prefix=%pI6, prefixlen=%d, ifindex=%d, label=%u, replace=%d)\n", + +net/sunrpc/auth_gss/gss_rpc_xdr.c:253: error: DEAD_STORE + The value written to &p is never used. + 251. if (unlikely(p == NULL)) + 252. return -ENOSPC; + 253. > count = be32_to_cpup(p++); + 254. if (!count) + 255. return 0; + +kernel/softirq.c:244: error: DEAD_STORE + The value written to &end is never used. + 242. asmlinkage __visible void __softirq_entry __do_softirq(void) + 243. { + 244. > unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. int max_restart = MAX_SOFTIRQ_RESTART; + +kernel/softirq.c:246: error: DEAD_STORE + The value written to &max_restart is never used. + 244. unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. > int max_restart = MAX_SOFTIRQ_RESTART; + 247. struct softirq_action *h; + 248. bool in_hardirq; + +kernel/softirq.c:303: error: DEAD_STORE + The value written to &max_restart is never used. + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + 303. > --max_restart) + 304. goto restart; + 305. + +drivers/md/dm-stripe.c:255: error: DEAD_STORE + The value written to §or is never used. + 253. sector = *result; + 254. if (sc->chunk_size_shift < 0) + 255. > *result -= sector_div(sector, sc->chunk_size); + 256. else + 257. *result = sector & ~(sector_t)(sc->chunk_size - 1); + +drivers/video/fbdev/core/sysfillrect.c:296: error: DEAD_STORE + The value written to &fill_op is never used. + 294. } else { + 295. int right, r; + 296. > void (*fill_op)(struct fb_info *p, unsigned long *dst, + 297. int dst_idx, unsigned long pat, int left, + 298. int right, unsigned n, int bits) = NULL; + +drivers/video/fbdev/core/sysfillrect.c:271: error: DEAD_STORE + The value written to &fill_op32 is never used. + 269. p->fbops->fb_sync(p); + 270. if (!left) { + 271. > void (*fill_op32)(struct fb_info *p, unsigned long *dst, + 272. int dst_idx, unsigned long pat, unsigned n, + 273. int bits) = NULL; + +init/main.c:254: error: DEAD_STORE + The value written to &val is never used. + 252. val[-2] = '='; + 253. memmove(val-1, val, strlen(val)+1); + 254. > val--; + 255. } else + 256. BUG(); + +kernel/cgroup/freezer.c:253: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 246 could be null and is dereferenced at line 253, column 8. + 251. lockdep_assert_held(&freezer_mutex); + 252. + 253. > if (!(freezer->state & CGROUP_FREEZING) || + 254. (freezer->state & CGROUP_FROZEN)) + 255. return; + +net/ipv6/inet6_hashtables.c:255: error: DEAD_STORE + The value written to &ports is never used. + 253. struct net *net = sock_net(sk); + 254. const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + 257. inet->inet_dport); + +net/ipv6/inet6_hashtables.c:254: error: DEAD_STORE + The value written to &sdif is never used. + 252. const int dif = sk->sk_bound_dev_if; + 253. struct net *net = sock_net(sk); + 254. > const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + +drivers/pcmcia/yenta_socket.c:299: error: DEAD_STORE + The value written to ® is never used. + 297. exca_writeb(socket, I365_POWER, reg); + 298. } else { + 299. > u32 reg = 0; /* CB_SC_STPCLK? */ + 300. switch (state->Vcc) { + 301. case 33: + +arch/x86/events/amd/iommu.c:252: error: DEAD_STORE + The value written to ® is never used. + 250. u8 bank = hwc->iommu_bank; + 251. u8 cntr = hwc->iommu_cntr; + 252. > u64 reg = 0ULL; + 253. + 254. reg = GET_CSOURCE(hwc); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:254: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 249 could be null and is dereferenced at line 254, column 6. + 252. * the panel can support backlight control over the aux channel + 253. */ + 254. > if (intel_dp->edp_dpcd[1] & DP_EDP_TCON_BACKLIGHT_ADJUSTMENT_CAP && + 255. (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP) && + 256. !(intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_PWM_PIN_CAP)) { + +drivers/gpu/drm/i915/intel_dp_mst.c:268: error: DEAD_STORE + The value written to &ret is never used. + 266. DRM_ERROR("Timed out waiting for ACT sent\n"); + 267. + 268. > ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + +drivers/gpu/drm/i915/intel_dp_mst.c:270: error: DEAD_STORE + The value written to &ret is never used. + 268. ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. > ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + 271. if (pipe_config->has_audio) + 272. intel_audio_codec_enable(encoder, pipe_config, conn_state); + +lib/iomap.c:250: error: DEAD_STORE + The value written to &port is never used. + 248. void pci_iounmap(struct pci_dev *dev, void __iomem * addr) + 249. { + 250. > IO_COND(addr, /* nothing */, iounmap(addr)); + 251. } + 252. EXPORT_SYMBOL(pci_iounmap); + +sound/core/pcm_native.c:268: error: DEAD_STORE + The value written to &old_mask is never used. + 266. + 267. if (trace_hw_mask_param_enabled()) + 268. > old_mask = *m; + 269. + 270. changed = snd_mask_refine(m, constrs_mask(constrs, k)); + +net/ipv6/mcast.c:254: error: DEAD_STORE + The value written to &idev is never used. + 252. { + 253. struct net_device *dev = NULL; + 254. > struct inet6_dev *idev = NULL; + 255. + 256. if (ifindex == 0) { + +sound/core/timer.c:254: error: DEAD_STORE + The value written to &timeri is never used. + 252. { + 253. struct snd_timer *timer; + 254. > struct snd_timer_instance *timeri = NULL; + 255. int err; + 256. + +include/linux/ptr_ring.h:288: error: DEAD_STORE + The value written to &consumer_head is never used. + 286. } + 287. if (unlikely(consumer_head >= r->size)) { + 288. > consumer_head = 0; + 289. r->consumer_tail = 0; + 290. } + +drivers/cpufreq/acpi-cpufreq.c:258: error: DEAD_STORE + The value written to &dummy is never used. + 256. u32 val, dummy; + 257. + 258. > rdmsr(MSR_IA32_PERF_CTL, val, dummy); + 259. return val; + 260. } + +drivers/pcmcia/ds.c:260: error: DEAD_STORE + The value written to &ret is never used. + 258. struct pcmcia_socket *s; + 259. cistpl_config_t cis_config; + 260. > int ret = 0; + 261. + 262. dev = get_device(dev); + +security/keys/request_key.c:272: error: NULL_DEREFERENCE + pointer `cred` last assigned on line 257 could be null and is dereferenced at line 272, column 11. + 270. /* use a default keyring; falling through the cases until we + 271. * find one that we actually have */ + 272. > switch (cred->jit_keyring) { + 273. case KEY_REQKEY_DEFL_DEFAULT: + 274. case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: + +net/core/scm.c:264: error: DEAD_STORE + The value written to &err is never used. + 262. struct file **fp = scm->fp->fp; + 263. int __user *cmfptr; + 264. > int err = 0, i; + 265. + 266. if (MSG_CMSG_COMPAT & msg->msg_flags) { + +net/ipv6/xfrm6_policy.c:274: error: NULL_DEREFERENCE + pointer `xdst` last assigned on line 273 could be null and is dereferenced at line 274, column 12. + 272. in6_dev_hold(loopback_idev); + 273. xdst = (struct xfrm_dst *)xfrm_dst_child(&xdst->u.dst); + 274. > } while (xdst->u.dst.xfrm); + 275. + 276. __in6_dev_put(loopback_idev); + +net/sunrpc/auth_gss/gss_mech_switch.c:257: error: DEAD_STORE + The value written to &pos is never used. + 255. int gss_mech_list_pseudoflavors(rpc_authflavor_t *array_ptr, int size) + 256. { + 257. > struct gss_api_mech *pos = NULL; + 258. int j, i = 0; + 259. + +net/wireless/trace.h:255: error: DEAD_STORE + The value written to &p is never used. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +sound/core/sound.c:263: error: DEAD_STORE + The value written to &err is never used. + 261. { + 262. int minor; + 263. > int err = 0; + 264. struct snd_minor *preg; + 265. + +crypto/jitterentropy.c:263: error: DEAD_STORE + The value written to &i is never used. + 261. unsigned char *tmpval = NULL; + 262. unsigned int wrap = 0; + 263. > __u64 i = 0; + 264. #define MAX_ACC_LOOP_BIT 7 + 265. #define MIN_ACC_LOOP_BIT 0 + +crypto/jitterentropy.c:261: error: DEAD_STORE + The value written to &tmpval is never used. + 259. static unsigned int jent_memaccess(struct rand_data *ec, __u64 loop_cnt) + 260. { + 261. > unsigned char *tmpval = NULL; + 262. unsigned int wrap = 0; + 263. __u64 i = 0; + +crypto/jitterentropy.c:262: error: DEAD_STORE + The value written to &wrap is never used. + 260. { + 261. unsigned char *tmpval = NULL; + 262. > unsigned int wrap = 0; + 263. __u64 i = 0; + 264. #define MAX_ACC_LOOP_BIT 7 + +drivers/pci/access.c:260: error: DEAD_STORE + The value written to &ret is never used. + 258. EXPORT_SYMBOL_GPL(pci_user_write_config_##size); + 259. + 260. > PCI_USER_READ_CONFIG(byte, u8) + 261. PCI_USER_READ_CONFIG(word, u16) + 262. PCI_USER_READ_CONFIG(dword, u32) + +drivers/pci/access.c:261: error: DEAD_STORE + The value written to &ret is never used. + 259. + 260. PCI_USER_READ_CONFIG(byte, u8) + 261. > PCI_USER_READ_CONFIG(word, u16) + 262. PCI_USER_READ_CONFIG(dword, u32) + 263. PCI_USER_WRITE_CONFIG(byte, u8) + +drivers/pci/slot.c:267: error: DEAD_STORE + The value written to &err is never used. + 265. struct pci_dev *dev; + 266. struct pci_slot *slot; + 267. > int err = 0; + 268. char *slot_name = NULL; + 269. + +drivers/pci/access.c:262: error: DEAD_STORE + The value written to &ret is never used. + 260. PCI_USER_READ_CONFIG(byte, u8) + 261. PCI_USER_READ_CONFIG(word, u16) + 262. > PCI_USER_READ_CONFIG(dword, u32) + 263. PCI_USER_WRITE_CONFIG(byte, u8) + 264. PCI_USER_WRITE_CONFIG(word, u16) + +drivers/tty/serial/serial_core.c:283: error: NULL_DEREFERENCE + pointer `uport` last assigned on line 264 could be null and is dereferenced by call to `uart_port_dtr_rts()` at line 283, column 4. + 281. + 282. if (!tty || C_HUPCL(tty)) + 283. > uart_port_dtr_rts(uport, 0); + 284. + 285. uart_port_shutdown(port); + +drivers/gpu/drm/i915/intel_opregion.c:330: error: DEAD_STORE + The value written to &timeout__ is never used. + 328. /* Poll for the result. */ + 329. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 330. > if (wait_for(C, dslp)) { + 331. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 332. return -ETIMEDOUT; + +drivers/gpu/drm/i915/intel_opregion.c:330: error: DEAD_STORE + The value written to &wait__ is never used. + 328. /* Poll for the result. */ + 329. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 330. > if (wait_for(C, dslp)) { + 331. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 332. return -ETIMEDOUT; + +drivers/pci/access.c:263: error: DEAD_STORE + The value written to &ret is never used. + 261. PCI_USER_READ_CONFIG(word, u16) + 262. PCI_USER_READ_CONFIG(dword, u32) + 263. > PCI_USER_WRITE_CONFIG(byte, u8) + 264. PCI_USER_WRITE_CONFIG(word, u16) + 265. PCI_USER_WRITE_CONFIG(dword, u32) + +drivers/gpu/drm/i915/intel_dsi_pll.c:271: error: DEAD_STORE + The value written to &m is never used. + 269. u32 dsi_clock, pclk; + 270. u32 pll_ctl, pll_div; + 271. > u32 m = 0, p = 0, n; + 272. int refclk = IS_CHERRYVIEW(dev_priv) ? 100000 : 25000; + 273. int i; + +drivers/pci/access.c:264: error: DEAD_STORE + The value written to &ret is never used. + 262. PCI_USER_READ_CONFIG(dword, u32) + 263. PCI_USER_WRITE_CONFIG(byte, u8) + 264. > PCI_USER_WRITE_CONFIG(word, u16) + 265. PCI_USER_WRITE_CONFIG(dword, u32) + 266. + +net/compat.c:271: error: DEAD_STORE + The value written to &err is never used. + 269. struct file **fp = scm->fp->fp; + 270. int __user *cmfptr; + 271. > int err = 0, i; + 272. + 273. if (fdnum < fdmax) + +sound/core/pcm_lib.c:408: error: DEAD_STORE + The value written to &hw_base is never used. + 406. /* move new_hw_ptr according jiffies not pos variable */ + 407. new_hw_ptr = old_hw_ptr; + 408. > hw_base = delta; + 409. /* use loop to avoid checks for delta overflows */ + 410. /* the delta value is small or zero in most cases */ + +drivers/pci/access.c:265: error: DEAD_STORE + The value written to &ret is never used. + 263. PCI_USER_WRITE_CONFIG(byte, u8) + 264. PCI_USER_WRITE_CONFIG(word, u16) + 265. > PCI_USER_WRITE_CONFIG(dword, u32) + 266. + 267. /* VPD access through PCI 2.2+ VPD capability */ + +drivers/video/fbdev/core/cfbimgblt.c:267: error: DEAD_STORE + The value written to &pitch_index is never used. + 265. void cfb_imageblit(struct fb_info *p, const struct fb_image *image) + 266. { + 267. > u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0; + 268. u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel; + 269. u32 width = image->width; + +net/ipv4/inet_hashtables.c:276: error: DEAD_STORE + The value written to &phash is never used. + 274. struct sock *sk, *result = NULL; + 275. int score, hiscore = 0; + 276. > u32 phash = 0; + 277. + 278. inet_lhash2_for_each_icsk_rcu(icsk, &ilb2->head) { + +net/ipv6/addrlabel.c:269: error: DEAD_STORE + The value written to &p is never used. + 267. int ifindex) + 268. { + 269. > struct ip6addrlbl_entry *p = NULL; + 270. struct hlist_node *n; + 271. int ret = -ESRCH; + +drivers/gpu/drm/drm_crtc_helper.c:281: error: DEAD_STORE + The value written to &ret is never used. + 279. bool saved_enabled; + 280. struct drm_encoder *encoder; + 281. > bool ret = true; + 282. + 283. drm_warn_on_modeset_not_all_locked(dev); + +drivers/net/ethernet/intel/e1000e/ethtool.c:321: error: DEAD_STORE + The value written to &advertising is never used. + 319. hw->phy.autoneg_advertised = advertising | + 320. ADVERTISED_TP | ADVERTISED_Autoneg; + 321. > advertising = hw->phy.autoneg_advertised; + 322. if (adapter->fc_autoneg) + 323. hw->fc.requested_mode = e1000_fc_default; + +net/wireless/trace.h:269: error: DEAD_STORE + The value written to &p is never used. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +drivers/char/agp/amd64-agp.c:273: error: DEAD_STORE + The value written to &order is never used. + 271. { + 272. u64 aper, nb_aper; + 273. > int order = 0; + 274. u32 nb_order, nb_base; + 275. u16 apsize; + +drivers/net/ethernet/intel/e1000/e1000_param.c:283: error: DEAD_STORE + The value written to &mac_type is never used. + 281. struct e1000_tx_ring *tx_ring = adapter->tx_ring; + 282. int i; + 283. > e1000_mac_type mac_type = adapter->hw.mac_type; + 284. + 285. opt = (struct e1000_option) { + +drivers/net/ethernet/intel/e1000/e1000_param.c:311: error: DEAD_STORE + The value written to &mac_type is never used. + 309. struct e1000_rx_ring *rx_ring = adapter->rx_ring; + 310. int i; + 311. > e1000_mac_type mac_type = adapter->hw.mac_type; + 312. + 313. opt = (struct e1000_option) { + +drivers/cpufreq/acpi-cpufreq.c:275: error: DEAD_STORE + The value written to &dummy is never used. + 273. u32 val, dummy; + 274. + 275. > rdmsr(MSR_AMD_PERF_CTL, val, dummy); + 276. return val; + 277. } + +drivers/base/cpu.c:275: error: DEAD_STORE + The value written to &n is never used. + 273. struct device_attribute *attr, char *buf) + 274. { + 275. > int n = 0, len = PAGE_SIZE-2; + 276. cpumask_var_t isolated; + 277. + +net/ipv6/calipso.c:280: error: DEAD_STORE + The value written to &entry is never used. + 278. int ret_val = -EPERM; + 279. u32 bkt; + 280. > struct calipso_map_cache_entry *entry = NULL; + 281. struct calipso_map_cache_entry *old_entry = NULL; + 282. u32 calipso_ptr_len; + +net/ipv6/calipso.c:281: error: DEAD_STORE + The value written to &old_entry is never used. + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + 281. > struct calipso_map_cache_entry *old_entry = NULL; + 282. u32 calipso_ptr_len; + 283. + +net/ipv6/calipso.c:278: error: DEAD_STORE + The value written to &ret_val is never used. + 276. const struct netlbl_lsm_secattr *secattr) + 277. { + 278. > int ret_val = -EPERM; + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + +drivers/usb/host/ehci-q.c:314: error: DEAD_STORE + The value written to &token is never used. + 312. struct ehci_qtd *qtd; + 313. struct urb *urb; + 314. > u32 token = 0; + 315. + 316. qtd = list_entry (entry, struct ehci_qtd, qtd_list); + +drivers/video/fbdev/core/cfbfillrect.c:333: error: DEAD_STORE + The value written to &fill_op is never used. + 331. } else { + 332. int right, r; + 333. > void (*fill_op)(struct fb_info *p, unsigned long __iomem *dst, + 334. int dst_idx, unsigned long pat, int left, + 335. int right, unsigned n, int bits) = NULL; + +drivers/video/fbdev/core/cfbfillrect.c:307: error: DEAD_STORE + The value written to &fill_op32 is never used. + 305. if (!left) { + 306. u32 bswapmask = fb_compute_bswapmask(p); + 307. > void (*fill_op32)(struct fb_info *p, + 308. unsigned long __iomem *dst, int dst_idx, + 309. unsigned long pat, unsigned n, int bits, + +net/ipv6/af_inet6.c:288: error: DEAD_STORE + The value written to &addr_type is never used. + 286. unsigned short snum; + 287. bool saved_ipv6only; + 288. > int addr_type = 0; + 289. int err = 0; + 290. + +drivers/video/fbdev/core/fbmem.c:286: error: DEAD_STORE + The value written to &fg is never used. + 284. const u8 *src = logo->data; + 285. u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0; + 286. > u8 fg = 1, d; + 287. + 288. switch (fb_get_color_depth(&info->var, &info->fix)) { + +net/netfilter/nfnetlink.c:335: error: DEAD_STORE + The value written to &err is never used. + 333. memset(&extack, 0, sizeof(extack)); + 334. nlh = nlmsg_hdr(skb); + 335. > err = 0; + 336. + 337. if (nlh->nlmsg_len < NLMSG_HDRLEN || + +net/wireless/trace.h:281: error: DEAD_STORE + The value written to &p is never used. + 279. ); + 280. + 281. > DECLARE_EVENT_CLASS(wiphy_only_evt, + 282. TP_PROTO(struct wiphy *wiphy), + 283. TP_ARGS(wiphy), + +drivers/cpuidle/governors/menu.c:294: error: NULL_DEREFERENCE + pointer `device` last assigned on line 286 could be null and is dereferenced by call to `dev_pm_qos_raw_read_value()` at line 294, column 23. + 292. unsigned int expected_interval; + 293. unsigned long nr_iowaiters, cpu_load; + 294. > int resume_latency = dev_pm_qos_raw_read_value(device); + 295. + 296. if (data->needs_update) { + +drivers/md/dm-rq.c:288: error: DEAD_STORE + The value written to &rq_end_io is never used. + 286. int r = DM_ENDIO_DONE; + 287. struct dm_rq_target_io *tio = clone->end_io_data; + 288. > dm_request_endio_fn rq_end_io = NULL; + 289. + 290. if (tio->ti) { + +sound/core/pcm_native.c:304: error: DEAD_STORE + The value written to &old_interval is never used. + 302. + 303. if (trace_hw_interval_param_enabled()) + 304. > old_interval = *i; + 305. + 306. changed = snd_interval_refine(i, constrs_interval(constrs, k)); + +drivers/ata/libata-acpi.c:291: error: DEAD_STORE + The value written to &rc is never used. + 289. union acpi_object *out_obj; + 290. acpi_status status; + 291. > int rc = 0; + 292. acpi_handle handle = ACPI_HANDLE(&ap->tdev); + 293. + +block/blk-lib.c:293: error: DEAD_STORE + The value written to &bi_size is never used. + 291. struct request_queue *q = bdev_get_queue(bdev); + 292. struct bio *bio = *biop; + 293. > int bi_size = 0; + 294. unsigned int sz; + 295. + +block/partitions/efi.c:307: error: DEAD_STORE + The value written to &pte is never used. + 305. (u8 *) pte, count) < count) { + 306. kfree(pte); + 307. > pte=NULL; + 308. return NULL; + 309. } + +drivers/dma-buf/reservation.c:340: error: DEAD_STORE + The value written to &dst_list is never used. + 338. } + 339. } else { + 340. > dst_list = NULL; + 341. } + 342. + +drivers/dma-buf/reservation.c:343: error: DEAD_STORE + The value written to &new is never used. + 341. } + 342. + 343. > new = dma_fence_get_rcu_safe(&src->fence_excl); + 344. rcu_read_unlock(); + 345. + +drivers/gpu/drm/drm_fb_helper.c:291: error: DEAD_STORE + The value written to &helper is never used. + 289. int drm_fb_helper_debug_enter(struct fb_info *info) + 290. { + 291. > struct drm_fb_helper *helper = info->par; + 292. const struct drm_crtc_helper_funcs *funcs; + 293. int i; + +drivers/gpu/drm/drm_pci.c:293: error: DEAD_STORE + The value written to &pdev is never used. + 291. int drm_legacy_pci_init(struct drm_driver *driver, struct pci_driver *pdriver) + 292. { + 293. > struct pci_dev *pdev = NULL; + 294. const struct pci_device_id *pid; + 295. int i; + +block/scsi_ioctl.c:296: error: DEAD_STORE + The value written to &ret is never used. + 294. { + 295. unsigned long start_time; + 296. > ssize_t ret = 0; + 297. int writing = 0; + 298. int at_head = 0; + +net/netlabel/netlabel_calipso.c:295: error: DEAD_STORE + The value written to &ret_val is never used. + 293. static int netlbl_calipso_remove(struct sk_buff *skb, struct genl_info *info) + 294. { + 295. > int ret_val = -EINVAL; + 296. struct netlbl_domhsh_walk_arg cb_arg; + 297. struct netlbl_audit audit_info; + +net/netlabel/netlabel_mgmt.c:297: error: DEAD_STORE + The value written to &ret_val is never used. + 295. struct netlbl_dom_map *entry) + 296. { + 297. > int ret_val = 0; + 298. struct nlattr *nla_a; + 299. struct nlattr *nla_b; + +arch/x86/platform/efi/efi.c:342: error: DEAD_STORE + The value written to &tmp is never used. + 340. efi_systab.tables = data ? (unsigned long)data->tables : + 341. systab64->tables; + 342. > tmp |= data ? data->tables : systab64->tables; + 343. + 344. early_memunmap(systab64, sizeof(*systab64)); + +drivers/char/hw_random/core.c:297: error: DEAD_STORE + The value written to &ret is never used. + 295. static int enable_best_rng(void) + 296. { + 297. > int ret = -ENODEV; + 298. + 299. BUG_ON(!mutex_is_locked(&rng_mutex)); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: DEAD_STORE + The value written to &timeout__ is never used. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: DEAD_STORE + The value written to &timeout__ is never used. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: DEAD_STORE + The value written to &wait__ is never used. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: DEAD_STORE + The value written to &wait__ is never used. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_lpe_audio.c:302: error: DEAD_STORE + The value written to &desc is never used. + 300. return; + 301. + 302. > desc = irq_to_desc(dev_priv->lpe_audio.irq); + 303. + 304. lpe_audio_platdev_destroy(dev_priv); + +drivers/md/dm-io.c:314: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 314, column 29. + 312. */ + 313. if (op == REQ_OP_DISCARD) + 314. > special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + +drivers/md/dm-io.c:316: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 316, column 29. + 314. special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. > special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. special_cmd_max_sectors = q->limits.max_write_same_sectors; + +drivers/md/dm-io.c:318: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 318, column 29. + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. > special_cmd_max_sectors = q->limits.max_write_same_sectors; + 319. if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES || + 320. op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) { + +usr/gen_init_cpio.c:303: error: DEAD_STORE + The value written to &file is never used. + 301. struct stat buf; + 302. long size; + 303. > int file = -1; + 304. int retval; + 305. int rc = -1; + +net/ipv6/sit.c:302: error: DEAD_STORE + The value written to &ret is never used. + 300. struct ip_tunnel_prl_entry *prl; + 301. unsigned int cmax, c = 0, ca, len; + 302. > int ret = 0; + 303. + 304. if (copy_from_user(&kprl, a, sizeof(kprl))) + +net/ipv6/sit.c:329: error: DEAD_STORE + The value written to &ret is never used. + 327. kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC); + 328. if (!kp) { + 329. > ret = -ENOMEM; + 330. goto out; + 331. } + +net/ipv4/inet_hashtables.c:313: error: DEAD_STORE + The value written to &phash is never used. + 311. int score, hiscore = 0; + 312. unsigned int hash2; + 313. > u32 phash = 0; + 314. + 315. if (ilb->count <= 10 || !hashinfo->lhash2) + +lib/swiotlb.c:308: error: DEAD_STORE + The value written to &rc is never used. + 306. unsigned char *vstart = NULL; + 307. unsigned int order; + 308. > int rc = 0; + 309. + 310. if (!io_tlb_nslabs) { + +drivers/edac/edac_mc.c:345: error: DEAD_STORE + The value written to &mci is never used. + 343. * hardcode everything into a single struct. + 344. */ + 345. > mci = edac_align_ptr(&ptr, sizeof(*mci), 1); + 346. layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers); + 347. for (i = 0; i < n_layers; i++) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:316: error: DEAD_STORE + The value written to &p is never used. + 314. if (unlikely(p == NULL)) + 315. return -ENOSPC; + 316. > p = xdr_decode_hyper(p, &status->major_status); + 317. + 318. /* status->mech */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:327: error: DEAD_STORE + The value written to &p is never used. + 325. if (unlikely(p == NULL)) + 326. return -ENOSPC; + 327. > p = xdr_decode_hyper(p, &status->minor_status); + 328. + 329. /* status->major_status_string */ + +drivers/hid/hid-lg4ff.c:311: error: DEAD_STORE + The value written to &new_value is never used. + 309. { + 310. struct lg4ff_device_entry *entry = drv_data->device_props; + 311. > s32 new_value = 0; + 312. + 313. if (!entry) { + +kernel/reboot.c:312: error: DEAD_STORE + The value written to &ret is never used. + 310. struct pid_namespace *pid_ns = task_active_pid_ns(current); + 311. char buffer[256]; + 312. > int ret = 0; + 313. + 314. /* We only trust the superuser with rebooting the system. */ + +kernel/reboot.c:315: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 310 could be null and is dereferenced at line 315, column 18. + 313. + 314. /* We only trust the superuser with rebooting the system. */ + 315. > if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT)) + 316. return -EPERM; + 317. + +drivers/gpu/drm/i915/intel_pm.c:324: error: DEAD_STORE + The value written to &timeout__ is never used. + 322. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 323. + 324. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 325. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 326. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +drivers/gpu/drm/i915/intel_pm.c:324: error: DEAD_STORE + The value written to &wait__ is never used. + 322. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 323. + 324. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 325. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 326. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +drivers/net/ethernet/intel/e1000e/nvm.c:312: error: DEAD_STORE + The value written to &eerd is never used. + 310. { + 311. struct e1000_nvm_info *nvm = &hw->nvm; + 312. > u32 i, eerd = 0; + 313. s32 ret_val = 0; + 314. + +net/ipv4/cipso_ipv4.c:316: error: DEAD_STORE + The value written to &entry is never used. + 314. int ret_val = -EPERM; + 315. u32 bkt; + 316. > struct cipso_v4_map_cache_entry *entry = NULL; + 317. struct cipso_v4_map_cache_entry *old_entry = NULL; + 318. u32 cipso_ptr_len; + +net/ipv4/cipso_ipv4.c:317: error: DEAD_STORE + The value written to &old_entry is never used. + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + 317. > struct cipso_v4_map_cache_entry *old_entry = NULL; + 318. u32 cipso_ptr_len; + 319. + +net/ipv4/cipso_ipv4.c:314: error: DEAD_STORE + The value written to &ret_val is never used. + 312. const struct netlbl_lsm_secattr *secattr) + 313. { + 314. > int ret_val = -EPERM; + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + +net/wireless/trace.h:313: error: DEAD_STORE + The value written to &p is never used. + 311. ); + 312. + 313. > DECLARE_EVENT_CLASS(wiphy_enabled_evt, + 314. TP_PROTO(struct wiphy *wiphy, bool enabled), + 315. TP_ARGS(wiphy, enabled), + +drivers/video/fbdev/core/syscopyarea.c:320: error: DEAD_STORE + The value written to &base is never used. + 318. u32 height = area->height, width = area->width; + 319. unsigned long const bits_per_line = p->fix.line_length*8u; + 320. > unsigned long *base = NULL; + 321. int bits = BITS_PER_LONG, bytes = bits >> 3; + 322. unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + +drivers/video/fbdev/core/syscopyarea.c:322: error: DEAD_STORE + The value written to &dst_idx is never used. + 320. unsigned long *base = NULL; + 321. int bits = BITS_PER_LONG, bytes = bits >> 3; + 322. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 323. + 324. if (p->state != FBINFO_STATE_RUNNING) + +drivers/video/fbdev/core/syscopyarea.c:322: error: DEAD_STORE + The value written to &src_idx is never used. + 320. unsigned long *base = NULL; + 321. int bits = BITS_PER_LONG, bytes = bits >> 3; + 322. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 323. + 324. if (p->state != FBINFO_STATE_RUNNING) + +kernel/params.c:317: error: DEAD_STORE + The value written to &err is never used. + 315. int param_set_bool_enable_only(const char *val, const struct kernel_param *kp) + 316. { + 317. > int err = 0; + 318. bool new_value; + 319. bool orig_value = *(bool *)kp->arg; + +drivers/char/agp/isoch.c:336: error: DEAD_STORE + The value written to &arqsz is never used. + 334. return -ENODEV; + 335. + 336. > arqsz = (tstatus >> 13) & 0x7; + 337. + 338. /* + +drivers/char/hw_random/core.c:322: error: DEAD_STORE + The value written to &err is never used. + 320. const char *buf, size_t len) + 321. { + 322. > int err = -ENODEV; + 323. struct hwrng *rng; + 324. + +net/ipv6/mcast.c:427: error: DEAD_STORE + The value written to &rv is never used. + 425. pmc->sflist = psl = newpsl; + 426. } + 427. > rv = 1; /* > 0 for insert logic below if sl_count is 0 */ + 428. for (i = 0; i < psl->sl_count; i++) { + 429. rv = !ipv6_addr_equal(&psl->sl_addr[i], source); + +drivers/pcmcia/ti113x.h:323: error: DEAD_STORE + The value written to &isa_irq_mask is never used. + 321. int isa_irq = -1; + 322. u8 intctl; + 323. > u32 isa_irq_mask = 0; + 324. + 325. if (!isa_probe) + +sound/core/pcm_native.c:397: error: DEAD_STORE + The value written to &old_interval is never used. + 395. if (trace_hw_interval_param_enabled()) { + 396. if (hw_is_interval(r->var)) + 397. > old_interval = *hw_param_interval(params, r->var); + 398. } + 399. + +sound/core/pcm_native.c:393: error: DEAD_STORE + The value written to &old_mask is never used. + 391. if (trace_hw_mask_param_enabled()) { + 392. if (hw_is_mask(r->var)) + 393. > old_mask = *hw_param_mask(params, r->var); + 394. } + 395. if (trace_hw_interval_param_enabled()) { + +block/partitions/efi.c:334: error: DEAD_STORE + The value written to &gpt is never used. + 332. if (read_lba(state, lba, (u8 *) gpt, ssz) < ssz) { + 333. kfree(gpt); + 334. > gpt=NULL; + 335. return NULL; + 336. } + +drivers/char/agp/amd64-agp.c:335: error: DEAD_STORE + The value written to &i is never used. + 333. return -ENODEV; + 334. + 335. > i = 0; + 336. for (i = 0; i < amd_nb_num(); i++) { + 337. struct pci_dev *dev = node_to_amd_nb(i)->misc; + +drivers/net/phy/mdio_bus.c:329: error: DEAD_STORE + The value written to &ret is never used. + 327. { + 328. struct mdio_device *mdiodev; + 329. > int ret = 0; + 330. + 331. mdiodev = mdio_device_create(bus, bi->mdio_addr); + +net/netfilter/nf_log.c:327: error: DEAD_STORE + The value written to &net is never used. + 325. static void *seq_start(struct seq_file *seq, loff_t *pos) + 326. { + 327. > struct net *net = seq_file_net(seq); + 328. + 329. mutex_lock(&nf_log_mutex); + +drivers/gpu/drm/drm_dp_mst_topology.c:373: error: DEAD_STORE + The value written to &crc4 is never used. + 371. if (msg->curchunk_idx >= msg->curchunk_len) { + 372. /* do CRC */ + 373. > crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1); + 374. /* copy chunk into bigger msg */ + 375. memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1); + +kernel/smp.c:328: error: DEAD_STORE + The value written to &err is never used. + 326. int smp_call_function_single_async(int cpu, call_single_data_t *csd) + 327. { + 328. > int err = 0; + 329. + 330. preempt_disable(); + +net/ipv4/sysctl_net_ipv4.c:329: error: DEAD_STORE + The value written to &ret is never used. + 327. void __user *buffer, size_t *lenp, loff_t *ppos) + 328. { + 329. > int ret = 0; + 330. + 331. ret = proc_dointvec(table, write, buffer, lenp, ppos); + +sound/core/pcm_memory.c:331: error: DEAD_STORE + The value written to &dmab is never used. + 329. { + 330. struct snd_pcm_runtime *runtime; + 331. > struct snd_dma_buffer *dmab = NULL; + 332. + 333. if (PCM_RUNTIME_CHECK(substream)) + +lib/mpi/mpicoder.c:338: error: DEAD_STORE + The value written to &val is never used. + 336. const u8 *buff; + 337. mpi_limb_t a; + 338. > MPI val = NULL; + 339. + 340. ents = sg_nents_for_len(sgl, nbytes); + +net/ipv6/addrlabel.c:332: error: DEAD_STORE + The value written to &p is never used. + 330. static void __net_exit ip6addrlbl_net_exit(struct net *net) + 331. { + 332. > struct ip6addrlbl_entry *p = NULL; + 333. struct hlist_node *n; + 334. + +drivers/tty/vt/vt_ioctl.c:814: error: DEAD_STORE + The value written to &arg is never used. + 812. vt_disallocate_all(); + 813. else + 814. > ret = vt_disallocate(--arg); + 815. break; + 816. + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: DEAD_STORE + The value written to &timeout__ is never used. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: DEAD_STORE + The value written to &timeout__ is never used. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: DEAD_STORE + The value written to &wait__ is never used. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: DEAD_STORE + The value written to &wait__ is never used. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_runtime_pm.c:335: error: DEAD_STORE + The value written to &id is never used. + 333. struct i915_power_well *power_well) + 334. { + 335. > enum i915_power_well_id id = power_well->id; + 336. bool disabled; + 337. u32 reqs; + +drivers/gpu/drm/i915/intel_runtime_pm.c:348: error: DEAD_STORE + The value written to &timeout__ is never used. + 346. * diagnostic message. + 347. */ + 348. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 349. HSW_PWR_WELL_CTL_STATE(id))) || + 350. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +drivers/gpu/drm/i915/intel_runtime_pm.c:348: error: DEAD_STORE + The value written to &wait__ is never used. + 346. * diagnostic message. + 347. */ + 348. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 349. HSW_PWR_WELL_CTL_STATE(id))) || + 350. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +drivers/mailbox/pcc.c:341: error: DEAD_STORE + The value written to &ret is never used. + 339. u64 doorbell_write; + 340. u32 id = chan - pcc_mbox_channels; + 341. > int ret = 0; + 342. + 343. if (id >= pcc_mbox_ctrl.num_chans) { + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &p is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &ret is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +drivers/connector/cn_proc.c:338: error: DEAD_STORE + The value written to &mc_op is never used. + 336. struct netlink_skb_parms *nsp) + 337. { + 338. > enum proc_cn_mcast_op *mc_op = NULL; + 339. int err = 0; + 340. + +drivers/char/agp/intel-gtt.c:342: error: DEAD_STORE + The value written to &stolen_size is never used. + 340. int local = 0; + 341. static const int ddt[4] = { 0, 16, 32, 64 }; + 342. > resource_size_t stolen_size = 0; + 343. + 344. if (INTEL_GTT_GEN == 1) + +net/netlabel/netlabel_cipso_v4.c:340: error: DEAD_STORE + The value written to &doi_def is never used. + 338. { + 339. int ret_val; + 340. > struct cipso_v4_doi *doi_def = NULL; + 341. + 342. if (!info->attrs[NLBL_CIPSOV4_A_TAGLST]) + +net/netfilter/nf_log.c:339: error: DEAD_STORE + The value written to &net is never used. + 337. static void *seq_next(struct seq_file *s, void *v, loff_t *pos) + 338. { + 339. > struct net *net = seq_file_net(s); + 340. + 341. (*pos)++; + +drivers/input/ff-memless.c:354: error: DEAD_STORE + The value written to &effect is never used. + 352. + 353. state = &ml->states[i]; + 354. > effect = state->effect; + 355. + 356. if (!test_bit(FF_EFFECT_STARTED, &state->flags)) + +block/badblocks.c:356: error: DEAD_STORE + The value written to §ors is never used. + 354. s >>= bb->shift; + 355. target >>= bb->shift; + 356. > sectors = target - s; + 357. } + 358. + +security/keys/process_keys.c:350: error: DEAD_STORE + The value written to &key_ref is never used. + 348. * in terms of priority: success > -ENOKEY > -EAGAIN > other error + 349. */ + 350. > key_ref = NULL; + 351. ret = NULL; + 352. err = ERR_PTR(-EAGAIN); + +block/blk-sysfs.c:343: error: DEAD_STORE + The value written to &ret is never used. + 341. queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) + 342. { + 343. > ssize_t ret = -EINVAL; + 344. #ifdef CONFIG_SMP + 345. unsigned long val; + +net/netfilter/nf_nat_sip.c:368: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 351 could be null and is dereferenced at line 368, column 12. + 366. * original direction, try to use the destination port in the opposite + 367. * direction. */ + 368. > srcport = ct_sip_info->forced_dport ? : + 369. ct->tuplehash[dir].tuple.src.u.udp.port; + 370. if (exp->tuple.dst.u.udp.port == srcport) + +net/ipv4/sysctl_net_ipv4.c:345: error: DEAD_STORE + The value written to &ret is never used. + 343. void __user *buffer, size_t *lenp, loff_t *ppos) + 344. { + 345. > int ret = 0; + 346. + 347. ret = proc_dointvec(table, write, buffer, lenp, ppos); + +drivers/firmware/efi/esrt.c:352: error: DEAD_STORE + The value written to &esre is never used. + 350. + 351. for (i = 0; i < le32_to_cpu(esrt->fw_resource_count); i++) { + 352. > void *esre = NULL; + 353. if (esrt->fw_resource_version == 1) { + 354. esre = &v1_entries[i]; + +drivers/tty/tty_io.c:348: error: DEAD_STORE + The value written to &prefix_length is never used. + 346. struct tty_driver *p; + 347. int ret; + 348. > int index, prefix_length = 0; + 349. const char *str; + 350. + +crypto/jitterentropy.c:350: error: DEAD_STORE + The value written to ¤t_delta is never used. + 348. __u64 time = 0; + 349. __u64 data = 0; + 350. > __u64 current_delta = 0; + 351. + 352. /* Invoke one noise source before time measurement to add variations */ + +lib/assoc_array.c:413: error: DEAD_STORE + The value written to &cursor is never used. + 411. shortcut = assoc_array_ptr_to_shortcut(parent); + 412. BUG_ON(shortcut->next_node != cursor); + 413. > cursor = parent; + 414. parent = shortcut->back_pointer; + 415. slot = shortcut->parent_slot; + +net/sched/act_api.c:354: error: DEAD_STORE + The value written to &id is never used. + 352. struct tc_action *p; + 353. int ret; + 354. > unsigned long id = 1; + 355. + 356. idr_for_each_entry_ul(idr, p, id) { + +drivers/gpu/drm/i915/i915_gem.c:391: error: DEAD_STORE + The value written to &rps_client is never used. + 389. gen6_rps_boost(rq, rps_client); + 390. else + 391. > rps_client = NULL; + 392. } + 393. + +kernel/locking/rwsem-xadd.c:353: error: DEAD_STORE + The value written to &ret is never used. + 351. { + 352. struct task_struct *owner; + 353. > bool ret = true; + 354. + 355. if (need_resched()) + +net/wireless/trace.h:350: error: DEAD_STORE + The value written to &p is never used. + 348. ); + 349. + 350. > DECLARE_EVENT_CLASS(wiphy_wdev_evt, + 351. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 352. TP_ARGS(wiphy, wdev), + +scripts/asn1_compiler.c:361: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 361, column 3. + 359. token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token)); + 360. if (!tokens) { + 361. > perror(NULL); + 362. exit(1); + 363. } + +crypto/api.c:354: error: DEAD_STORE + The value written to &tfm is never used. + 352. u32 mask) + 353. { + 354. > struct crypto_tfm *tfm = NULL; + 355. unsigned int tfm_size; + 356. int err = -ENOMEM; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:378: error: DEAD_STORE + The value written to &err is never used. + 376. opt.value.data = LUCID_VALUE; + 377. opt.value.len = sizeof(LUCID_VALUE); + 378. > err = gssx_enc_option(xdr, &opt); + 379. + 380. /* ..and user creds */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:371: error: NULL_DEREFERENCE + pointer `p` last assigned on line 370 could be null and is dereferenced at line 371, column 2. + 369. /* ctx->options */ + 370. p = xdr_reserve_space(xdr, 4); + 371. > *p = cpu_to_be32(2); + 372. + 373. /* we want a lucid_v1 context */ + +sound/hda/hdac_controller.c:360: error: DEAD_STORE + The value written to &timeout is never used. + 358. snd_hdac_chip_updatel(bus, GCTL, AZX_GCTL_RESET, 0); + 359. + 360. > timeout = jiffies + msecs_to_jiffies(100); + 361. while ((snd_hdac_chip_readb(bus, GCTL) & AZX_GCTL_RESET) && + 362. time_before(jiffies, timeout)) + +sound/core/timer.c:356: error: DEAD_STORE + The value written to &timer is never used. + 354. static int snd_timer_close_locked(struct snd_timer_instance *timeri) + 355. { + 356. > struct snd_timer *timer = NULL; + 357. struct snd_timer_instance *slave, *tmp; + 358. + +drivers/gpu/drm/i915/intel_opregion.c:362: error: DEAD_STORE + The value written to &type is never used. + 360. struct drm_i915_private *dev_priv = to_i915(intel_encoder->base.dev); + 361. u32 parm = 0; + 362. > u32 type = 0; + 363. u32 port; + 364. + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:394: error: DEAD_STORE + The value written to &ret_val is never used. + 392. + 393. /* ...and verify the command was successful. */ + 394. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 395. + 396. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +drivers/input/serio/i8042.c:363: error: DEAD_STORE + The value written to &retval is never used. + 361. { + 362. unsigned long flags; + 363. > int retval = 0; + 364. + 365. spin_lock_irqsave(&i8042_lock, flags); + +net/sunrpc/clnt.c:367: error: DEAD_STORE + The value written to &clnt is never used. + 365. const struct rpc_program *program = args->program; + 366. const struct rpc_version *version; + 367. > struct rpc_clnt *clnt = NULL; + 368. const struct rpc_timeout *timeout; + 369. const char *nodename = args->nodename; + +kernel/trace/trace_uprobe.c:373: error: DEAD_STORE + The value written to &ret is never used. + 371. + 372. inode = NULL; + 373. > ret = 0; + 374. is_delete = false; + 375. is_return = false; + +kernel/trace/trace_uprobe.c:501: error: DEAD_STORE + The value written to &ret is never used. + 499. + 500. /* parse arguments */ + 501. > ret = 0; + 502. for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) { + 503. struct probe_arg *parg = &tu->tp.args[i]; + +drivers/scsi/scsi_logging.c:375: error: DEAD_STORE + The value written to &off is never used. + 373. return; + 374. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 375. > off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr); + 376. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + 377. scsi_log_release_buffer(logbuf); + +drivers/scsi/scsi_logging.c:383: error: DEAD_STORE + The value written to &off is never used. + 381. return; + 382. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 383. > off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, + 384. sshdr->asc, sshdr->ascq); + 385. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + +drivers/gpu/drm/drm_modes.c:459: error: DEAD_STORE + The value written to &hperiod is never used. + 457. vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. > hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + 460. + 461. /* 13. Find the actual Vertical field frequency: */ + +drivers/gpu/drm/drm_modes.c:452: error: DEAD_STORE + The value written to &vback_porch is never used. + 450. vsync_plus_bp = (vsync_plus_bp + 500) / 1000; + 451. /* 9. Find the number of lines in V back porch alone: */ + 452. > vback_porch = vsync_plus_bp - V_SYNC_RQD; + 453. /* 10. Find the total number of lines in Vertical field period: */ + 454. vtotal_lines = vdisplay_rnd + top_margin + bottom_margin + + +drivers/gpu/drm/drm_modes.c:457: error: DEAD_STORE + The value written to &vfieldrate_est is never used. + 455. vsync_plus_bp + GTF_MIN_V_PORCH; + 456. /* 11. Estimate the Vertical field frequency: */ + 457. > vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + +drivers/gpu/drm/drm_modes.c:465: error: DEAD_STORE + The value written to &vframe_rate is never used. + 463. /* 14. Find the Vertical frame frequency: */ + 464. if (interlaced) + 465. > vframe_rate = vfield_rate / 2; + 466. else + 467. vframe_rate = vfield_rate; + +drivers/gpu/drm/drm_modes.c:467: error: DEAD_STORE + The value written to &vframe_rate is never used. + 465. vframe_rate = vfield_rate / 2; + 466. else + 467. > vframe_rate = vfield_rate; + 468. /* 15. Find number of pixels in left margin: */ + 469. if (margins) + +drivers/pci/slot.c:369: error: DEAD_STORE + The value written to &kobj is never used. + 367. { + 368. struct hotplug_slot *slot = pci_slot->hotplug; + 369. > struct kobject *kobj = NULL; + 370. int ret; + 371. + +drivers/usb/core/message.c:455: error: DEAD_STORE + The value written to &i is never used. + 453. urb->transfer_buffer_length = len; + 454. } + 455. > io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; + 456. + 457. /* transaction state */ + +drivers/block/loop.c:375: error: DEAD_STORE + The value written to &ret is never used. + 373. struct page *page; + 374. ssize_t len; + 375. > int ret = 0; + 376. + 377. page = alloc_page(GFP_NOIO); + +drivers/md/dm-stripe.c:384: error: DEAD_STORE + The value written to &sz is never used. + 382. } + 383. buffer[i] = '\0'; + 384. > DMEMIT("1 %s", buffer); + 385. break; + 386. + +drivers/pcmcia/ti113x.h:417: error: DEAD_STORE + The value written to &mfunc_old is never used. + 415. dev_info(&socket->dev->dev, + 416. "TI: all-serial interrupts ok\n"); + 417. > mfunc_old = mfunc; + 418. goto out; + 419. } + +drivers/pcmcia/ti113x.h:462: error: DEAD_STORE + The value written to &mfunc_old is never used. + 460. pci_irq_status = yenta_probe_cb_irq(socket); + 461. if (pci_irq_status == 1) { + 462. > mfunc_old = mfunc; + 463. dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n"); + 464. } else { + +kernel/sched/cpuacct.c:377: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 376 could be null and is dereferenced at line 377, column 3. + 375. rcu_read_lock(); + 376. for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca)) + 377. > this_cpu_ptr(ca->cpustat)->cpustat[index] += val; + 378. rcu_read_unlock(); + 379. } + +sound/hda/hdac_controller.c:379: error: DEAD_STORE + The value written to &timeout is never used. + 377. snd_hdac_chip_updateb(bus, GCTL, 0, AZX_GCTL_RESET); + 378. + 379. > timeout = jiffies + msecs_to_jiffies(100); + 380. while (!snd_hdac_chip_readb(bus, GCTL) && time_before(jiffies, timeout)) + 381. usleep_range(500, 1000); + +drivers/pci/access.c:378: error: DEAD_STORE + The value written to &max_sleep is never used. + 376. struct pci_vpd *vpd = dev->vpd; + 377. unsigned long timeout = jiffies + msecs_to_jiffies(125); + 378. > unsigned long max_sleep = 16; + 379. u16 status; + 380. int ret; + +drivers/pci/access.c:377: error: DEAD_STORE + The value written to &timeout is never used. + 375. { + 376. struct pci_vpd *vpd = dev->vpd; + 377. > unsigned long timeout = jiffies + msecs_to_jiffies(125); + 378. unsigned long max_sleep = 16; + 379. u16 status; + +net/wireless/trace.h:374: error: DEAD_STORE + The value written to &p is never used. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/netlabel/netlabel_cipso_v4.c:379: error: DEAD_STORE + The value written to &doi_def is never used. + 377. { + 378. int ret_val; + 379. > struct cipso_v4_doi *doi_def = NULL; + 380. + 381. if (!info->attrs[NLBL_CIPSOV4_A_TAGLST]) + +drivers/gpu/drm/drm_mode_object.c:381: error: DEAD_STORE + The value written to &ret is never used. + 379. struct drm_mode_obj_get_properties *arg = data; + 380. struct drm_mode_object *obj; + 381. > int ret = 0; + 382. + 383. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/gpu/drm/i915/intel_device_info.c:400: error: DEAD_STORE + The value written to &freq is never used. + 398. } else if (INTEL_GEN(dev_priv) <= 9) { + 399. u32 ctc_reg = I915_READ(CTC_MODE); + 400. > u32 freq = 0; + 401. + 402. if ((ctc_reg & CTC_SOURCE_PARAMETER_MASK) == CTC_SOURCE_DIVIDE_LOGIC) { + +drivers/gpu/drm/i915/intel_device_info.c:419: error: DEAD_STORE + The value written to &rpm_config_reg is never used. + 417. u32 ctc_reg = I915_READ(CTC_MODE); + 418. u32 freq = 0; + 419. > u32 rpm_config_reg = 0; + 420. + 421. /* First figure out the reference frequency. There are 2 ways + +net/ipv6/addrlabel.c:384: error: DEAD_STORE + The value written to &err is never used. + 382. struct in6_addr *pfx; + 383. u32 label; + 384. > int err = 0; + 385. + 386. err = nlmsg_parse(nlh, sizeof(*ifal), tb, IFAL_MAX, ifal_policy, + +block/blk-lib.c:380: error: DEAD_STORE + The value written to &ret is never used. + 378. sector_t nr_sects, gfp_t gfp_mask, unsigned flags) + 379. { + 380. > int ret = 0; + 381. sector_t bs_mask; + 382. struct bio *bio; + +drivers/char/nvram.c:380: error: DEAD_STORE + The value written to &i is never used. + 378. { + 379. unsigned char contents[NVRAM_BYTES]; + 380. > int i = 0; + 381. + 382. spin_lock_irq(&rtc_lock); + +lib/radix-tree.c:383: error: DEAD_STORE + The value written to &ret is never used. + 381. unsigned int count, unsigned int exceptional) + 382. { + 383. > struct radix_tree_node *ret = NULL; + 384. + 385. /* + +sound/pci/hda/hda_controller.c:391: error: DEAD_STORE + The value written to &timeout is never used. + 389. bool direction; + 390. u32 dma_select; + 391. > u32 timeout = 200; + 392. u32 retry_count = 0; + 393. + +drivers/gpu/drm/drm_blend.c:386: error: DEAD_STORE + The value written to &ret is never used. + 384. struct drm_plane *plane; + 385. struct drm_plane_state *old_plane_state, *new_plane_state; + 386. > int i, ret = 0; + 387. + 388. for_each_oldnew_plane_in_state(state, plane, old_plane_state, new_plane_state, i) { + +drivers/pci/search.c:381: error: DEAD_STORE + The value written to &found is never used. + 379. int pci_dev_present(const struct pci_device_id *ids) + 380. { + 381. > struct pci_dev *found = NULL; + 382. + 383. WARN_ON(in_interrupt()); + +kernel/cgroup/cpuset.c:382: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 382 could be null and is dereferenced by call to `parent_cs()` at line 382, column 8. + 380. { + 381. while (!nodes_intersects(cs->effective_mems, node_states[N_MEMORY])) + 382. > cs = parent_cs(cs); + 383. nodes_and(*pmask, cs->effective_mems, node_states[N_MEMORY]); + 384. } + +drivers/gpu/drm/drm_framebuffer.c:383: error: DEAD_STORE + The value written to &fb is never used. + 381. void *data, struct drm_file *file_priv) + 382. { + 383. > struct drm_framebuffer *fb = NULL; + 384. struct drm_framebuffer *fbl = NULL; + 385. uint32_t *id = data; + +drivers/gpu/drm/drm_framebuffer.c:384: error: DEAD_STORE + The value written to &fbl is never used. + 382. { + 383. struct drm_framebuffer *fb = NULL; + 384. > struct drm_framebuffer *fbl = NULL; + 385. uint32_t *id = data; + 386. int found = 0; + +drivers/video/fbdev/core/cfbcopyarea.c:386: error: DEAD_STORE + The value written to &base is never used. + 384. u32 height = area->height, width = area->width; + 385. unsigned long const bits_per_line = p->fix.line_length*8u; + 386. > unsigned long __iomem *base = NULL; + 387. int bits = BITS_PER_LONG, bytes = bits >> 3; + 388. unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + +drivers/video/fbdev/core/cfbcopyarea.c:388: error: DEAD_STORE + The value written to &dst_idx is never used. + 386. unsigned long __iomem *base = NULL; + 387. int bits = BITS_PER_LONG, bytes = bits >> 3; + 388. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 389. u32 bswapmask = fb_compute_bswapmask(p); + 390. + +drivers/video/fbdev/core/cfbcopyarea.c:388: error: DEAD_STORE + The value written to &src_idx is never used. + 386. unsigned long __iomem *base = NULL; + 387. int bits = BITS_PER_LONG, bytes = bits >> 3; + 388. > unsigned dst_idx = 0, src_idx = 0, rev_copy = 0; + 389. u32 bswapmask = fb_compute_bswapmask(p); + 390. + +drivers/gpu/drm/i915/intel_dsi_pll.c:388: error: DEAD_STORE + The value written to &ddr_clk is never used. + 386. u32 dsi_rate = 0; + 387. u32 pll_ratio = 0; + 388. > u32 ddr_clk = 0; + 389. u32 div1_value = 0; + 390. u32 div2_value = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:389: error: DEAD_STORE + The value written to &div1_value is never used. + 387. u32 pll_ratio = 0; + 388. u32 ddr_clk = 0; + 389. > u32 div1_value = 0; + 390. u32 div2_value = 0; + 391. u32 txesc1_div = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:390: error: DEAD_STORE + The value written to &div2_value is never used. + 388. u32 ddr_clk = 0; + 389. u32 div1_value = 0; + 390. > u32 div2_value = 0; + 391. u32 txesc1_div = 0; + 392. u32 txesc2_div = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:386: error: DEAD_STORE + The value written to &dsi_rate is never used. + 384. { + 385. struct drm_i915_private *dev_priv = to_i915(dev); + 386. > u32 dsi_rate = 0; + 387. u32 pll_ratio = 0; + 388. u32 ddr_clk = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:387: error: DEAD_STORE + The value written to &pll_ratio is never used. + 385. struct drm_i915_private *dev_priv = to_i915(dev); + 386. u32 dsi_rate = 0; + 387. > u32 pll_ratio = 0; + 388. u32 ddr_clk = 0; + 389. u32 div1_value = 0; + +drivers/gpu/drm/i915/intel_dsi_pll.c:391: error: DEAD_STORE + The value written to &txesc1_div is never used. + 389. u32 div1_value = 0; + 390. u32 div2_value = 0; + 391. > u32 txesc1_div = 0; + 392. u32 txesc2_div = 0; + 393. + +drivers/gpu/drm/i915/intel_dsi_pll.c:392: error: DEAD_STORE + The value written to &txesc2_div is never used. + 390. u32 div2_value = 0; + 391. u32 txesc1_div = 0; + 392. > u32 txesc2_div = 0; + 393. + 394. pll_ratio = config->dsi_pll.ctrl & BXT_DSI_PLL_RATIO_MASK; + +drivers/clk/clk-divider.c:388: error: DEAD_STORE + The value written to &flags is never used. + 386. struct clk_divider *divider = to_clk_divider(hw); + 387. int value; + 388. > unsigned long flags = 0; + 389. u32 val; + 390. + +lib/kobject_uevent.c:388: error: DEAD_STORE + The value written to &devpath is never used. + 386. struct kobj_uevent_env *env; + 387. const char *action_string = kobject_actions[action]; + 388. > const char *devpath = NULL; + 389. const char *subsystem; + 390. struct kobject *top_kobj; + +lib/kobject_uevent.c:393: error: DEAD_STORE + The value written to &i is never used. + 391. struct kset *kset; + 392. const struct kset_uevent_ops *uevent_ops; + 393. > int i = 0; + 394. int retval = 0; + 395. + +lib/kobject_uevent.c:394: error: DEAD_STORE + The value written to &retval is never used. + 392. const struct kset_uevent_ops *uevent_ops; + 393. int i = 0; + 394. > int retval = 0; + 395. + 396. pr_debug("kobject: '%s' (%p): %s\n", + +net/sunrpc/cache.c:420: error: DEAD_STORE + The value written to &ch is never used. + 418. + 419. if (current_detail && current_index < current_detail->hash_size) { + 420. > struct cache_head *ch = NULL; + 421. struct cache_detail *d; + 422. struct hlist_head *head; + +drivers/video/console/vgacon.c:386: error: DEAD_STORE + The value written to &display_desc is never used. + 384. static const char *vgacon_startup(void) + 385. { + 386. > const char *display_desc = NULL; + 387. u16 saved1, saved2; + 388. volatile u16 *p; + +net/xfrm/xfrm_policy.c:390: error: DEAD_STORE + The value written to &entry0 is never used. + 388. int dir) + 389. { + 390. > struct hlist_node *tmp, *entry0 = NULL; + 391. struct xfrm_policy *pol; + 392. unsigned int h0 = 0; + +net/xfrm/xfrm_policy.c:413: error: DEAD_STORE + The value written to &entry0 is never used. + 411. hlist_add_behind_rcu(&pol->bydst, entry0); + 412. } + 413. > entry0 = &pol->bydst; + 414. } + 415. if (!hlist_empty(list)) { + +net/xfrm/xfrm_policy.c:416: error: DEAD_STORE + The value written to &entry0 is never used. + 414. } + 415. if (!hlist_empty(list)) { + 416. > entry0 = NULL; + 417. goto redo; + 418. } + +net/xfrm/xfrm_policy.c:392: error: DEAD_STORE + The value written to &h0 is never used. + 390. struct hlist_node *tmp, *entry0 = NULL; + 391. struct xfrm_policy *pol; + 392. > unsigned int h0 = 0; + 393. u8 dbits; + 394. u8 sbits; + +net/xfrm/xfrm_policy.c:406: error: DEAD_STORE + The value written to &h0 is never used. + 404. hlist_del_rcu(&pol->bydst); + 405. hlist_add_head_rcu(&pol->bydst, ndsttable + h); + 406. > h0 = h; + 407. } else { + 408. if (h != h0) + +drivers/gpu/drm/drm_mm.c:387: error: DEAD_STORE + The value written to &end is never used. + 385. int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node) + 386. { + 387. > u64 end = node->start + node->size; + 388. struct drm_mm_node *hole; + 389. u64 hole_start, hole_end; + +kernel/cgroup/freezer.c:409: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 398 could be null and is dereferenced at line 409, column 10. + 407. else + 408. freezer_apply_state(pos_f, + 409. > parent->state & CGROUP_FREEZING, + 410. CGROUP_FREEZING_PARENT); + 411. + +drivers/scsi/sr.c:388: error: DEAD_STORE + The value written to &block is never used. + 386. static int sr_init_command(struct scsi_cmnd *SCpnt) + 387. { + 388. > int block = 0, this_count, s_size; + 389. struct scsi_cd *cd; + 390. struct request *rq = SCpnt->request; + +net/ipv4/inet_hashtables.c:392: error: DEAD_STORE + The value written to &acookie is never used. + 390. const int dif, const int sdif) + 391. { + 392. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + +net/ipv4/inet_hashtables.c:393: error: DEAD_STORE + The value written to &ports is never used. + 391. { + 392. INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + 395. const struct hlist_nulls_node *node; + +drivers/gpu/drm/i915/i915_gem_shrinker.c:392: error: DEAD_STORE + The value written to &timeout is never used. + 390. int timeout_ms) + 391. { + 392. > unsigned long timeout = jiffies + msecs_to_jiffies_timeout(timeout_ms); + 393. + 394. do { + +security/selinux/ss/avtab.c:489: error: DEAD_STORE + The value written to &items is never used. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +crypto/rsa-pkcs1pad.c:399: error: DEAD_STORE + The value written to &digest_size is never used. + 397. const struct rsa_asn1_template *digest_info = ictx->digest_info; + 398. int err; + 399. > unsigned int ps_end, digest_size = 0; + 400. + 401. if (!ctx->key_size) + +arch/x86/power/cpu.c:393: error: DEAD_STORE + The value written to &i is never used. + 391. static int msr_init_context(const u32 *msr_id, const int total_num) + 392. { + 393. > int i = 0; + 394. struct saved_msr *msr_array; + 395. + +net/wireless/trace.h:392: error: DEAD_STORE + The value written to &p is never used. + 390. ); + 391. + 392. > DECLARE_EVENT_CLASS(key_handle, + 393. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 394. bool pairwise, const u8 *mac_addr), + +drivers/md/dm-region-hash.c:399: error: DEAD_STORE + The value written to &recovering is never used. + 397. struct dm_region *reg; + 398. region_t region = dm_rh_bio_to_region(rh, bio); + 399. > int recovering = 0; + 400. + 401. if (bio->bi_opf & REQ_PREFLUSH) { + +arch/x86/lib/insn-eval.c:397: error: DEAD_STORE + The value written to ®no is never used. + 395. enum reg_type type) + 396. { + 397. > int regno = 0; + 398. + 399. static const int regoff[] = { + +drivers/cpuidle/sysfs.c:398: error: DEAD_STORE + The value written to &ret is never used. + 396. static int cpuidle_add_state_sysfs(struct cpuidle_device *device) + 397. { + 398. > int i, ret = -ENOMEM; + 399. struct cpuidle_state_kobj *kobj; + 400. struct cpuidle_device_kobj *kdev = device->kobj_dev; + +drivers/gpu/drm/drm_agpsupport.c:398: error: DEAD_STORE + The value written to &head is never used. + 396. struct drm_agp_head *drm_agp_init(struct drm_device *dev) + 397. { + 398. > struct drm_agp_head *head = NULL; + 399. + 400. head = kzalloc(sizeof(*head), GFP_KERNEL); + +drivers/gpu/drm/i915/dvo_ivch.c:401: error: DEAD_STORE + The value written to &vr40 is never used. + 399. { + 400. struct ivch_priv *priv = dvo->dev_priv; + 401. > uint16_t vr40 = 0; + 402. uint16_t vr01 = 0; + 403. uint16_t vr10; + +net/sunrpc/xprtsock.c:399: error: DEAD_STORE + The value written to &err is never used. + 397. { + 398. unsigned int remainder = xdr->len - base; + 399. > int err = 0; + 400. int sent = 0; + 401. + +kernel/taskstats.c:401: error: DEAD_STORE + The value written to &rc is never used. + 399. static int cgroupstats_user_cmd(struct sk_buff *skb, struct genl_info *info) + 400. { + 401. > int rc = 0; + 402. struct sk_buff *rep_skb; + 403. struct cgroupstats *stats; + +drivers/input/mouse/byd.c:403: error: DEAD_STORE + The value written to &error is never used. + 401. static int byd_reconnect(struct psmouse *psmouse) + 402. { + 403. > int retry = 0, error = 0; + 404. + 405. psmouse_dbg(psmouse, "Reconnect\n"); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:530: error: DEAD_STORE + The value written to &icr is never used. + 528. + 529. /* Clear any pending interrupt events. */ + 530. > icr = er32(ICR); + 531. + 532. /* If MWI was previously enabled, reenable it. */ + +security/selinux/ss/conditional.c:406: error: DEAD_STORE + The value written to &expr is never used. + 404. u32 len, i; + 405. int rc; + 406. > struct cond_expr *expr = NULL, *last = NULL; + 407. + 408. rc = next_entry(buf, fp, sizeof(u32) * 2); + +net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c:408: error: DEAD_STORE + The value written to &ret is never used. + 406. static int __init nf_conntrack_l3proto_ipv6_init(void) + 407. { + 408. > int ret = 0; + 409. + 410. need_conntrack(); + +net/sunrpc/auth_gss/svcauth_gss.c:417: error: DEAD_STORE + The value written to &gm is never used. + 415. time_t expiry; + 416. int status = -EINVAL; + 417. > struct gss_api_mech *gm = NULL; + 418. + 419. memset(&rsci, 0, sizeof(rsci)); + +net/core/net-sysfs.c:413: error: DEAD_STORE + The value written to &ret is never used. + 411. const struct net_device *netdev = to_net_dev(dev); + 412. char tmp[IFALIASZ]; + 413. > ssize_t ret = 0; + 414. + 415. ret = dev_get_alias(netdev, tmp, sizeof(tmp)); + +drivers/base/cpu.c:415: error: DEAD_STORE + The value written to &dev is never used. + 413. const char *fmt, va_list args) + 414. { + 415. > struct device *dev = NULL; + 416. int retval = -ENODEV; + 417. + +drivers/base/cpu.c:416: error: DEAD_STORE + The value written to &retval is never used. + 414. { + 415. struct device *dev = NULL; + 416. > int retval = -ENODEV; + 417. + 418. dev = kzalloc(sizeof(*dev), GFP_KERNEL); + +lib/kfifo.c:419: error: DEAD_STORE + The value written to &recsize is never used. + 417. l = __KFIFO_PEEK(data, fifo->out, mask); + 418. + 419. > if (--recsize) + 420. l |= __KFIFO_PEEK(data, fifo->out + 1, mask) << 8; + 421. + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &bytes is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &skip is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +kernel/audit_watch.c:420: error: DEAD_STORE + The value written to &ret is never used. + 418. struct audit_parent *parent; + 419. struct path parent_path; + 420. > int h, ret = 0; + 421. + 422. mutex_unlock(&audit_filter_mutex); + +net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c:418: error: DEAD_STORE + The value written to &ret is never used. + 416. static int __init nf_conntrack_l3proto_ipv4_init(void) + 417. { + 418. > int ret = 0; + 419. + 420. need_conntrack(); + +drivers/cpufreq/acpi-cpufreq.c:423: error: DEAD_STORE + The value written to &next_perf_state is never used. + 421. struct acpi_processor_performance *perf; + 422. const struct cpumask *mask; + 423. > unsigned int next_perf_state = 0; /* Index into perf table */ + 424. int result = 0; + 425. + +net/netlabel/netlabel_domainhash.c:420: error: DEAD_STORE + The value written to &ret_val is never used. + 418. struct netlbl_audit *audit_info) + 419. { + 420. > int ret_val = 0; + 421. struct netlbl_dom_map *entry_old, *entry_b; + 422. struct netlbl_af4list *iter4; + +drivers/char/hpet.c:422: error: DEAD_STORE + The value written to &irq is never used. + 420. struct hpet_dev *devp; + 421. struct hpet_timer __iomem *timer; + 422. > int irq = 0; + 423. + 424. devp = file->private_data; + +drivers/scsi/scsi_scan.c:422: error: DEAD_STORE + The value written to &dev is never used. + 420. { + 421. struct Scsi_Host *shost = dev_to_shost(parent); + 422. > struct device *dev = NULL; + 423. unsigned long flags; + 424. const int size = sizeof(struct scsi_target) + +net/ipv6/raw.c:430: error: NULL_DEREFERENCE + pointer `rp` last assigned on line 422 could be null and is dereferenced at line 430, column 7. + 428. } + 429. + 430. > if (!rp->checksum) + 431. skb->ip_summed = CHECKSUM_UNNECESSARY; + 432. + +kernel/time/posix-cpu-timers.c:424: error: DEAD_STORE + The value written to &head is never used. + 422. cleanup_timers_list(head); + 423. cleanup_timers_list(++head); + 424. > cleanup_timers_list(++head); + 425. } + 426. + +net/ipv6/icmp.c:436: error: DEAD_STORE + The value written to &addr_type is never used. + 434. struct ipcm6_cookie ipc6; + 435. int iif = 0; + 436. > int addr_type = 0; + 437. int len; + 438. u32 mark = IP6_REPLY_MARK(net, skb->mark); + +net/ipv6/icmp.c:424: error: DEAD_STORE + The value written to &idev is never used. + 422. { + 423. struct net *net = dev_net(skb->dev); + 424. > struct inet6_dev *idev = NULL; + 425. struct ipv6hdr *hdr = ipv6_hdr(skb); + 426. struct sock *sk; + +net/ipv6/icmp.c:435: error: DEAD_STORE + The value written to &iif is never used. + 433. struct sockcm_cookie sockc_unused = {0}; + 434. struct ipcm6_cookie ipc6; + 435. > int iif = 0; + 436. int addr_type = 0; + 437. int len; + +crypto/jitterentropy.c:442: error: DEAD_STORE + The value written to &i is never used. + 440. */ + 441. union c mixer; + 442. > unsigned int i = 0; + 443. + 444. /* + +kernel/events/core.c:428: error: DEAD_STORE + The value written to &tmp is never used. + 426. tmp = div_u64(tmp, 100); + 427. if (!tmp) + 428. > tmp = 1; + 429. + 430. WRITE_ONCE(perf_sample_allowed_ns, tmp); + +net/ipv6/ip6_output.c:506: error: DEAD_STORE + The value written to &target is never used. + 504. */ + 505. if (skb->dev == dst->dev && opt->srcrt == 0 && !skb_sec_path(skb)) { + 506. > struct in6_addr *target = NULL; + 507. struct inet_peer *peer; + 508. struct rt6_info *rt; + +drivers/gpu/drm/i915/intel_guc_ct.c:426: error: DEAD_STORE + The value written to &dev_priv is never used. + 424. int intel_guc_enable_ct(struct intel_guc *guc) + 425. { + 426. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 427. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 428. int err; + +block/blk-merge.c:444: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced at line 444, column 3. + 442. (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1; + 443. + 444. > sg->length += pad_len; + 445. rq->extra_len += pad_len; + 446. } + +block/blk-merge.c:452: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced by call to `sg_unmark_end()` at line 452, column 3. + 450. memset(q->dma_drain_buffer, 0, q->dma_drain_size); + 451. + 452. > sg_unmark_end(sg); + 453. sg = sg_next(sg); + 454. sg_set_page(sg, virt_to_page(q->dma_drain_buffer), + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:463: error: DEAD_STORE + The value written to &ret_val is never used. + 461. + 462. /* ...and verify the command was successful. */ + 463. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 464. + 465. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:437: error: DEAD_STORE + The value written to &p is never used. + 435. if (unlikely(p == NULL)) + 436. return -ENOSPC; + 437. > count = be32_to_cpup(p++); + 438. for (i = 0; i < count; i++) { + 439. gssx_dec_name_attr(xdr, &dummy); + +arch/x86/events/intel/pt.c:432: error: DEAD_STORE + The value written to &range is never used. + 430. struct pt_filters *filters = event->hw.addr_filters; + 431. struct pt *pt = this_cpu_ptr(&pt_ctx); + 432. > unsigned int range = 0; + 433. u64 rtit_ctl = 0; + 434. + +drivers/scsi/scsi_logging.c:476: error: DEAD_STORE + The value written to &off is never used. + 474. + 475. if (db_string) + 476. > off += scnprintf(logbuf + off, logbuf_len - off, + 477. "driverbyte=%s", db_string); + 478. else + +drivers/scsi/scsi_logging.c:479: error: DEAD_STORE + The value written to &off is never used. + 477. "driverbyte=%s", db_string); + 478. else + 479. > off += scnprintf(logbuf + off, logbuf_len - off, + 480. "driverbyte=0x%02x", driver_byte(cmd->result)); + 481. out_printk: + +drivers/gpu/drm/i915/intel_dsi_pll.c:435: error: DEAD_STORE + The value written to &dsi_rate is never used. + 433. struct drm_i915_private *dev_priv = to_i915(dev); + 434. u32 tmp; + 435. > u32 dsi_rate = 0; + 436. u32 pll_ratio = 0; + 437. u32 rx_div; + +drivers/gpu/drm/i915/intel_dsi_pll.c:436: error: DEAD_STORE + The value written to &pll_ratio is never used. + 434. u32 tmp; + 435. u32 dsi_rate = 0; + 436. > u32 pll_ratio = 0; + 437. u32 rx_div; + 438. u32 tx_div; + +net/netfilter/nf_log.c:435: error: DEAD_STORE + The value written to &r is never used. + 433. const struct nf_logger *logger; + 434. char buf[NFLOGGER_NAME_LEN]; + 435. > int r = 0; + 436. int tindex = (unsigned long)table->extra1; + 437. struct net *net = table->extra2; + +drivers/md/dm-stripe.c:437: error: DEAD_STORE + The value written to &ret is never used. + 435. { + 436. struct stripe_c *sc = ti->private; + 437. > int ret = 0; + 438. unsigned i = 0; + 439. + +kernel/irq/irqdesc.c:436: error: DEAD_STORE + The value written to &mask is never used. + 434. const struct cpumask *affinity, struct module *owner) + 435. { + 436. > const struct cpumask *mask = NULL; + 437. struct irq_desc *desc; + 438. unsigned int flags; + +net/wireless/trace.h:433: error: DEAD_STORE + The value written to &p is never used. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/ipv4/udp.c:443: error: DEAD_STORE + The value written to &hash is never used. + 441. struct sock *sk, *result; + 442. int score, badness; + 443. > u32 hash = 0; + 444. + 445. result = NULL; + +net/ipv4/inet_hashtables.c:446: error: DEAD_STORE + The value written to &acookie is never used. + 444. struct net *net = sock_net(sk); + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + +net/ipv4/inet_hashtables.c:447: error: DEAD_STORE + The value written to &ports is never used. + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + 449. saddr, inet->inet_dport); + +net/ipv4/inet_hashtables.c:445: error: DEAD_STORE + The value written to &sdif is never used. + 443. int dif = sk->sk_bound_dev_if; + 444. struct net *net = sock_net(sk); + 445. > int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + +drivers/cpuidle/sysfs.c:441: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 438 could be null and is dereferenced at line 441, column 18. + 439. int i; + 440. + 441. > for (i = 0; i < drv->state_count; i++) + 442. cpuidle_free_state_kobj(device, i); + 443. } + +net/ipv4/fib_semantics.c:441: error: DEAD_STORE + The value written to &state is never used. + 439. { + 440. struct neighbour *n; + 441. > int state = NUD_NONE; + 442. + 443. n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev); + +kernel/cgroup/freezer.c:442: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 440 could be null and is dereferenced at line 442, column 16. + 440. struct freezer *freezer = css_freezer(css); + 441. + 442. > return (bool)(freezer->state & CGROUP_FREEZING_SELF); + 443. } + 444. + +drivers/gpu/drm/drm_property.c:444: error: DEAD_STORE + The value written to &value_count is never used. + 442. struct drm_property *property; + 443. int enum_count = 0; + 444. > int value_count = 0; + 445. int i, copied; + 446. struct drm_property_enum *prop_enum; + +drivers/gpu/drm/i915/intel_hdmi.c:459: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 443 could be null and is dereferenced at line 459, column 2. + 457. len++; + 458. + 459. > intel_dig_port->write_infoframe(encoder, crtc_state, frame->any.type, buffer, len); + 460. } + 461. + +kernel/auditfilter.c:442: error: DEAD_STORE + The value written to &err is never used. + 440. size_t datasz) + 441. { + 442. > int err = 0; + 443. struct audit_entry *entry; + 444. void *bufp; + +net/netfilter/nf_conntrack_proto.c:443: error: DEAD_STORE + The value written to &pn is never used. + 441. { + 442. int ret = 0; + 443. > struct nf_proto_net *pn = NULL; + 444. + 445. if (l4proto->init_net) { + +drivers/gpu/drm/i915/intel_bios.c:445: error: DEAD_STORE + The value written to &count is never used. + 443. struct sdvo_device_mapping *mapping; + 444. const struct child_device_config *child; + 445. > int i, count = 0; + 446. + 447. /* + +drivers/hid/usbhid/hiddev.c:444: error: DEAD_STORE + The value written to &uref_multi is never used. + 442. struct hid_device *hid = hiddev->hid; + 443. struct hiddev_report_info rinfo; + 444. > struct hiddev_usage_ref_multi *uref_multi = NULL; + 445. struct hiddev_usage_ref *uref; + 446. struct hid_report *report; + +net/netfilter/nf_conntrack_helper.c:449: error: NULL_DEREFERENCE + pointer `help` last assigned on line 442 could be null and is dereferenced at line 449, column 9. + 447. return true; + 448. + 449. > this = rcu_dereference_protected(help->helper, + 450. lockdep_is_held(&nf_conntrack_expect_lock)); + 451. return this == me; + +kernel/relay.c:443: error: DEAD_STORE + The value written to &buf is never used. + 441. static struct rchan_buf *relay_open_buf(struct rchan *chan, unsigned int cpu) + 442. { + 443. > struct rchan_buf *buf = NULL; + 444. struct dentry *dentry; + 445. + +net/ipv6/seg6.c:443: error: DEAD_STORE + The value written to &err is never used. + 441. int __init seg6_init(void) + 442. { + 443. > int err = -ENOMEM; + 444. + 445. err = genl_register_family(&seg6_genl_family); + +net/xfrm/xfrm_policy.c:456: error: DEAD_STORE + The value written to &odst is never used. + 454. write_seqcount_begin(&xfrm_policy_hash_generation); + 455. + 456. > odst = rcu_dereference_protected(net->xfrm.policy_bydst[dir].table, + 457. lockdep_is_held(&net->xfrm.xfrm_policy_lock)); + 458. + +kernel/power/swap.c:445: error: DEAD_STORE + The value written to &error is never used. + 443. struct hib_bio_batch *hb) + 444. { + 445. > int error = 0; + 446. sector_t offset; + 447. + +sound/core/seq/seq_queue.c:444: error: DEAD_STORE + The value written to &result is never used. + 442. int snd_seq_queue_timer_open(int queueid) + 443. { + 444. > int result = 0; + 445. struct snd_seq_queue *queue; + 446. struct snd_seq_timer *tmr; + +crypto/api.c:447: error: DEAD_STORE + The value written to &tfm is never used. + 445. { + 446. char *mem; + 447. > struct crypto_tfm *tfm = NULL; + 448. unsigned int tfmsize; + 449. unsigned int total; + +net/sched/sch_generic.c:461: error: DEAD_STORE + The value written to &trans_start is never used. + 459. + 460. txq = netdev_get_tx_queue(dev, i); + 461. > trans_start = txq->trans_start; + 462. if (netif_xmit_stopped(txq) && + 463. time_after(jiffies, (trans_start + + +kernel/cgroup/freezer.c:450: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 448 could be null and is dereferenced at line 450, column 16. + 448. struct freezer *freezer = css_freezer(css); + 449. + 450. > return (bool)(freezer->state & CGROUP_FREEZING_PARENT); + 451. } + 452. + +drivers/gpu/drm/i915/intel_guc_ct.c:449: error: DEAD_STORE + The value written to &dev_priv is never used. + 447. void intel_guc_disable_ct(struct intel_guc *guc) + 448. { + 449. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 450. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 451. + +drivers/mailbox/pcc.c:454: error: DEAD_STORE + The value written to &status is never used. + 452. int count, i, rc; + 453. int sum = 0; + 454. > acpi_status status = AE_OK; + 455. + 456. /* Search for PCCT */ + +drivers/gpu/drm/i915/intel_sdvo.c:457: error: DEAD_STORE + The value written to &ret is never used. + 455. u8 *buf, status; + 456. struct i2c_msg *msgs; + 457. > int i, ret = true; + 458. + 459. /* Would be simpler to allocate both in one go ? */ + +net/sunrpc/auth.c:456: error: DEAD_STORE + The value written to &expired is never used. + 454. spinlock_t *cache_lock; + 455. struct rpc_cred *cred, *next; + 456. > unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; + 457. long freed = 0; + 458. + +net/sunrpc/auth.c:461: error: DEAD_STORE + The value written to &nr_to_scan is never used. + 459. list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { + 460. + 461. > if (nr_to_scan-- == 0) + 462. break; + 463. /* + +lib/kobject.c:456: error: DEAD_STORE + The value written to &devpath is never used. + 454. { + 455. int error = 0; + 456. > const char *devpath = NULL; + 457. const char *dup_name = NULL, *name; + 458. char *devpath_string = NULL; + +lib/kobject.c:455: error: DEAD_STORE + The value written to &error is never used. + 453. int kobject_rename(struct kobject *kobj, const char *new_name) + 454. { + 455. > int error = 0; + 456. const char *devpath = NULL; + 457. const char *dup_name = NULL, *name; + +net/sunrpc/clnt.c:456: error: DEAD_STORE + The value written to &clnt is never used. + 454. struct rpc_xprt *xprt) + 455. { + 456. > struct rpc_clnt *clnt = NULL; + 457. struct rpc_xprt_switch *xps; + 458. + +drivers/gpu/drm/drm_plane.c:466: error: DEAD_STORE + The value written to &config is never used. + 464. return -EINVAL; + 465. + 466. > config = &dev->mode_config; + 467. plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr); + 468. + +security/keys/request_key.c:491: error: DEAD_STORE + The value written to &ret is never used. + 489. } + 490. } else if (ret == -EINPROGRESS) { + 491. > ret = 0; + 492. } else { + 493. goto error_put_dest_keyring; + +lib/swiotlb.c:466: error: DEAD_STORE + The value written to &sz is never used. + 464. unsigned int offset = orig_addr & ~PAGE_MASK; + 465. char *buffer; + 466. > unsigned int sz = 0; + 467. unsigned long flags; + 468. + +drivers/i2c/i2c-core-acpi.c:463: error: DEAD_STORE + The value written to &ret is never used. + 461. struct i2c_msg msgs[1]; + 462. u8 *buffer; + 463. > int ret = AE_OK; + 464. + 465. buffer = kzalloc(data_len + 1, GFP_KERNEL); + +net/wireless/trace.h:457: error: DEAD_STORE + The value written to &p is never used. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/ipv4/tcp_fastopen.c:468: error: DEAD_STORE + The value written to &tfo_bh_timeout is never used. + 466. bool tcp_fastopen_active_should_disable(struct sock *sk) + 467. { + 468. > unsigned int tfo_bh_timeout = sock_net(sk)->ipv4.sysctl_tcp_fastopen_blackhole_timeout; + 469. int tfo_da_times = atomic_read(&sock_net(sk)->ipv4.tfo_active_disable_times); + 470. unsigned long timeout; + +drivers/base/regmap/regcache.c:470: error: DEAD_STORE + The value written to &ret is never used. + 468. unsigned int max) + 469. { + 470. > int ret = 0; + 471. + 472. if (!map->cache_ops || !map->cache_ops->drop) + +drivers/net/ethernet/intel/e1000e/phy.c:473: error: DEAD_STORE + The value written to &ret_val is never used. + 471. + 472. if (!locked) { + 473. > s32 ret_val = 0; + 474. + 475. if (!hw->phy.ops.acquire) + +drivers/usb/core/devices.c:480: error: DEAD_STORE + The value written to &childdev is never used. + 478. unsigned int length; + 479. ssize_t total_written = 0; + 480. > struct usb_device *childdev = NULL; + 481. + 482. /* don't bother with anything else if we're not writing any data */ + +net/ipv4/udp.c:479: error: DEAD_STORE + The value written to &hash is never used. + 477. bool exact_dif = udp_lib_exact_dif_match(net, skb); + 478. int score, badness; + 479. > u32 hash = 0; + 480. + 481. if (hslot->count > 10) { + +net/xfrm/xfrm_state.c:480: error: DEAD_STORE + The value written to &err is never used. + 478. long next = LONG_MAX; + 479. int warn = 0; + 480. > int err = 0; + 481. + 482. spin_lock(&x->lock); + +net/wireless/trace.h:474: error: DEAD_STORE + The value written to &p is never used. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +crypto/jitterentropy.c:483: error: DEAD_STORE + The value written to &data is never used. + 481. + 482. while (1) { + 483. > __u64 data = 0; + 484. + 485. if (ec->disable_unbias == 1) + +drivers/base/bus.c:478: error: DEAD_STORE + The value written to &error is never used. + 476. { + 477. struct bus_type *bus = bus_get(dev->bus); + 478. > int error = 0; + 479. + 480. if (bus) { + +drivers/pci/access.c:481: error: DEAD_STORE + The value written to &ret is never used. + 479. const u8 *buf = arg; + 480. loff_t end = pos + count; + 481. > int ret = 0; + 482. + 483. if (pos < 0 || (pos & 3) || (count & 3)) + +arch/x86/platform/efi/efi.c:482: error: DEAD_STORE + The value written to &i is never used. + 480. efi_char16_t *c16; + 481. char vendor[100] = "unknown"; + 482. > int i = 0; + 483. void *tmp; + 484. + +drivers/cpuidle/cpuidle.c:484: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 482 could be null and is dereferenced at line 484, column 22. + 482. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 483. + 484. > if (!try_module_get(drv->owner)) + 485. return -EINVAL; + 486. + +drivers/firmware/dmi_scan.c:502: error: DEAD_STORE + The value written to &c is never used. + 500. dmi_get_system_info(DMI_BIOS_VERSION)); + 501. c += scnprintf(buf + c, len - c, " "); + 502. > c += print_filtered(buf + c, len - c, + 503. dmi_get_system_info(DMI_BIOS_DATE)); + 504. } + +net/ipv6/exthdrs.c:496: error: DEAD_STORE + The value written to &accept_source_route is never used. + 494. idev = __in6_dev_get(skb->dev); + 495. if (idev && accept_source_route > idev->cnf.accept_source_route) + 496. > accept_source_route = idev->cnf.accept_source_route; + 497. + 498. if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) || + +net/ipv6/exthdrs.c:485: error: DEAD_STORE + The value written to &addr is never used. + 483. { + 484. struct inet6_skb_parm *opt = IP6CB(skb); + 485. > struct in6_addr *addr = NULL; + 486. struct in6_addr daddr; + 487. struct inet6_dev *idev; + +drivers/hid/hid-debug.c:486: error: DEAD_STORE + The value written to &buf is never used. + 484. char *hid_resolv_usage(unsigned usage, struct seq_file *f) { + 485. const struct hid_usage_entry *p; + 486. > char *buf = NULL; + 487. int len = 0; + 488. + +drivers/pcmcia/pcmcia_resource.c:493: error: DEAD_STORE + The value written to &option is never used. + 491. unsigned char status = 0; + 492. unsigned char ext_status = 0; + 493. > unsigned char option = 0; + 494. unsigned int flags = p_dev->config_flags; + 495. + +kernel/trace/blktrace.c:490: error: DEAD_STORE + The value written to &bt is never used. + 488. struct blk_user_trace_setup *buts) + 489. { + 490. > struct blk_trace *bt = NULL; + 491. struct dentry *dir = NULL; + 492. int ret; + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:525: error: DEAD_STORE + The value written to &ret_val is never used. + 523. * only the first byte of the word is being modified + 524. */ + 525. > ret_val = e1000_read_eeprom(hw, last_word, 1, + 526. &eeprom_buff[last_word - first_word]); + 527. } + +lib/rhashtable.c:521: error: DEAD_STORE + The value written to &head is never used. + 519. + 520. RCU_INIT_POINTER(list->next, plist); + 521. > head = rht_dereference_bucket(head->next, tbl, hash); + 522. RCU_INIT_POINTER(list->rhead.next, head); + 523. rcu_assign_pointer(*pprev, obj); + +lib/rhashtable.c:518: error: DEAD_STORE + The value written to &plist is never used. + 516. + 517. list = container_of(obj, struct rhlist_head, rhead); + 518. > plist = container_of(head, struct rhlist_head, rhead); + 519. + 520. RCU_INIT_POINTER(list->next, plist); + +drivers/gpu/drm/i915/intel_crt.c:494: error: DEAD_STORE + The value written to &tries is never used. + 492. u32 stat; + 493. bool ret = false; + 494. > int i, tries = 0; + 495. + 496. if (HAS_PCH_SPLIT(dev_priv)) + +drivers/pci/pcie/aer/aerdrv_core.c:491: error: DEAD_STORE + The value written to &result is never used. + 489. static void do_recovery(struct pci_dev *dev, int severity) + 490. { + 491. > pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED; + 492. enum pci_channel_state state; + 493. + +net/sunrpc/cache.c:492: error: DEAD_STORE + The value written to &ch is never used. + 490. void cache_purge(struct cache_detail *detail) + 491. { + 492. > struct cache_head *ch = NULL; + 493. struct hlist_head *head = NULL; + 494. struct hlist_node *tmp = NULL; + +net/sunrpc/cache.c:493: error: DEAD_STORE + The value written to &head is never used. + 491. { + 492. struct cache_head *ch = NULL; + 493. > struct hlist_head *head = NULL; + 494. struct hlist_node *tmp = NULL; + 495. int i = 0; + +net/sunrpc/cache.c:495: error: DEAD_STORE + The value written to &i is never used. + 493. struct hlist_head *head = NULL; + 494. struct hlist_node *tmp = NULL; + 495. > int i = 0; + 496. + 497. write_lock(&detail->hash_lock); + +net/sunrpc/cache.c:494: error: DEAD_STORE + The value written to &tmp is never used. + 492. struct cache_head *ch = NULL; + 493. struct hlist_head *head = NULL; + 494. > struct hlist_node *tmp = NULL; + 495. int i = 0; + 496. + +drivers/gpu/drm/drm_lease.c:504: error: DEAD_STORE + The value written to &fd is never used. + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + 504. > int fd = -1; + 505. uint32_t *object_ids; + 506. + +drivers/gpu/drm/drm_lease.c:500: error: DEAD_STORE + The value written to &lessee is never used. + 498. struct idr leases; + 499. struct drm_master *lessor = lessor_priv->master; + 500. > struct drm_master *lessee = NULL; + 501. struct file *lessee_file = NULL; + 502. struct file *lessor_file = lessor_priv->filp; + +drivers/gpu/drm/drm_lease.c:501: error: DEAD_STORE + The value written to &lessee_file is never used. + 499. struct drm_master *lessor = lessor_priv->master; + 500. struct drm_master *lessee = NULL; + 501. > struct file *lessee_file = NULL; + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + +drivers/gpu/drm/drm_lease.c:497: error: DEAD_STORE + The value written to &ret is never used. + 495. struct drm_mode_create_lease *cl = data; + 496. size_t object_count; + 497. > int ret = 0; + 498. struct idr leases; + 499. struct drm_master *lessor = lessor_priv->master; + +tools/lib/subcmd/parse-options.c:544: error: NULL_DEREFERENCE + pointer `*ctx->argv[0]` last assigned on line 543 could be null and is dereferenced at line 544, column 6. + 542. */ + 543. ctx->argv[0] = strdup(ctx->opt - 1); + 544. > *(char *)ctx->argv[0] = '-'; + 545. goto unknown; + 546. case -3: + +kernel/locking/rwsem-xadd.c:504: error: DEAD_STORE + The value written to &count is never used. + 502. + 503. /* undo write bias from down_write operation, stop active locking */ + 504. > count = atomic_long_sub_return(RWSEM_ACTIVE_WRITE_BIAS, &sem->count); + 505. + 506. /* do optimistic spinning and steal lock if possible */ + +net/ipv6/addrlabel.c:502: error: DEAD_STORE + The value written to &err is never used. + 500. struct in6_addr *addr; + 501. u32 lseq; + 502. > int err = 0; + 503. struct ip6addrlbl_entry *p; + 504. struct sk_buff *skb; + +security/selinux/hooks.c:499: error: DEAD_STORE + The value written to &rc is never used. + 497. struct dentry *root = sb->s_root; + 498. struct inode *root_inode = d_backing_inode(root); + 499. > int rc = 0; + 500. + 501. if (sbsec->behavior == SECURITY_FS_USE_XATTR) { + +block/blk-core.c:535: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 535, column 33. + 533. */ + 534. if (drain_all) { + 535. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 536. drain |= !list_empty(&q->queue_head); + 537. for (i = 0; i < 2; i++) { + +block/partition-generic.c:510: error: DEAD_STORE + The value written to &state is never used. + 508. if (state && !IS_ERR(state)) { + 509. free_partitions(state); + 510. > state = NULL; + 511. } + 512. + +net/ipv6/ndisc.c:518: error: DEAD_STORE + The value written to &override is never used. + 516. src_addr = solicited_addr; + 517. if (ifp->flags & IFA_F_OPTIMISTIC) + 518. > override = false; + 519. inc_opt |= ifp->idev->cnf.force_tllao; + 520. in6_ifa_put(ifp); + +net/socket.c:528: error: DEAD_STORE + The value written to &buffer is never used. + 526. return -ERANGE; + 527. memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len); + 528. > buffer += len; + 529. } + 530. + +drivers/gpu/drm/i915/intel_pipe_crc.c:517: error: DEAD_STORE + The value written to &ret is never used. + 515. struct drm_atomic_state *state; + 516. struct drm_modeset_acquire_ctx ctx; + 517. > int ret = 0; + 518. + 519. drm_modeset_acquire_init(&ctx, 0); + +block/blk-mq-sched.c:513: error: DEAD_STORE + The value written to &set is never used. + 511. static void blk_mq_sched_tags_teardown(struct request_queue *q) + 512. { + 513. > struct blk_mq_tag_set *set = q->tag_set; + 514. struct blk_mq_hw_ctx *hctx; + 515. int i; + +drivers/gpu/drm/drm_prime.c:518: error: DEAD_STORE + The value written to &ret is never used. + 516. { + 517. struct drm_gem_object *obj; + 518. > int ret = 0; + 519. struct dma_buf *dmabuf; + 520. + +lib/bitmap.c:525: error: DEAD_STORE + The value written to &group_size is never used. + 523. totaldigits = c = 0; + 524. old_a = old_b = 0; + 525. > group_size = used_size = 0; + 526. bitmap_zero(maskp, nmaskbits); + 527. do { + +drivers/gpu/drm/drm_crtc_helper.c:524: error: DEAD_STORE + The value written to &count is never used. + 522. struct drm_connector *connector; + 523. struct drm_connector_list_iter conn_iter; + 524. > int count = 0, ro, fail = 0; + 525. const struct drm_crtc_helper_funcs *crtc_funcs; + 526. struct drm_mode_set save_set; + +drivers/gpu/drm/drm_crtc_helper.c:632: error: DEAD_STORE + The value written to &count is never used. + 630. + 631. /* a) traverse passed in connector list and get encoders for them */ + 632. > count = 0; + 633. drm_connector_list_iter_begin(dev, &conn_iter); + 634. drm_for_each_connector_iter(connector, &conn_iter) { + +drivers/gpu/drm/drm_crtc_helper.c:674: error: DEAD_STORE + The value written to &count is never used. + 672. } + 673. + 674. > count = 0; + 675. drm_connector_list_iter_begin(dev, &conn_iter); + 676. drm_for_each_connector_iter(connector, &conn_iter) { + +net/ipv6/ip6_flowlabel.c:520: error: DEAD_STORE + The value written to &sfl1 is never used. + 518. struct ipv6_pinfo *np = inet6_sk(sk); + 519. struct in6_flowlabel_req freq; + 520. > struct ipv6_fl_socklist *sfl1 = NULL; + 521. struct ipv6_fl_socklist *sfl; + 522. struct ipv6_fl_socklist __rcu **sflp; + +lib/kobject.c:519: error: DEAD_STORE + The value written to &devpath is never used. + 517. int error; + 518. struct kobject *old_parent; + 519. > const char *devpath = NULL; + 520. char *devpath_string = NULL; + 521. char *envp[2]; + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &p is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &ret is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +drivers/gpu/drm/i915/intel_cdclk.c:548: error: DEAD_STORE + The value written to &timeout__ is never used. + 546. val |= (cmd << DSPFREQGUAR_SHIFT); + 547. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 548. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 549. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 550. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:569: error: DEAD_STORE + The value written to &timeout__ is never used. + 567. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 568. + 569. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 570. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 571. 50)) + +drivers/gpu/drm/i915/intel_cdclk.c:548: error: DEAD_STORE + The value written to &wait__ is never used. + 546. val |= (cmd << DSPFREQGUAR_SHIFT); + 547. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 548. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 549. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 550. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:569: error: DEAD_STORE + The value written to &wait__ is never used. + 567. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 568. + 569. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 570. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 571. 50)) + +drivers/i2c/i2c-core-smbus.c:539: error: DEAD_STORE + The value written to &orig_jiffies is never used. + 537. + 538. /* Retry automatically on arbitration loss */ + 539. > orig_jiffies = jiffies; + 540. for (res = 0, try = 0; try <= adapter->retries; try++) { + 541. res = adapter->algo->smbus_xfer(adapter, addr, flags, + +block/blk-flush.c:526: error: DEAD_STORE + The value written to &ret is never used. + 524. struct request_queue *q; + 525. struct bio *bio; + 526. > int ret = 0; + 527. + 528. if (bdev->bd_disk == NULL) + +include/net/sock.h:526: error: DEAD_STORE + The value written to &off is never used. + 524. + 525. if (unlikely(off >= 0)) { + 526. > off = max_t(s32, off - val, 0); + 527. WRITE_ONCE(sk->sk_peek_off, off); + 528. } + +drivers/ata/libata-transport.c:527: error: DEAD_STORE + The value written to &i is never used. + 525. { + 526. struct ata_device *ata_dev = transport_class_to_dev(dev); + 527. > int written = 0, i = 0; + 528. + 529. if (ata_dev->class == ATA_DEV_PMP) + +kernel/profile.c:532: error: DEAD_STORE + The value written to &err is never used. + 530. #endif + 531. + 532. > int err = 0; + 533. + 534. if (!prof_on) + +kernel/rcu/srcutree.c:558: error: DEAD_STORE + The value written to &idxnext is never used. + 556. /* Initiate callback invocation as needed. */ + 557. idx = rcu_seq_ctr(gpseq) % ARRAY_SIZE(snp->srcu_have_cbs); + 558. > idxnext = (idx + 1) % ARRAY_SIZE(snp->srcu_have_cbs); + 559. rcu_for_each_node_breadth_first(sp, snp) { + 560. spin_lock_irq_rcu_node(snp); + +tools/objtool/elf.c:533: error: DEAD_STORE + The value written to &idx is never used. + 531. { + 532. struct rela *rela; + 533. > int nr, idx = 0, size; + 534. GElf_Rela *relas; + 535. + +drivers/gpu/drm/i915/intel_hdmi.c:541: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 537 could be null and is dereferenced at line 541, column 13. + 539. i915_reg_t reg = VIDEO_DIP_CTL; + 540. u32 val = I915_READ(reg); + 541. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 542. + 543. assert_hdmi_port_disabled(intel_hdmi); + +kernel/sched/deadline.c:534: error: DEAD_STORE + The value written to &later_rq is never used. + 532. static struct rq *dl_task_offline_migration(struct rq *rq, struct task_struct *p) + 533. { + 534. > struct rq *later_rq = NULL; + 535. + 536. later_rq = find_lock_later_rq(p, rq); + +drivers/usb/host/ehci-sched.c:552: error: DEAD_STORE + The value written to &type is never used. + 550. __hc32 *hw_p = &ehci->periodic[i]; + 551. union ehci_shadow here = *prev; + 552. > __hc32 type = 0; + 553. + 554. /* skip the iso nodes at list head */ + +security/keys/process_keys.c:710: error: DEAD_STORE + The value written to &ret is never used. + 708. * the permission checks as it is only concerned with the keyring */ + 709. if (lflags & KEY_LOOKUP_FOR_UNLINK) { + 710. > ret = 0; + 711. goto error; + 712. } + +lib/rhashtable.c:567: error: DEAD_STORE + The value written to &head is never used. + 565. return ERR_PTR(-ENOMEM); + 566. + 567. > head = rht_dereference_bucket(*pprev, tbl, hash); + 568. + 569. RCU_INIT_POINTER(obj->next, head); + +net/sched/act_api.c:537: error: DEAD_STORE + The value written to &err is never used. + 535. tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) + 536. { + 537. > int err = -EINVAL; + 538. unsigned char *b = skb_tail_pointer(skb); + 539. struct nlattr *nest; + +drivers/gpu/drm/i915/intel_fbdev.c:633: error: DEAD_STORE + The value written to &intel_crtc is never used. + 631. /* Final pass to check if any active pipes don't have fbs */ + 632. for_each_crtc(dev, crtc) { + 633. > intel_crtc = to_intel_crtc(crtc); + 634. + 635. if (!crtc->state->active) + +drivers/input/evdev.c:543: error: DEAD_STORE + The value written to &retval is never used. + 541. struct evdev *evdev = client->evdev; + 542. struct input_event event; + 543. > int retval = 0; + 544. + 545. if (count != 0 && count < input_event_size()) + +net/core/dev_addr_lists.c:539: error: DEAD_STORE + The value written to &err is never used. + 537. int dev_uc_sync(struct net_device *to, struct net_device *from) + 538. { + 539. > int err = 0; + 540. + 541. if (to->addr_len != from->addr_len) + +drivers/net/ethernet/intel/e1000e/phy.c:546: error: DEAD_STORE + The value written to &ret_val is never used. + 544. + 545. if (!locked) { + 546. > s32 ret_val = 0; + 547. + 548. if (!hw->phy.ops.acquire) + +drivers/ata/libata-transport.c:546: error: DEAD_STORE + The value written to &i is never used. + 544. { + 545. struct ata_device *ata_dev = transport_class_to_dev(dev); + 546. > int written = 0, i = 0; + 547. + 548. if (ata_dev->class != ATA_DEV_PMP) + +drivers/iommu/dmar.c:544: error: DEAD_STORE + The value written to &status is never used. + 542. static int __init dmar_table_detect(void) + 543. { + 544. > acpi_status status = AE_OK; + 545. + 546. /* if we could find DMAR table, then there are DMAR devices */ + +drivers/gpu/drm/i915/intel_guc_submission.c:568: error: DEAD_STORE + The value written to &cs is never used. + 566. } + 567. *cs++ = MI_USER_INTERRUPT; + 568. > *cs++ = MI_NOOP; + 569. + 570. GEM_BUG_ON(!IS_ALIGNED(ring->size, + +net/sunrpc/sched.c:550: error: DEAD_STORE + The value written to &task is never used. + 548. bool (*func)(struct rpc_task *, void *), void *data) + 549. { + 550. > struct rpc_task *task = NULL; + 551. + 552. dprintk("RPC: wake_up_first(%p \"%s\")\n", + +net/netfilter/nf_conntrack_ftp.c:557: error: NULL_DEREFERENCE + pointer `ftp` last assigned on line 551 could be null and is dereferenced at line 557, column 2. + 555. * failover breaks. + 556. */ + 557. > ftp->flags[IP_CT_DIR_ORIGINAL] |= NF_CT_FTP_SEQ_PICKUP; + 558. ftp->flags[IP_CT_DIR_REPLY] |= NF_CT_FTP_SEQ_PICKUP; + 559. return 0; + +net/packet/af_packet.c:555: error: DEAD_STORE + The value written to &mbits is never used. + 553. { + 554. struct net_device *dev; + 555. > unsigned int mbits = 0, msec = 0, div = 0, tmo = 0; + 556. struct ethtool_link_ksettings ecmd; + 557. int err; + +net/packet/af_packet.c:555: error: DEAD_STORE + The value written to &tmo is never used. + 553. { + 554. struct net_device *dev; + 555. > unsigned int mbits = 0, msec = 0, div = 0, tmo = 0; + 556. struct ethtool_link_ksettings ecmd; + 557. int err; + +security/selinux/ss/services.c:563: error: DEAD_STORE + The value written to &masked is never used. + 561. struct type_datum *source; + 562. struct type_datum *target; + 563. > u32 masked = 0; + 564. + 565. source = flex_array_get_ptr(policydb.type_val_to_struct_array, + +drivers/gpu/drm/drm_bufs.c:568: error: DEAD_STORE + The value written to &r_list is never used. + 566. if (r_list->master == master) { + 567. drm_legacy_rmmap_locked(dev, r_list->map); + 568. > r_list = NULL; + 569. } + 570. } + +drivers/input/mouse/alps.c:586: error: DEAD_STORE + The value written to &z is never used. + 584. x = (s8)(((packet[0] & 0x20) << 2) | (packet[1] & 0x7f)); + 585. y = (s8)(((packet[0] & 0x10) << 3) | (packet[2] & 0x7f)); + 586. > z = (packet[4] & 0x7c) >> 2; + 587. + 588. /* + +drivers/gpu/drm/i915/i915_pmu.c:595: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 591 could be null and is dereferenced at line 595, column 3. + 593. engine_event_instance(event)); + 594. GEM_BUG_ON(!engine); + 595. > engine->pmu.enable |= BIT(sample); + 596. + 597. GEM_BUG_ON(sample >= I915_PMU_SAMPLE_BITS); + +kernel/exit.c:565: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 564 could be null and is dereferenced at line 565, column 31. + 563. { + 564. struct pid_namespace *pid_ns = task_active_pid_ns(father); + 565. > struct task_struct *reaper = pid_ns->child_reaper; + 566. + 567. if (likely(reaper != father)) + +net/wireless/trace.h:561: error: DEAD_STORE + The value written to &p is never used. + 559. ); + 560. + 561. > DECLARE_EVENT_CLASS(wiphy_netdev_evt, + 562. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 563. TP_ARGS(wiphy, netdev), + +drivers/mailbox/pcc.c:564: error: DEAD_STORE + The value written to &ret is never used. + 562. static int pcc_mbox_probe(struct platform_device *pdev) + 563. { + 564. > int ret = 0; + 565. + 566. pcc_mbox_ctrl.chans = pcc_mbox_channels; + +net/core/sock.c:566: error: DEAD_STORE + The value written to &ret is never used. + 564. int optlen) + 565. { + 566. > int ret = -ENOPROTOOPT; + 567. #ifdef CONFIG_NETDEVICES + 568. struct net *net = sock_net(sk); + +drivers/gpu/drm/i915/i915_gem_stolen.c:625: error: DEAD_STORE + The value written to &ret is never used. + 623. vma = i915_vma_instance(obj, &ggtt->base, NULL); + 624. if (IS_ERR(vma)) { + 625. > ret = PTR_ERR(vma); + 626. goto err_pages; + 627. } + +net/sched/act_api.c:570: error: DEAD_STORE + The value written to &err is never used. + 568. { + 569. struct tc_action *a; + 570. > int err = -EINVAL; + 571. struct nlattr *nest; + 572. + +net/core/dev_addr_lists.c:569: error: DEAD_STORE + The value written to &err is never used. + 567. int dev_uc_sync_multiple(struct net_device *to, struct net_device *from) + 568. { + 569. > int err = 0; + 570. + 571. if (to->addr_len != from->addr_len) + +net/netfilter/nf_conntrack_proto.c:577: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 570 could be null and is dereferenced by call to `nf_ct_l4proto_register_sysctl()` at line 577, column 8. + 575. if (err < 0) + 576. return err; + 577. > err = nf_ct_l4proto_register_sysctl(net, + 578. pn, + 579. &nf_conntrack_l4proto_generic); + +drivers/gpu/drm/drm_plane.c:578: error: DEAD_STORE + The value written to &ret is never used. + 576. struct drm_modeset_acquire_ctx *ctx) + 577. { + 578. > int ret = 0; + 579. + 580. /* No fb means shut it down */ + +arch/x86/events/intel/rapl.c:578: error: NULL_DEREFERENCE + pointer `pmu` last assigned on line 571 could be null and is dereferenced at line 578, column 2. + 576. return 0; + 577. + 578. > pmu->cpu = -1; + 579. /* Find a new cpu to collect rapl events */ + 580. target = cpumask_any_but(topology_core_cpumask(cpu), cpu); + +security/selinux/hooks.c:578: error: DEAD_STORE + The value written to &rc is never used. + 576. struct security_mnt_opts *opts) + 577. { + 578. > int rc = 0, i; + 579. struct superblock_security_struct *sbsec = sb->s_security; + 580. char *context = NULL; + +drivers/base/dd.c:578: error: DEAD_STORE + The value written to &ret is never used. + 576. int driver_probe_device(struct device_driver *drv, struct device *dev) + 577. { + 578. > int ret = 0; + 579. + 580. if (!device_is_registered(dev)) + +net/netfilter/nf_conntrack_ftp.c:578: error: DEAD_STORE + The value written to &ret is never used. + 576. static int __init nf_conntrack_ftp_init(void) + 577. { + 578. > int i, ret = 0; + 579. + 580. NF_CT_HELPER_BUILD_BUG_ON(sizeof(struct nf_ct_ftp_master)); + +drivers/char/hpet.c:594: error: DEAD_STORE + The value written to &hpet is never used. + 592. case HPET_IRQFREQ: + 593. timer = devp->hd_timer; + 594. > hpet = devp->hd_hpet; + 595. hpetp = devp->hd_hpets; + 596. break; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:620: error: DEAD_STORE + The value written to &p is never used. + 618. + 619. /* ctx->ctx_flags */ + 620. > p = xdr_encode_hyper(p, ctx->ctx_flags); + 621. + 622. /* ctx->locally_initiated */ + +arch/x86/events/amd/ibs.c:645: error: DEAD_STORE + The value written to &buf is never used. + 643. } + 644. if (ibs_caps & IBS_CAPS_OPDATA4) { + 645. > rdmsrl(MSR_AMD64_IBSOPDATA4, *buf++); + 646. size++; + 647. } + +drivers/char/hw_random/core.c:580: error: DEAD_STORE + The value written to &ret is never used. + 578. static int __init hwrng_modinit(void) + 579. { + 580. > int ret = -ENOMEM; + 581. + 582. /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ + +drivers/gpu/drm/i915/intel_fbc.c:582: error: DEAD_STORE + The value written to &compressed_llb is never used. + 580. struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 581. struct intel_fbc *fbc = &dev_priv->fbc; + 582. > struct drm_mm_node *uninitialized_var(compressed_llb); + 583. int size, fb_cpp, ret; + 584. + +kernel/time/posix-timers.c:589: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 589, column 9. + 587. return do_timer_create(which_clock, &event, created_timer_id); + 588. } + 589. > return do_timer_create(which_clock, NULL, created_timer_id); + 590. } + 591. + +drivers/md/md-bitmap.c:588: error: DEAD_STORE + The value written to &err is never used. + 586. int nodes = 0; + 587. unsigned long sectors_reserved = 0; + 588. > int err = -EINVAL; + 589. struct page *sb_page; + 590. loff_t offset = bitmap->mddev->bitmap_info.offset; + +sound/core/pcm_native.c:609: error: DEAD_STORE + The value written to &old_interval is never used. + 607. if (trace_hw_interval_param_enabled()) { + 608. if (hw_is_interval(*v)) + 609. > old_interval = *hw_param_interval(params, *v); + 610. } + 611. if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) + +sound/core/pcm_native.c:605: error: DEAD_STORE + The value written to &old_mask is never used. + 603. if (trace_hw_mask_param_enabled()) { + 604. if (hw_is_mask(*v)) + 605. > old_mask = *hw_param_mask(params, *v); + 606. } + 607. if (trace_hw_interval_param_enabled()) { + +block/bsg.c:596: error: DEAD_STORE + The value written to &rq is never used. + 594. + 595. nr_commands = count / sizeof(struct sg_io_v4); + 596. > rq = NULL; + 597. bc = NULL; + 598. ret = 0; + +block/bsg.c:620: error: DEAD_STORE + The value written to &rq is never used. + 618. if (IS_ERR(rq)) { + 619. ret = PTR_ERR(rq); + 620. > rq = NULL; + 621. break; + 622. } + +block/bsg.c:626: error: DEAD_STORE + The value written to &rq is never used. + 624. bsg_add_command(bd, q, bc, rq); + 625. bc = NULL; + 626. > rq = NULL; + 627. nr_commands--; + 628. buf += sizeof(struct sg_io_v4); + +sound/core/seq/seq_clientmgr.c:589: error: DEAD_STORE + The value written to &dest is never used. + 587. int filter, int atomic, int hop) + 588. { + 589. > struct snd_seq_client *dest = NULL; + 590. struct snd_seq_client_port *dest_port = NULL; + 591. int result = -ENOENT; + +net/netfilter/nf_conntrack_proto.c:592: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 589 could be null and is dereferenced at line 592, column 2. + 590. &nf_conntrack_l4proto_generic); + 591. + 592. > pn->users--; + 593. nf_ct_l4proto_unregister_sysctl(net, + 594. pn, + +include/linux/pagemap.h:609: error: DEAD_STORE + The value written to &c is never used. + 607. if (((unsigned long)uaddr & PAGE_MASK) == + 608. ((unsigned long)end & PAGE_MASK)) { + 609. > return __get_user(c, end); + 610. } + 611. + +net/ipv6/ip6_fib.c:598: error: DEAD_STORE + The value written to &pn is never used. + 596. { + 597. struct fib6_node *fn, *in, *ln; + 598. > struct fib6_node *pn = NULL; + 599. struct rt6key *key; + 600. int bit; + +drivers/net/phy/phy_device.c:594: error: DEAD_STORE + The value written to &mode is never used. + 592. { + 593. struct phy_device *phydev = to_phy_device(dev); + 594. > const char *mode = NULL; + 595. + 596. if (phy_is_internal(phydev)) + +drivers/usb/host/ohci-q.c:682: error: DEAD_STORE + The value written to &cnt is never used. + 680. && cnt < urb_priv->length) { + 681. td_fill (ohci, info, 0, 0, urb, cnt); + 682. > cnt++; + 683. } + 684. /* maybe kickstart bulk list */ + +drivers/usb/host/ohci-q.c:706: error: DEAD_STORE + The value written to &cnt is never used. + 704. ? TD_CC | TD_DP_IN | TD_T_DATA1 + 705. : TD_CC | TD_DP_OUT | TD_T_DATA1; + 706. > td_fill (ohci, info, data, 0, urb, cnt++); + 707. /* maybe kickstart control list */ + 708. wmb (); + +drivers/usb/host/ohci-q.c:600: error: DEAD_STORE + The value written to &info is never used. + 598. int data_len = urb->transfer_buffer_length; + 599. int cnt = 0; + 600. > u32 info = 0; + 601. int is_out = usb_pipeout (urb->pipe); + 602. int periodic = 0; + +drivers/dma/dmaengine.c:595: error: DEAD_STORE + The value written to &err is never used. + 593. struct dma_chan *dma_get_slave_channel(struct dma_chan *chan) + 594. { + 595. > int err = -EBUSY; + 596. + 597. /* lock against __dma_request_channel */ + +kernel/time/posix-timers.c:604: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 604, column 9. + 602. return do_timer_create(which_clock, &event, created_timer_id); + 603. } + 604. > return do_timer_create(which_clock, NULL, created_timer_id); + 605. } + 606. #endif + +kernel/sched/cputime.c:624: error: DEAD_STORE + The value written to &utime is never used. + 622. */ + 623. if (stime == 0) { + 624. > utime = rtime; + 625. goto update; + 626. } + +net/ipv4/ip_sockglue.c:811: error: DEAD_STORE + The value written to &dev is never used. + 809. case IP_UNICAST_IF: + 810. { + 811. > struct net_device *dev = NULL; + 812. int ifindex; + 813. int midx; + +net/ipv4/ip_sockglue.c:845: error: DEAD_STORE + The value written to &dev is never used. + 843. { + 844. struct ip_mreqn mreq; + 845. > struct net_device *dev = NULL; + 846. int midx; + 847. + +net/ipv4/ip_sockglue.c:1087: error: DEAD_STORE + The value written to &gsf is never used. + 1085. struct sockaddr_in *psin; + 1086. struct ip_msfilter *msf = NULL; + 1087. > struct group_filter *gsf = NULL; + 1088. int msize, i, ifindex; + 1089. + +kernel/smp.c:599: error: DEAD_STORE + The value written to &ret is never used. + 597. { + 598. unsigned long flags; + 599. > int ret = 0; + 600. + 601. preempt_disable(); + +lib/iov_iter.c:608: error: DEAD_STORE + The value written to &skip is never used. + 606. if (iter_is_iovec(i)) + 607. might_fault(); + 608. > iterate_all_kinds(i, bytes, v, ({ + 609. if (copyin((to += v.iov_len) - v.iov_len, + 610. v.iov_base, v.iov_len)) + +block/partitions/efi.c:600: error: DEAD_STORE + The value written to &good_pgpt is never used. + 598. gpt_entry **ptes) + 599. { + 600. > int good_pgpt = 0, good_agpt = 0, good_pmbr = 0; + 601. gpt_header *pgpt = NULL, *agpt = NULL; + 602. gpt_entry *pptes = NULL, *aptes = NULL; + +block/partitions/efi.c:600: error: DEAD_STORE + The value written to &good_pmbr is never used. + 598. gpt_entry **ptes) + 599. { + 600. > int good_pgpt = 0, good_agpt = 0, good_pmbr = 0; + 601. gpt_header *pgpt = NULL, *agpt = NULL; + 602. gpt_entry *pptes = NULL, *aptes = NULL; + +drivers/ata/libata-scsi.c:601: error: DEAD_STORE + The value written to &sensebuf is never used. + 599. int rc = 0; + 600. u8 scsi_cmd[MAX_COMMAND_SIZE]; + 601. > u8 args[4], *argbuf = NULL, *sensebuf = NULL; + 602. int argsize = 0; + 603. enum dma_data_direction data_dir; + +drivers/gpu/drm/i915/intel_cdclk.c:628: error: DEAD_STORE + The value written to &timeout__ is never used. + 626. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 627. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 628. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 629. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 630. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:628: error: DEAD_STORE + The value written to &wait__ is never used. + 626. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 627. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 628. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 629. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 630. 50)) { + +net/ipv4/tcp_ipv4.c:610: error: DEAD_STORE + The value written to &hash_location is never used. + 608. #ifdef CONFIG_TCP_MD5SIG + 609. struct tcp_md5sig_key *key = NULL; + 610. > const __u8 *hash_location = NULL; + 611. unsigned char newhash[16]; + 612. int genhash; + +net/ipv4/tcp_ipv4.c:613: error: DEAD_STORE + The value written to &sk1 is never used. + 611. unsigned char newhash[16]; + 612. int genhash; + 613. > struct sock *sk1 = NULL; + 614. #endif + 615. struct net *net; + +drivers/gpu/drm/drm_dp_mst_topology.c:620: error: DEAD_STORE + The value written to &idx is never used. + 618. msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1; + 619. msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7); + 620. > idx++; + 621. return true; + 622. fail_len: + +net/ipv4/devinet.c:609: error: DEAD_STORE + The value written to &err is never used. + 607. struct ifaddrmsg *ifm; + 608. struct in_ifaddr *ifa, **ifap; + 609. > int err = -EINVAL; + 610. + 611. ASSERT_RTNL(); + +net/ipv4/udp.c:622: error: DEAD_STORE + The value written to &err is never used. + 620. } + 621. + 622. > err = 0; + 623. harderr = 0; + 624. inet = inet_sk(sk); + +net/ipv6/esp6.c:613: error: DEAD_STORE + The value written to &ret is never used. + 611. int assoclen; + 612. int seqhilen; + 613. > int ret = 0; + 614. void *tmp; + 615. __be32 *seqhi; + +net/ipv6/ip6_output.c:614: error: DEAD_STORE + The value written to &err is never used. + 612. int hroom, troom; + 613. __be32 frag_id; + 614. > int ptr, offset = 0, err = 0; + 615. u8 *prevhdr, nexthdr = 0; + 616. + +net/ipv6/ip6_output.c:615: error: DEAD_STORE + The value written to &nexthdr is never used. + 613. __be32 frag_id; + 614. int ptr, offset = 0, err = 0; + 615. > u8 *prevhdr, nexthdr = 0; + 616. + 617. err = ip6_find_1stfragopt(skb, &prevhdr); + +crypto/drbg.c:608: error: DEAD_STORE + The value written to &i is never used. + 606. { + 607. int ret = -EFAULT; + 608. > int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + 610. LIST_HEAD(seedlist); + +crypto/drbg.c:607: error: DEAD_STORE + The value written to &ret is never used. + 605. int reseed) + 606. { + 607. > int ret = -EFAULT; + 608. int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + +drivers/thermal/thermal_core.c:608: error: DEAD_STORE + The value written to &cdev is never used. + 606. const char *cdev_type, size_t size) + 607. { + 608. > struct thermal_cooling_device *cdev = NULL; + 609. + 610. mutex_lock(&thermal_list_lock); + +net/netlabel/netlabel_mgmt.c:610: error: DEAD_STORE + The value written to &ans_skb is never used. + 608. { + 609. int ret_val = -ENOMEM; + 610. > struct sk_buff *ans_skb = NULL; + 611. void *data; + 612. struct netlbl_dom_map *entry; + +drivers/pcmcia/ds.c:614: error: DEAD_STORE + The value written to &ret is never used. + 612. cistpl_longlink_mfc_t mfc; + 613. unsigned int no_funcs, i, no_chains; + 614. > int ret = -EAGAIN; + 615. + 616. mutex_lock(&s->ops_mutex); + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &p is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &ret is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +tools/lib/subcmd/parse-options.c:659: error: QUANDARY_TAINT_ERROR + EnvironmentVariable(getenv at line 66, column 22) -> ShellExec(execvp at line 180, column 2). + 657. else + 658. astrcatf(&error_buf, "unknown switch `%c'", *ctx.opt); + 659. > usage_with_options(usagestr, options); + 660. } + 661. + +drivers/gpu/drm/i915/i915_pmu.c:635: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 625 could be null and is dereferenced at line 635, column 7. + 633. * bitmask when the last listener on an event goes away. + 634. */ + 635. > if (--engine->pmu.enable_count[sample] == 0) + 636. engine->pmu.enable &= ~BIT(sample); + 637. } + +net/netfilter/nf_conntrack_core.c:624: error: DEAD_STORE + The value written to &zone is never used. + 622. unsigned int sequence; + 623. + 624. > zone = nf_ct_zone(ct); + 625. + 626. local_bh_disable(); + +drivers/tty/pty.c:617: error: DEAD_STORE + The value written to &fd is never used. + 615. int ptm_open_peer(struct file *master, struct tty_struct *tty, int flags) + 616. { + 617. > int fd = -1; + 618. struct file *filp; + 619. int retval = -EINVAL; + +drivers/tty/pty.c:619: error: DEAD_STORE + The value written to &retval is never used. + 617. int fd = -1; + 618. struct file *filp; + 619. > int retval = -EINVAL; + 620. struct path path; + 621. + +net/sunrpc/svc_xprt.c:649: error: DEAD_STORE + The value written to &i is never used. + 647. } + 648. rqstp->rq_page_end = &rqstp->rq_pages[i]; + 649. > rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */ + 650. + 651. /* Make arg->head point to first page and arg->pages point to rest */ + +net/core/sock.c:624: error: DEAD_STORE + The value written to &ret is never used. + 622. int __user *optlen, int len) + 623. { + 624. > int ret = -ENOPROTOOPT; + 625. #ifdef CONFIG_NETDEVICES + 626. struct net *net = sock_net(sk); + +net/netlabel/netlabel_kapi.c:624: error: DEAD_STORE + The value written to &iter is never used. + 622. int netlbl_catmap_walk(struct netlbl_lsm_catmap *catmap, u32 offset) + 623. { + 624. > struct netlbl_lsm_catmap *iter = catmap; + 625. u32 idx; + 626. u32 bit; + +net/wireless/util.c:630: error: DEAD_STORE + The value written to &frame is never used. + 628. { + 629. unsigned int hlen = ALIGN(extra_headroom, 4); + 630. > struct sk_buff *frame = NULL; + 631. u16 ethertype; + 632. u8 *payload; + +drivers/thermal/thermal_core.c:628: error: DEAD_STORE + The value written to &cdev is never used. + 626. const char *cdev_type, size_t size) + 627. { + 628. > struct thermal_cooling_device *cdev = NULL; + 629. + 630. mutex_lock(&thermal_list_lock); + +drivers/gpu/drm/drm_dp_mst_topology.c:643: error: DEAD_STORE + The value written to &idx is never used. + 641. + 642. msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]); + 643. > idx++; + 644. return true; + 645. fail_len: + +kernel/trace/trace_kprobe.c:659: error: DEAD_STORE + The value written to &event is never used. + 657. int i, ret = 0; + 658. bool is_return = false, is_delete = false; + 659. > char *symbol = NULL, *event = NULL, *group = NULL; + 660. int maxactive = 0; + 661. char *arg; + +kernel/trace/trace_kprobe.c:657: error: DEAD_STORE + The value written to &ret is never used. + 655. */ + 656. struct trace_kprobe *tk; + 657. > int i, ret = 0; + 658. bool is_return = false, is_delete = false; + 659. char *symbol = NULL, *event = NULL, *group = NULL; + +kernel/trace/trace_kprobe.c:783: error: DEAD_STORE + The value written to &ret is never used. + 781. + 782. /* parse arguments */ + 783. > ret = 0; + 784. for (i = 0; i < argc && i < MAX_TRACE_ARGS; i++) { + 785. struct probe_arg *parg = &tk->tp.args[i]; + +sound/core/info.c:635: error: DEAD_STORE + The value written to &c is never used. + 633. int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) + 634. { + 635. > int c = -1; + 636. + 637. if (snd_BUG_ON(!buffer || !buffer->buffer)) + +drivers/base/bus.c:638: error: DEAD_STORE + The value written to &error is never used. + 636. struct bus_type *bus; + 637. struct driver_private *priv; + 638. > int error = 0; + 639. + 640. bus = bus_get(drv->bus); + +net/ipv4/ipconfig.c:709: error: DEAD_STORE + The value written to &e is never used. + 707. } + 708. + 709. > *e++ = 255; /* End of the list */ + 710. } + 711. + +security/selinux/ss/avtab.c:638: error: DEAD_STORE + The value written to &rc is never used. + 636. { + 637. unsigned int i; + 638. > int rc = 0; + 639. struct avtab_node *cur; + 640. __le32 buf[1]; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:683: error: DEAD_STORE + The value written to &p is never used. + 681. + 682. /* ctx->ctx_flags */ + 683. > p = xdr_decode_hyper(p, &ctx->ctx_flags); + 684. + 685. /* ctx->locally_initiated */ + +drivers/cpufreq/acpi-cpufreq.c:647: error: DEAD_STORE + The value written to &result is never used. + 645. unsigned int cpu = policy->cpu; + 646. struct acpi_cpufreq_data *data; + 647. > unsigned int result = 0; + 648. struct cpuinfo_x86 *c = &cpu_data(policy->cpu); + 649. struct acpi_processor_performance *perf; + +drivers/char/agp/frontend.c:660: error: DEAD_STORE + The value written to &controller is never used. + 658. agp_controller_release_current(controller, priv); + 659. agp_remove_controller(controller); + 660. > controller = NULL; + 661. } + 662. } + +drivers/platform/x86/eeepc-laptop.c:645: error: DEAD_STORE + The value written to &status is never used. + 643. static void eeepc_rfkill_hotplug_update(struct eeepc_laptop *eeepc, char *node) + 644. { + 645. > acpi_status status = AE_OK; + 646. acpi_handle handle; + 647. + +drivers/gpu/drm/i915/intel_guc_submission.c:663: error: DEAD_STORE + The value written to &count is never used. + 661. rq = port_unpack(&port[n], &count); + 662. if (rq && count == 0) { + 663. > port_set(&port[n], port_pack(rq, ++count)); + 664. + 665. flush_ggtt_writes(rq->ring->vma); + +net/ipv6/netfilter/nf_conntrack_reasm.c:653: error: DEAD_STORE + The value written to &ret is never used. + 651. int nf_ct_frag6_init(void) + 652. { + 653. > int ret = 0; + 654. + 655. nf_frags.hashfn = nf_hashfn; + +security/commoncap.c:655: error: DEAD_STORE + The value written to &rc is never used. + 653. static int get_file_caps(struct linux_binprm *bprm, bool *effective, bool *has_fcap) + 654. { + 655. > int rc = 0; + 656. struct cpu_vfs_cap_data vcaps; + 657. + +crypto/jitterentropy.c:659: error: DEAD_STORE + The value written to &entropy_collector is never used. + 657. entropy_collector->mem = NULL; + 658. jent_zfree(entropy_collector); + 659. > entropy_collector = NULL; + 660. } + 661. + +crypto/drbg.c:676: error: DEAD_STORE + The value written to &outlen is never used. + 674. list_add_tail(&data.list, &datalist); + 675. while (len < buflen) { + 676. > unsigned int outlen = 0; + 677. /* 10.1.2.5 step 4.1 */ + 678. ret = drbg_kcapi_hash(drbg, drbg->V, &datalist); + +crypto/drbg.c:662: error: DEAD_STORE + The value written to &ret is never used. + 660. { + 661. int len = 0; + 662. > int ret = 0; + 663. struct drbg_string data; + 664. LIST_HEAD(datalist); + +security/selinux/avc.c:672: error: DEAD_STORE + The value written to &rc is never used. + 670. struct hlist_head *head; + 671. spinlock_t *lock; + 672. > int rc = 0; + 673. + 674. hvalue = avc_hash(ssid, tsid, tclass); + +drivers/tty/vt/consolemap.c:660: error: DEAD_STORE + The value written to &err is never used. + 658. int con_set_default_unimap(struct vc_data *vc) + 659. { + 660. > int i, j, err = 0, err1; + 661. u16 *q; + 662. struct uni_pagedir *p; + +net/sunrpc/auth_gss/svcauth_gss.c:666: error: DEAD_STORE + The value written to &flavor is never used. + 664. struct xdr_buf rpchdr; + 665. struct xdr_netobj checksum; + 666. > u32 flavor = 0; + 667. struct kvec *argv = &rqstp->rq_arg.head[0]; + 668. struct kvec iov; + +crypto/jitterentropy.c:699: error: DEAD_STORE + The value written to &delta is never used. + 697. __u64 time2 = 0; + 698. __u64 folded = 0; + 699. > __u64 delta = 0; + 700. unsigned int lowdelta = 0; + 701. + +crypto/jitterentropy.c:700: error: DEAD_STORE + The value written to &lowdelta is never used. + 698. __u64 folded = 0; + 699. __u64 delta = 0; + 700. > unsigned int lowdelta = 0; + 701. + 702. jent_get_nstime(&time); + +lib/iov_iter.c:673: error: DEAD_STORE + The value written to &skip is never used. + 671. if (unlikely(i->count < bytes)) + 672. return false; + 673. > iterate_all_kinds(i, bytes, v, ({ + 674. if (__copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len, + 675. v.iov_base, v.iov_len)) + +net/ipv4/netfilter/ip_tables.c:674: error: DEAD_STORE + The value written to &ret is never used. + 672. unsigned int *offsets; + 673. unsigned int i; + 674. > int ret = 0; + 675. + 676. newinfo->size = repl->size; + +net/ipv6/icmp.c:673: error: DEAD_STORE + The value written to &saddr is never used. + 671. struct inet6_dev *idev; + 672. struct ipv6_pinfo *np; + 673. > const struct in6_addr *saddr = NULL; + 674. struct icmp6hdr *icmph = icmp6_hdr(skb); + 675. struct icmp6hdr tmp_hdr; + +ipc/sem.c:717: error: DEAD_STORE + The value written to &result is never used. + 715. curr = &sma->sems[sop->sem_num]; + 716. sem_op = sop->sem_op; + 717. > result = curr->semval; + 718. + 719. if (sop->sem_flg & SEM_UNDO) { + +net/core/ethtool.c:672: error: DEAD_STORE + The value written to &err is never used. + 670. void __user *useraddr) + 671. { + 672. > int err = 0; + 673. struct ethtool_link_ksettings link_ksettings; + 674. + +drivers/rtc/rtc-cmos.c:674: error: DEAD_STORE + The value written to &retval is never used. + 672. { + 673. struct cmos_rtc_board_info *info = dev_get_platdata(dev); + 674. > int retval = 0; + 675. unsigned char rtc_control; + 676. unsigned address_space; + +drivers/gpu/drm/drm_property.c:679: error: DEAD_STORE + The value written to &old_blob is never used. + 677. { + 678. struct drm_property_blob *new_blob = NULL; + 679. > struct drm_property_blob *old_blob = NULL; + 680. int ret; + 681. + +net/wireless/chan.c:676: error: DEAD_STORE + The value written to &t1 is never used. + 674. { + 675. int width; + 676. > unsigned int t1 = 0, t2 = 0; + 677. + 678. if (WARN_ON(!cfg80211_chandef_valid(chandef))) + +net/wireless/chan.c:676: error: DEAD_STORE + The value written to &t2 is never used. + 674. { + 675. int width; + 676. > unsigned int t1 = 0, t2 = 0; + 677. + 678. if (WARN_ON(!cfg80211_chandef_valid(chandef))) + +kernel/kexec_core.c:759: error: DEAD_STORE + The value written to &addr is never used. + 757. continue; + 758. } + 759. > addr = old_addr; + 760. page = old_page; + 761. break; + +net/ipv6/tcp_ipv6.c:677: error: DEAD_STORE + The value written to &hash_location is never used. + 675. { + 676. #ifdef CONFIG_TCP_MD5SIG + 677. > const __u8 *hash_location = NULL; + 678. struct tcp_md5sig_key *hash_expected; + 679. const struct ipv6hdr *ip6h = ipv6_hdr(skb); + +net/ipv6/udp.c:687: error: DEAD_STORE + The value written to &dif is never used. + 685. unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. > int dif = inet6_iif(skb); + 688. struct hlist_node *node; + 689. struct sk_buff *nskb; + +net/ipv6/udp.c:685: error: DEAD_STORE + The value written to &offset is never used. + 683. unsigned short hnum = ntohs(uh->dest); + 684. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 685. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. int dif = inet6_iif(skb); + +net/ipv6/udp.c:697: error: DEAD_STORE + The value written to &offset is never used. + 695. start_lookup: + 696. hslot = &udptable->hash2[hash2]; + 697. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 698. } + 699. + +lib/decompress_bunzip2.c:686: error: DEAD_STORE + The value written to &i is never used. + 684. { + 685. struct bunzip_data *bd; + 686. > int i = -1; + 687. unsigned char *inbuf; + 688. + +net/ipv4/arp.c:687: error: DEAD_STORE + The value written to &tha is never used. + 685. struct rtable *rt; + 686. unsigned char *sha; + 687. > unsigned char *tha = NULL; + 688. __be32 sip, tip; + 689. u16 dev_type = dev->type; + +drivers/gpu/drm/i915/intel_hdmi.c:692: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 688 could be null and is dereferenced at line 692, column 13. + 690. i915_reg_t reg = TVIDEO_DIP_CTL(intel_crtc->pipe); + 691. u32 val = I915_READ(reg); + 692. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 693. + 694. assert_hdmi_port_disabled(intel_hdmi); + +drivers/net/ethernet/intel/e1000e/ethtool.c:687: error: DEAD_STORE + The value written to &set_rx is never used. + 685. struct e1000_ring *temp_tx = NULL, *temp_rx = NULL; + 686. int err = 0, size = sizeof(struct e1000_ring); + 687. > bool set_tx = false, set_rx = false; + 688. u16 new_rx_count, new_tx_count; + 689. + +drivers/net/ethernet/intel/e1000e/ethtool.c:687: error: DEAD_STORE + The value written to &set_tx is never used. + 685. struct e1000_ring *temp_tx = NULL, *temp_rx = NULL; + 686. int err = 0, size = sizeof(struct e1000_ring); + 687. > bool set_tx = false, set_rx = false; + 688. u16 new_rx_count, new_tx_count; + 689. + +net/ipv6/netfilter/ip6_tables.c:692: error: DEAD_STORE + The value written to &ret is never used. + 690. unsigned int *offsets; + 691. unsigned int i; + 692. > int ret = 0; + 693. + 694. newinfo->size = repl->size; + +kernel/cgroup/cgroup-v1.c:700: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 698 could be null and is dereferenced at line 700, column 7. + 698. for_each_subsys(ss, i) + 699. seq_printf(m, "%s\t%d\t%d\t%d\n", + 700. > ss->legacy_name, ss->root->hierarchy_id, + 701. atomic_read(&ss->root->nr_cgrps), + 702. cgroup_ssid_enabled(i)); + +drivers/input/mouse/alps.c:692: error: DEAD_STORE + The value written to &palm_data is never used. + 690. struct psmouse *psmouse) + 691. { + 692. > u64 palm_data = 0; + 693. struct alps_data *priv = psmouse->private; + 694. + +drivers/platform/x86/eeepc-laptop.c:693: error: DEAD_STORE + The value written to &status is never used. + 691. char *node) + 692. { + 693. > acpi_status status = AE_OK; + 694. acpi_handle handle; + 695. + +drivers/iommu/intel-iommu.c:694: error: DEAD_STORE + The value written to &agaw is never used. + 692. { + 693. unsigned long sagaw; + 694. > int agaw = -1; + 695. + 696. sagaw = cap_sagaw(iommu->cap); + +kernel/resource.c:695: error: DEAD_STORE + The value written to &err is never used. + 693. struct resource_constraint *constraint) + 694. { + 695. > int err=0; + 696. struct resource new = *old; + 697. struct resource *conflict; + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: DEAD_STORE + The value written to &timeout__ is never used. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: DEAD_STORE + The value written to &timeout__ is never used. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: DEAD_STORE + The value written to &wait__ is never used. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: DEAD_STORE + The value written to &wait__ is never used. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +sound/pci/hda/hda_proc.c:699: error: DEAD_STORE + The value written to &curr is never used. + 697. struct hda_codec *codec, hda_nid_t nid) + 698. { + 699. > int i, curr = -1; + 700. u8 dev_list[AC_MAX_DEV_LIST_LEN]; + 701. int devlist_len; + +net/ipv4/ping.c:709: error: DEAD_STORE + The value written to &rt is never used. + 707. struct icmphdr user_icmph; + 708. struct pingfakehdr pfh; + 709. > struct rtable *rt = NULL; + 710. struct ip_options_data opt_copy; + 711. int free = 0; + +net/ipv6/ndisc.c:720: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 720, column 3. + 718. __func__, target); + 719. } + 720. > ndisc_send_ns(dev, target, target, saddr, 0); + 721. } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) { + 722. neigh_app_ns(neigh); + +net/ipv6/ndisc.c:725: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 725, column 3. + 723. } else { + 724. addrconf_addr_solict_mult(target, &mcaddr); + 725. > ndisc_send_ns(dev, target, &mcaddr, saddr, 0); + 726. } + 727. } + +sound/core/pcm.c:728: error: DEAD_STORE + The value written to &prev is never used. + 726. } + 727. } + 728. > prev = NULL; + 729. for (idx = 0, prev = NULL; idx < substream_count; idx++) { + 730. substream = kzalloc(sizeof(*substream), GFP_KERNEL); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:711: error: DEAD_STORE + The value written to &p is never used. + 709. if (!p) + 710. return -ENOSPC; + 711. > p = xdr_encode_hyper(p, cb->initiator_addrtype); + 712. + 713. /* cb->initiator_address */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:722: error: DEAD_STORE + The value written to &p is never used. + 720. if (!p) + 721. return -ENOSPC; + 722. > p = xdr_encode_hyper(p, cb->acceptor_addrtype); + 723. + 724. /* cb->acceptor_address */ + +drivers/ata/libata-scsi.c:708: error: DEAD_STORE + The value written to &sensebuf is never used. + 706. int rc = 0; + 707. u8 scsi_cmd[MAX_COMMAND_SIZE]; + 708. > u8 args[7], *sensebuf = NULL; + 709. struct scsi_sense_hdr sshdr; + 710. int cmd_result; + +net/ipv6/ip6_flowlabel.c:706: error: DEAD_STORE + The value written to &fl is never used. + 704. static struct ip6_flowlabel *ip6fl_get_first(struct seq_file *seq) + 705. { + 706. > struct ip6_flowlabel *fl = NULL; + 707. struct ip6fl_iter_state *state = ip6fl_seq_private(seq); + 708. struct net *net = seq_file_net(seq); + +net/netlabel/netlabel_cipso_v4.c:706: error: DEAD_STORE + The value written to &ret_val is never used. + 704. static int netlbl_cipsov4_remove(struct sk_buff *skb, struct genl_info *info) + 705. { + 706. > int ret_val = -EINVAL; + 707. struct netlbl_domhsh_walk_arg cb_arg; + 708. struct netlbl_audit audit_info; + +net/sunrpc/svcsock.c:739: error: DEAD_STORE + The value written to &err is never used. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/xfrm/xfrm_state.c:706: error: DEAD_STORE + The value written to &err is never used. + 704. int xfrm_state_flush(struct net *net, u8 proto, bool task_valid) + 705. { + 706. > int i, err = 0, cnt = 0; + 707. + 708. spin_lock_bh(&net->xfrm.xfrm_state_lock); + +drivers/char/agp/intel-gtt.c:710: error: DEAD_STORE + The value written to &timeout is never used. + 708. static void i830_chipset_flush(void) + 709. { + 710. > unsigned long timeout = jiffies + msecs_to_jiffies(1000); + 711. + 712. /* Forcibly evict everything from the CPU write buffers. + +net/wireless/scan.c:719: error: DEAD_STORE + The value written to &now is never used. + 717. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); + 718. struct cfg80211_internal_bss *bss, *res = NULL; + 719. > unsigned long now = jiffies; + 720. int bss_privacy; + 721. + +net/wireless/trace.h:710: error: DEAD_STORE + The value written to &p is never used. + 708. ); + 709. + 710. > DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, + 711. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 712. TP_ARGS(wiphy, netdev, mac), + +net/ipv4/ipconfig.c:742: error: DEAD_STORE + The value written to &e is never used. + 740. *e++ = 150; + 741. + 742. > *e++ = 255; /* End of the list */ + 743. } + 744. + +drivers/gpu/drm/i915/i915_gem_gtt.c:719: error: DEAD_STORE + The value written to &ret is never used. + 717. { + 718. struct i915_page_directory_pointer *pdp; + 719. > int ret = -ENOMEM; + 720. + 721. WARN_ON(!use_4lvl(vm)); + +arch/x86/events/intel/p4.c:724: error: NULL_DEREFERENCE + pointer `bind` last assigned on line 723 could be null and is dereferenced at line 724, column 9. + 722. config = p4_general_events[hw_event]; + 723. bind = p4_config_get_bind(config); + 724. > esel = P4_OPCODE_ESEL(bind->opcode); + 725. config |= p4_config_pack_cccr(P4_CCCR_ESEL(esel)); + 726. + +drivers/pcmcia/rsrc_nonstatic.c:720: error: DEAD_STORE + The value written to &ret is never used. + 718. unsigned int align, struct resource **parent) + 719. { + 720. > int i, ret = 0; + 721. + 722. /* Check for an already-allocated window that must conflict with + +drivers/base/dd.c:719: error: DEAD_STORE + The value written to &ret is never used. + 717. static int __device_attach(struct device *dev, bool allow_async) + 718. { + 719. > int ret = 0; + 720. + 721. device_lock(dev); + +net/netfilter/nf_conntrack_core.c:746: error: DEAD_STORE + The value written to &zone is never used. + 744. return NF_ACCEPT; + 745. + 746. > zone = nf_ct_zone(ct); + 747. local_bh_disable(); + 748. + +drivers/char/agp/intel-agp.c:728: error: DEAD_STORE + The value written to &cap_ptr is never used. + 726. { + 727. struct agp_bridge_data *bridge; + 728. > u8 cap_ptr = 0; + 729. struct resource *r; + 730. int i, err; + +include/linux/rhashtable.h:784: error: DEAD_STORE + The value written to &head is never used. + 782. + 783. RCU_INIT_POINTER(list->next, plist); + 784. > head = rht_dereference_bucket(head->next, tbl, hash); + 785. RCU_INIT_POINTER(list->rhead.next, head); + 786. rcu_assign_pointer(*pprev, obj); + +include/linux/rhashtable.h:801: error: DEAD_STORE + The value written to &head is never used. + 799. goto slow_path; + 800. + 801. > head = rht_dereference_bucket(*pprev, tbl, hash); + 802. + 803. RCU_INIT_POINTER(obj->next, head); + +include/linux/rhashtable.h:781: error: DEAD_STORE + The value written to &plist is never used. + 779. + 780. list = container_of(obj, struct rhlist_head, rhead); + 781. > plist = container_of(head, struct rhlist_head, rhead); + 782. + 783. RCU_INIT_POINTER(list->next, plist); + +drivers/edac/edac_mc_sysfs.c:732: error: DEAD_STORE + The value written to &new_bw is never used. + 730. struct mem_ctl_info *mci = to_mci(dev); + 731. unsigned long bandwidth = 0; + 732. > int new_bw = 0; + 733. + 734. if (kstrtoul(data, 10, &bandwidth) < 0) + +drivers/firmware/efi/efivars.c:729: error: DEAD_STORE + The value written to &error is never used. + 727. { + 728. struct kobject *parent_kobj = efivars_kobject(); + 729. > int error = 0; + 730. + 731. if (!efi_enabled(EFI_RUNTIME_SERVICES)) + +net/wireless/trace.h:727: error: DEAD_STORE + The value written to &p is never used. + 725. ); + 726. + 727. > DECLARE_EVENT_CLASS(station_del, + 728. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 729. struct station_del_parameters *params), + +arch/x86/events/amd/ibs.c:738: error: DEAD_STORE + The value written to &attr is never used. + 736. if (ibs_caps & IBS_CAPS_OPCNT) { + 737. perf_ibs_op.config_mask |= IBS_OP_CNT_CTL; + 738. > *attr++ = &format_attr_cnt_ctl.attr; + 739. } + 740. perf_ibs_pmu_init(&perf_ibs_op, "ibs_op"); + +drivers/gpu/drm/drm_plane.c:736: error: DEAD_STORE + The value written to &fb is never used. + 734. { + 735. struct drm_device *dev = crtc->dev; + 736. > struct drm_framebuffer *fb = NULL; + 737. struct drm_mode_fb_cmd2 fbreq = { + 738. .width = req->width, + +drivers/gpu/drm/drm_plane.c:747: error: DEAD_STORE + The value written to &ret is never used. + 745. uint32_t crtc_w = 0, crtc_h = 0; + 746. uint32_t src_w = 0, src_h = 0; + 747. > int ret = 0; + 748. + 749. BUG_ON(!crtc->cursor); + +drivers/clk/clk.c:735: error: DEAD_STORE + The value written to &ret is never used. + 733. static int clk_core_prepare(struct clk_core *core) + 734. { + 735. > int ret = 0; + 736. + 737. lockdep_assert_held(&prepare_lock); + +include/net/xfrm.h:735: error: DEAD_STORE + The value written to &audit_buf is never used. + 733. static inline struct audit_buffer *xfrm_audit_start(const char *op) + 734. { + 735. > struct audit_buffer *audit_buf = NULL; + 736. + 737. if (audit_enabled == 0) + +net/netlabel/netlabel_mgmt.c:742: error: DEAD_STORE + The value written to &ans_skb is never used. + 740. { + 741. int ret_val = -ENOMEM; + 742. > struct sk_buff *ans_skb = NULL; + 743. void *data; + 744. + +arch/x86/events/intel/lbr.c:744: error: DEAD_STORE + The value written to &ret is never used. + 742. int intel_pmu_setup_lbr_filter(struct perf_event *event) + 743. { + 744. > int ret = 0; + 745. + 746. /* + +drivers/pcmcia/ti113x.h:780: error: DEAD_STORE + The value written to &mfunc is never used. + 778. default: + 779. if (operation == HOOK_POWER_PRE) + 780. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + +drivers/pcmcia/ti113x.h:782: error: DEAD_STORE + The value written to &mfunc is never used. + 780. mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + 783. } + 784. + +net/xfrm/xfrm_state.c:747: error: DEAD_STORE + The value written to &err is never used. + 745. int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid) + 746. { + 747. > int i, err = 0, cnt = 0; + 748. + 749. spin_lock_bh(&net->xfrm.xfrm_state_lock); + +drivers/usb/host/ehci-q.c:758: error: DEAD_STORE + The value written to &maxp is never used. + 756. u32 info1 = 0, info2 = 0; + 757. int is_input, type; + 758. > int maxp = 0; + 759. int mult; + 760. struct usb_tt *tt = urb->dev->tt; + +drivers/video/fbdev/core/fbmem.c:795: error: DEAD_STORE + The value written to &dst is never used. + 793. dst = buffer; + 794. fb_memcpy_fromfb(dst, src, c); + 795. > dst += c; + 796. src += c; + 797. + +drivers/edac/edac_mc_sysfs.c:755: error: DEAD_STORE + The value written to &bandwidth is never used. + 753. { + 754. struct mem_ctl_info *mci = to_mci(dev); + 755. > int bandwidth = 0; + 756. + 757. bandwidth = mci->get_sdram_scrub_rate(mci); + +drivers/char/agp/amd64-agp.c:755: error: DEAD_STORE + The value written to &err is never used. + 753. int __init agp_amd64_init(void) + 754. { + 755. > int err = 0; + 756. + 757. if (agp_off) + +net/ipv6/udp.c:760: error: DEAD_STORE + The value written to &ulen is never used. + 758. struct udphdr *uh; + 759. struct sock *sk; + 760. > u32 ulen = 0; + 761. + 762. if (!pskb_may_pull(skb, sizeof(struct udphdr))) + +net/sunrpc/sched.c:757: error: DEAD_STORE + The value written to &status is never used. + 755. struct rpc_wait_queue *queue; + 756. int task_is_async = RPC_IS_ASYNC(task); + 757. > int status = 0; + 758. + 759. dprintk("RPC: %5u __rpc_execute flags=0x%x\n", + +arch/x86/include/asm/processor.h:757: error: DEAD_STORE + The value written to &debugctlmsr is never used. + 755. static inline unsigned long get_debugctlmsr(void) + 756. { + 757. > unsigned long debugctlmsr = 0; + 758. + 759. #ifndef CONFIG_X86_DEBUGCTLMSR + +lib/rhashtable.c:760: error: DEAD_STORE + The value written to &p is never used. + 758. struct rhlist_head *list = iter->list; + 759. struct rhashtable *ht = iter->ht; + 760. > struct rhash_head *p = iter->p; + 761. bool rhlist = ht->rhlist; + 762. + +net/ipv6/raw.c:766: error: DEAD_STORE + The value written to &dst is never used. + 764. struct ipv6_txoptions *opt = NULL; + 765. struct ip6_flowlabel *flowlabel = NULL; + 766. > struct dst_entry *dst = NULL; + 767. struct raw6_frag_vec rfv; + 768. struct flowi6 fl6; + +drivers/usb/host/ohci-q.c:759: error: DEAD_STORE + The value written to &cc is never used. + 757. { + 758. u32 tdINFO = hc32_to_cpup (ohci, &td->hwINFO); + 759. > int cc = 0; + 760. int status = -EINPROGRESS; + 761. + +drivers/usb/host/ohci-q.c:767: error: DEAD_STORE + The value written to &dlen is never used. + 765. if (tdINFO & TD_ISO) { + 766. u16 tdPSW = ohci_hwPSW(ohci, td, 0); + 767. > int dlen = 0; + 768. + 769. /* NOTE: assumes FC in tdINFO == 0, and that + +sound/core/timer.c:763: error: DEAD_STORE + The value written to &use_tasklet is never used. + 761. struct list_head *p, *ack_list_head; + 762. unsigned long flags; + 763. > int use_tasklet = 0; + 764. + 765. if (timer == NULL) + +net/core/dev_addr_lists.c:760: error: DEAD_STORE + The value written to &err is never used. + 758. int dev_mc_sync(struct net_device *to, struct net_device *from) + 759. { + 760. > int err = 0; + 761. + 762. if (to->addr_len != from->addr_len) + +kernel/printk/printk.c:813: error: DEAD_STORE + The value written to &len is never used. + 811. facility = LOG_FACILITY(u); + 812. endp++; + 813. > len -= endp - line; + 814. line = endp; + 815. } + +arch/x86/events/intel/pt.c:769: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 765 could be null and is dereferenced at line 769, column 9. + 767. + 768. /* offset of the first region in this table from the beginning of buf */ + 769. > base = buf->cur->offset + buf->output_off; + 770. + 771. /* offset of the current output region within this table */ + +drivers/gpu/drm/drm_property.c:769: error: DEAD_STORE + The value written to &ret is never used. + 767. struct drm_mode_create_blob *out_resp = data; + 768. struct drm_property_blob *blob; + 769. > int ret = 0; + 770. + 771. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +net/sched/act_api.c:768: error: DEAD_STORE + The value written to &err is never used. + 766. int compat_mode) + 767. { + 768. > int err = 0; + 769. struct gnet_dump d; + 770. + +kernel/rcu/srcutree.c:789: error: DEAD_STORE + The value written to &t is never used. + 787. + 788. /* First, see if enough time has passed since the last GP. */ + 789. > t = ktime_get_mono_fast_ns(); + 790. if (exp_holdoff == 0 || + 791. time_in_range_open(t, sp->srcu_last_gp_end, + +net/ipv4/udp.c:775: error: DEAD_STORE + The value written to &csum is never used. + 773. int offset = skb_transport_offset(skb); + 774. int len = skb->len - offset; + 775. > __wsum csum = 0; + 776. + 777. /* + +net/ipv4/udp.c:771: error: DEAD_STORE + The value written to &err is never used. + 769. struct inet_sock *inet = inet_sk(sk); + 770. struct udphdr *uh; + 771. > int err = 0; + 772. int is_udplite = IS_UDPLITE(sk); + 773. int offset = skb_transport_offset(skb); + +drivers/i2c/busses/i2c-i801.c:771: error: DEAD_STORE + The value written to &result is never used. + 769. int command, int hwpec) + 770. { + 771. > int result = 0; + 772. unsigned char hostc; + 773. + +kernel/time/alarmtimer.c:776: error: DEAD_STORE + The value written to &ret is never used. + 774. struct alarm alarm; + 775. ktime_t exp; + 776. > int ret = 0; + 777. + 778. if (!alarmtimer_get_rtcdev()) + +net/ipv4/tcp_input.c:793: error: DEAD_STORE + The value written to &rate is never used. + 791. + 792. if (likely(tp->srtt_us)) + 793. > do_div(rate, tp->srtt_us); + 794. + 795. /* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate + +kernel/kexec_core.c:779: error: DEAD_STORE + The value written to &result is never used. + 777. unsigned char *kbuf = NULL; + 778. + 779. > result = 0; + 780. if (image->file_mode) + 781. kbuf = segment->kbuf; + +kernel/auditfilter.c:774: error: DEAD_STORE + The value written to &ret is never used. + 772. struct audit_field *sf) + 773. { + 774. > int ret = 0; + 775. char *lsm_str; + 776. + +net/wireless/trace.h:772: error: DEAD_STORE + The value written to &p is never used. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +drivers/usb/core/usb.c:776: error: DEAD_STORE + The value written to &jiffies_expire is never used. + 774. const struct usb_interface *iface) + 775. { + 776. > unsigned long jiffies_expire = jiffies + HZ; + 777. + 778. if (udev->state == USB_STATE_NOTATTACHED) + +lib/iov_iter.c:786: error: DEAD_STORE + The value written to &skip is never used. + 784. return 0; + 785. } + 786. > iterate_all_kinds(i, bytes, v, + 787. copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len), + 788. memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page, + +drivers/md/md-bitmap.c:781: error: DEAD_STORE + The value written to &offset is never used. + 779. int slot_number) + 780. { + 781. > int pnum, offset = 0; + 782. unsigned long num_pages; + 783. unsigned long bytes; + +arch/x86/events/intel/lbr.c:787: error: DEAD_STORE + The value written to &is64 is never used. + 785. int ext, to_plm, from_plm; + 786. u8 buf[MAX_INSN_SIZE]; + 787. > int is64 = 0; + 788. + 789. to_plm = kernel_ip(to) ? X86_BR_KERNEL : X86_BR_USER; + +drivers/md/dm-ioctl.c:783: error: DEAD_STORE + The value written to &hc is never used. + 781. static struct hash_cell *__find_device_hash_cell(struct dm_ioctl *param) + 782. { + 783. > struct hash_cell *hc = NULL; + 784. + 785. if (*param->uuid) { + +drivers/gpu/drm/i915/intel_overlay.c:789: error: DEAD_STORE + The value written to &scale_changed is never used. + 787. int ret, tmp_width; + 788. struct overlay_registers __iomem *regs; + 789. > bool scale_changed = false; + 790. struct drm_i915_private *dev_priv = overlay->i915; + 791. u32 swidth, swidthsw, sheight, ostride; + +net/wireless/sme.c:850: error: DEAD_STORE + The value written to &next is never used. + 848. ev->cr.pmkid = next; + 849. memcpy((void *)ev->cr.pmkid, params->pmkid, WLAN_PMKID_LEN); + 850. > next += WLAN_PMKID_LEN; + 851. } + 852. ev->cr.update_erp_next_seq_num = params->update_erp_next_seq_num; + +drivers/ata/libata-scsi.c:789: error: DEAD_STORE + The value written to &rc is never used. + 787. { + 788. unsigned long val; + 789. > int rc = -EINVAL; + 790. unsigned long flags; + 791. + +drivers/input/serio/i8042.c:787: error: DEAD_STORE + The value written to &retval is never used. + 785. static int __init i8042_check_aux(void) + 786. { + 787. > int retval = -1; + 788. bool irq_registered = false; + 789. bool aux_loop_broken = false; + +tools/lib/subcmd/parse-options.c:788: error: DEAD_STORE + The value written to &o is never used. + 786. { + 787. int nr_opts = 0, len; + 788. > const struct option *o = opts; + 789. struct option *ordered; + 790. + +net/core/dev_addr_lists.c:790: error: DEAD_STORE + The value written to &err is never used. + 788. int dev_mc_sync_multiple(struct net_device *to, struct net_device *from) + 789. { + 790. > int err = 0; + 791. + 792. if (to->addr_len != from->addr_len) + +drivers/gpu/drm/i915/intel_runtime_pm.c:814: error: DEAD_STORE + The value written to &timeout__ is never used. + 812. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 813. + 814. > if (wait_for(COND, 100)) + 815. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 816. state, + +drivers/gpu/drm/i915/intel_runtime_pm.c:814: error: DEAD_STORE + The value written to &wait__ is never used. + 812. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 813. + 814. > if (wait_for(COND, 100)) + 815. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 816. state, + +sound/pci/hda/hda_controller.c:802: error: DEAD_STORE + The value written to &loopcounter is never used. + 800. timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. > for (loopcounter = 0;; loopcounter++) { + 803. spin_lock_irq(&bus->reg_lock); + 804. if (chip->polling_mode || do_poll) + +sound/pci/hda/hda_controller.c:802: error: DEAD_STORE + The value written to &loopcounter is never used. + 800. timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. > for (loopcounter = 0;; loopcounter++) { + 803. spin_lock_irq(&bus->reg_lock); + 804. if (chip->polling_mode || do_poll) + +sound/pci/hda/hda_controller.c:800: error: DEAD_STORE + The value written to &timeout is never used. + 798. + 799. again: + 800. > timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. for (loopcounter = 0;; loopcounter++) { + +net/wireless/trace.h:793: error: DEAD_STORE + The value written to &p is never used. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +drivers/usb/core/config.c:801: error: DEAD_STORE + The value written to &result is never used. + 799. struct device *ddev = &dev->dev; + 800. int ncfg = dev->descriptor.bNumConfigurations; + 801. > int result = 0; + 802. unsigned int cfgno, length; + 803. unsigned char *bigbuffer; + +drivers/usb/core/config.c:833: error: DEAD_STORE + The value written to &result is never used. + 831. goto err2; + 832. + 833. > result = 0; + 834. for (; cfgno < ncfg; cfgno++) { + 835. /* We grab just the first descriptor so we know how long + +drivers/gpu/drm/drm_property.c:804: error: DEAD_STORE + The value written to &blob is never used. + 802. { + 803. struct drm_mode_destroy_blob *out_resp = data; + 804. > struct drm_property_blob *blob = NULL, *bt; + 805. bool found = false; + 806. int ret = 0; + +drivers/gpu/drm/drm_property.c:806: error: DEAD_STORE + The value written to &ret is never used. + 804. struct drm_property_blob *blob = NULL, *bt; + 805. bool found = false; + 806. > int ret = 0; + 807. + 808. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/usb/mon/mon_bin.c:849: error: DEAD_STORE + The value written to &buf is never used. + 847. } + 848. nbytes -= step_len; + 849. > buf += step_len; + 850. rp->b_read += step_len; + 851. done += step_len; + +drivers/usb/mon/mon_bin.c:848: error: DEAD_STORE + The value written to &nbytes is never used. + 846. return -EFAULT; + 847. } + 848. > nbytes -= step_len; + 849. buf += step_len; + 850. rp->b_read += step_len; + +security/keys/key.c:814: error: DEAD_STORE + The value written to &key is never used. + 812. struct assoc_array_edit *edit; + 813. const struct cred *cred = current_cred(); + 814. > struct key *keyring, *key = NULL; + 815. key_ref_t key_ref; + 816. int ret; + +arch/x86/events/intel/p4.c:804: error: DEAD_STORE + The value written to &rc is never used. + 802. { + 803. int cpu = get_cpu(); + 804. > int rc = 0; + 805. u32 escr, cccr; + 806. + +drivers/gpu/drm/drm_prime.c:804: error: DEAD_STORE + The value written to &sg is never used. + 802. struct sg_table *drm_prime_pages_to_sg(struct page **pages, unsigned int nr_pages) + 803. { + 804. > struct sg_table *sg = NULL; + 805. int ret; + 806. + +drivers/gpu/drm/i915/i915_pmu.c:805: error: DEAD_STORE + The value written to &pmu is never used. + 803. static int i915_pmu_cpu_online(unsigned int cpu, struct hlist_node *node) + 804. { + 805. > struct i915_pmu *pmu = hlist_entry_safe(node, typeof(*pmu), node); + 806. + 807. GEM_BUG_ON(!pmu->base.event_init); + +net/ipv6/af_inet6.c:806: error: DEAD_STORE + The value written to &err is never used. + 804. static int __net_init inet6_net_init(struct net *net) + 805. { + 806. > int err = 0; + 807. + 808. net->ipv6.sysctl.bindv6only = 0; + +drivers/gpu/drm/drm_plane.c:812: error: DEAD_STORE + The value written to &ret is never used. + 810. struct drm_crtc *crtc; + 811. struct drm_modeset_acquire_ctx ctx; + 812. > int ret = 0; + 813. + 814. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +drivers/net/phy/phy.c:808: error: DEAD_STORE + The value written to &err is never used. + 806. void phy_start(struct phy_device *phydev) + 807. { + 808. > int err = 0; + 809. + 810. mutex_lock(&phydev->lock); + +net/ipv4/ipmr.c:821: error: DEAD_STORE + The value written to &now is never used. + 819. goto out; + 820. + 821. > now = jiffies; + 822. expires = 10*HZ; + 823. + +kernel/time/posix-cpu-timers.c:832: error: DEAD_STORE + The value written to &timers is never used. + 830. tsk_expires->virt_exp = expires; + 831. + 832. > tsk_expires->sched_exp = check_timers_list(++timers, firing, + 833. tsk->se.sum_exec_runtime); + 834. + +net/sunrpc/svc_xprt.c:810: error: DEAD_STORE + The value written to &xprt is never used. + 808. int svc_recv(struct svc_rqst *rqstp, long timeout) + 809. { + 810. > struct svc_xprt *xprt = NULL; + 811. struct svc_serv *serv = rqstp->rq_server; + 812. int len, err; + +arch/x86/events/intel/pt.c:832: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 832, column 32. + 830. */ + 831. if (!pt_cap_get(PT_CAP_topa_multiple_entries) || + 832. > buf->output_off == sizes(TOPA_ENTRY(buf->cur, buf->cur_idx)->size)) { + 833. perf_aux_output_flag(&pt->handle, + 834. PERF_AUX_FLAG_TRUNCATED); + +arch/x86/events/intel/pt.c:843: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 843, column 52. + 841. * before the output reaches its output region's boundary. + 842. */ + 843. > if (!pt_cap_get(PT_CAP_topa_multiple_entries) && !buf->snapshot && + 844. pt_buffer_region_size(buf) - buf->output_off <= TOPA_PMI_MARGIN) { + 845. void *head = pt_buffer_region(buf); + +net/netfilter/nf_conntrack_netlink.c:817: error: DEAD_STORE + The value written to &l3proto is never used. + 815. struct hlist_nulls_node *n; + 816. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 817. > u_int8_t l3proto = nfmsg->nfgen_family; + 818. struct nf_conn *nf_ct_evict[8]; + 819. int res, i; + +net/netfilter/nf_conntrack_netlink.c:812: error: DEAD_STORE + The value written to &net is never used. + 810. ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) + 811. { + 812. > struct net *net = sock_net(skb->sk); + 813. struct nf_conn *ct, *last; + 814. struct nf_conntrack_tuple_hash *h; + +net/wireless/trace.h:810: error: DEAD_STORE + The value written to &p is never used. + 808. ); + 809. + 810. > DECLARE_EVENT_CLASS(mpath_evt, + 811. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 812. u8 *next_hop), + +drivers/video/fbdev/core/fbmem.c:873: error: DEAD_STORE + The value written to &src is never used. + 871. fb_memcpy_tofb(dst, src, c); + 872. dst += c; + 873. > src += c; + 874. *ppos += c; + 875. buf += c; + +kernel/cgroup/cgroup-v1.c:818: error: DEAD_STORE + The value written to &agentbuf is never used. + 816. struct cgroup *cgrp = + 817. container_of(work, struct cgroup, release_agent_work); + 818. > char *pathbuf = NULL, *agentbuf = NULL; + 819. char *argv[3], *envp[3]; + 820. int ret; + +kernel/cgroup/cgroup-v1.c:818: error: DEAD_STORE + The value written to &pathbuf is never used. + 816. struct cgroup *cgrp = + 817. container_of(work, struct cgroup, release_agent_work); + 818. > char *pathbuf = NULL, *agentbuf = NULL; + 819. char *argv[3], *envp[3]; + 820. int ret; + +drivers/i2c/busses/i2c-i801.c:825: error: DEAD_STORE + The value written to &ret is never used. + 823. int hwpec; + 824. int block = 0; + 825. > int ret = 0, xact = 0; + 826. struct i801_priv *priv = i2c_get_adapdata(adap); + 827. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:891: error: DEAD_STORE + The value written to &ret_val is never used. + 889. + 890. data &= ~I82579_LPI_100_PLL_SHUT; + 891. > ret_val = e1000_write_emi_reg_locked(hw, I82579_LPI_PLL_SHUT, + 892. data); + 893. } + +drivers/net/ethernet/intel/e1000e/82571.c:827: error: DEAD_STORE + The value written to &eewr is never used. + 825. { + 826. struct e1000_nvm_info *nvm = &hw->nvm; + 827. > u32 i, eewr = 0; + 828. s32 ret_val = 0; + 829. + +sound/core/info.c:826: error: DEAD_STORE + The value written to &p is never used. + 824. int snd_info_register(struct snd_info_entry * entry) + 825. { + 826. > struct proc_dir_entry *root, *p = NULL; + 827. + 828. if (snd_BUG_ON(!entry)) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:829: error: DEAD_STORE + The value written to &txcw is never used. + 827. u32 ctrl; + 828. u32 status; + 829. > u32 txcw = 0; + 830. u32 i; + 831. u32 signal = 0; + +net/xfrm/xfrm_user.c:832: error: DEAD_STORE + The value written to &ret is never used. + 830. struct sk_buff *skb) + 831. { + 832. > int ret = 0; + 833. + 834. copy_to_user_state(x, p); + +net/netfilter/nf_conntrack_core.c:851: error: DEAD_STORE + The value written to &zone is never used. + 849. struct nf_conn *ct; + 850. + 851. > zone = nf_ct_zone(ignored_conntrack); + 852. + 853. rcu_read_lock(); + +scripts/asn1_compiler.c:843: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 843, column 3. + 841. struct element *e = calloc(1, sizeof(*e)); + 842. if (!e) { + 843. > perror(NULL); + 844. exit(1); + 845. } + +drivers/tty/vt/vt.c:846: error: DEAD_STORE + The value written to &err is never used. + 844. unsigned int cols, unsigned int lines) + 845. { + 846. > unsigned long old_origin, new_origin, new_scr_end, rlth, rrem, err = 0; + 847. unsigned long end; + 848. unsigned int old_rows, old_row_size; + +kernel/seccomp.c:848: error: DEAD_STORE + The value written to &prepared is never used. + 846. { + 847. const unsigned long seccomp_mode = SECCOMP_MODE_FILTER; + 848. > struct seccomp_filter *prepared = NULL; + 849. long ret = -EINVAL; + 850. + +drivers/gpu/drm/drm_syncobj.c:852: error: DEAD_STORE + The value written to &ret is never used. + 850. { + 851. signed long timeout = drm_timeout_abs_to_jiffies(wait->timeout_nsec); + 852. > signed long ret = 0; + 853. uint32_t first = ~0; + 854. + +kernel/time/alarmtimer.c:849: error: DEAD_STORE + The value written to &error is never used. + 847. { + 848. struct platform_device *pdev; + 849. > int error = 0; + 850. int i; + 851. + +net/sunrpc/rpcb_clnt.c:858: error: NULL_DEREFERENCE + pointer `p` last assigned on line 858 could be null and is dereferenced at line 858, column 2. + 856. + 857. p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2); + 858. > *p++ = cpu_to_be32(rpcb->r_prog); + 859. *p++ = cpu_to_be32(rpcb->r_vers); + 860. *p++ = cpu_to_be32(rpcb->r_prot); + +drivers/pci/pci-sysfs.c:915: error: DEAD_STORE + The value written to &off is never used. + 913. pci_user_read_config_byte(dev, off, &val); + 914. data[off - init_off] = val; + 915. > off++; + 916. --size; + 917. } + +drivers/pci/pci-sysfs.c:916: error: DEAD_STORE + The value written to &size is never used. + 914. data[off - init_off] = val; + 915. off++; + 916. > --size; + 917. } + 918. + +drivers/char/agp/generic.c:867: error: DEAD_STORE + The value written to &size is never used. + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + 867. > size = page_order = num_entries = 0; + 868. + 869. if (bridge->driver->size_type != FIXED_APER_SIZE) { + +drivers/char/agp/generic.c:873: error: DEAD_STORE + The value written to &size is never used. + 871. switch (bridge->driver->size_type) { + 872. case U8_APER_SIZE: + 873. > size = A_SIZE_8(temp)->size; + 874. page_order = + 875. A_SIZE_8(temp)->page_order; + +drivers/char/agp/generic.c:880: error: DEAD_STORE + The value written to &size is never used. + 878. break; + 879. case U16_APER_SIZE: + 880. > size = A_SIZE_16(temp)->size; + 881. page_order = A_SIZE_16(temp)->page_order; + 882. num_entries = A_SIZE_16(temp)->num_entries; + +drivers/char/agp/generic.c:885: error: DEAD_STORE + The value written to &size is never used. + 883. break; + 884. case U32_APER_SIZE: + 885. > size = A_SIZE_32(temp)->size; + 886. page_order = A_SIZE_32(temp)->page_order; + 887. num_entries = A_SIZE_32(temp)->num_entries; + +drivers/char/agp/generic.c:893: error: DEAD_STORE + The value written to &size is never used. + 891. case LVL2_APER_SIZE: + 892. default: + 893. > size = page_order = num_entries = 0; + 894. break; + 895. } + +drivers/char/agp/generic.c:923: error: DEAD_STORE + The value written to &size is never used. + 921. } while (!table && (i < bridge->driver->num_aperture_sizes)); + 922. } else { + 923. > size = ((struct aper_size_info_fixed *) temp)->size; + 924. page_order = ((struct aper_size_info_fixed *) temp)->page_order; + 925. num_entries = ((struct aper_size_info_fixed *) temp)->num_entries; + +drivers/char/agp/generic.c:864: error: DEAD_STORE + The value written to &table is never used. + 862. return -EINVAL; + 863. + 864. > table = NULL; + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + +net/wireless/trace.h:849: error: DEAD_STORE + The value written to &p is never used. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +kernel/cpu.c:858: error: DEAD_STORE + The value written to &ret is never used. + 856. { + 857. struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu); + 858. > int prev_state, ret = 0; + 859. + 860. if (num_online_cpus() == 1) + +drivers/block/loop.c:912: error: DEAD_STORE + The value written to &error is never used. + 910. goto out_putf; + 911. + 912. > error = 0; + 913. + 914. set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0); + +drivers/iommu/amd_iommu_init.c:859: error: DEAD_STORE + The value written to &old_devtb is never used. + 857. { + 858. u64 int_ctl, int_tab_len, entry = 0, last_entry = 0; + 859. > struct dev_table_entry *old_devtb = NULL; + 860. u32 lo, hi, devid, old_devtb_size; + 861. phys_addr_t old_devtb_phys; + +drivers/net/phy/phy_device.c:860: error: DEAD_STORE + The value written to &ret is never used. + 858. int phy_init_hw(struct phy_device *phydev) + 859. { + 860. > int ret = 0; + 861. + 862. /* Deassert the reset signal */ + +net/sunrpc/rpc_pipe.c:864: error: DEAD_STORE + The value written to &error is never used. + 862. struct dentry *parent; + 863. struct inode *dir; + 864. > int error = 0; + 865. + 866. parent = dget_parent(dentry); + +drivers/clk/clk.c:862: error: DEAD_STORE + The value written to &ret is never used. + 860. static int clk_core_enable(struct clk_core *core) + 861. { + 862. > int ret = 0; + 863. + 864. lockdep_assert_held(&enable_lock); + +drivers/pcmcia/rsrc_nonstatic.c:864: error: DEAD_STORE + The value written to &ret is never used. + 862. struct socket_data *data = s->resource_data; + 863. unsigned long size = end - start + 1; + 864. > int ret = 0; + 865. + 866. if (end < start) + +drivers/platform/x86/eeepc-laptop.c:862: error: DEAD_STORE + The value written to &result is never used. + 860. static int eeepc_rfkill_init(struct eeepc_laptop *eeepc) + 861. { + 862. > int result = 0; + 863. + 864. mutex_init(&eeepc->hotplug_lock); + +drivers/usb/host/ehci-hub.c:1108: error: DEAD_STORE + The value written to &temp1 is never used. + 1106. // status may be from integrated TT + 1107. if (ehci->has_hostpc) { + 1108. > temp1 = ehci_readl(ehci, hostpc_reg); + 1109. status |= ehci_port_speed(ehci, temp1); + 1110. } else + +drivers/iommu/intel-iommu.c:863: error: DEAD_STORE + The value written to &drhd is never used. + 861. static struct intel_iommu *device_to_iommu(struct device *dev, u8 *bus, u8 *devfn) + 862. { + 863. > struct dmar_drhd_unit *drhd = NULL; + 864. struct intel_iommu *iommu; + 865. struct device *tmp; + +kernel/time/clocksource.c:867: error: DEAD_STORE + The value written to &count is never used. + 865. struct device_attribute *attr, char *buf) + 866. { + 867. > ssize_t count = 0; + 868. + 869. mutex_lock(&clocksource_mutex); + +net/ipv6/ip6_fib.c:874: error: DEAD_STORE + The value written to &iter is never used. + 872. struct rt6_info *leaf = rcu_dereference_protected(fn->leaf, + 873. lockdep_is_held(&rt->rt6i_table->tb6_lock)); + 874. > struct rt6_info *iter = NULL; + 875. struct rt6_info __rcu **ins; + 876. struct rt6_info __rcu **fallback_ins = NULL; + +net/ipv4/af_inet.c:873: error: DEAD_STORE + The value written to &err is never used. + 871. { + 872. struct sock *sk = sock->sk; + 873. > int err = 0; + 874. struct net *net = sock_net(sk); + 875. void __user *p = (void __user *)arg; + +kernel/time/posix-timers.c:879: error: DEAD_STORE + The value written to &error is never used. + 877. struct k_itimer *timr; + 878. unsigned long flag; + 879. > int error = 0; + 880. + 881. if (!timespec64_valid(&new_spec64->it_interval) || + +net/ipv4/route.c:887: error: DEAD_STORE + The value written to &log_martians is never used. + 885. return; + 886. } + 887. > log_martians = IN_DEV_LOG_MARTIANS(in_dev); + 888. vif = l3mdev_master_ifindex_rcu(rt->dst.dev); + 889. rcu_read_unlock(); + +kernel/sched/topology.c:903: error: NULL_DEREFERENCE + pointer `last` last assigned on line 876 could be null and is dereferenced at line 903, column 2. + 901. last = sg; + 902. } + 903. > last->next = first; + 904. sd->groups = first; + 905. + +net/wireless/trace.h:873: error: DEAD_STORE + The value written to &p is never used. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +drivers/gpu/drm/i915/i915_drv.c:882: error: DEAD_STORE + The value written to &ret is never used. + 880. (struct intel_device_info *)ent->driver_data; + 881. struct intel_device_info *device_info; + 882. > int ret = 0; + 883. + 884. if (i915_inject_load_failure()) + +drivers/md/dm-raid1.c:887: error: DEAD_STORE + The value written to &ms is never used. + 885. { + 886. size_t len; + 887. > struct mirror_set *ms = NULL; + 888. + 889. len = sizeof(*ms) + (sizeof(ms->mirror[0]) * nr_mirrors); + +net/ipv6/tcp_ipv6.c:888: error: DEAD_STORE + The value written to &hash_location is never used. + 886. struct tcp_md5sig_key *key = NULL; + 887. #ifdef CONFIG_TCP_MD5SIG + 888. > const __u8 *hash_location = NULL; + 889. struct ipv6hdr *ipv6h = ipv6_hdr(skb); + 890. unsigned char newhash[16]; + +net/ipv6/tcp_ipv6.c:892: error: DEAD_STORE + The value written to &sk1 is never used. + 890. unsigned char newhash[16]; + 891. int genhash; + 892. > struct sock *sk1 = NULL; + 893. #endif + 894. int oif = 0; + +net/wireless/scan.c:891: error: DEAD_STORE + The value written to &found is never used. + 889. bool signal_valid) + 890. { + 891. > struct cfg80211_internal_bss *found = NULL; + 892. + 893. if (WARN_ON(!tmp->pub.channel)) + +drivers/thermal/thermal_core.c:891: error: DEAD_STORE + The value written to &pos is never used. + 889. int i, ret; + 890. const struct thermal_zone_params *tzp; + 891. > struct thermal_zone_device *pos = NULL; + 892. + 893. mutex_lock(&thermal_list_lock); + +net/sunrpc/cache.c:894: error: DEAD_STORE + The value written to &ret is never used. + 892. struct page *page; + 893. char *kaddr; + 894. > ssize_t ret = -ENOMEM; + 895. + 896. if (count >= PAGE_SIZE) + +drivers/usb/core/driver.c:892: error: DEAD_STORE + The value written to &retval is never used. + 890. struct module *owner) + 891. { + 892. > int retval = 0; + 893. + 894. if (usb_disabled()) + +kernel/cgroup/cgroup-v1.c:897: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 895 could be null and is dereferenced at line 897, column 25. + 895. for_each_subsys(ss, ssid) + 896. if (root->subsys_mask & (1 << ssid)) + 897. > seq_show_option(seq, ss->legacy_name, NULL); + 898. if (root->flags & CGRP_ROOT_NOPREFIX) + 899. seq_puts(seq, ",noprefix"); + +drivers/net/ethernet/intel/e1000e/82571.c:919: error: DEAD_STORE + The value written to &ret_val is never used. + 917. } else { + 918. data &= ~IGP02E1000_PM_D0_LPLU; + 919. > ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data); + 920. /* LPLU and SmartSpeed are mutually exclusive. LPLU is used + 921. * during Dx states where the power conservation is most + +net/wireless/trace.h:894: error: DEAD_STORE + The value written to &p is never used. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +drivers/hid/hid-ntrig.c:956: error: DEAD_STORE + The value written to &ret is never used. + 954. ntrig_report_version(hdev); + 955. + 956. > ret = sysfs_create_group(&hdev->dev.kobj, + 957. &ntrig_attribute_group); + 958. + +drivers/pci/setup-bus.c:903: error: DEAD_STORE + The value written to &size0 is never used. + 901. struct resource *b_res = find_free_bus_resource(bus, IORESOURCE_IO, + 902. IORESOURCE_IO); + 903. > resource_size_t size = 0, size0 = 0, size1 = 0; + 904. resource_size_t children_add_size = 0; + 905. resource_size_t min_align, align; + +net/unix/af_unix.c:911: error: DEAD_STORE + The value written to &err is never used. + 909. struct sock *u; + 910. struct path path; + 911. > int err = 0; + 912. + 913. if (sunname->sun_path[0]) { + +drivers/gpu/drm/drm_plane.c:915: error: DEAD_STORE + The value written to &ret is never used. + 913. u32 target_vblank = page_flip->sequence; + 914. struct drm_modeset_acquire_ctx ctx; + 915. > int ret = -EINVAL; + 916. + 917. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +net/core/neighbour.c:917: error: DEAD_STORE + The value written to &next is never used. + 915. state = neigh->nud_state; + 916. now = jiffies; + 917. > next = now + HZ; + 918. + 919. if (!(state & NUD_IN_TIMER)) + +net/core/neighbour.c:926: error: DEAD_STORE + The value written to &next is never used. + 924. neigh->confirmed + neigh->parms->reachable_time)) { + 925. neigh_dbg(2, "neigh %p is still alive\n", neigh); + 926. > next = neigh->confirmed + neigh->parms->reachable_time; + 927. } else if (time_before_eq(now, + 928. neigh->used + + +net/core/neighbour.c:934: error: DEAD_STORE + The value written to &next is never used. + 932. neigh->updated = jiffies; + 933. neigh_suspect(neigh); + 934. > next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); + 935. } else { + 936. neigh_dbg(2, "neigh %p is suspected\n", neigh); + +net/core/neighbour.c:951: error: DEAD_STORE + The value written to &next is never used. + 949. neigh_connect(neigh); + 950. notify = 1; + 951. > next = neigh->confirmed + neigh->parms->reachable_time; + 952. } else { + 953. neigh_dbg(2, "neigh %p is probed\n", neigh); + +net/core/neighbour.c:958: error: DEAD_STORE + The value written to &next is never used. + 956. atomic_set(&neigh->probes, 0); + 957. notify = 1; + 958. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 959. } + 960. } else { + +net/core/neighbour.c:962: error: DEAD_STORE + The value written to &next is never used. + 960. } else { + 961. /* NUD_PROBE|NUD_INCOMPLETE */ + 962. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 963. } + 964. + +kernel/time/posix-timers.c:914: error: DEAD_STORE + The value written to &error is never used. + 912. struct itimerspec64 new_spec, old_spec; + 913. struct itimerspec64 *rtn = old_setting ? &old_spec : NULL; + 914. > int error = 0; + 915. + 916. if (!new_setting) + +net/sunrpc/rpcb_clnt.c:920: error: NULL_DEREFERENCE + pointer `p` last assigned on line 919 could be null and is dereferenced by call to `xdr_encode_opaque()` at line 920, column 2. + 918. len = maxstrlen; + 919. p = xdr_reserve_space(xdr, 4 + len); + 920. > xdr_encode_opaque(p, string, len); + 921. } + 922. + +ipc/mqueue.c:982: error: DEAD_STORE + The value written to &new_leaf is never used. + 980. INIT_LIST_HEAD(&new_leaf->msg_list); + 981. info->node_cache = new_leaf; + 982. > new_leaf = NULL; + 983. } else { + 984. kfree(new_leaf); + +net/netfilter/nf_conntrack_netlink.c:914: error: DEAD_STORE + The value written to &ret is never used. + 912. struct nlattr *tb[CTA_IP_MAX+1]; + 913. struct nf_conntrack_l3proto *l3proto; + 914. > int ret = 0; + 915. + 916. ret = nla_parse_nested(tb, CTA_IP_MAX, attr, NULL, NULL); + +kernel/time/posix-cpu-timers.c:947: error: DEAD_STORE + The value written to &timers is never used. + 945. prof_expires = check_timers_list(timers, firing, ptime); + 946. virt_expires = check_timers_list(++timers, firing, utime); + 947. > sched_expires = check_timers_list(++timers, firing, sum_sched_runtime); + 948. + 949. /* + +drivers/usb/early/ehci-dbgp.c:954: error: DEAD_STORE + The value written to &ret is never used. + 952. } + 953. if (chunk > 0) { + 954. > ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, + 955. dbgp_endpoint_out, buf, chunk); + 956. } + +net/core/ethtool.c:920: error: DEAD_STORE + The value written to &info_buf is never used. + 918. u64 sset_mask; + 919. int i, idx = 0, n_bits = 0, ret, rc; + 920. > u32 *info_buf = NULL; + 921. + 922. if (copy_from_user(&info, useraddr, sizeof(info))) + +net/core/ethtool.c:919: error: DEAD_STORE + The value written to &n_bits is never used. + 917. struct ethtool_sset_info info; + 918. u64 sset_mask; + 919. > int i, idx = 0, n_bits = 0, ret, rc; + 920. u32 *info_buf = NULL; + 921. + +net/core/net-sysfs.c:919: error: DEAD_STORE + The value written to &error is never used. + 917. struct netdev_rx_queue *queue = dev->_rx + index; + 918. struct kobject *kobj = &queue->kobj; + 919. > int error = 0; + 920. + 921. kobj->kset = dev->queues_kset; + +drivers/gpu/drm/i915/intel_pipe_crc.c:924: error: DEAD_STORE + The value written to &ret is never used. + 922. enum intel_pipe_crc_source source; + 923. u32 val = 0; /* shut up gcc */ + 924. > int ret = 0; + 925. + 926. if (display_crc_ctl_parse_source(source_name, &source) < 0) { + +kernel/cgroup/cgroup-v1.c:922: error: DEAD_STORE + The value written to &mask is never used. + 920. char *token, *o = data; + 921. bool all_ss = false, one_ss = false; + 922. > u16 mask = U16_MAX; + 923. struct cgroup_subsys *ss; + 924. int nr_opts = 0; + +net/wireless/trace.h:918: error: DEAD_STORE + The value written to &p is never used. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +drivers/video/fbdev/core/fbcon.c:927: error: DEAD_STORE + The value written to &font is never used. + 925. struct display *p = &fb_display[fg_console]; + 926. struct vc_data *vc = vc_cons[fg_console].d; + 927. > const struct font_desc *font = NULL; + 928. struct module *owner; + 929. struct fb_info *info = NULL; + +drivers/video/fbdev/core/fbcon.c:929: error: DEAD_STORE + The value written to &info is never used. + 927. const struct font_desc *font = NULL; + 928. struct module *owner; + 929. > struct fb_info *info = NULL; + 930. struct fbcon_ops *ops; + 931. int rows, cols; + +net/ipv4/ipconfig.c:982: error: DEAD_STORE + The value written to &h is never used. + 980. + 981. b = (struct bootp_pkt *)skb_network_header(skb); + 982. > h = &b->iph; + 983. + 984. /* One reply at a time, please. */ + +net/sunrpc/rpcb_clnt.c:936: error: NULL_DEREFERENCE + pointer `p` last assigned on line 936 could be null and is dereferenced at line 936, column 2. + 934. + 935. p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2); + 936. > *p++ = cpu_to_be32(rpcb->r_prog); + 937. *p = cpu_to_be32(rpcb->r_vers); + 938. + +arch/x86/platform/efi/efi.c:927: error: DEAD_STORE + The value written to &new_memmap is never used. + 925. { + 926. int count = 0, pg_shift = 0; + 927. > void *new_memmap = NULL; + 928. efi_status_t status; + 929. unsigned long pa; + +drivers/gpu/drm/drm_syncobj.c:930: error: DEAD_STORE + The value written to &ret is never used. + 928. struct drm_syncobj_wait *args = data; + 929. struct drm_syncobj **syncobjs; + 930. > int ret = 0; + 931. + 932. if (!drm_core_check_feature(dev, DRIVER_SYNCOBJ)) + +drivers/pci/pci-sysfs.c:976: error: DEAD_STORE + The value written to &off is never used. + 974. if (size) { + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. > off++; + 977. --size; + 978. } + +drivers/pci/pci-sysfs.c:977: error: DEAD_STORE + The value written to &size is never used. + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. off++; + 977. > --size; + 978. } + 979. + +drivers/i2c/i2c-core-base.c:949: error: DEAD_STORE + The value written to &blank is never used. + 947. + 948. /* Parse remaining parameters, reject extra parameters */ + 949. > res = sscanf(++blank, "%hi%c", &info.addr, &end); + 950. if (res < 1) { + 951. dev_err(dev, "%s: Can't parse I2C address\n", "new_device"); + +net/xfrm/xfrm_policy.c:927: error: DEAD_STORE + The value written to &err is never used. + 925. int xfrm_policy_flush(struct net *net, u8 type, bool task_valid) + 926. { + 927. > int dir, err = 0, cnt = 0; + 928. + 929. spin_lock_bh(&net->xfrm.xfrm_policy_lock); + +drivers/iommu/iommu.c:932: error: DEAD_STORE + The value written to &group is never used. + 930. struct group_for_pci_data data; + 931. struct pci_bus *bus; + 932. > struct iommu_group *group = NULL; + 933. u64 devfns[4] = { 0 }; + 934. + +sound/hda/hdac_device.c:934: error: DEAD_STORE + The value written to &val is never used. + 932. { + 933. int i; + 934. > unsigned int val = 0, rate, stream; + 935. + 936. val = query_pcm_param(codec, nid); + +drivers/gpu/drm/i915/intel_lvds.c:941: error: DEAD_STORE + The value written to &fixed_mode is never used. + 939. struct drm_encoder *encoder; + 940. struct drm_display_mode *scan; /* *modes, *bios_mode; */ + 941. > struct drm_display_mode *fixed_mode = NULL; + 942. struct drm_display_mode *downclock_mode = NULL; + 943. struct edid *edid; + +kernel/time/posix-timers.c:937: error: DEAD_STORE + The value written to &error is never used. + 935. struct itimerspec64 new_spec, old_spec; + 936. struct itimerspec64 *rtn = old ? &old_spec : NULL; + 937. > int error = 0; + 938. + 939. if (!new) + +drivers/gpu/drm/drm_mm.c:938: error: DEAD_STORE + The value written to &total is never used. + 936. { + 937. const struct drm_mm_node *entry; + 938. > u64 total_used = 0, total_free = 0, total = 0; + 939. + 940. total_free += drm_mm_dump_hole(p, &mm->head_node); + +drivers/usb/host/ohci-q.c:938: error: DEAD_STORE + The value written to &td is never used. + 936. { + 937. u32 td_dma; + 938. > struct td *td = NULL; + 939. + 940. td_dma = hc32_to_cpup (ohci, &ohci->hcca->done_head); + +drivers/iommu/dmar.c:938: error: DEAD_STORE + The value written to &err is never used. + 936. static int map_iommu(struct intel_iommu *iommu, u64 phys_addr) + 937. { + 938. > int map_size, err=0; + 939. + 940. iommu->reg_phys = phys_addr; + +drivers/gpu/drm/i915/intel_dpio_phy.c:943: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 940 could be null and is dereferenced at line 943, column 6. + 941. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 942. + 943. > if (dport->release_cl2_override) { + 944. chv_phy_powergate_ch(dev_priv, DPIO_PHY0, DPIO_CH1, false); + 945. dport->release_cl2_override = false; + +drivers/net/ethernet/broadcom/tg3.c:955: error: DEAD_STORE + The value written to &apedata is never used. + 953. APE_HOST_SEG_LEN_MAGIC); + 954. apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT); + 955. > tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata); + 956. tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID, + 957. APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM)); + +net/netfilter/nf_conntrack_netlink.c:944: error: DEAD_STORE + The value written to &ret is never used. + 942. const struct nf_conntrack_l4proto *l4proto; + 943. struct nlattr *tb[CTA_PROTO_MAX+1]; + 944. > int ret = 0; + 945. + 946. ret = nla_parse_nested(tb, CTA_PROTO_MAX, attr, proto_nla_policy, + +drivers/rtc/interface.c:943: error: DEAD_STORE + The value written to &ret is never used. + 941. ktime_t expires, ktime_t period) + 942. { + 943. > int ret = 0; + 944. mutex_lock(&rtc->ops_lock); + 945. if (timer->enabled) + +drivers/thermal/thermal_core.c:947: error: DEAD_STORE + The value written to &pos is never used. + 945. { + 946. struct thermal_cooling_device *cdev; + 947. > struct thermal_zone_device *pos = NULL; + 948. int result; + 949. + +drivers/net/ethernet/realtek/8139too.c:945: error: DEAD_STORE + The value written to &dev is never used. + 943. const struct pci_device_id *ent) + 944. { + 945. > struct net_device *dev = NULL; + 946. struct rtl8139_private *tp; + 947. int i, addr_len, option; + +net/ipv4/devinet.c:958: error: DEAD_STORE + The value written to &ret is never used. + 956. struct net_device *dev; + 957. char *colon; + 958. > int ret = -EFAULT; + 959. int tryaddrmatch = 0; + 960. + +drivers/usb/core/driver.c:953: error: DEAD_STORE + The value written to &retval is never used. + 951. const char *mod_name) + 952. { + 953. > int retval = 0; + 954. + 955. if (usb_disabled()) + +kernel/time/timer.c:956: error: DEAD_STORE + The value written to &ret is never used. + 954. unsigned int idx = UINT_MAX; + 955. unsigned long clk = 0, flags; + 956. > int ret = 0; + 957. + 958. BUG_ON(!timer->function); + +drivers/usb/core/hub.c:959: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 958 could be null and is dereferenced at line 959, column 9. + 957. return -EINVAL; + 958. hub = usb_hub_to_struct_hub(udev->parent); + 959. > intf = to_usb_interface(hub->intfdev); + 960. + 961. usb_autopm_get_interface(intf); + +net/wireless/trace.h:956: error: DEAD_STORE + The value written to &p is never used. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/ipv4/netfilter/ip_tables.c:984: error: DEAD_STORE + The value written to &ret is never used. + 982. + 983. if (compat) { + 984. > ret = compat_table_info(private, &tmp); + 985. xt_compat_flush_offsets(AF_INET); + 986. private = &tmp; + +drivers/gpu/drm/i915/intel_opregion.c:965: error: DEAD_STORE + The value written to &err is never used. + 963. u32 asls, mboxes; + 964. char buf[sizeof(OPREGION_SIGNATURE)]; + 965. > int err = 0; + 966. void *base; + 967. const void *vbt; + +net/unix/af_unix.c:964: error: DEAD_STORE + The value written to &err is never used. + 962. struct dentry *dentry; + 963. struct path path; + 964. > int err = 0; + 965. /* + 966. * Get the parent directory, calculate the hash for last + +block/bsg.c:967: error: DEAD_STORE + The value written to &class_dev is never used. + 965. dev_t dev; + 966. int ret; + 967. > struct device *class_dev = NULL; + 968. const char *devname; + 969. + +net/ipv6/udp.c:973: error: DEAD_STORE + The value written to &csum is never used. + 971. struct udphdr *uh = udp_hdr(skb); + 972. struct sk_buff *frags = skb_shinfo(skb)->frag_list; + 973. > __wsum csum = 0; + 974. + 975. if (!frags) { + +drivers/hid/usbhid/hid-core.c:974: error: DEAD_STORE + The value written to &quirks is never used. + 972. struct usb_device *dev = interface_to_usbdev (intf); + 973. struct hid_descriptor *hdesc; + 974. > u32 quirks = 0; + 975. unsigned int rsize = 0; + 976. char *rdesc; + +net/core/skbuff.c:1000: error: DEAD_STORE + The value written to &next is never used. + 998. uarg->len++; + 999. uarg->bytelen = bytelen; + 1000. > atomic_set(&sk->sk_zckey, ++next); + 1001. sock_zerocopy_get(uarg); + 1002. return uarg; + +net/wireless/trace.h:973: error: DEAD_STORE + The value written to &p is never used. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &size is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &skip is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +net/ipv6/netfilter/ip6_tables.c:1001: error: DEAD_STORE + The value written to &ret is never used. + 999. + 1000. if (compat) { + 1001. > ret = compat_table_info(private, &tmp); + 1002. xt_compat_flush_offsets(AF_INET6); + 1003. private = &tmp; + +drivers/gpu/drm/i915/intel_dpio_phy.c:990: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 989 could be null and is dereferenced by call to `vlv_dport_to_channel()` at line 990, column 27. + 988. struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc); + 989. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 990. > enum dpio_channel port = vlv_dport_to_channel(dport); + 991. enum pipe pipe = intel_crtc->pipe; + 992. + +drivers/md/md-bitmap.c:989: error: DEAD_STORE + The value written to &set is never used. + 987. void *paddr; + 988. unsigned long chunk = block >> bitmap->counts.chunkshift; + 989. > int set = 0; + 990. + 991. page = filemap_get_page(&bitmap->storage, chunk); + +drivers/md/dm.c:996: error: DEAD_STORE + The value written to &offset is never used. + 994. offset = dm_target_offset(ti, sector); + 995. if (unlikely(ti->max_io_len & (ti->max_io_len - 1))) + 996. > max_len = sector_div(offset, ti->max_io_len); + 997. else + 998. max_len = offset & (ti->max_io_len - 1); + +net/sunrpc/svcsock.c:991: error: DEAD_STORE + The value written to &req is never used. + 989. { + 990. struct rpc_xprt *bc_xprt = svsk->sk_xprt.xpt_bc_xprt; + 991. > struct rpc_rqst *req = NULL; + 992. struct kvec *src, *dst; + 993. __be32 *p = (__be32 *)rqstp->rq_arg.head[0].iov_base; + +kernel/relay.c:996: error: DEAD_STORE + The value written to &consumed is never used. + 994. size_t n_subbufs = buf->chan->n_subbufs; + 995. size_t produced = buf->subbufs_produced; + 996. > size_t consumed = buf->subbufs_consumed; + 997. + 998. relay_file_read_consume(buf, read_pos, 0); + +net/netfilter/nf_conntrack_core.c:995: error: DEAD_STORE + The value written to &nf_conntrack_max95 is never used. + 993. unsigned int min_interval = max(HZ / GC_MAX_BUCKETS_DIV, 1u); + 994. unsigned int i, goal, buckets = 0, expired_count = 0; + 995. > unsigned int nf_conntrack_max95 = 0; + 996. struct conntrack_gc_work *gc_work; + 997. unsigned int ratio, scanned = 0; + +net/netfilter/nf_conntrack_core.c:1005: error: DEAD_STORE + The value written to &nf_conntrack_max95 is never used. + 1003. i = gc_work->last_bucket; + 1004. if (gc_work->early_drop) + 1005. > nf_conntrack_max95 = nf_conntrack_max / 100u * 95u; + 1006. + 1007. do { + +drivers/cpufreq/cpufreq.c:995: error: DEAD_STORE + The value written to &ret is never used. + 993. { + 994. struct freq_attr **drv_attr; + 995. > int ret = 0; + 996. + 997. /* set up files for this cpu device */ + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &size is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &skip is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +net/wireless/trace.h:993: error: DEAD_STORE + The value written to &p is never used. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/ipv6/addrconf.c:1010: error: DEAD_STORE + The value written to &err is never used. + 1008. struct inet6_ifaddr *ifa = NULL; + 1009. struct rt6_info *rt = NULL; + 1010. > int err = 0; + 1011. int addr_type = ipv6_addr_type(addr); + 1012. + +security/selinux/avc.c:1022: error: DEAD_STORE + The value written to &node is never used. + 1020. node = avc_lookup(ssid, tsid, tclass); + 1021. if (unlikely(!node)) { + 1022. > node = avc_compute_av(ssid, tsid, tclass, &avd, xp_node); + 1023. } else { + 1024. memcpy(&avd, &node->ae.avd, sizeof(avd)); + +drivers/ata/ata_piix.c:1009: error: DEAD_STORE + The value written to &rc is never used. + 1007. struct ata_host *host = pci_get_drvdata(pdev); + 1008. unsigned long flags; + 1009. > int rc = 0; + 1010. + 1011. rc = ata_host_suspend(host, mesg); + +drivers/pci/setup-bus.c:1018: error: DEAD_STORE + The value written to &children_add_align is never used. + 1016. mask | IORESOURCE_PREFETCH, type); + 1017. resource_size_t children_add_size = 0; + 1018. > resource_size_t children_add_align = 0; + 1019. resource_size_t add_align = 0; + 1020. + +drivers/pci/pci.c:1028: error: DEAD_STORE + The value written to &i is never used. + 1026. pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]); + 1027. pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]); + 1028. > pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]); + 1029. + 1030. return 0; + +net/ipv6/udp.c:1013: error: DEAD_STORE + The value written to &csum is never used. + 1011. int err = 0; + 1012. int is_udplite = IS_UDPLITE(sk); + 1013. > __wsum csum = 0; + 1014. int offset = skb_transport_offset(skb); + 1015. int len = skb->len - offset; + +net/ipv6/udp.c:1011: error: DEAD_STORE + The value written to &err is never used. + 1009. struct sock *sk = skb->sk; + 1010. struct udphdr *uh; + 1011. > int err = 0; + 1012. int is_udplite = IS_UDPLITE(sk); + 1013. __wsum csum = 0; + +drivers/usb/host/ehci-q.c:1017: error: DEAD_STORE + The value written to &qh is never used. + 1015. ) + 1016. { + 1017. > struct ehci_qh *qh = NULL; + 1018. __hc32 qh_addr_mask = cpu_to_hc32(ehci, 0x7f); + 1019. + +net/wireless/trace.h:1012: error: DEAD_STORE + The value written to &p is never used. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +block/elevator.c:1016: error: DEAD_STORE + The value written to &old_registered is never used. + 1014. { + 1015. struct elevator_queue *old = q->elevator; + 1016. > bool old_registered = false; + 1017. int err; + 1018. + +sound/core/pcm_native.c:1022: error: DEAD_STORE + The value written to &s is never used. + 1020. int state, int do_lock) + 1021. { + 1022. > struct snd_pcm_substream *s = NULL; + 1023. struct snd_pcm_substream *s1; + 1024. int res = 0, depth = 1; + +drivers/iommu/dmar.c:1023: error: DEAD_STORE + The value written to &agaw is never used. + 1021. struct intel_iommu *iommu; + 1022. u32 ver, sts; + 1023. > int agaw = 0; + 1024. int msagaw = 0; + 1025. int err; + +drivers/iommu/dmar.c:1024: error: DEAD_STORE + The value written to &msagaw is never used. + 1022. u32 ver, sts; + 1023. int agaw = 0; + 1024. > int msagaw = 0; + 1025. int err; + 1026. + +drivers/gpu/drm/i915/intel_display.c:1022: error: DEAD_STORE + The value written to &dev_priv is never used. + 1020. static void wait_for_pipe_scanline_moving(struct intel_crtc *crtc, bool state) + 1021. { + 1022. > struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 1023. enum pipe pipe = crtc->pipe; + 1024. + +drivers/gpu/drm/i915/intel_display.c:1026: error: DEAD_STORE + The value written to &timeout__ is never used. + 1024. + 1025. /* Wait for the display line to settle/start moving */ + 1026. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1027. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1028. pipe_name(pipe), onoff(state)); + +drivers/gpu/drm/i915/intel_display.c:1026: error: DEAD_STORE + The value written to &wait__ is never used. + 1024. + 1025. /* Wait for the display line to settle/start moving */ + 1026. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1027. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1028. pipe_name(pipe), onoff(state)); + +arch/x86/events/intel/ds.c:1027: error: DEAD_STORE + The value written to &is_64bit is never used. + 1025. unsigned long old_to, to = cpuc->lbr_entries[0].to; + 1026. unsigned long ip = regs->ip; + 1027. > int is_64bit = 0; + 1028. void *kaddr; + 1029. int size; + +net/ipv4/ping.c:1027: error: DEAD_STORE + The value written to &net is never used. + 1025. struct sock *sk; + 1026. struct ping_iter_state *state = seq->private; + 1027. > struct net *net = seq_file_net(seq); + 1028. + 1029. for (state->bucket = start; state->bucket < PING_HTABLE_SIZE; + +drivers/nvmem/core.c:1045: error: DEAD_STORE + The value written to &rc is never used. + 1043. + 1044. /* setup the first byte with lsb bits from nvmem */ + 1045. > rc = nvmem_reg_read(nvmem, cell->offset, &v, 1); + 1046. *b++ |= GENMASK(bit_offset - 1, 0) & v; + 1047. + +drivers/nvmem/core.c:1062: error: DEAD_STORE + The value written to &rc is never used. + 1060. if ((nbits + bit_offset) % BITS_PER_BYTE) { + 1061. /* setup the last byte with msb bits from nvmem */ + 1062. > rc = nvmem_reg_read(nvmem, + 1063. cell->offset + cell->bytes - 1, &v, 1); + 1064. *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v; + +lib/vsprintf.c:1078: error: DEAD_STORE + The value written to &needcolon is never used. + 1076. if (needcolon) { + 1077. *p++ = ':'; + 1078. > needcolon = false; + 1079. } + 1080. /* hex u16 without leading 0s */ + +include/linux/rhashtable.h:1065: error: DEAD_STORE + The value written to &list is never used. + 1063. continue; + 1064. + 1065. > list = rht_dereference_bucket(list->next, tbl, hash); + 1066. RCU_INIT_POINTER(*lpprev, list); + 1067. err = 0; + +net/netfilter/x_tables.c:1029: error: DEAD_STORE + The value written to &info is never used. + 1027. struct xt_table_info *xt_alloc_table_info(unsigned int size) + 1028. { + 1029. > struct xt_table_info *info = NULL; + 1030. size_t sz = sizeof(*info) + size; + 1031. + +drivers/gpu/drm/i915/intel_uncore.c:1028: error: DEAD_STORE + The value written to &val is never used. + 1026. } + 1027. + 1028. > __gen5_read(8) + 1029. __gen5_read(16) + 1030. __gen5_read(32) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1067: error: DEAD_STORE + The value written to &ret_val is never used. + 1065. if ((hw->mac_type == e1000_82545_rev_3) || + 1066. (hw->mac_type == e1000_82546_rev_3)) { + 1067. > ret_val = + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1070: error: DEAD_STORE + The value written to &ret_val is never used. + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + 1070. > ret_val = + 1071. e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); + 1072. } + +drivers/cpufreq/cpufreq.c:1031: error: DEAD_STORE + The value written to &gov is never used. + 1029. static int cpufreq_init_policy(struct cpufreq_policy *policy) + 1030. { + 1031. > struct cpufreq_governor *gov = NULL; + 1032. struct cpufreq_policy new_policy; + 1033. + +drivers/gpu/drm/i915/intel_uncore.c:1029: error: DEAD_STORE + The value written to &val is never used. + 1027. + 1028. __gen5_read(8) + 1029. > __gen5_read(16) + 1030. __gen5_read(32) + 1031. __gen5_read(64) + +drivers/gpu/drm/i915/intel_uncore.c:1030: error: DEAD_STORE + The value written to &val is never used. + 1028. __gen5_read(8) + 1029. __gen5_read(16) + 1030. > __gen5_read(32) + 1031. __gen5_read(64) + 1032. __gen2_read(8) + +drivers/gpu/drm/i915/intel_uncore.c:1031: error: DEAD_STORE + The value written to &val is never used. + 1029. __gen5_read(16) + 1030. __gen5_read(32) + 1031. > __gen5_read(64) + 1032. __gen2_read(8) + 1033. __gen2_read(16) + +drivers/gpu/drm/i915/intel_uncore.c:1032: error: DEAD_STORE + The value written to &val is never used. + 1030. __gen5_read(32) + 1031. __gen5_read(64) + 1032. > __gen2_read(8) + 1033. __gen2_read(16) + 1034. __gen2_read(32) + +drivers/gpu/drm/i915/intel_uncore.c:1033: error: DEAD_STORE + The value written to &val is never used. + 1031. __gen5_read(64) + 1032. __gen2_read(8) + 1033. > __gen2_read(16) + 1034. __gen2_read(32) + 1035. __gen2_read(64) + +drivers/pci/pci.c:1050: error: DEAD_STORE + The value written to &i is never used. + 1048. pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]); + 1049. pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]); + 1050. > pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]); + 1051. } + 1052. + +drivers/video/fbdev/core/fbcon.c:1074: error: DEAD_STORE + The value written to &font is never used. + 1072. REFCOUNT(p->fontdata)++; + 1073. } else { + 1074. > const struct font_desc *font = NULL; + 1075. + 1076. if (!fontname[0] || !(font = find_font(fontname))) + +drivers/gpu/drm/i915/intel_uncore.c:1034: error: DEAD_STORE + The value written to &val is never used. + 1032. __gen2_read(8) + 1033. __gen2_read(16) + 1034. > __gen2_read(32) + 1035. __gen2_read(64) + 1036. + +drivers/gpu/drm/i915/intel_uncore.c:1035: error: DEAD_STORE + The value written to &val is never used. + 1033. __gen2_read(16) + 1034. __gen2_read(32) + 1035. > __gen2_read(64) + 1036. + 1037. #undef __gen5_read + +drivers/gpu/drm/i915/intel_dpio_phy.c:1050: error: DEAD_STORE + The value written to &val is never used. + 1048. + 1049. /* Enable clock channels for this port */ + 1050. > val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(port)); + 1051. val = 0; + 1052. if (pipe) + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1040 could be null and is dereferenced at line 1043, column 17. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 1039 could be null and is dereferenced at line 1043, column 2. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +net/ipv6/tcp_ipv6.c:1072: error: DEAD_STORE + The value written to &newinet is never used. + 1070. inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; + 1071. + 1072. > newinet = inet_sk(newsk); + 1073. newnp = inet6_sk(newsk); + 1074. newtp = tcp_sk(newsk); + +net/sched/act_api.c:1045: error: DEAD_STORE + The value written to &err is never used. + 1043. { + 1044. struct sk_buff *skb; + 1045. > int err = 0; + 1046. + 1047. skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); + +drivers/iommu/intel-iommu.c:1046: error: DEAD_STORE + The value written to &pte is never used. + 1044. int level, int *large_page) + 1045. { + 1046. > struct dma_pte *parent, *pte = NULL; + 1047. int total = agaw_to_level(domain->agaw); + 1048. int offset; + +kernel/cpu.c:1044: error: DEAD_STORE + The value written to &err is never used. + 1042. static int do_cpu_up(unsigned int cpu, enum cpuhp_state target) + 1043. { + 1044. > int err = 0; + 1045. + 1046. if (!cpu_possible(cpu)) { + +net/wireless/trace.h:1042: error: DEAD_STORE + The value written to &p is never used. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/ipv6/route.c:1061: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1060 could be null and is dereferenced by call to `dev_net()` at line 1061, column 23. + 1059. rcu_read_lock(); + 1060. dev = ip6_rt_get_dev_rcu(ort); + 1061. > rt = __ip6_dst_alloc(dev_net(dev), dev, 0); + 1062. rcu_read_unlock(); + 1063. if (!rt) + +kernel/events/core.c:1055: error: DEAD_STORE + The value written to &rotations is never used. + 1053. { + 1054. struct perf_cpu_context *cpuctx; + 1055. > int rotations = 0; + 1056. + 1057. lockdep_assert_irqs_disabled(); + +kernel/cgroup/cgroup-v1.c:1056: error: DEAD_STORE + The value written to &ret is never used. + 1054. static int cgroup1_remount(struct kernfs_root *kf_root, int *flags, char *data) + 1055. { + 1056. > int ret = 0; + 1057. struct cgroup_root *root = cgroup_root_from_kf(kf_root); + 1058. struct cgroup_sb_opts opts; + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &maxsize is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &skip is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +net/sched/act_api.c:1067: error: DEAD_STORE + The value written to &ret is never used. + 1065. struct nlmsghdr *n, u32 portid, int ovr) + 1066. { + 1067. > int ret = 0; + 1068. LIST_HEAD(actions); + 1069. + +drivers/thermal/thermal_core.c:1070: error: DEAD_STORE + The value written to &pos is never used. + 1068. const struct thermal_zone_params *tzp; + 1069. struct thermal_zone_device *tz; + 1070. > struct thermal_cooling_device *pos = NULL; + 1071. + 1072. if (!cdev) + +net/xfrm/xfrm_state.c:1074: error: DEAD_STORE + The value written to &x is never used. + 1072. { + 1073. unsigned int h; + 1074. > struct xfrm_state *rx = NULL, *x = NULL; + 1075. + 1076. spin_lock_bh(&net->xfrm.xfrm_state_lock); + +net/wireless/trace.h:1069: error: DEAD_STORE + The value written to &p is never used. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +drivers/gpu/drm/drm_dp_mst_topology.c:1079: error: DEAD_STORE + The value written to &ret is never used. + 1077. case DP_PEER_DEVICE_SST_SINK: + 1078. /* add i2c over sideband */ + 1079. > ret = drm_dp_mst_register_i2c_bus(&port->aux); + 1080. break; + 1081. case DP_PEER_DEVICE_MST_BRANCHING: + +drivers/md/dm-raid1.c:1142: error: DEAD_STORE + The value written to &argv is never used. + 1140. goto err_destroy_wq; + 1141. + 1142. > argv += args_used; + 1143. argc -= args_used; + 1144. + +kernel/power/snapshot.c:1073: error: DEAD_STORE + The value written to &error is never used. + 1071. { + 1072. struct memory_bitmap *bm1, *bm2; + 1073. > int error = 0; + 1074. + 1075. if (forbidden_pages_map && free_pages_map) + +drivers/video/console/vgacon.c:1075: error: DEAD_STORE + The value written to &font_select is never used. + 1073. { + 1074. unsigned short video_port_status = vga_video_port_reg + 6; + 1075. > int font_select = 0x00, beg, i; + 1076. char *charmap; + 1077. bool clear_attribs = false; + +net/sunrpc/svc.c:1083: error: DEAD_STORE + The value written to &error is never used. + 1081. */ + 1082. if (error == -EPROTONOSUPPORT) + 1083. > error = rpcb_register(net, program, version, 0, 0); + 1084. + 1085. dprintk("svc: %s(%sv%u), error %d\n", + +drivers/iommu/intel-iommu.c:1078: error: DEAD_STORE + The value written to &large_page is never used. + 1076. unsigned long last_pfn) + 1077. { + 1078. > unsigned int large_page = 1; + 1079. struct dma_pte *first_pte, *pte; + 1080. + +drivers/pci/pci.c:1087: error: DEAD_STORE + The value written to &i is never used. + 1085. cap = (u16 *)&save_state->cap.data[0]; + 1086. + 1087. > pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]); + 1088. } + 1089. + +drivers/gpu/drm/i915/intel_dsi.c:1152: error: DEAD_STORE + The value written to &vbp is never used. + 1150. vfp = I915_READ(MIPI_VFP_COUNT(port)); + 1151. vsync = I915_READ(MIPI_VSYNC_PADDING_COUNT(port)); + 1152. > vbp = I915_READ(MIPI_VBP_COUNT(port)); + 1153. + 1154. adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp; + +block/elevator.c:1091: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `elevator_switch()` at line 1091, column 10. + 1089. */ + 1090. if (q->mq_ops && !strncmp(name, "none", 4)) + 1091. > return elevator_switch(q, NULL); + 1092. + 1093. strlcpy(elevator_name, name, sizeof(elevator_name)); + +kernel/irq/irqdomain.c:1090: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1089 could be null and is dereferenced at line 1090, column 9. + 1088. for (i = 0; i < nr_irqs; i++) { + 1089. irq_data = irq_get_irq_data(virq + i); + 1090. > tmp = irq_data->parent_data; + 1091. irq_data->parent_data = NULL; + 1092. irq_data->domain = NULL; + +net/sched/act_api.c:1090: error: DEAD_STORE + The value written to &ret is never used. + 1088. struct nlattr *tca[TCA_ROOT_MAX + 1]; + 1089. u32 portid = skb ? NETLINK_CB(skb).portid : 0; + 1090. > int ret = 0, ovr = 0; + 1091. + 1092. if ((n->nlmsg_type != RTM_GETACTION) && + +drivers/firmware/efi/vars.c:1089: error: DEAD_STORE + The value written to &err is never used. + 1087. struct list_head *head, void *data) + 1088. { + 1089. > int err = 0; + 1090. + 1091. err = efivar_entry_iter_begin(); + +net/netfilter/nf_conntrack_sip.c:1099: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1094 could be null and is dereferenced at line 1099, column 11. + 1097. (code >= 200 && code <= 299)) + 1098. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1099. > else if (ct_sip_info->invite_cseq == cseq) + 1100. flush_expectations(ct, true); + 1101. return NF_ACCEPT; + +net/wireless/trace.h:1087: error: DEAD_STORE + The value written to &p is never used. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/ipv6/route.c:1095: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1094 could be null and is dereferenced by call to `dev_net()` at line 1095, column 28. + 1093. rcu_read_lock(); + 1094. dev = ip6_rt_get_dev_rcu(rt); + 1095. > pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags); + 1096. rcu_read_unlock(); + 1097. if (!pcpu_rt) + +crypto/gcm.c:1098: error: DEAD_STORE + The value written to &err is never used. + 1096. struct crypto_skcipher *null; + 1097. unsigned long align; + 1098. > int err = 0; + 1099. + 1100. aead = crypto_spawn_aead(spawn); + +drivers/video/fbdev/core/fbmem.c:1100: error: DEAD_STORE + The value written to &ret is never used. + 1098. struct fb_event event; + 1099. void __user *argp = (void __user *)arg; + 1100. > long ret = 0; + 1101. + 1102. switch (cmd) { + +drivers/pcmcia/rsrc_nonstatic.c:1099: error: DEAD_STORE + The value written to &ret is never used. + 1097. unsigned long start_addr, end_addr; + 1098. unsigned int add = ADD_MANAGED_RESOURCE; + 1099. > ssize_t ret = 0; + 1100. + 1101. ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); + +drivers/gpu/drm/drm_dp_mst_topology.c:1102: error: DEAD_STORE + The value written to &ret is never used. + 1100. if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) { + 1101. if (mstb->port_parent) { + 1102. > ret = drm_dp_send_dpcd_write( + 1103. mstb->mgr, + 1104. mstb->port_parent, + +drivers/gpu/drm/drm_dp_mst_topology.c:1110: error: DEAD_STORE + The value written to &ret is never used. + 1108. } else { + 1109. + 1110. > ret = drm_dp_dpcd_write( + 1111. mstb->mgr->aux, + 1112. DP_GUID, + +security/selinux/avc.c:1110: error: DEAD_STORE + The value written to &node is never used. + 1108. node = avc_lookup(ssid, tsid, tclass); + 1109. if (unlikely(!node)) + 1110. > node = avc_compute_av(ssid, tsid, tclass, avd, &xp_node); + 1111. else + 1112. memcpy(avd, &node->ae.avd, sizeof(*avd)); + +security/selinux/ss/services.c:1101: error: DEAD_STORE + The value written to &scontext is never used. + 1099. { + 1100. u16 tclass; + 1101. > struct context *scontext = NULL, *tcontext = NULL; + 1102. + 1103. read_lock(&policy_rwlock); + +security/selinux/ss/services.c:1101: error: DEAD_STORE + The value written to &tcontext is never used. + 1099. { + 1100. u16 tclass; + 1101. > struct context *scontext = NULL, *tcontext = NULL; + 1102. + 1103. read_lock(&policy_rwlock); + +net/wireless/reg.c:1097: error: DEAD_STORE + The value written to ®_rule is never used. + 1095. static bool is_valid_rd(const struct ieee80211_regdomain *rd) + 1096. { + 1097. > const struct ieee80211_reg_rule *reg_rule = NULL; + 1098. unsigned int i; + 1099. + +drivers/input/mouse/alps.c:1113: error: DEAD_STORE + The value written to &z is never used. + 1111. y = (packet[3] & 0x07) | (packet[4] & 0xb8) | + 1112. ((packet[3] & 0x20) << 1); + 1113. > z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1); + 1114. + 1115. left = (packet[1] & 0x01); + +net/packet/af_packet.c:1102: error: DEAD_STORE + The value written to &curr is never used. + 1100. int status, unsigned int len) + 1101. { + 1102. > char *curr = NULL; + 1103. switch (po->tp_version) { + 1104. case TPACKET_V1: + +drivers/gpu/drm/i915/intel_ddi.c:1102: error: DEAD_STORE + The value written to &refclk is never used. + 1100. i915_reg_t reg) + 1101. { + 1102. > int refclk = LC_FREQ; + 1103. int n, p, r; + 1104. u32 wrpll; + +drivers/gpu/drm/i915/intel_uncore.c:1099: error: DEAD_STORE + The value written to &val is never used. + 1097. #define __fwtable_read(x) __gen_read(fwtable, x) + 1098. + 1099. > __fwtable_read(8) + 1100. __fwtable_read(16) + 1101. __fwtable_read(32) + +drivers/gpu/drm/i915/intel_uncore.c:1100: error: DEAD_STORE + The value written to &val is never used. + 1098. + 1099. __fwtable_read(8) + 1100. > __fwtable_read(16) + 1101. __fwtable_read(32) + 1102. __fwtable_read(64) + +drivers/gpu/drm/i915/intel_uncore.c:1101: error: DEAD_STORE + The value written to &val is never used. + 1099. __fwtable_read(8) + 1100. __fwtable_read(16) + 1101. > __fwtable_read(32) + 1102. __fwtable_read(64) + 1103. __gen6_read(8) + +drivers/gpu/drm/i915/intel_uncore.c:1102: error: DEAD_STORE + The value written to &val is never used. + 1100. __fwtable_read(16) + 1101. __fwtable_read(32) + 1102. > __fwtable_read(64) + 1103. __gen6_read(8) + 1104. __gen6_read(16) + +kernel/irq/irqdomain.c:1112: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1111 could be null and is dereferenced at line 1112, column 3. + 1110. for (i = 0; i < nr_irqs; i++) { + 1111. irq_data = irq_get_irq_data(virq + i); + 1112. > irq_data->domain = domain; + 1113. + 1114. for (parent = domain->parent; parent; parent = parent->parent) { + +drivers/char/random.c:1113: error: DEAD_STORE + The value written to &idx is never used. + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + 1113. > ptr += idx++; + 1114. WRITE_ONCE(f->reg_idx, idx); + 1115. return *ptr; + +drivers/gpu/drm/i915/intel_uncore.c:1103: error: DEAD_STORE + The value written to &val is never used. + 1101. __fwtable_read(32) + 1102. __fwtable_read(64) + 1103. > __gen6_read(8) + 1104. __gen6_read(16) + 1105. __gen6_read(32) + +net/wireless/trace.h:1103: error: DEAD_STORE + The value written to &p is never used. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +drivers/gpu/drm/i915/intel_uncore.c:1104: error: DEAD_STORE + The value written to &val is never used. + 1102. __fwtable_read(64) + 1103. __gen6_read(8) + 1104. > __gen6_read(16) + 1105. __gen6_read(32) + 1106. __gen6_read(64) + +net/netfilter/nf_conntrack_sip.c:1116: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1111 could be null and is dereferenced at line 1116, column 11. + 1114. (code >= 200 && code <= 299)) + 1115. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1116. > else if (ct_sip_info->invite_cseq == cseq) + 1117. flush_expectations(ct, true); + 1118. return NF_ACCEPT; + +drivers/gpu/drm/i915/intel_uncore.c:1105: error: DEAD_STORE + The value written to &val is never used. + 1103. __gen6_read(8) + 1104. __gen6_read(16) + 1105. > __gen6_read(32) + 1106. __gen6_read(64) + 1107. + +kernel/signal.c:1108: error: DEAD_STORE + The value written to &from_ancestor_ns is never used. + 1106. int group) + 1107. { + 1108. > int from_ancestor_ns = 0; + 1109. + 1110. #ifdef CONFIG_PID_NS + +drivers/gpu/drm/i915/intel_uncore.c:1106: error: DEAD_STORE + The value written to &val is never used. + 1104. __gen6_read(16) + 1105. __gen6_read(32) + 1106. > __gen6_read(64) + 1107. + 1108. #undef __fwtable_read + +drivers/thermal/thermal_core.c:1115: error: DEAD_STORE + The value written to &pos is never used. + 1113. { + 1114. int i, ret; + 1115. > struct thermal_cooling_device *pos = NULL; + 1116. const struct thermal_zone_params *tzp = tz->tzp; + 1117. + +kernel/auditfilter.c:1119: error: DEAD_STORE + The value written to &err is never used. + 1117. int audit_rule_change(int type, int seq, void *data, size_t datasz) + 1118. { + 1119. > int err = 0; + 1120. struct audit_entry *entry; + 1121. + +drivers/hid/hid-lg4ff.c:1127: error: DEAD_STORE + The value written to &state is never used. + 1125. struct lg_drv_data *drv_data = hid_get_drvdata(hid); + 1126. struct lg4ff_device_entry *entry; + 1127. > int i, state = 0; + 1128. + 1129. if (!drv_data) { + +security/keys/keyctl.c:1138: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `keyctl_instantiate_key_common()` at line 1138, column 9. + 1136. } + 1137. + 1138. > return keyctl_instantiate_key_common(id, NULL, ringid); + 1139. } + 1140. + +net/netfilter/nf_conntrack_sip.c:1133: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1128 could be null and is dereferenced at line 1133, column 11. + 1131. (code >= 200 && code <= 299)) + 1132. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1133. > else if (ct_sip_info->invite_cseq == cseq) + 1134. flush_expectations(ct, true); + 1135. return NF_ACCEPT; + +drivers/iommu/amd_iommu_init.c:1129: error: DEAD_STORE + The value written to &devid is never used. + 1127. u8 *p = (u8 *)h; + 1128. u8 *end = p, flags = 0; + 1129. > u16 devid = 0, devid_start = 0, devid_to = 0; + 1130. u32 dev_i, ext_flags = 0; + 1131. bool alias = false; + +net/sunrpc/sched.c:1127: error: DEAD_STORE + The value written to &wq is never used. + 1125. static void rpciod_stop(void) + 1126. { + 1127. > struct workqueue_struct *wq = NULL; + 1128. + 1129. if (rpciod_workqueue == NULL) + +net/wireless/trace.h:1127: error: DEAD_STORE + The value written to &p is never used. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/ipv6/ip6_fib.c:1135: error: DEAD_STORE + The value written to &err is never used. + 1133. struct fib6_table *table = rt->rt6i_table; + 1134. struct fib6_node *fn, *pn = NULL; + 1135. > int err = -ENOMEM; + 1136. int allow_create = 1; + 1137. int replace_required = 0; + +net/ipv6/ip6_fib.c:1134: error: DEAD_STORE + The value written to &pn is never used. + 1132. { + 1133. struct fib6_table *table = rt->rt6i_table; + 1134. > struct fib6_node *fn, *pn = NULL; + 1135. int err = -ENOMEM; + 1136. int allow_create = 1; + +net/ipv6/ip6_fib.c:1164: error: DEAD_STORE + The value written to &pn is never used. + 1162. } + 1163. + 1164. > pn = fn; + 1165. + 1166. #ifdef CONFIG_IPV6_SUBTREES + +drivers/base/property.c:1132: error: DEAD_STORE + The value written to &attr is never used. + 1130. enum dev_dma_attr device_get_dma_attr(struct device *dev) + 1131. { + 1132. > enum dev_dma_attr attr = DEV_DMA_NOT_SUPPORTED; + 1133. + 1134. if (IS_ENABLED(CONFIG_OF) && dev->of_node) { + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &maxsize is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &skip is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_tv.c:1194: error: DEAD_STORE + The value written to &type is never used. + 1192. intel_wait_for_vblank(dev_priv, intel_crtc->pipe); + 1193. + 1194. > type = -1; + 1195. tv_dac = I915_READ(TV_DAC); + 1196. DRM_DEBUG_KMS("TV detected: %x, %x\n", tv_ctl, tv_dac); + +net/netfilter/nf_conntrack_sip.c:1151: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1145 could be null and is dereferenced at line 1151, column 3. + 1149. ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1150. if (ret == NF_ACCEPT) + 1151. > ct_sip_info->invite_cseq = cseq; + 1152. return ret; + 1153. } + +security/selinux/ss/services.c:1148: error: DEAD_STORE + The value written to &scontext is never used. + 1146. struct av_decision *avd) + 1147. { + 1148. > struct context *scontext = NULL, *tcontext = NULL; + 1149. + 1150. read_lock(&policy_rwlock); + +security/selinux/ss/services.c:1148: error: DEAD_STORE + The value written to &tcontext is never used. + 1146. struct av_decision *avd) + 1147. { + 1148. > struct context *scontext = NULL, *tcontext = NULL; + 1149. + 1150. read_lock(&policy_rwlock); + +kernel/cgroup/cpuset.c:1165: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 1156 could be null and is dereferenced at line 1165, column 16. + 1163. */ + 1164. if (is_in_v2_mode() && nodes_empty(*new_mems)) + 1165. > *new_mems = parent->effective_mems; + 1166. + 1167. /* Skip the whole subtree if the nodemask remains the same. */ + +net/sunrpc/svc.c:1155: error: DEAD_STORE + The value written to &procp is never used. + 1153. struct svc_program *progp; + 1154. const struct svc_version *versp = NULL; /* compiler food */ + 1155. > const struct svc_procedure *procp = NULL; + 1156. struct svc_serv *serv = rqstp->rq_server; + 1157. __be32 *statp; + +net/sunrpc/svc.c:1163: error: DEAD_STORE + The value written to &rpc_stat is never used. + 1161. __be32 *reply_statp; + 1162. + 1163. > rpc_stat = rpc_success; + 1164. + 1165. if (argv->iov_len < 6*4) + +net/sunrpc/svc.c:1154: error: DEAD_STORE + The value written to &versp is never used. + 1152. { + 1153. struct svc_program *progp; + 1154. > const struct svc_version *versp = NULL; /* compiler food */ + 1155. const struct svc_procedure *procp = NULL; + 1156. struct svc_serv *serv = rqstp->rq_server; + +crypto/drbg.c:1153: error: DEAD_STORE + The value written to &ret is never used. + 1151. static inline int drbg_alloc_state(struct drbg_state *drbg) + 1152. { + 1153. > int ret = -ENOMEM; + 1154. unsigned int sb_size = 0; + 1155. + +crypto/drbg.c:1154: error: DEAD_STORE + The value written to &sb_size is never used. + 1152. { + 1153. int ret = -ENOMEM; + 1154. > unsigned int sb_size = 0; + 1155. + 1156. switch (drbg->core->flags & DRBG_TYPE_MASK) { + +net/ipv6/sit.c:1157: error: DEAD_STORE + The value written to &err is never used. + 1155. ipip6_tunnel_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) + 1156. { + 1157. > int err = 0; + 1158. struct ip_tunnel_parm p; + 1159. struct ip_tunnel_prl prl; + +net/wireless/trace.h:1157: error: DEAD_STORE + The value written to &p is never used. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +drivers/pcmcia/rsrc_nonstatic.c:1165: error: DEAD_STORE + The value written to &ret is never used. + 1163. unsigned long start_addr, end_addr; + 1164. unsigned int add = ADD_MANAGED_RESOURCE; + 1165. > ssize_t ret = 0; + 1166. + 1167. ret = sscanf(buf, "+ 0x%lx - 0x%lx", &start_addr, &end_addr); + +net/sunrpc/auth_gss/svcauth_gss.c:1165: error: DEAD_STORE + The value written to &gm is never used. + 1163. static atomic64_t ctxhctr; + 1164. long long ctxh; + 1165. > struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. int status = -EINVAL; + +net/sunrpc/auth_gss/svcauth_gss.c:1167: error: DEAD_STORE + The value written to &status is never used. + 1165. struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. > int status = -EINVAL; + 1168. + 1169. memset(&rsci, 0, sizeof(rsci)); + +net/sunrpc/auth_gss/svcauth_gss.c:1205: error: DEAD_STORE + The value written to &status is never used. + 1203. rsci.cred.cr_gss_mech = gm; + 1204. + 1205. > status = -EINVAL; + 1206. /* mech-specific data: */ + 1207. status = gss_import_sec_context(ud->out_handle.data, + +net/sched/act_api.c:1175: error: DEAD_STORE + The value written to &act_count is never used. + 1173. struct nla_bitfield32 bf; + 1174. u32 msecs_since = 0; + 1175. > u32 act_count = 0; + 1176. + 1177. ret = nlmsg_parse(cb->nlh, sizeof(struct tcamsg), tb, TCA_ROOT_MAX, + +net/sched/act_api.c:1170: error: DEAD_STORE + The value written to &count_attr is never used. + 1168. struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1169. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1170. > struct nlattr *count_attr = NULL; + 1171. unsigned long jiffy_since = 0; + 1172. struct nlattr *kind = NULL; + +net/sched/act_api.c:1172: error: DEAD_STORE + The value written to &kind is never used. + 1170. struct nlattr *count_attr = NULL; + 1171. unsigned long jiffy_since = 0; + 1172. > struct nlattr *kind = NULL; + 1173. struct nla_bitfield32 bf; + 1174. u32 msecs_since = 0; + +net/sched/act_api.c:1167: error: DEAD_STORE + The value written to &ret is never used. + 1165. struct nlattr *nest; + 1166. struct tc_action_ops *a_o; + 1167. > int ret = 0; + 1168. struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1169. struct nlattr *tb[TCA_ROOT_MAX + 1]; + +net/sched/act_api.c:1168: error: DEAD_STORE + The value written to &t is never used. + 1166. struct tc_action_ops *a_o; + 1167. int ret = 0; + 1168. > struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1169. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1170. struct nlattr *count_attr = NULL; + +net/xfrm/xfrm_policy.c:1171: error: DEAD_STORE + The value written to &err is never used. + 1169. if (pol != NULL) { + 1170. bool match; + 1171. > int err = 0; + 1172. + 1173. if (pol->family != family) { + +drivers/tty/vt/vt_ioctl.c:1177: error: DEAD_STORE + The value written to &ret is never used. + 1175. void __user *up = (void __user *)arg; + 1176. int perm; + 1177. > int ret = 0; + 1178. + 1179. console = vc->vc_num; + +net/core/dev.c:1177: error: DEAD_STORE + The value written to &err is never used. + 1175. unsigned char old_assign_type; + 1176. char oldname[IFNAMSIZ]; + 1177. > int err = 0; + 1178. int ret; + 1179. struct net *net; + +security/selinux/hooks.c:1176: error: DEAD_STORE + The value written to &rc is never used. + 1174. static int superblock_doinit(struct super_block *sb, void *data) + 1175. { + 1176. > int rc = 0; + 1177. char *options = data; + 1178. struct security_mnt_opts opts; + +net/wireless/trace.h:1178: error: DEAD_STORE + The value written to &p is never used. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +drivers/net/ethernet/broadcom/tg3.c:1213: error: DEAD_STORE + The value written to &frame_val is never used. + 1211. if ((frame_val & MI_COM_BUSY) == 0) { + 1212. udelay(5); + 1213. > frame_val = tr32(MAC_MI_COM); + 1214. break; + 1215. } + +drivers/cpufreq/cpufreq.c:1313: error: DEAD_STORE + The value written to &new_policy is never used. + 1311. __func__, cpu, ret); + 1312. /* cpufreq_policy_free() will notify based on this */ + 1313. > new_policy = false; + 1314. goto out_exit_policy; + 1315. } + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1226: error: DEAD_STORE + The value written to &batch is never used. + 1224. *batch++ = lower_32_bits(addr); + 1225. *batch++ = upper_32_bits(addr); + 1226. > *batch++ = upper_32_bits(target_offset); + 1227. } else { + 1228. *batch++ = (MI_STORE_DWORD_IMM_GEN4 | (1 << 21)) + 1; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1232: error: DEAD_STORE + The value written to &batch is never used. + 1230. *batch++ = upper_32_bits(addr); + 1231. *batch++ = lower_32_bits(target_offset); + 1232. > *batch++ = upper_32_bits(target_offset); + 1233. } + 1234. } else if (gen >= 6) { + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1238: error: DEAD_STORE + The value written to &batch is never used. + 1236. *batch++ = 0; + 1237. *batch++ = addr; + 1238. > *batch++ = target_offset; + 1239. } else if (gen >= 4) { + 1240. *batch++ = MI_STORE_DWORD_IMM_GEN4 | MI_USE_GGTT; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1243: error: DEAD_STORE + The value written to &batch is never used. + 1241. *batch++ = 0; + 1242. *batch++ = addr; + 1243. > *batch++ = target_offset; + 1244. } else { + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1247: error: DEAD_STORE + The value written to &batch is never used. + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + 1246. *batch++ = addr; + 1247. > *batch++ = target_offset; + 1248. } + 1249. + +arch/x86/pci/irq.c:1197: error: DEAD_STORE + The value written to &msg is never used. + 1195. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin); + 1196. if (pin && !pcibios_lookup_irq(dev, 1)) { + 1197. > char *msg = ""; + 1198. + 1199. if (!io_apic_assign_pci_irqs && dev->irq) + +kernel/relay.c:1203: error: DEAD_STORE + The value written to &pos is never used. + 1201. uint64_t pos = (uint64_t) *ppos; + 1202. uint32_t alloc_size = (uint32_t) rbuf->chan->alloc_size; + 1203. > size_t read_start = (size_t) do_div(pos, alloc_size); + 1204. size_t read_subbuf = read_start / subbuf_size; + 1205. size_t padding = rbuf->padding[read_subbuf]; + +drivers/gpu/drm/i915/intel_lrc.c:1197: error: DEAD_STORE + The value written to &ce is never used. + 1195. { + 1196. struct intel_engine_cs *engine = request->engine; + 1197. > struct intel_context *ce = &request->ctx->engine[engine->id]; + 1198. int ret; + 1199. + +net/netfilter/nf_conntrack_netlink.c:1251: error: DEAD_STORE + The value written to &err is never used. + 1249. ct = nf_ct_tuplehash_to_ctrack(h); + 1250. + 1251. > err = -ENOMEM; + 1252. skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); + 1253. if (skb2 == NULL) { + +net/netfilter/nf_conntrack_netlink.c:1205: error: DEAD_STORE + The value written to &skb2 is never used. + 1203. struct nf_conntrack_tuple tuple; + 1204. struct nf_conn *ct; + 1205. > struct sk_buff *skb2 = NULL; + 1206. struct nfgenmsg *nfmsg = nlmsg_data(nlh); + 1207. u_int8_t u3 = nfmsg->nfgen_family; + +drivers/iommu/intel-iommu.c:1244: error: DEAD_STORE + The value written to &last_pte is never used. + 1242. if (first_pte) + 1243. domain_flush_cache(domain, first_pte, + 1244. > (void *)++last_pte - (void *)first_pte); + 1245. + 1246. return freelist; + +net/wireless/trace.h:1206: error: DEAD_STORE + The value written to &p is never used. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/ipv6/calipso.c:1216: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1212 could be null and is dereferenced at line 1216, column 6. + 1214. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1215. + 1216. > if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt) + 1217. old = req_inet->ipv6_opt->hopopt; + 1218. else + +drivers/net/phy/phy_device.c:1212: error: DEAD_STORE + The value written to &ret is never used. + 1210. { + 1211. struct phy_driver *phydrv = to_phy_driver(phydev->mdio.dev.driver); + 1212. > int ret = 0; + 1213. + 1214. mutex_lock(&phydev->lock); + +net/ipv4/tcp_ipv4.c:1222: error: DEAD_STORE + The value written to &hash_location is never used. + 1220. * o MD5 hash and its wrong. + 1221. */ + 1222. > const __u8 *hash_location = NULL; + 1223. struct tcp_md5sig_key *hash_expected; + 1224. const struct iphdr *iph = ip_hdr(skb); + +drivers/md/dm-table.c:1214: error: DEAD_STORE + The value written to &dd is never used. + 1212. { + 1213. struct list_head *devices = dm_table_get_devices(t); + 1214. > struct dm_dev_internal *dd = NULL; + 1215. struct gendisk *prev_disk = NULL, *template_disk = NULL; + 1216. unsigned i; + +net/sched/sch_api.c:1216: error: DEAD_STORE + The value written to &err is never used. + 1214. { + 1215. struct qdisc_size_table *ostab, *stab = NULL; + 1216. > int err = 0; + 1217. + 1218. if (tca[TCA_OPTIONS]) { + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &next is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &skip is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1226: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 1224. { + 1225. struct e1000_hw *hw = &adapter->hw; + 1226. > u32 ctrl_reg = 0; + 1227. u32 stat_reg = 0; + 1228. + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1241: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 1239. } + 1240. + 1241. > ctrl_reg = er32(CTRL); + 1242. + 1243. /* force 1000, set loopback */ + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1227: error: DEAD_STORE + The value written to &stat_reg is never used. + 1225. struct e1000_hw *hw = &adapter->hw; + 1226. u32 ctrl_reg = 0; + 1227. > u32 stat_reg = 0; + 1228. + 1229. hw->autoneg = false; + +net/wireless/trace.h:1224: error: DEAD_STORE + The value written to &p is never used. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +drivers/net/ethernet/intel/e1000e/netdev.c:1230: error: DEAD_STORE + The value written to &hw is never used. + 1228. struct e1000_adapter *adapter = tx_ring->adapter; + 1229. struct net_device *netdev = adapter->netdev; + 1230. > struct e1000_hw *hw = &adapter->hw; + 1231. struct e1000_tx_desc *tx_desc, *eop_desc; + 1232. struct e1000_buffer *buffer_info; + +net/ipv4/netfilter/ip_tables.c:1237: error: DEAD_STORE + The value written to &ret is never used. + 1235. compat_uint_t origsize; + 1236. const struct xt_entry_match *ematch; + 1237. > int ret = 0; + 1238. + 1239. origsize = *size; + +kernel/locking/rtmutex.c:1237: error: DEAD_STORE + The value written to &ret is never used. + 1235. struct rt_mutex_waiter waiter; + 1236. unsigned long flags; + 1237. > int ret = 0; + 1238. + 1239. rt_mutex_init_waiter(&waiter); + +drivers/scsi/scsi_transport_spi.c:1235: error: DEAD_STORE + The value written to &msg is never used. + 1233. if (cmd->flags & SCMD_TAGGED) { + 1234. *msg++ = SIMPLE_QUEUE_TAG; + 1235. > *msg++ = cmd->request->tag; + 1236. return 2; + 1237. } + +drivers/ata/libahci.c:1258: error: DEAD_STORE + The value written to &tmp is never used. + 1256. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1257. writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL); + 1258. > tmp = readl(mmio + HOST_CTL); + 1259. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1260. } + +drivers/md/dm-raid1.c:1246: error: DEAD_STORE + The value written to &bd is never used. + 1244. struct mirror_set *ms = (struct mirror_set *) ti->private; + 1245. struct mirror *m = NULL; + 1246. > struct dm_bio_details *bd = NULL; + 1247. struct dm_raid1_bio_record *bio_record = + 1248. dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record)); + +drivers/md/dm-raid1.c:1245: error: DEAD_STORE + The value written to &m is never used. + 1243. int rw = bio_data_dir(bio); + 1244. struct mirror_set *ms = (struct mirror_set *) ti->private; + 1245. > struct mirror *m = NULL; + 1246. struct dm_bio_details *bd = NULL; + 1247. struct dm_raid1_bio_record *bio_record = + +crypto/drbg.c:1247: error: DEAD_STORE + The value written to &len is never used. + 1245. struct drbg_string *addtl) + 1246. { + 1247. > int len = 0; + 1248. LIST_HEAD(addtllist); + 1249. + +drivers/hid/hid-quirks.c:1246: error: DEAD_STORE + The value written to &quirk_entry is never used. + 1244. { + 1245. unsigned long quirks = 0; + 1246. > const struct hid_device_id *quirk_entry = NULL; + 1247. + 1248. /* NCR devices must not be queried for reports */ + +drivers/hid/hid-quirks.c:1245: error: DEAD_STORE + The value written to &quirks is never used. + 1243. unsigned long hid_lookup_quirk(const struct hid_device *hdev) + 1244. { + 1245. > unsigned long quirks = 0; + 1246. const struct hid_device_id *quirk_entry = NULL; + 1247. + +net/ipv6/netfilter/ip6_tables.c:1254: error: DEAD_STORE + The value written to &ret is never used. + 1252. compat_uint_t origsize; + 1253. const struct xt_entry_match *ematch; + 1254. > int ret = 0; + 1255. + 1256. origsize = *size; + +net/wireless/trace.h:1245: error: DEAD_STORE + The value written to &p is never used. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/ipv6/calipso.c:1257: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1252 could be null and is dereferenced at line 1257, column 7. + 1255. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1256. + 1257. > if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt) + 1258. return; + 1259. + +drivers/iommu/intel-iommu.c:1256: error: DEAD_STORE + The value written to &freelist is never used. + 1254. unsigned long last_pfn) + 1255. { + 1256. > struct page *freelist = NULL; + 1257. + 1258. BUG_ON(!domain_pfn_supported(domain, start_pfn)); + +security/selinux/selinuxfs.c:1257: error: DEAD_STORE + The value written to &dentry is never used. + 1255. int i, ret; + 1256. ssize_t len; + 1257. > struct dentry *dentry = NULL; + 1258. struct dentry *dir = bool_dir; + 1259. struct inode *inode = NULL; + +security/selinux/selinuxfs.c:1259: error: DEAD_STORE + The value written to &inode is never used. + 1257. struct dentry *dentry = NULL; + 1258. struct dentry *dir = bool_dir; + 1259. > struct inode *inode = NULL; + 1260. struct inode_security_struct *isec; + 1261. char **names = NULL, *page; + +drivers/md/dm-table.c:1258: error: DEAD_STORE + The value written to &template_disk is never used. + 1256. { + 1257. struct mapped_device *md = t->md; + 1258. > struct gendisk *template_disk = NULL; + 1259. + 1260. /* If target handles integrity itself do not register it here. */ + +drivers/md/dm-ioctl.c:1261: error: DEAD_STORE + The value written to &i is never used. + 1259. { + 1260. int r; + 1261. > unsigned int i = 0; + 1262. struct dm_target_spec *spec = (struct dm_target_spec *) param; + 1263. uint32_t next = param->data_start; + +drivers/gpu/drm/i915/i915_irq.c:1275: error: DEAD_STORE + The value written to &slice is never used. + 1273. char *parity_event[6]; + 1274. uint32_t misccpctl; + 1275. > uint8_t slice = 0; + 1276. + 1277. /* We must turn off DOP level clock gating to access the L3 registers. + +net/ipv4/tcp_ipv4.c:1273: error: DEAD_STORE + The value written to &net is never used. + 1271. { + 1272. struct inet_request_sock *ireq = inet_rsk(req); + 1273. > struct net *net = sock_net(sk_listener); + 1274. + 1275. sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr); + +net/netfilter/nf_conntrack_sip.c:1293: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1276 could be null and is dereferenced at line 1293, column 6. + 1291. * request and compare it here. + 1292. */ + 1293. > if (ct_sip_info->register_cseq != cseq) + 1294. return NF_ACCEPT; + 1295. + +drivers/gpu/drm/i915/intel_ddi.c:1280: error: DEAD_STORE + The value written to &link_clock is never used. + 1278. { + 1279. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 1280. > int link_clock = 0; + 1281. uint32_t cfgcr0; + 1282. enum intel_dpll_id pll_id; + +drivers/gpu/drm/i915/intel_sprite.c:1284: error: DEAD_STORE + The value written to &intel_plane is never used. + 1282. enum pipe pipe, int plane) + 1283. { + 1284. > struct intel_plane *intel_plane = NULL; + 1285. struct intel_plane_state *state = NULL; + 1286. unsigned long possible_crtcs; + +net/wireless/trace.h:1280: error: DEAD_STORE + The value written to &p is never used. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +block/bio.c:1312: error: DEAD_STORE + The value written to &ret is never used. + 1310. + 1311. if (unlikely(offs & queue_dma_alignment(q))) { + 1312. > ret = -EINVAL; + 1313. j = 0; + 1314. } else { + +drivers/dma/dmaengine.c:1287: error: DEAD_STORE + The value written to &dma_sync_wait_timeout is never used. + 1285. dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx) + 1286. { + 1287. > unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000); + 1288. + 1289. if (!tx) + +net/netfilter/nf_conntrack_netlink.c:1293: error: DEAD_STORE + The value written to &l3proto is never used. + 1291. struct hlist_nulls_node *n; + 1292. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 1293. > u_int8_t l3proto = nfmsg->nfgen_family; + 1294. int res; + 1295. int cpu; + +drivers/net/ethernet/intel/e1000e/82571.c:1292: error: DEAD_STORE + The value written to &vfta_value is never used. + 1290. { + 1291. u32 offset; + 1292. > u32 vfta_value = 0; + 1293. u32 vfta_offset = 0; + 1294. u32 vfta_bit_in_reg = 0; + +drivers/pcmcia/cistpl.c:1291: error: DEAD_STORE + The value written to &ret is never used. + 1289. int pcmcia_parse_tuple(tuple_t *tuple, cisparse_t *parse) + 1290. { + 1291. > int ret = 0; + 1292. + 1293. if (tuple->TupleDataLen > tuple->TupleDataMax) + +net/wireless/trace.h:1298: error: DEAD_STORE + The value written to &p is never used. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +drivers/thermal/thermal_core.c:1311: error: DEAD_STORE + The value written to &pos is never used. + 1309. const struct thermal_zone_params *tzp; + 1310. struct thermal_cooling_device *cdev; + 1311. > struct thermal_zone_device *pos = NULL; + 1312. + 1313. if (!tz) + +kernel/signal.c:1308: error: DEAD_STORE + The value written to &p is never used. + 1306. int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp) + 1307. { + 1308. > struct task_struct *p = NULL; + 1309. int retval, success; + 1310. + +lib/vsprintf.c:1316: error: DEAD_STORE + The value written to &fmt is never used. + 1314. bool uc = false; + 1315. + 1316. > switch (*(++fmt)) { + 1317. case 'L': + 1318. uc = true; /* fall-through */ + +drivers/usb/host/ehci-hub.c:1313: error: DEAD_STORE + The value written to &portnum is never used. + 1311. if (ehci_is_TDI(ehci)) + 1312. return; + 1313. > set_owner(ehci, --portnum, PORT_OWNER); + 1314. } + 1315. + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &size is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &skip is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +net/ipv4/ip_sockglue.c:1315: error: DEAD_STORE + The value written to &err is never used. + 1313. struct inet_sock *inet = inet_sk(sk); + 1314. bool needs_rtnl = getsockopt_needs_rtnl(optname); + 1315. > int val, err = 0; + 1316. int len; + 1317. + +net/sunrpc/auth_gss/auth_gss.c:1325: error: DEAD_STORE + The value written to &cred is never used. + 1323. { + 1324. struct gss_auth *gss_auth = container_of(auth, struct gss_auth, rpc_auth); + 1325. > struct gss_cred *cred = NULL; + 1326. int err = -ENOMEM; + 1327. + +net/wireless/trace.h:1321: error: DEAD_STORE + The value written to &p is never used. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/core/net-sysfs.c:1329: error: DEAD_STORE + The value written to &error is never used. + 1327. struct netdev_queue *queue = dev->_tx + index; + 1328. struct kobject *kobj = &queue->kobj; + 1329. > int error = 0; + 1330. + 1331. kobj->kset = dev->queues_kset; + +net/sunrpc/rpc_pipe.c:1331: error: DEAD_STORE + The value written to &pipe_dentry is never used. + 1329. struct dentry *gssd_dentry; + 1330. struct dentry *clnt_dentry = NULL; + 1331. > struct dentry *pipe_dentry = NULL; + 1332. struct qstr q = QSTR_INIT(files[RPCAUTH_gssd].name, + 1333. strlen(files[RPCAUTH_gssd].name)); + +net/sunrpc/rpc_pipe.c:1328: error: DEAD_STORE + The value written to &ret is never used. + 1326. rpc_gssd_dummy_populate(struct dentry *root, struct rpc_pipe *pipe_data) + 1327. { + 1328. > int ret = 0; + 1329. struct dentry *gssd_dentry; + 1330. struct dentry *clnt_dentry = NULL; + +security/selinux/ss/services.c:1336: error: DEAD_STORE + The value written to &rc is never used. + 1334. struct user_datum *usrdatum; + 1335. char *scontextp, *p, oldc; + 1336. > int rc = 0; + 1337. + 1338. context_init(ctx); + +kernel/kprobes.c:1329: error: DEAD_STORE + The value written to &ret is never used. + 1327. static int register_aggr_kprobe(struct kprobe *orig_p, struct kprobe *p) + 1328. { + 1329. > int ret = 0; + 1330. struct kprobe *ap = orig_p; + 1331. + +drivers/gpu/drm/i915/intel_ddi.c:1334: error: DEAD_STORE + The value written to &link_clock is never used. + 1332. { + 1333. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 1334. > int link_clock = 0; + 1335. uint32_t dpll_ctl1; + 1336. enum intel_dpll_id pll_id; + +drivers/net/ethernet/intel/e1000e/ethtool.c:1334: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 1332. { + 1333. struct e1000_hw *hw = &adapter->hw; + 1334. > u32 ctrl_reg = 0; + 1335. u16 phy_reg = 0; + 1336. s32 ret_val = 0; + +drivers/net/ethernet/intel/e1000e/ethtool.c:1336: error: DEAD_STORE + The value written to &ret_val is never used. + 1334. u32 ctrl_reg = 0; + 1335. u16 phy_reg = 0; + 1336. > s32 ret_val = 0; + 1337. + 1338. hw->mac.autoneg = 0; + +ipc/sem.c:1361: error: DEAD_STORE + The value written to &err is never used. + 1359. goto out_rcu_wakeup; + 1360. + 1361. > err = -EACCES; + 1362. switch (cmd) { + 1363. case GETALL: + +arch/x86/events/intel/p4.c:1347: error: DEAD_STORE + The value written to &high is never used. + 1345. BUILD_BUG_ON(ARCH_P4_MAX_CCCR > INTEL_PMC_MAX_GENERIC); + 1346. + 1347. > rdmsr(MSR_IA32_MISC_ENABLE, low, high); + 1348. if (!(low & (1 << 7))) { + 1349. pr_cont("unsupported Netburst CPU model %d ", + +net/wireless/trace.h:1343: error: DEAD_STORE + The value written to &p is never used. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/ipv4/tcp_input.c:1357: error: DEAD_STORE + The value written to &pcount is never used. + 1355. struct sk_buff *prev; + 1356. int mss; + 1357. > int pcount = 0; + 1358. int len; + 1359. int in_sack; + +net/ipv4/tcp_input.c:1473: error: DEAD_STORE + The value written to &pcount is never used. + 1471. len = skb->len; + 1472. if (skb_shift(prev, skb, len)) { + 1473. > pcount += tcp_skb_pcount(skb); + 1474. tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb), + 1475. len, mss, 0); + +drivers/cpufreq/intel_pstate.c:1361: error: DEAD_STORE + The value written to &pstate is never used. + 1359. + 1360. update_turbo_state(); + 1361. > pstate = intel_pstate_get_base_pstate(cpu); + 1362. pstate = max(cpu->pstate.min_pstate, cpu->max_perf_ratio); + 1363. intel_pstate_set_pstate(cpu, pstate); + +kernel/irq/irqdomain.c:1366: error: DEAD_STORE + The value written to &rv is never used. + 1364. struct irq_data *root_irq_data = irq_get_irq_data(virq); + 1365. struct irq_desc *desc; + 1366. > int rv = 0; + 1367. + 1368. /* + +drivers/net/ethernet/intel/e100.c:1368: error: DEAD_STORE + The value written to &err is never used. + 1366. { + 1367. const struct firmware *fw; + 1368. > int err = 0, counter = 50; + 1369. struct cb *cb = nic->cb_to_clean; + 1370. + +drivers/rtc/rtc-cmos.c:1368: error: DEAD_STORE + The value written to &retval is never used. + 1366. static int __init cmos_init(void) + 1367. { + 1368. > int retval = 0; + 1369. + 1370. #ifdef CONFIG_PNP + +net/wireless/trace.h:1366: error: DEAD_STORE + The value written to &p is never used. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +crypto/drbg.c:1378: error: DEAD_STORE + The value written to &chunk is never used. + 1376. do { + 1377. int err = 0; + 1378. > unsigned int chunk = 0; + 1379. slice = ((buflen - len) / drbg_max_request_bytes(drbg)); + 1380. chunk = slice ? drbg_max_request_bytes(drbg) : (buflen - len); + +crypto/drbg.c:1377: error: DEAD_STORE + The value written to &err is never used. + 1375. unsigned int slice = 0; + 1376. do { + 1377. > int err = 0; + 1378. unsigned int chunk = 0; + 1379. slice = ((buflen - len) / drbg_max_request_bytes(drbg)); + +crypto/drbg.c:1375: error: DEAD_STORE + The value written to &slice is never used. + 1373. { + 1374. unsigned int len = 0; + 1375. > unsigned int slice = 0; + 1376. do { + 1377. int err = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:1375: error: DEAD_STORE + The value written to &emi_val is never used. + 1373. struct e1000_mac_info *mac = &hw->mac; + 1374. s32 ret_val, tipg_reg = 0; + 1375. > u16 emi_addr, emi_val = 0; + 1376. bool link; + 1377. u16 phy_reg; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:1374: error: DEAD_STORE + The value written to &tipg_reg is never used. + 1372. { + 1373. struct e1000_mac_info *mac = &hw->mac; + 1374. > s32 ret_val, tipg_reg = 0; + 1375. u16 emi_addr, emi_val = 0; + 1376. bool link; + +drivers/thermal/thermal_core.c:1373: error: DEAD_STORE + The value written to &pos is never used. + 1371. struct thermal_zone_device *thermal_zone_get_zone_by_name(const char *name) + 1372. { + 1373. > struct thermal_zone_device *pos = NULL, *ref = ERR_PTR(-EINVAL); + 1374. unsigned int found = 0; + 1375. + +drivers/pcmcia/cistpl.c:1381: error: DEAD_STORE + The value written to &count is never used. + 1379. tuple_t *tuple; + 1380. cisparse_t *p; + 1381. > unsigned int count = 0; + 1382. int ret, reserved, dev_ok = 0, ident_ok = 0; + 1383. + +drivers/gpu/drm/i915/intel_ddi.c:1383: error: DEAD_STORE + The value written to &link_clock is never used. + 1381. { + 1382. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 1383. > int link_clock = 0; + 1384. u32 val, pll; + 1385. + +drivers/gpu/drm/drm_fb_helper.c:1391: error: DEAD_STORE + The value written to &ret is never used. + 1389. struct drm_crtc *crtc; + 1390. u16 *r, *g, *b; + 1391. > int i, ret = 0; + 1392. bool replaced; + 1393. + +net/core/net-sysfs.c:1386: error: DEAD_STORE + The value written to &error is never used. + 1384. static int register_queue_kobjects(struct net_device *dev) + 1385. { + 1386. > int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0; + 1387. + 1388. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1386: error: DEAD_STORE + The value written to &real_rx is never used. + 1384. static int register_queue_kobjects(struct net_device *dev) + 1385. { + 1386. > int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0; + 1387. + 1388. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1386: error: DEAD_STORE + The value written to &real_tx is never used. + 1384. static int register_queue_kobjects(struct net_device *dev) + 1385. { + 1386. > int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0; + 1387. + 1388. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1405: error: DEAD_STORE + The value written to &txq is never used. + 1403. if (error) + 1404. goto error; + 1405. > txq = real_tx; + 1406. + 1407. return 0; + +net/wireless/trace.h:1384: error: DEAD_STORE + The value written to &p is never used. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +drivers/gpu/drm/i915/intel_overlay.c:1429: error: DEAD_STORE + The value written to &ret is never used. + 1427. if (IS_ERR(vma)) { + 1428. DRM_ERROR("failed to pin overlay register bo\n"); + 1429. > ret = PTR_ERR(vma); + 1430. goto out_free_bo; + 1431. } + +drivers/md/dm.c:1399: error: NULL_DEREFERENCE + pointer `tio` last assigned on line 1398 could be null and is dereferenced at line 1399, column 2. + 1397. + 1398. tio = alloc_tio(ci, ti, 0, GFP_NOIO); + 1399. > tio->len_ptr = len; + 1400. r = clone_bio(tio, bio, sector, *len); + 1401. if (r < 0) { + +net/wireless/reg.c:1402: error: DEAD_STORE + The value written to &bw_fits is never used. + 1400. int i; + 1401. bool band_rule_found = false; + 1402. > bool bw_fits = false; + 1403. + 1404. if (!regd) + +net/wireless/reg.c:1409: error: DEAD_STORE + The value written to &fr is never used. + 1407. for (i = 0; i < regd->n_reg_rules; i++) { + 1408. const struct ieee80211_reg_rule *rr; + 1409. > const struct ieee80211_freq_range *fr = NULL; + 1410. + 1411. rr = ®d->reg_rules[i]; + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1449: error: DEAD_STORE + The value written to &l is never used. + 1447. if (!ret_val) + 1448. good_cnt++; + 1449. > if (unlikely(++l == rxdr->count)) + 1450. l = 0; + 1451. /* time + 20 msecs (200 msecs on 2.4) is more than + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1450: error: DEAD_STORE + The value written to &l is never used. + 1448. good_cnt++; + 1449. if (unlikely(++l == rxdr->count)) + 1450. > l = 0; + 1451. /* time + 20 msecs (200 msecs on 2.4) is more than + 1452. * enough time to complete the receives, if it's + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1435: error: DEAD_STORE + The value written to &time is never used. + 1433. E1000_WRITE_FLUSH(); + 1434. msleep(200); + 1435. > time = jiffies; /* set the start time for the receive */ + 1436. good_cnt = 0; + 1437. do { /* receive the sent packets */ + +net/netfilter/nf_conntrack_sip.c:1423: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1405 could be null and is dereferenced at line 1423, column 3. + 1421. port != ct->tuplehash[dir].tuple.src.u.udp.port && + 1422. nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3)) + 1423. > ct_sip_info->forced_dport = port; + 1424. + 1425. for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) { + +drivers/md/dm-raid1.c:1422: error: DEAD_STORE + The value written to &sz is never used. + 1420. (unsigned long long)ms->nr_regions, buffer); + 1421. + 1422. > sz += log->type->status(log, type, result+sz, maxlen-sz); + 1423. + 1424. break; + +drivers/md/dm-raid1.c:1441: error: DEAD_STORE + The value written to &sz is never used. + 1439. DMEMIT(" handle_errors"); + 1440. if (keep_log(ms)) + 1441. > DMEMIT(" keep_log"); + 1442. } + 1443. + +drivers/gpu/drm/i915/intel_runtime_pm.c:1425: error: DEAD_STORE + The value written to &timeout__ is never used. + 1423. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1424. + 1425. > if (wait_for(COND, 100)) + 1426. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1427. state, + +drivers/gpu/drm/i915/intel_runtime_pm.c:1425: error: DEAD_STORE + The value written to &wait__ is never used. + 1423. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1424. + 1425. > if (wait_for(COND, 100)) + 1426. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1427. state, + +net/wireless/trace.h:1405: error: DEAD_STORE + The value written to &p is never used. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +drivers/net/ethernet/broadcom/tg3.c:1421: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 1420 could be null and is dereferenced at line 1421, column 10. + 1419. + 1420. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 1421. > switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) { + 1422. case PHY_ID_BCM50610: + 1423. case PHY_ID_BCM50610M: + +net/core/net-sysfs.c:1417: error: DEAD_STORE + The value written to &real_rx is never used. + 1415. static void remove_queue_kobjects(struct net_device *dev) + 1416. { + 1417. > int real_rx = 0, real_tx = 0; + 1418. + 1419. #ifdef CONFIG_SYSFS + +net/core/net-sysfs.c:1417: error: DEAD_STORE + The value written to &real_tx is never used. + 1415. static void remove_queue_kobjects(struct net_device *dev) + 1416. { + 1417. > int real_rx = 0, real_tx = 0; + 1418. + 1419. #ifdef CONFIG_SYSFS + +net/ipv6/netfilter/ip6_tables.c:1428: error: DEAD_STORE + The value written to &ret is never used. + 1426. struct ip6t_replace repl; + 1427. unsigned int size; + 1428. > int ret = 0; + 1429. + 1430. info = *pinfo; + +drivers/gpu/drm/i915/intel_tv.c:1432: error: NULL_DEREFERENCE + pointer `old_state` last assigned on line 1429 could be null and is dereferenced at line 1432, column 6. + 1430. new_crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc); + 1431. + 1432. > if (old_state->tv.mode != new_state->tv.mode || + 1433. old_state->tv.margins.left != new_state->tv.margins.left || + 1434. old_state->tv.margins.right != new_state->tv.margins.right || + +net/wireless/trace.h:1421: error: DEAD_STORE + The value written to &p is never used. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/sunrpc/auth_gss/auth_gss.c:1431: error: DEAD_STORE + The value written to &ret is never used. + 1429. struct gss_cl_ctx *ctx; + 1430. unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ); + 1431. > int ret = 0; + 1432. + 1433. rcu_read_lock(); + +net/sunrpc/auth_gss/auth_gss.c:1430: error: DEAD_STORE + The value written to &timeout is never used. + 1428. struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base); + 1429. struct gss_cl_ctx *ctx; + 1430. > unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ); + 1431. int ret = 0; + 1432. + +net/sunrpc/svcsock.c:1442: error: DEAD_STORE + The value written to &svsk is never used. + 1440. int err = 0; + 1441. struct socket *so = sockfd_lookup(fd, &err); + 1442. > struct svc_sock *svsk = NULL; + 1443. struct sockaddr_storage addr; + 1444. struct sockaddr *sin = (struct sockaddr *)&addr; + +sound/core/seq/seq_clientmgr.c:1442: error: DEAD_STORE + The value written to &receiver is never used. + 1440. struct snd_seq_port_subscribe *subs = arg; + 1441. int result = -EINVAL; + 1442. > struct snd_seq_client *receiver = NULL, *sender = NULL; + 1443. struct snd_seq_client_port *sport = NULL, *dport = NULL; + 1444. + +drivers/gpu/drm/drm_connector.c:1449: error: DEAD_STORE + The value written to &copied is never used. + 1447. int encoders_count = 0; + 1448. int ret = 0; + 1449. > int copied = 0; + 1450. int i; + 1451. struct drm_mode_modeinfo u_mode; + +drivers/gpu/drm/drm_connector.c:1448: error: DEAD_STORE + The value written to &ret is never used. + 1446. int mode_count = 0; + 1447. int encoders_count = 0; + 1448. > int ret = 0; + 1449. int copied = 0; + 1450. int i; + +kernel/cgroup/cgroup.c:1452: error: DEAD_STORE + The value written to &ssid is never used. + 1450. u16 new_ss_mask = cur_ss_mask; + 1451. + 1452. > do_each_subsys_mask(ss, ssid, cur_ss_mask) { + 1453. new_ss_mask |= ss->depends_on; + 1454. } while_each_subsys_mask(); + +net/wireless/trace.h:1441: error: DEAD_STORE + The value written to &p is never used. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +kernel/resource.c:1448: error: DEAD_STORE + The value written to &dr is never used. + 1446. resource_size_t n, const char *name) + 1447. { + 1448. > struct region_devres *dr = NULL; + 1449. struct resource *res; + 1450. + +net/ipv4/devinet.c:1466: error: DEAD_STORE + The value written to &in_dev is never used. + 1464. /* Re-enabling IP */ + 1465. if (inetdev_valid_mtu(dev->mtu)) + 1466. > in_dev = inetdev_init(dev); + 1467. } + 1468. goto out; + +drivers/gpu/drm/drm_vblank.c:1550: error: DEAD_STORE + The value written to &end is never used. + 1548. DRM_DEBUG("waiting on vblank count %llu, crtc %u\n", + 1549. req_seq, pipe); + 1550. > DRM_WAIT_ON(ret, vblank->queue, 3 * HZ, + 1551. vblank_passed(drm_vblank_count(dev, pipe), + 1552. req_seq) || + +drivers/pci/probe.c:1453: error: DEAD_STORE + The value written to &pos is never used. + 1451. u16 cmd; + 1452. u8 hdr_type; + 1453. > int pos = 0; + 1454. struct pci_bus_region region; + 1455. struct resource *res; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &bytes is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &skip is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +lib/assoc_array.c:1517: error: DEAD_STORE + The value written to &new_ptr_pp is never used. + 1515. new_n->parent_slot = node->parent_slot; + 1516. *new_ptr_pp = new_parent = assoc_array_node_to_ptr(new_n); + 1517. > new_ptr_pp = NULL; + 1518. slot = 0; + 1519. + +net/wireless/trace.h:1461: error: DEAD_STORE + The value written to &p is never used. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +sound/core/pcm_native.c:1464: error: DEAD_STORE + The value written to &err is never used. + 1462. { + 1463. struct snd_pcm_substream *substream; + 1464. > int stream, err = 0; + 1465. + 1466. if (! pcm) + +drivers/net/ethernet/intel/e100.c:1472: error: DEAD_STORE + The value written to &stat is never used. + 1470. nic->mii.phy_id = (addr == 0) ? 1 : (addr == 1) ? 0 : addr; + 1471. bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR); + 1472. > stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1473. stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1474. if (!((bmcr == 0xFFFF) || ((stat == 0) && (bmcr == 0)))) + +drivers/scsi/sg.c:1478: error: DEAD_STORE + The value written to &cdev is never used. + 1476. struct gendisk *disk; + 1477. Sg_device *sdp = NULL; + 1478. > struct cdev * cdev = NULL; + 1479. int error; + 1480. unsigned long iflags; + +drivers/scsi/sg.c:1477: error: DEAD_STORE + The value written to &sdp is never used. + 1475. struct scsi_device *scsidp = to_scsi_device(cl_dev->parent); + 1476. struct gendisk *disk; + 1477. > Sg_device *sdp = NULL; + 1478. struct cdev * cdev = NULL; + 1479. int error; + +net/wireless/reg.c:1479: error: DEAD_STORE + The value written to &freq_range is never used. + 1477. const struct ieee80211_channel *chan) + 1478. { + 1479. > const struct ieee80211_freq_range *freq_range = NULL; + 1480. u32 max_bandwidth_khz, bw_flags = 0; + 1481. + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1496: error: DEAD_STORE + The value written to &c is never used. + 1494. end = addr + size; + 1495. for (; addr < end; addr += PAGE_SIZE) { + 1496. > int err = __get_user(c, addr); + 1497. if (err) + 1498. return err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1500: error: DEAD_STORE + The value written to &c is never used. + 1498. return err; + 1499. } + 1500. > return __get_user(c, end - 1); + 1501. } + 1502. + +block/blk-core.c:1484: error: DEAD_STORE + The value written to &ret is never used. + 1482. gfp_t gfp_mask = flags & BLK_MQ_REQ_NOWAIT ? GFP_ATOMIC : + 1483. __GFP_DIRECT_RECLAIM; + 1484. > int ret = 0; + 1485. + 1486. WARN_ON_ONCE(q->mq_ops); + +sound/core/seq/seq_clientmgr.c:1484: error: DEAD_STORE + The value written to &receiver is never used. + 1482. struct snd_seq_port_subscribe *subs = arg; + 1483. int result = -ENXIO; + 1484. > struct snd_seq_client *receiver = NULL, *sender = NULL; + 1485. struct snd_seq_client_port *sport = NULL, *dport = NULL; + 1486. + +security/selinux/hooks.c:1489: error: DEAD_STORE + The value written to &context is never used. + 1487. struct dentry *dentry; + 1488. #define INITCONTEXTLEN 255 + 1489. > char *context = NULL; + 1490. unsigned len = 0; + 1491. int rc = 0; + +security/selinux/hooks.c:1490: error: DEAD_STORE + The value written to &len is never used. + 1488. #define INITCONTEXTLEN 255 + 1489. char *context = NULL; + 1490. > unsigned len = 0; + 1491. int rc = 0; + 1492. + +security/selinux/hooks.c:1483: error: DEAD_STORE + The value written to &sbsec is never used. + 1481. static int inode_doinit_with_dentry(struct inode *inode, struct dentry *opt_dentry) + 1482. { + 1483. > struct superblock_security_struct *sbsec = NULL; + 1484. struct inode_security_struct *isec = inode->i_security; + 1485. u32 task_sid, sid = 0; + +security/selinux/hooks.c:1485: error: DEAD_STORE + The value written to &sid is never used. + 1483. struct superblock_security_struct *sbsec = NULL; + 1484. struct inode_security_struct *isec = inode->i_security; + 1485. > u32 task_sid, sid = 0; + 1486. u16 sclass; + 1487. struct dentry *dentry; + +drivers/cpufreq/intel_pstate.c:1485: error: DEAD_STORE + The value written to &max_pstate is never used. + 1483. static int intel_pstate_prepare_request(struct cpudata *cpu, int pstate) + 1484. { + 1485. > int max_pstate = intel_pstate_get_base_pstate(cpu); + 1486. int min_pstate; + 1487. + +block/bio.c:1497: error: DEAD_STORE + The value written to &nr_pages is never used. + 1495. struct bio *bio; + 1496. void *p = data; + 1497. > int nr_pages = 0; + 1498. + 1499. /* + +net/sunrpc/auth_gss/auth_gss.c:1500: error: DEAD_STORE + The value written to &maj_stat is never used. + 1498. struct gss_cl_ctx *ctx = gss_cred_get_ctx(cred); + 1499. __be32 *cred_len; + 1500. > u32 maj_stat = 0; + 1501. struct xdr_netobj mic; + 1502. struct kvec iov; + +kernel/sched/rt.c:1498: error: DEAD_STORE + The value written to &next is never used. + 1496. { + 1497. struct rt_prio_array *array = &rt_rq->active; + 1498. > struct sched_rt_entity *next = NULL; + 1499. struct list_head *queue; + 1500. int idx; + +security/keys/keyctl.c:1518: error: DEAD_STORE + The value written to &keyring_r is never used. + 1516. + 1517. cred->session_keyring = key_ref_to_ptr(keyring_r); + 1518. > keyring_r = NULL; + 1519. init_task_work(newwork, key_change_session_keyring); + 1520. + +kernel/cgroup/cpuset.c:1503: error: DEAD_STORE + The value written to &cs is never used. + 1501. + 1502. cgroup_taskset_first(tset, &css); + 1503. > cs = css_cs(css); + 1504. + 1505. mutex_lock(&cpuset_mutex); + +drivers/gpu/drm/drm_fb_helper.c:1512: error: DEAD_STORE + The value written to &ret is never used. + 1510. struct drm_mode_set *mode_set; + 1511. struct drm_crtc *crtc; + 1512. > int ret = 0; + 1513. + 1514. mutex_lock(&fb_helper->lock); + +net/wireless/trace.h:1506: error: DEAD_STORE + The value written to &p is never used. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/ipv4/ip_output.c:1518: error: DEAD_STORE + The value written to &rt is never used. + 1516. struct ipcm_cookie ipc; + 1517. struct flowi4 fl4; + 1518. > struct rtable *rt = skb_rtable(skb); + 1519. struct net *net = sock_net(sk); + 1520. struct sk_buff *nskb; + +net/wireless/reg.c:1521: error: DEAD_STORE + The value written to &bw_flags is never used. + 1519. struct ieee80211_channel *chan) + 1520. { + 1521. > u32 flags, bw_flags = 0; + 1522. const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. const struct ieee80211_power_rule *power_rule = NULL; + +net/wireless/reg.c:1523: error: DEAD_STORE + The value written to &power_rule is never used. + 1521. u32 flags, bw_flags = 0; + 1522. const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. > const struct ieee80211_power_rule *power_rule = NULL; + 1524. struct wiphy *request_wiphy = NULL; + 1525. struct regulatory_request *lr = get_last_request(); + +net/wireless/reg.c:1522: error: DEAD_STORE + The value written to ®_rule is never used. + 1520. { + 1521. u32 flags, bw_flags = 0; + 1522. > const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. const struct ieee80211_power_rule *power_rule = NULL; + 1524. struct wiphy *request_wiphy = NULL; + +net/wireless/reg.c:1524: error: DEAD_STORE + The value written to &request_wiphy is never used. + 1522. const struct ieee80211_reg_rule *reg_rule = NULL; + 1523. const struct ieee80211_power_rule *power_rule = NULL; + 1524. > struct wiphy *request_wiphy = NULL; + 1525. struct regulatory_request *lr = get_last_request(); + 1526. const struct ieee80211_regdomain *regd; + +drivers/net/phy/phy_device.c:1523: error: DEAD_STORE + The value written to &lpagb is never used. + 1521. int err; + 1522. int lpa; + 1523. > int lpagb = 0; + 1524. int common_adv; + 1525. int common_adv_gb = 0; + +kernel/time/timer.c:1521: error: DEAD_STORE + The value written to &base is never used. + 1519. u64 get_next_timer_interrupt(unsigned long basej, u64 basem) + 1520. { + 1521. > struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]); + 1522. u64 expires = KTIME_MAX; + 1523. unsigned long nextevt; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1651: error: DEAD_STORE + The value written to &mii_1000t_ctrl_reg is never used. + 1649. + 1650. if (hw->phy_type == e1000_phy_8201) { + 1651. > mii_1000t_ctrl_reg = 0; + 1652. } else { + 1653. ret_val = e1000_write_phy_reg(hw, PHY_1000T_CTRL, + +drivers/hid/hid-core.c:1529: error: DEAD_STORE + The value written to &ret is never used. + 1527. struct hid_driver *hdrv; + 1528. struct hid_report *report; + 1529. > int ret = 0; + 1530. + 1531. if (!hid) + +net/wireless/trace.h:1524: error: DEAD_STORE + The value written to &p is never used. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +drivers/pci/setup-bus.c:1532: error: DEAD_STORE + The value written to &idx is never used. + 1530. unsigned old_flags = 0; + 1531. struct resource *b_res; + 1532. > int idx = 1; + 1533. + 1534. b_res = &dev->resource[PCI_BRIDGE_RESOURCES]; + +drivers/pci/setup-bus.c:1530: error: DEAD_STORE + The value written to &old_flags is never used. + 1528. struct pci_dev *dev = bus->self; + 1529. struct resource *r; + 1530. > unsigned old_flags = 0; + 1531. struct resource *b_res; + 1532. int idx = 1; + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: DEAD_STORE + The value written to &timeout__ is never used. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: DEAD_STORE + The value written to &wait__ is never used. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +net/wireless/trace.h:1545: error: DEAD_STORE + The value written to &p is never used. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/xfrm/xfrm_policy.c:1638: error: NULL_DEREFERENCE + pointer `xdst_prev` last assigned on line 1559 could be null and is dereferenced by call to `xfrm_dst_set_child()` at line 1638, column 2. + 1636. } + 1637. + 1638. > xfrm_dst_set_child(xdst_prev, dst); + 1639. xdst0->path = dst; + 1640. + +drivers/net/ethernet/intel/e100.c:1557: error: DEAD_STORE + The value written to &err is never used. + 1555. static int e100_hw_init(struct nic *nic) + 1556. { + 1557. > int err = 0; + 1558. + 1559. e100_hw_reset(nic); + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: DEAD_STORE + The value written to &timeout__ is never used. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: DEAD_STORE + The value written to &wait__ is never used. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +net/ipv4/cipso_ipv4.c:1571: error: DEAD_STORE + The value written to &doi_def is never used. + 1569. u8 opt_len; + 1570. u8 tag_len; + 1571. > struct cipso_v4_doi *doi_def = NULL; + 1572. u32 tag_iter; + 1573. + +net/wireless/trace.h:1564: error: DEAD_STORE + The value written to &p is never used. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +drivers/gpu/drm/drm_edid.c:1573: error: DEAD_STORE + The value written to &j is never used. + 1571. void *data) + 1572. { + 1573. > int i, j = 0, valid_extensions = 0; + 1574. u8 *edid, *new; + 1575. struct edid *override = NULL; + +drivers/gpu/drm/drm_edid.c:1573: error: DEAD_STORE + The value written to &valid_extensions is never used. + 1571. void *data) + 1572. { + 1573. > int i, j = 0, valid_extensions = 0; + 1574. u8 *edid, *new; + 1575. struct edid *override = NULL; + +include/linux/blkdev.h:1571: error: DEAD_STORE + The value written to §or is never used. + 1569. { + 1570. unsigned int granularity = max(lim->physical_block_size, lim->io_min); + 1571. > unsigned int alignment = sector_div(sector, granularity >> 9) << 9; + 1572. + 1573. return (granularity + lim->alignment_offset - alignment) % granularity; + +net/core/net-sysfs.c:1578: error: DEAD_STORE + The value written to &error is never used. + 1576. struct device *dev = &ndev->dev; + 1577. const struct attribute_group **groups = ndev->sysfs_groups; + 1578. > int error = 0; + 1579. + 1580. device_initialize(dev); + +net/core/net-sysfs.c:1596: error: DEAD_STORE + The value written to &groups is never used. + 1594. #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211) + 1595. if (ndev->ieee80211_ptr) + 1596. > *groups++ = &wireless_group; + 1597. #if IS_ENABLED(CONFIG_WIRELESS_EXT) + 1598. else if (ndev->wireless_handlers) + +security/selinux/ss/services.c:1586: error: DEAD_STORE + The value written to &roletr is never used. + 1584. struct class_datum *cladatum = NULL; + 1585. struct context *scontext = NULL, *tcontext = NULL, newcontext; + 1586. > struct role_trans *roletr = NULL; + 1587. struct avtab_key avkey; + 1588. struct avtab_datum *avdatum; + +security/selinux/ss/services.c:1585: error: DEAD_STORE + The value written to &scontext is never used. + 1583. { + 1584. struct class_datum *cladatum = NULL; + 1585. > struct context *scontext = NULL, *tcontext = NULL, newcontext; + 1586. struct role_trans *roletr = NULL; + 1587. struct avtab_key avkey; + +security/selinux/ss/services.c:1585: error: DEAD_STORE + The value written to &tcontext is never used. + 1583. { + 1584. struct class_datum *cladatum = NULL; + 1585. > struct context *scontext = NULL, *tcontext = NULL, newcontext; + 1586. struct role_trans *roletr = NULL; + 1587. struct avtab_key avkey; + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: DEAD_STORE + The value written to &timeout__ is never used. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: DEAD_STORE + The value written to &wait__ is never used. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +kernel/trace/trace.c:1582: error: DEAD_STORE + The value written to &ret is never used. + 1580. { + 1581. struct tracer *t; + 1582. > int ret = 0; + 1583. + 1584. if (!type->name) { + +drivers/gpu/drm/i915/intel_engine_cs.c:1601: error: DEAD_STORE + The value written to &timeout__ is never used. + 1599. * are truly idle. + 1600. */ + 1601. > if (wait_for(intel_engine_is_idle(engine), 10)) { + 1602. struct drm_printer p = drm_debug_printer(__func__); + 1603. + +drivers/gpu/drm/i915/intel_engine_cs.c:1601: error: DEAD_STORE + The value written to &wait__ is never used. + 1599. * are truly idle. + 1600. */ + 1601. > if (wait_for(intel_engine_is_idle(engine), 10)) { + 1602. struct drm_printer p = drm_debug_printer(__func__); + 1603. + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: DEAD_STORE + The value written to &timeout__ is never used. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: DEAD_STORE + The value written to &timeout__ is never used. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: DEAD_STORE + The value written to &wait__ is never used. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: DEAD_STORE + The value written to &wait__ is never used. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +net/wireless/trace.h:1587: error: DEAD_STORE + The value written to &p is never used. + 1585. ); + 1586. + 1587. > DECLARE_EVENT_CLASS(tx_rx_evt, + 1588. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1589. TP_ARGS(wiphy, rx, tx), + +kernel/trace/trace_events.c:1597: error: DEAD_STORE + The value written to &filtered_pids is never used. + 1595. struct seq_file *m = filp->private_data; + 1596. struct trace_array *tr = m->private; + 1597. > struct trace_pid_list *filtered_pids = NULL; + 1598. struct trace_pid_list *pid_list; + 1599. struct trace_event_file *file; + +drivers/net/ethernet/intel/e1000e/mac.c:1594: error: DEAD_STORE + The value written to &ledctl_blink is never used. + 1592. s32 e1000e_blink_led_generic(struct e1000_hw *hw) + 1593. { + 1594. > u32 ledctl_blink = 0; + 1595. u32 i; + 1596. + +drivers/gpu/drm/drm_dp_mst_topology.c:1605: error: DEAD_STORE + The value written to &len is never used. + 1603. + 1604. txmsg->dst = mstb; + 1605. > len = build_link_address(txmsg); + 1606. + 1607. mstb->link_address_sent = true; + +net/sunrpc/auth_gss/svcauth_gss.c:1616: error: DEAD_STORE + The value written to &p is never used. + 1614. BUG_ON(integ_len % 4); + 1615. *p++ = htonl(integ_len); + 1616. > *p++ = htonl(gc->gc_seq); + 1617. if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset, integ_len)) { + 1618. WARN_ON_ONCE(1); + +drivers/scsi/scsi_lib.c:1608: error: NULL_DEREFERENCE + pointer `cmd` last assigned on line 1599 could be null and is dereferenced at line 1608, column 9. + 1606. scmd_printk(KERN_INFO, cmd, "killing request\n"); + 1607. + 1608. > sdev = cmd->device; + 1609. starget = scsi_target(sdev); + 1610. shost = sdev->host; + +include/linux/blkdev.h:1611: error: DEAD_STORE + The value written to §or is never used. + 1609. + 1610. /* Offset of the partition start in 'granularity' sectors */ + 1611. > offset = sector_div(sector, granularity); + 1612. + 1613. /* And why do we do this modulus *again* in blkdev_issue_discard()? */ + +net/netfilter/nf_conntrack_netlink.c:1603: error: DEAD_STORE + The value written to &err is never used. + 1601. const struct nf_conntrack_l4proto *l4proto; + 1602. struct nlattr *tb[CTA_PROTOINFO_MAX+1]; + 1603. > int err = 0; + 1604. + 1605. err = nla_parse_nested(tb, CTA_PROTOINFO_MAX, attr, protoinfo_policy, + +kernel/cpu.c:1609: error: DEAD_STORE + The value written to &ret is never used. + 1607. bool multi_instance) + 1608. { + 1609. > int cpu, ret = 0; + 1610. bool dynstate; + 1611. + +drivers/scsi/scsi_transport_spi.c:1625: error: DEAD_STORE + The value written to &error is never used. + 1623. if (error) + 1624. return error; + 1625. > error = anon_transport_class_register(&spi_device_class); + 1626. return transport_class_register(&spi_host_class); + 1627. } + +kernel/cgroup/cpuset.c:1614: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1609 could be null and is dereferenced by call to `is_cpuset_online()` at line 1614, column 7. + 1612. + 1613. mutex_lock(&cpuset_mutex); + 1614. > if (!is_cpuset_online(cs)) { + 1615. retval = -ENODEV; + 1616. goto out_unlock; + +net/wireless/trace.h:1609: error: DEAD_STORE + The value written to &p is never used. + 1607. ); + 1608. + 1609. > DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, + 1610. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1611. TP_ARGS(wiphy, netdev, id), + +drivers/md/dm-table.c:1616: error: DEAD_STORE + The value written to &template_disk is never used. + 1614. static void dm_table_verify_integrity(struct dm_table *t) + 1615. { + 1616. > struct gendisk *template_disk = NULL; + 1617. + 1618. if (t->integrity_added) + +crypto/drbg.c:1619: error: DEAD_STORE + The value written to &input is never used. + 1617. { + 1618. struct sdesc *sdesc = (struct sdesc *)drbg->priv_data; + 1619. > struct drbg_string *input = NULL; + 1620. + 1621. crypto_shash_init(&sdesc->shash); + +drivers/clk/clk.c:1621: error: DEAD_STORE + The value written to &best_parent_rate is never used. + 1619. struct clk_core *top = core; + 1620. struct clk_core *old_parent, *parent; + 1621. > unsigned long best_parent_rate = 0; + 1622. unsigned long new_rate; + 1623. unsigned long min_rate; + +drivers/clk/clk.c:1635: error: DEAD_STORE + The value written to &best_parent_rate is never used. + 1633. parent = old_parent = core->parent; + 1634. if (parent) + 1635. > best_parent_rate = parent->rate; + 1636. + 1637. clk_core_get_boundaries(core, &min_rate, &max_rate); + +kernel/trace/blktrace.c:1619: error: DEAD_STORE + The value written to &bt is never used. + 1617. struct block_device *bdev) + 1618. { + 1619. > struct blk_trace *bt = NULL; + 1620. int ret = -ENOMEM; + 1621. + +kernel/trace/ring_buffer.c:1621: error: DEAD_STORE + The value written to &err is never used. + 1619. struct ring_buffer_per_cpu *cpu_buffer; + 1620. unsigned long nr_pages; + 1621. > int cpu, err = 0; + 1622. + 1623. /* + +net/ipv4/tcp_input.c:1631: error: DEAD_STORE + The value written to &found_dup_sack is never used. + 1629. int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3); + 1630. int used_sacks; + 1631. > bool found_dup_sack = false; + 1632. int i, j; + 1633. int first_sack_index; + +drivers/gpu/drm/i915/intel_cdclk.c:1628: error: DEAD_STORE + The value written to &timeout__ is never used. + 1626. + 1627. /* Timeout 200us */ + 1628. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1629. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1630. + +drivers/gpu/drm/i915/intel_cdclk.c:1628: error: DEAD_STORE + The value written to &wait__ is never used. + 1626. + 1627. /* Timeout 200us */ + 1628. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1629. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1630. + +kernel/trace/trace_events_filter.c:1634: error: DEAD_STORE + The value written to &n_preds is never used. + 1632. struct pred_stack stack = { }; /* init to NULL */ + 1633. int err; + 1634. > int n_preds = 0; + 1635. + 1636. n_preds = count_preds(ps); + +kernel/cgroup/cgroup.c:1632: error: DEAD_STORE + The value written to &ssid is never used. + 1630. lockdep_assert_held(&cgroup_mutex); + 1631. + 1632. > do_each_subsys_mask(ss, ssid, ss_mask) { + 1633. /* + 1634. * If @ss has non-root csses attached to it, can't move. + +kernel/cgroup/cgroup.c:1647: error: DEAD_STORE + The value written to &ssid is never used. + 1645. } while_each_subsys_mask(); + 1646. + 1647. > do_each_subsys_mask(ss, ssid, ss_mask) { + 1648. struct cgroup_root *src_root = ss->root; + 1649. struct cgroup *scgrp = &src_root->cgrp; + +drivers/scsi/scsi_lib.c:1631: error: DEAD_STORE + The value written to &wait_for is never used. + 1629. { + 1630. struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); + 1631. > unsigned long wait_for = (cmd->allowed + 1) * rq->timeout; + 1632. int disposition; + 1633. + +drivers/gpu/drm/i915/intel_cdclk.c:1646: error: DEAD_STORE + The value written to &timeout__ is never used. + 1644. + 1645. /* Timeout 200us */ + 1646. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1647. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1648. + +drivers/gpu/drm/i915/intel_cdclk.c:1646: error: DEAD_STORE + The value written to &wait__ is never used. + 1644. + 1645. /* Timeout 200us */ + 1646. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1647. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1648. + +kernel/printk/printk.c:1638: error: DEAD_STORE + The value written to &owner is never used. + 1636. static int console_trylock_spinning(void) + 1637. { + 1638. > struct task_struct *owner = NULL; + 1639. bool waiter; + 1640. bool spin = false; + +net/wireless/trace.h:1636: error: DEAD_STORE + The value written to &p is never used. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +drivers/hid/usbhid/hid-core.c:1641: error: DEAD_STORE + The value written to &retval is never used. + 1639. static int __init hid_init(void) + 1640. { + 1641. > int retval = -ENOMEM; + 1642. + 1643. retval = hid_quirks_init(quirks_param, BUS_USB, MAX_USBHID_BOOT_QUIRKS); + +drivers/hid/hid-core.c:1698: error: DEAD_STORE + The value written to &len is never used. + 1696. ((struct hiddev *)hdev->hiddev)->minor); + 1697. if (hdev->claimed & HID_CLAIMED_HIDRAW) + 1698. > len += sprintf(buf + len, "%shidraw%d", len ? "," : "", + 1699. ((struct hidraw *)hdev->hidraw)->minor); + 1700. + +drivers/net/ethernet/intel/e1000e/ethtool.c:1706: error: DEAD_STORE + The value written to &l is never used. + 1704. l++; + 1705. if (l == rx_ring->count) + 1706. > l = 0; + 1707. /* time + 20 msecs (200 msecs on 2.4) is more than + 1708. * enough time to complete the receives, if it's + +drivers/net/ethernet/intel/e1000e/ethtool.c:1690: error: DEAD_STORE + The value written to &time is never used. + 1688. e1e_flush(); + 1689. msleep(200); + 1690. > time = jiffies; /* set the start time for the receive */ + 1691. good_cnt = 0; + 1692. /* receive the sent packets */ + +net/sunrpc/auth_gss/svcauth_gss.c:1651: error: DEAD_STORE + The value written to &inpages is never used. + 1649. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1650. struct xdr_buf *resbuf = &rqstp->rq_res; + 1651. > struct page **inpages = NULL; + 1652. __be32 *p, *len; + 1653. int offset; + +net/sunrpc/auth_gss/svcauth_gss.c:1661: error: DEAD_STORE + The value written to &p is never used. + 1659. len = p++; + 1660. offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base; + 1661. > *p++ = htonl(gc->gc_seq); + 1662. inpages = resbuf->pages; + 1663. /* XXX: Would be better to write some xdr helper functions for + +drivers/gpu/drm/drm_dp_mst_topology.c:1659: error: DEAD_STORE + The value written to &len is never used. + 1657. + 1658. txmsg->dst = mstb; + 1659. > len = build_enum_path_resources(txmsg, port->port_num); + 1660. + 1661. drm_dp_queue_down_tx(mgr, txmsg); + +kernel/cgroup/cpuset.c:1661: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1656 could be null and is dereferenced by call to `is_cpuset_online()` at line 1661, column 7. + 1659. + 1660. mutex_lock(&cpuset_mutex); + 1661. > if (!is_cpuset_online(cs)) + 1662. goto out_unlock; + 1663. + +net/netfilter/nf_conntrack_netlink.c:1661: error: DEAD_STORE + The value written to &ret is never used. + 1659. { + 1660. struct nf_conn_seqadj *seqadj = nfct_seqadj(ct); + 1661. > int ret = 0; + 1662. + 1663. if (!seqadj) + +drivers/net/ethernet/broadcom/tg3.c:1699: error: DEAD_STORE + The value written to &data is never used. + 1697. else + 1698. val = 0; + 1699. > *data++ = val; + 1700. } + 1701. + +drivers/usb/host/uhci-q.c:1688: error: DEAD_STORE + The value written to &status is never used. + 1686. if (qh->state != QH_STATE_ACTIVE) { + 1687. urbp = NULL; + 1688. > status = 0; + 1689. + 1690. } else { + +drivers/usb/host/uhci-q.c:1670: error: DEAD_STORE + The value written to &urbp is never used. + 1668. static int uhci_advance_check(struct uhci_hcd *uhci, struct uhci_qh *qh) + 1669. { + 1670. > struct urb_priv *urbp = NULL; + 1671. struct uhci_td *td; + 1672. int ret = 1; + +drivers/usb/host/uhci-q.c:1687: error: DEAD_STORE + The value written to &urbp is never used. + 1685. * test whether such queues have advanced. */ + 1686. if (qh->state != QH_STATE_ACTIVE) { + 1687. > urbp = NULL; + 1688. status = 0; + 1689. + +security/selinux/selinuxfs.c:1671: error: DEAD_STORE + The value written to &dentry is never used. + 1669. struct dentry *dir) + 1670. { + 1671. > struct dentry *dentry = NULL; + 1672. struct inode *inode = NULL; + 1673. int rc; + +security/selinux/selinuxfs.c:1672: error: DEAD_STORE + The value written to &inode is never used. + 1670. { + 1671. struct dentry *dentry = NULL; + 1672. > struct inode *inode = NULL; + 1673. int rc; + 1674. + +drivers/scsi/scsi_lib.c:1677: error: DEAD_STORE + The value written to &rtn is never used. + 1675. { + 1676. struct Scsi_Host *host = cmd->device->host; + 1677. > int rtn = 0; + 1678. + 1679. atomic_inc(&cmd->device->iorequest_cnt); + +net/wireless/trace.h:1675: error: DEAD_STORE + The value written to &p is never used. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +drivers/gpu/drm/i915/intel_hdmi.c:1688: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1683 could be null and is dereferenced at line 1688, column 2. + 1686. intel_hdmi_prepare(encoder, pipe_config); + 1687. + 1688. > intel_dig_port->set_infoframes(&encoder->base, + 1689. pipe_config->has_infoframe, + 1690. pipe_config, conn_state); + +sound/core/timer.c:1685: error: DEAD_STORE + The value written to &err is never used. + 1683. struct snd_timer_select tselect; + 1684. char str[32]; + 1685. > int err = 0; + 1686. + 1687. tu = file->private_data; + +kernel/time/hrtimer.c:1685: error: DEAD_STORE + The value written to &ret is never used. + 1683. struct restart_block *restart; + 1684. struct hrtimer_sleeper t; + 1685. > int ret = 0; + 1686. u64 slack; + 1687. + +net/sunrpc/auth_gss/auth_gss.c:1690: error: DEAD_STORE + The value written to &integ_len is never used. + 1688. struct xdr_buf *snd_buf = &rqstp->rq_snd_buf; + 1689. struct xdr_buf integ_buf; + 1690. > __be32 *integ_len = NULL; + 1691. struct xdr_netobj mic; + 1692. u32 offset; + +net/sunrpc/auth_gss/auth_gss.c:1695: error: DEAD_STORE + The value written to &maj_stat is never used. + 1693. __be32 *q; + 1694. struct kvec *iov; + 1695. > u32 maj_stat = 0; + 1696. int status = -EIO; + 1697. + +kernel/power/snapshot.c:1688: error: DEAD_STORE + The value written to &pages is never used. + 1686. { + 1687. struct zone *zone; + 1688. > unsigned long saveable, size, max_size, count, highmem, pages = 0; + 1689. unsigned long alloc, save_highmem, pages_highmem, avail_normal; + 1690. ktime_t start, stop; + +security/selinux/hooks.c:1687: error: DEAD_STORE + The value written to &perm is never used. + 1685. static inline u32 signal_to_av(int sig) + 1686. { + 1687. > u32 perm = 0; + 1688. + 1689. switch (sig) { + +net/wireless/trace.h:1692: error: DEAD_STORE + The value written to &p is never used. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +drivers/gpu/drm/i915/intel_hdmi.c:1706: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1697 could be null and is dereferenced at line 1706, column 2. + 1704. 0x2b247878); + 1705. + 1706. > dport->set_infoframes(&encoder->base, + 1707. pipe_config->has_infoframe, + 1708. pipe_config, conn_state); + +kernel/cgroup/cgroup.c:1698: error: DEAD_STORE + The value written to &buf is never used. + 1696. { + 1697. int len = 0; + 1698. > char *buf = NULL; + 1699. struct cgroup_root *kf_cgroot = cgroup_root_from_kf(kf_root); + 1700. struct cgroup *ns_cgroup; + +kernel/cgroup/cgroup.c:1697: error: DEAD_STORE + The value written to &len is never used. + 1695. struct kernfs_root *kf_root) + 1696. { + 1697. > int len = 0; + 1698. char *buf = NULL; + 1699. struct cgroup_root *kf_cgroot = cgroup_root_from_kf(kf_root); + +drivers/gpu/drm/drm_atomic_helper.c:1705: error: DEAD_STORE + The value written to &completed is never used. + 1703. { + 1704. struct drm_crtc_commit *commit, *stall_commit = NULL; + 1705. > bool completed = true; + 1706. int i; + 1707. long ret = 0; + +drivers/gpu/drm/drm_atomic_helper.c:1707: error: DEAD_STORE + The value written to &ret is never used. + 1705. bool completed = true; + 1706. int i; + 1707. > long ret = 0; + 1708. + 1709. spin_lock(&crtc->commit_lock); + +drivers/clk/clk.c:1707: error: DEAD_STORE + The value written to &ret is never used. + 1705. { + 1706. struct clk_core *child, *tmp_clk, *fail_clk = NULL; + 1707. > int ret = NOTIFY_DONE; + 1708. + 1709. if (core->rate == core->new_rate) + +net/sunrpc/auth_gss/svcauth_gss.c:1716: error: DEAD_STORE + The value written to &stat is never used. + 1714. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1715. struct xdr_buf *resbuf = &rqstp->rq_res; + 1716. > int stat = -EINVAL; + 1717. struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id); + 1718. + +drivers/gpu/drm/drm_dp_mst_topology.c:1747: error: DEAD_STORE + The value written to &len is never used. + 1745. + 1746. txmsg->dst = mstb; + 1747. > len = build_allocate_payload(txmsg, port_num, + 1748. id, + 1749. pbn, port->num_sdp_streams, sinks); + +drivers/block/loop.c:1717: error: DEAD_STORE + The value written to &ret is never used. + 1715. const bool write = op_is_write(req_op(cmd->rq)); + 1716. struct loop_device *lo = cmd->rq->q->queuedata; + 1717. > int ret = 0; + 1718. + 1719. if (write && (lo->lo_flags & LO_FLAGS_READ_ONLY)) { + +drivers/video/fbdev/core/fbmem.c:1722: error: DEAD_STORE + The value written to &ret is never used. + 1720. { + 1721. struct fb_event event; + 1722. > int i, ret = 0; + 1723. + 1724. i = fb_info->node; + +drivers/md/dm-ioctl.c:1751: error: DEAD_STORE + The value written to &dmi is never used. + 1749. * Use kmalloc() rather than vmalloc() when we can. + 1750. */ + 1751. > dmi = NULL; + 1752. noio_flag = memalloc_noio_save(); + 1753. dmi = kvmalloc(param_kernel->data_size, GFP_KERNEL | __GFP_HIGH); + +drivers/usb/host/ehci-sched.c:1728: error: DEAD_STORE + The value written to &type is never used. + 1726. __hc32 *hw_p = &ehci->periodic[frame]; + 1727. union ehci_shadow here = *prev; + 1728. > __hc32 type = 0; + 1729. + 1730. /* skip any iso nodes which might belong to previous microframes */ + +sound/core/seq/seq_clientmgr.c:1732: error: DEAD_STORE + The value written to &result is never used. + 1730. { + 1731. struct snd_seq_queue_timer *timer = arg; + 1732. > int result = 0; + 1733. + 1734. if (timer->type != SNDRV_SEQ_TIMER_ALSA) + +net/wireless/trace.h:1732: error: DEAD_STORE + The value written to &p is never used. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +security/selinux/selinuxfs.c:1738: error: DEAD_STORE + The value written to &dentry is never used. + 1736. { + 1737. unsigned int iter; + 1738. > struct dentry *dentry = NULL; + 1739. struct inode *inode = NULL; + 1740. + +security/selinux/selinuxfs.c:1739: error: DEAD_STORE + The value written to &inode is never used. + 1737. unsigned int iter; + 1738. struct dentry *dentry = NULL; + 1739. > struct inode *inode = NULL; + 1740. + 1741. sel_remove_entries(policycap_dir); + +drivers/base/core.c:1743: error: DEAD_STORE + The value written to &glue_dir is never used. + 1741. struct class_interface *class_intf; + 1742. int error = -EINVAL; + 1743. > struct kobject *glue_dir = NULL; + 1744. + 1745. dev = get_device(dev); + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: DEAD_STORE + The value written to &timeout__ is never used. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: DEAD_STORE + The value written to &wait__ is never used. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +net/sched/sch_api.c:1750: error: DEAD_STORE + The value written to &err is never used. + 1748. u32 portid = oskb ? NETLINK_CB(oskb).portid : 0; + 1749. struct sk_buff *skb; + 1750. > int err = 0; + 1751. + 1752. if (!cops->delete) + +drivers/gpu/drm/i915/i915_debugfs.c:1751: error: DEAD_STORE + The value written to &ret is never used. + 1749. struct drm_i915_private *dev_priv = node_to_i915(m->private); + 1750. struct intel_rps *rps = &dev_priv->gt_pm.rps; + 1751. > int ret = 0; + 1752. int gpu_freq, ia_freq; + 1753. unsigned int max_gpu_freq, min_gpu_freq; + +net/xfrm/xfrm_state.c:1779: error: DEAD_STORE + The value written to &spi is never used. + 1777. x->id.spi = minspi; + 1778. } else { + 1779. > u32 spi = 0; + 1780. for (h = 0; h < high-low+1; h++) { + 1781. spi = low + prandom_u32()%(high-low+1); + +net/wireless/trace.h:1752: error: DEAD_STORE + The value written to &p is never used. + 1750. ); + 1751. + 1752. > DECLARE_EVENT_CLASS(rdev_pmksa, + 1753. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1754. struct cfg80211_pmksa *pmksa), + +drivers/gpu/drm/i915/intel_ddi.c:1760: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 1756 could be null and is dereferenced at line 1760, column 10. + 1758. + 1759. if (intel_ddi_get_hw_state(encoder, &pipe)) + 1760. > return BIT_ULL(dig_port->ddi_io_power_domain); + 1761. + 1762. return 0; + +kernel/workqueue.c:1758: error: DEAD_STORE + The value written to &id is never used. + 1756. { + 1757. struct worker *worker = NULL; + 1758. > int id = -1; + 1759. char id_buf[16]; + 1760. + +drivers/block/loop.c:1783: error: DEAD_STORE + The value written to &err is never used. + 1781. i = err; + 1782. + 1783. > err = -ENOMEM; + 1784. lo->tag_set.ops = &loop_mq_ops; + 1785. lo->tag_set.nr_hw_queues = 1; + +drivers/gpu/drm/i915/intel_hdmi.c:1777: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1767 could be null and is dereferenced at line 1777, column 2. + 1775. chv_set_phy_signal_level(encoder, 128, 102, false); + 1776. + 1777. > dport->set_infoframes(&encoder->base, + 1778. pipe_config->has_infoframe, + 1779. pipe_config, conn_state); + +drivers/net/ethernet/intel/e100.c:1775: error: DEAD_STORE + The value written to &skb is never used. + 1773. if (pci_dma_mapping_error(nic->pdev, dma_addr)) { + 1774. dev_kfree_skb_any(skb); + 1775. > skb = NULL; + 1776. return -ENOMEM; + 1777. } + +drivers/gpu/drm/drm_dp_mst_topology.c:1784: error: DEAD_STORE + The value written to &len is never used. + 1782. + 1783. txmsg->dst = port->parent; + 1784. > len = build_power_updown_phy(txmsg, port->port_num, power_up); + 1785. drm_dp_queue_down_tx(mgr, txmsg); + 1786. + +sound/core/pcm_native.c:1776: error: DEAD_STORE + The value written to &result is never used. + 1774. struct snd_pcm_substream *s; + 1775. wait_queue_entry_t wait; + 1776. > int result = 0; + 1777. int nonblock = 0; + 1778. + +net/wireless/trace.h:1770: error: DEAD_STORE + The value written to &p is never used. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +kernel/futex.c:1791: error: DEAD_STORE + The value written to &top_waiter is never used. + 1789. struct futex_pi_state **ps, int set_waiters) + 1790. { + 1791. > struct futex_q *top_waiter = NULL; + 1792. u32 curval; + 1793. int ret, vpid; + +drivers/gpu/drm/drm_fb_helper.c:1790: error: DEAD_STORE + The value written to &crtc_count is never used. + 1788. { + 1789. int ret = 0; + 1790. > int crtc_count = 0; + 1791. int i; + 1792. struct drm_fb_helper_surface_size sizes; + +drivers/gpu/drm/drm_fb_helper.c:1789: error: DEAD_STORE + The value written to &ret is never used. + 1787. int preferred_bpp) + 1788. { + 1789. > int ret = 0; + 1790. int crtc_count = 0; + 1791. int i; + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: DEAD_STORE + The value written to &timeout__ is never used. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: DEAD_STORE + The value written to &wait__ is never used. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +crypto/drbg.c:1794: error: DEAD_STORE + The value written to &i is never used. + 1792. int *coreref, bool *pr) + 1793. { + 1794. > int i = 0; + 1795. size_t start = 0; + 1796. int len = 0; + +crypto/drbg.c:1796: error: DEAD_STORE + The value written to &len is never used. + 1794. int i = 0; + 1795. size_t start = 0; + 1796. > int len = 0; + 1797. + 1798. *pr = true; + +crypto/drbg.c:1795: error: DEAD_STORE + The value written to &start is never used. + 1793. { + 1794. int i = 0; + 1795. > size_t start = 0; + 1796. int len = 0; + 1797. + +drivers/iommu/iommu.c:1795: error: DEAD_STORE + The value written to &ret is never used. + 1793. enum iommu_attr attr, void *data) + 1794. { + 1795. > int ret = 0; + 1796. u32 *count; + 1797. + +net/wireless/trace.h:1800: error: DEAD_STORE + The value written to &p is never used. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +kernel/cgroup/cpuset.c:1817: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1813 could be null and is dereferenced at line 1817, column 10. + 1815. switch (type) { + 1816. case FILE_SCHED_RELAX_DOMAIN_LEVEL: + 1817. > return cs->relax_domain_level; + 1818. default: + 1819. BUG(); + +drivers/usb/core/hub.c:1831: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1817 could be null and is dereferenced at line 1831, column 9. + 1829. info->nports = hdev->maxchild; + 1830. for (i = 0; i < info->nports; i++) { + 1831. > if (hub->ports[i]->child == NULL) + 1832. info->port[i] = 0; + 1833. else + +drivers/md/dm-ioctl.c:1827: error: DEAD_STORE + The value written to &fn is never used. + 1825. unsigned int cmd; + 1826. struct dm_ioctl *uninitialized_var(param); + 1827. > ioctl_fn fn = NULL; + 1828. size_t input_param_size; + 1829. struct dm_ioctl param_kernel; + +drivers/md/dm-ioctl.c:1822: error: DEAD_STORE + The value written to &r is never used. + 1820. static int ctl_ioctl(struct file *file, uint command, struct dm_ioctl __user *user) + 1821. { + 1822. > int r = 0; + 1823. int ioctl_flags; + 1824. int param_flags; + +drivers/iommu/amd_iommu.c:1825: error: DEAD_STORE + The value written to &flags is never used. + 1823. { + 1824. u64 pte_root = 0; + 1825. > u64 flags = 0; + 1826. + 1827. if (domain->mode != PAGE_MODE_NONE) + +net/wireless/trace.h:1821: error: DEAD_STORE + The value written to &p is never used. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/ipv4/cipso_ipv4.c:1831: error: DEAD_STORE + The value written to &buf is never used. + 1829. { + 1830. int ret_val = -EPERM; + 1831. > unsigned char *buf = NULL; + 1832. u32 buf_len; + 1833. u32 opt_len; + +net/ipv4/cipso_ipv4.c:1874: error: DEAD_STORE + The value written to &buf is never used. + 1872. opt->opt.cipso = sizeof(struct iphdr); + 1873. kfree(buf); + 1874. > buf = NULL; + 1875. + 1876. sk_inet = inet_sk(sk); + +net/ipv4/cipso_ipv4.c:1830: error: DEAD_STORE + The value written to &ret_val is never used. + 1828. const struct netlbl_lsm_secattr *secattr) + 1829. { + 1830. > int ret_val = -EPERM; + 1831. unsigned char *buf = NULL; + 1832. u32 buf_len; + +kernel/sched/deadline.c:1831: error: DEAD_STORE + The value written to &p is never used. + 1829. { + 1830. struct rb_node *next_node = rq->dl.pushable_dl_tasks_root.rb_leftmost; + 1831. > struct task_struct *p = NULL; + 1832. + 1833. if (!has_pushable_dl_tasks(rq)) + +drivers/usb/host/ehci-sched.c:1888: error: DEAD_STORE + The value written to &dev is never used. + 1886. + 1887. /* give urb back to the driver; completion often (re)submits */ + 1888. > dev = urb->dev; + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + +drivers/usb/host/ehci-sched.c:1891: error: DEAD_STORE + The value written to &urb is never used. + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + 1891. > urb = NULL; + 1892. + 1893. --ehci->isoc_count; + +kernel/sys.c:1835: error: DEAD_STORE + The value written to &mm is never used. + 1833. { + 1834. unsigned long mmap_max_addr = TASK_SIZE; + 1835. > struct mm_struct *mm = current->mm; + 1836. int error = -EINVAL, i; + 1837. + +net/unix/af_unix.c:1836: error: DEAD_STORE + The value written to &other is never used. + 1834. { + 1835. struct sock *sk = sock->sk; + 1836. > struct sock *other = NULL; + 1837. int err, size; + 1838. struct sk_buff *skb; + +drivers/i2c/i2c-core-base.c:1855: error: DEAD_STORE + The value written to &orig_jiffies is never used. + 1853. + 1854. /* Retry automatically on arbitration loss */ + 1855. > orig_jiffies = jiffies; + 1856. for (ret = 0, try = 0; try <= adap->retries; try++) { + 1857. ret = adap->algo->master_xfer(adap, msgs, num); + +drivers/iommu/dmar.c:1836: error: DEAD_STORE + The value written to &ret is never used. + 1834. dmar_res_handler_t handler, void *arg) + 1835. { + 1836. > int ret = -ENODEV; + 1837. union acpi_object *obj; + 1838. struct acpi_dmar_header *start; + +net/sched/sch_api.c:1842: error: DEAD_STORE + The value written to &q is never used. + 1840. struct nlattr *tca[TCA_MAX + 1]; + 1841. struct net_device *dev; + 1842. > struct Qdisc *q = NULL; + 1843. const struct Qdisc_class_ops *cops; + 1844. unsigned long cl = 0; + +drivers/iommu/amd_iommu_init.c:1841: error: DEAD_STORE + The value written to &ret is never used. + 1839. { + 1840. struct amd_iommu *iommu; + 1841. > int ret = 0; + 1842. + 1843. for_each_iommu(iommu) { + +net/wireless/trace.h:1838: error: DEAD_STORE + The value written to &p is never used. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +drivers/gpu/drm/drm_atomic.c:1845: error: DEAD_STORE + The value written to &e is never used. + 1843. struct drm_crtc *crtc, uint64_t user_data) + 1844. { + 1845. > struct drm_pending_vblank_event *e = NULL; + 1846. + 1847. e = kzalloc(sizeof *e, GFP_KERNEL); + +net/sunrpc/xprtsock.c:1850: error: DEAD_STORE + The value written to &port is never used. + 1848. if (port <= xprt_min_resvport || port > xprt_max_resvport) + 1849. return xprt_max_resvport; + 1850. > return --port; + 1851. } + 1852. static int xs_bind(struct sock_xprt *transport, struct socket *sock) + +drivers/iommu/intel-iommu.c:1850: error: DEAD_STORE + The value written to &count is never used. + 1848. struct intel_iommu *iommu) + 1849. { + 1850. > int num, count = INT_MAX; + 1851. + 1852. assert_spin_locked(&device_domain_lock); + +drivers/scsi/sg.c:1851: error: DEAD_STORE + The value written to &ret_sz is never used. + 1849. sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size) + 1850. { + 1851. > int ret_sz = 0, i, k, rem_sz, num, mx_sc_elems; + 1852. int sg_tablesize = sfp->parentdp->sg_tablesize; + 1853. int blk_size = buff_size, order; + +net/ipv4/af_inet.c:1854: error: DEAD_STORE + The value written to &rc is never used. + 1852. struct inet_protosw *q; + 1853. struct list_head *r; + 1854. > int rc = -EINVAL; + 1855. + 1856. sock_skb_cb_check_size(sizeof(struct inet_skb_parm)); + +drivers/usb/core/hub.c:1865: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1855 could be null and is dereferenced at line 1865, column 15. + 1863. * will always have maxchild equal to 0. + 1864. */ + 1865. > *ppowner = &(hub->ports[port1 - 1]->port_owner); + 1866. return 0; + 1867. } + +net/wireless/trace.h:1855: error: DEAD_STORE + The value written to &p is never used. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +security/selinux/ss/services.c:1914: error: DEAD_STORE + The value written to &rc is never used. + 1912. + 1913. /* Convert the user. */ + 1914. > rc = -EINVAL; + 1915. usrdatum = hashtab_search(args->newp->p_users.table, + 1916. sym_name(args->oldp, SYM_USERS, c->user - 1)); + +security/selinux/ss/services.c:1922: error: DEAD_STORE + The value written to &rc is never used. + 1920. + 1921. /* Convert the role. */ + 1922. > rc = -EINVAL; + 1923. role = hashtab_search(args->newp->p_roles.table, + 1924. sym_name(args->oldp, SYM_ROLES, c->role - 1)); + +security/selinux/ss/services.c:1930: error: DEAD_STORE + The value written to &rc is never used. + 1928. + 1929. /* Convert the type. */ + 1930. > rc = -EINVAL; + 1931. typdatum = hashtab_search(args->newp->p_types.table, + 1932. sym_name(args->oldp, SYM_TYPES, c->type - 1)); + +security/selinux/ss/services.c:1960: error: DEAD_STORE + The value written to &rc is never used. + 1958. while (oc && oc->sid[0] != SECINITSID_UNLABELED) + 1959. oc = oc->next; + 1960. > rc = -EINVAL; + 1961. if (!oc) { + 1962. printk(KERN_ERR "SELinux: unable to look up" + +drivers/tty/tty_io.c:1867: error: DEAD_STORE + The value written to &driver is never used. + 1865. { + 1866. struct tty_struct *tty; + 1867. > struct tty_driver *driver = NULL; + 1868. int index = -1; + 1869. + +net/core/skbuff.c:1907: error: DEAD_STORE + The value written to &insp is never used. + 1905. struct sk_buff *list = skb_shinfo(skb)->frag_list; + 1906. struct sk_buff *clone = NULL; + 1907. > struct sk_buff *insp = NULL; + 1908. + 1909. do { + +drivers/clk/clk.c:1870: error: DEAD_STORE + The value written to &ret is never used. + 1868. struct clk_core *top, *fail_clk; + 1869. unsigned long rate; + 1870. > int ret = 0; + 1871. + 1872. if (!core) + +ipc/sem.c:1874: error: DEAD_STORE + The value written to &error is never used. + 1872. unsigned nsops, const struct timespec64 *timeout) + 1873. { + 1874. > int error = -EINVAL; + 1875. struct sem_array *sma; + 1876. struct sembuf fast_sops[SEMOPM_FAST]; + +include/net/tcp.h:1886: error: NULL_DEREFERENCE + pointer `skb` last assigned on line 1884 could be null and is dereferenced at line 1886, column 26. + 1884. const struct sk_buff *skb = tcp_rtx_queue_head(sk); + 1885. u32 rto = inet_csk(sk)->icsk_rto; + 1886. > u64 rto_time_stamp_us = skb->skb_mstamp + jiffies_to_usecs(rto); + 1887. + 1888. return rto_time_stamp_us - tcp_sk(sk)->tcp_mstamp; + +net/wireless/trace.h:1885: error: DEAD_STORE + The value written to &p is never used. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +kernel/trace/trace_events_filter.c:1893: error: DEAD_STORE + The value written to &ps is never used. + 1891. { + 1892. struct event_filter *filter; + 1893. > struct filter_parse_state *ps = NULL; + 1894. int err = 0; + 1895. + +drivers/gpu/drm/drm_edid.c:1893: error: DEAD_STORE + The value written to &n is never used. + 1891. cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure) + 1892. { + 1893. > int i, n = 0; + 1894. u8 d = ext[0x02]; + 1895. u8 *det_base = ext + d; + +kernel/kprobes.c:1894: error: DEAD_STORE + The value written to &flags is never used. + 1892. { + 1893. struct kretprobe *rp = container_of(p, struct kretprobe, kp); + 1894. > unsigned long hash, flags = 0; + 1895. struct kretprobe_instance *ri; + 1896. + +crypto/drbg.c:1902: error: DEAD_STORE + The value written to &drbg is never used. + 1900. #define OUTBUFLEN 16 + 1901. unsigned char buf[OUTBUFLEN]; + 1902. > struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. int rc = -EFAULT; + +crypto/drbg.c:1899: error: DEAD_STORE + The value written to &len is never used. + 1897. static inline int __init drbg_healthcheck_sanity(void) + 1898. { + 1899. > int len = 0; + 1900. #define OUTBUFLEN 16 + 1901. unsigned char buf[OUTBUFLEN]; + +crypto/drbg.c:1904: error: DEAD_STORE + The value written to &rc is never used. + 1902. struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. > int rc = -EFAULT; + 1905. bool pr = false; + 1906. int coreref = 0; + +crypto/drbg.c:1903: error: DEAD_STORE + The value written to &ret is never used. + 1901. unsigned char buf[OUTBUFLEN]; + 1902. struct drbg_state *drbg = NULL; + 1903. > int ret = -EFAULT; + 1904. int rc = -EFAULT; + 1905. bool pr = false; + +drivers/cpufreq/cpufreq.c:1906: error: DEAD_STORE + The value written to &retval is never used. + 1904. unsigned int intermediate_freq = 0; + 1905. unsigned int newfreq = policy->freq_table[index].frequency; + 1906. > int retval = -EINVAL; + 1907. bool notify; + 1908. + +drivers/usb/core/hub.c:1908: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1904 could be null and is dereferenced at line 1908, column 7. + 1906. + 1907. for (n = 0; n < hdev->maxchild; n++) { + 1908. > if (hub->ports[n]->port_owner == owner) + 1909. hub->ports[n]->port_owner = NULL; + 1910. } + +sound/core/seq/seq_clientmgr.c:1908: error: DEAD_STORE + The value written to &sender is never used. + 1906. struct snd_seq_port_subscribe *subs = arg; + 1907. int result; + 1908. > struct snd_seq_client *sender = NULL; + 1909. struct snd_seq_client_port *sport = NULL; + 1910. struct snd_seq_subscribers *p; + +net/wireless/trace.h:1908: error: DEAD_STORE + The value written to &p is never used. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/ipv4/cipso_ipv4.c:1916: error: DEAD_STORE + The value written to &buf is never used. + 1914. { + 1915. int ret_val = -EPERM; + 1916. > unsigned char *buf = NULL; + 1917. u32 buf_len; + 1918. u32 opt_len; + +net/ipv4/cipso_ipv4.c:1951: error: DEAD_STORE + The value written to &buf is never used. + 1949. opt->opt.cipso = sizeof(struct iphdr); + 1950. kfree(buf); + 1951. > buf = NULL; + 1952. + 1953. req_inet = inet_rsk(req); + +net/ipv4/cipso_ipv4.c:1915: error: DEAD_STORE + The value written to &ret_val is never used. + 1913. const struct netlbl_lsm_secattr *secattr) + 1914. { + 1915. > int ret_val = -EPERM; + 1916. unsigned char *buf = NULL; + 1917. u32 buf_len; + +drivers/tty/tty_io.c:1919: error: DEAD_STORE + The value written to &driver is never used. + 1917. { + 1918. struct tty_struct *tty; + 1919. > struct tty_driver *driver = NULL; + 1920. int index = -1; + 1921. int retval; + +drivers/usb/core/hub.c:1922: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1921 could be null and is dereferenced at line 1922, column 11. + 1920. return false; + 1921. hub = usb_hub_to_struct_hub(udev->parent); + 1922. > return !!hub->ports[udev->portnum - 1]->port_owner; + 1923. } + 1924. + +drivers/cdrom/cdrom.c:1927: error: DEAD_STORE + The value written to &ret is never used. + 1925. struct packet_command *cgc) + 1926. { + 1927. > int ret = 0, size; + 1928. u_char *buf; + 1929. const struct cdrom_device_ops *cdo = cdi->ops; + +drivers/usb/core/hub.c:1931: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1927 could be null and is dereferenced at line 1931, column 7. + 1929. + 1930. for (i = 0; i < udev->maxchild; ++i) { + 1931. > if (hub->ports[i]->child) + 1932. recursively_mark_NOTATTACHED(hub->ports[i]->child); + 1933. } + +drivers/video/fbdev/core/fbmem.c:1934: error: DEAD_STORE + The value written to &err is never used. + 1932. struct fb_modelist *modelist; + 1933. struct fb_videomode *m, mode; + 1934. > int err = 1; + 1935. + 1936. list_for_each_safe(pos, n, &info->modelist) { + +sound/core/seq/seq_clientmgr.c:1941: error: DEAD_STORE + The value written to &cptr is never used. + 1939. struct snd_seq_query_subs *subs = arg; + 1940. int result = -ENXIO; + 1941. > struct snd_seq_client *cptr = NULL; + 1942. struct snd_seq_client_port *port = NULL; + 1943. struct snd_seq_port_subs_info *group; + +net/wireless/trace.h:1939: error: DEAD_STORE + The value written to &p is never used. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +drivers/input/mouse/alps.c:1948: error: DEAD_STORE + The value written to &ret is never used. + 1946. { + 1947. u16 reg_val = 0x181; + 1948. > int ret = -1; + 1949. + 1950. /* enter monitor mode, to write the register */ + +net/ipv4/udp.c:1956: error: DEAD_STORE + The value written to &dif is never used. + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. > int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + +net/ipv4/udp.c:1955: error: DEAD_STORE + The value written to &offset is never used. + 1953. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + +net/ipv4/udp.c:1967: error: DEAD_STORE + The value written to &offset is never used. + 1965. start_lookup: + 1966. hslot = &udptable->hash2[hash2]; + 1967. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 1968. } + 1969. + +net/ipv4/udp.c:1957: error: DEAD_STORE + The value written to &sdif is never used. + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. > int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + 1959. struct sk_buff *nskb; + +drivers/base/core.c:1951: error: DEAD_STORE + The value written to &glue_dir is never used. + 1949. { + 1950. struct device *parent = dev->parent; + 1951. > struct kobject *glue_dir = NULL; + 1952. struct class_interface *class_intf; + 1953. + +drivers/ata/libahci.c:1954: error: DEAD_STORE + The value written to &rc is never used. + 1952. struct ata_host *host = dev_instance; + 1953. struct ahci_host_priv *hpriv; + 1954. > unsigned int rc = 0; + 1955. void __iomem *mmio; + 1956. u32 irq_stat, irq_masked; + +drivers/gpu/drm/i915/intel_sdvo.c:1957: error: DEAD_STORE + The value written to &format_map is never used. + 1955. const struct drm_connector_state *conn_state = connector->state; + 1956. struct intel_sdvo_sdtv_resolution_request tv_res; + 1957. > uint32_t reply = 0, format_map = 0; + 1958. int i; + 1959. + +drivers/md/md-bitmap.c:1954: error: DEAD_STORE + The value written to &rv is never used. + 1952. struct bitmap *get_bitmap_from_slot(struct mddev *mddev, int slot) + 1953. { + 1954. > int rv = 0; + 1955. struct bitmap *bitmap; + 1956. + +net/sunrpc/auth_gss/auth_gss.c:1965: error: DEAD_STORE + The value written to &status is never used. + 1963. struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; + 1964. int savedlen = head->iov_len; + 1965. > int status = -EIO; + 1966. + 1967. if (ctx->gc_proc != RPC_GSS_PROC_DATA) + +drivers/usb/core/hcd.c:1964: error: DEAD_STORE + The value written to &alt is never used. + 1962. { + 1963. int num_intfs, i, j; + 1964. > struct usb_host_interface *alt = NULL; + 1965. int ret = 0; + 1966. struct usb_hcd *hcd; + +drivers/usb/core/hcd.c:1965: error: DEAD_STORE + The value written to &ret is never used. + 1963. int num_intfs, i, j; + 1964. struct usb_host_interface *alt = NULL; + 1965. > int ret = 0; + 1966. struct usb_hcd *hcd; + 1967. struct usb_host_endpoint *ep; + +kernel/kprobes.c:1963: error: DEAD_STORE + The value written to &ret is never used. + 1961. int register_kretprobe(struct kretprobe *rp) + 1962. { + 1963. > int ret = 0; + 1964. struct kretprobe_instance *inst; + 1965. int i; + +net/wireless/trace.h:1961: error: DEAD_STORE + The value written to &p is never used. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +crypto/drbg.c:1971: error: DEAD_STORE + The value written to &pos is never used. + 1969. const struct drbg_core *core, int pr) + 1970. { + 1971. > int pos = 0; + 1972. static int priority = 200; + 1973. + +drivers/net/ethernet/broadcom/tg3.c:1973: error: DEAD_STORE + The value written to &flowctrl is never used. + 1971. { + 1972. u8 autoneg; + 1973. > u8 flowctrl = 0; + 1974. u32 old_rx_mode = tp->rx_mode; + 1975. u32 old_tx_mode = tp->tx_mode; + +kernel/cgroup/cpuset.c:1974: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1973 could be null and is dereferenced by call to `parent_cs()` at line 1974, column 26. + 1972. { + 1973. struct cpuset *cs = css_cs(css); + 1974. > struct cpuset *parent = parent_cs(cs); + 1975. struct cpuset *tmp_cs; + 1976. struct cgroup_subsys_state *pos_css; + +drivers/iommu/amd_iommu_init.c:1976: error: DEAD_STORE + The value written to &e is never used. + 1974. static int __init init_unity_map_range(struct ivmd_header *m) + 1975. { + 1976. > struct unity_map_entry *e = NULL; + 1977. char *s; + 1978. + +net/ipv4/cipso_ipv4.c:1979: error: DEAD_STORE + The value written to &hdr_delta is never used. + 1977. { + 1978. struct ip_options_rcu *opt = rcu_dereference_protected(*opt_ptr, 1); + 1979. > int hdr_delta = 0; + 1980. + 1981. if (!opt || opt->opt.cipso == 0) + +drivers/md/dm-table.c:1984: error: DEAD_STORE + The value written to &r is never used. + 1982. int dm_table_resume_targets(struct dm_table *t) + 1983. { + 1984. > int i, r = 0; + 1985. + 1986. lockdep_assert_held(&t->md->suspend_lock); + +drivers/net/ethernet/intel/e1000e/netdev.c:1992: error: DEAD_STORE + The value written to &ivar is never used. + 1990. struct e1000_ring *tx_ring = adapter->tx_ring; + 1991. int vector = 0; + 1992. > u32 ctrl_ext, ivar = 0; + 1993. + 1994. adapter->eiac_mask = 0; + +drivers/iommu/intel-iommu.c:1989: error: DEAD_STORE + The value written to &freelist is never used. + 1987. static void domain_exit(struct dmar_domain *domain) + 1988. { + 1989. > struct page *freelist = NULL; + 1990. + 1991. /* Domain 0 is reserved, so dont process it */ + +lib/vsprintf.c:2056: error: DEAD_STORE + The value written to &fmt is never used. + 2054. /* it's the next argument */ + 2055. spec->type = FORMAT_TYPE_WIDTH; + 2056. > return ++fmt - start; + 2057. } + 2058. + +lib/vsprintf.c:2071: error: DEAD_STORE + The value written to &fmt is never used. + 2069. /* it's the next argument */ + 2070. spec->type = FORMAT_TYPE_PRECISION; + 2071. > return ++fmt - start; + 2072. } + 2073. } + +lib/vsprintf.c:2097: error: DEAD_STORE + The value written to &fmt is never used. + 2095. case 'c': + 2096. spec->type = FORMAT_TYPE_CHAR; + 2097. > return ++fmt - start; + 2098. + 2099. case 's': + +lib/vsprintf.c:2101: error: DEAD_STORE + The value written to &fmt is never used. + 2099. case 's': + 2100. spec->type = FORMAT_TYPE_STR; + 2101. > return ++fmt - start; + 2102. + 2103. case 'p': + +lib/vsprintf.c:2105: error: DEAD_STORE + The value written to &fmt is never used. + 2103. case 'p': + 2104. spec->type = FORMAT_TYPE_PTR; + 2105. > return ++fmt - start; + 2106. + 2107. case '%': + +lib/vsprintf.c:2109: error: DEAD_STORE + The value written to &fmt is never used. + 2107. case '%': + 2108. spec->type = FORMAT_TYPE_PERCENT_CHAR; + 2109. > return ++fmt - start; + 2110. + 2111. /* integer number formats - set up the flags and "break" */ + +lib/vsprintf.c:2163: error: DEAD_STORE + The value written to &fmt is never used. + 2161. } + 2162. + 2163. > return ++fmt - start; + 2164. } + 2165. + +net/wireless/trace.h:1990: error: DEAD_STORE + The value written to &p is never used. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +drivers/tty/n_tty.c:2001: error: DEAD_STORE + The value written to &found is never used. + 1999. size_t eol; + 2000. size_t tail; + 2001. > int ret, found = 0; + 2002. + 2003. /* N.B. avoid overrun if nr == 0 */ + +drivers/gpu/drm/i915/i915_irq.c:2010: error: DEAD_STORE + The value written to &ier is never used. + 2008. u32 pipe_stats[I915_MAX_PIPES] = {}; + 2009. u32 hotplug_status = 0; + 2010. > u32 ier = 0; + 2011. + 2012. gt_iir = I915_READ(GTIIR); + +net/xfrm/xfrm_user.c:2004: error: DEAD_STORE + The value written to &mark is never used. + 2002. struct km_event c; + 2003. int err = -EINVAL; + 2004. > u32 mark = 0; + 2005. struct xfrm_mark m; + 2006. struct xfrm_aevent_id *p = nlmsg_data(nlh); + +drivers/cpufreq/cpufreq.c:2002: error: DEAD_STORE + The value written to &ret is never used. + 2000. unsigned int relation) + 2001. { + 2002. > int ret = -EINVAL; + 2003. + 2004. down_write(&policy->rwsem); + +drivers/gpu/drm/drm_dp_mst_topology.c:2019: error: DEAD_STORE + The value written to &len is never used. + 2017. } + 2018. + 2019. > len = build_dpcd_write(txmsg, port->port_num, offset, size, bytes); + 2020. txmsg->dst = mstb; + 2021. + +net/ipv4/tcp_ipv4.c:2005: error: DEAD_STORE + The value written to &net is never used. + 2003. { + 2004. struct tcp_iter_state *st = seq->private; + 2005. > struct net *net = seq_file_net(seq); + 2006. void *rc = NULL; + 2007. + +crypto/drbg.c:2008: error: DEAD_STORE + The value written to &j is never used. + 2006. { + 2007. unsigned int i = 0; /* pointer to drbg_algs */ + 2008. > unsigned int j = 0; /* pointer to drbg_cores */ + 2009. int ret; + 2010. + +net/netlink/af_netlink.c:2014: error: DEAD_STORE + The value written to &listeners is never used. + 2012. struct sock *sk; + 2013. struct netlink_sock *nlk; + 2014. > struct listeners *listeners = NULL; + 2015. struct mutex *cb_mutex = cfg ? cfg->cb_mutex : NULL; + 2016. unsigned int groups; + +drivers/net/ethernet/broadcom/tg3.c:2023: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2014 could be null and is dereferenced at line 2023, column 6. + 2021. oldflowctrl = tp->link_config.active_flowctrl; + 2022. + 2023. > if (phydev->link) { + 2024. lcl_adv = 0; + 2025. rmt_adv = 0; + +kernel/cgroup/cgroup.c:2022: error: NULL_DEREFERENCE + pointer `ns` last assigned on line 2015 could be null and is dereferenced at line 2022, column 18. + 2020. + 2021. /* Check if the caller has permission to mount. */ + 2022. > if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN)) { + 2023. put_cgroup_ns(ns); + 2024. return ERR_PTR(-EPERM); + +net/wireless/trace.h:2011: error: DEAD_STORE + The value written to &p is never used. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2015: error: DEAD_STORE + The value written to &blocked is never used. + 2013. static s32 e1000_check_reset_block_ich8lan(struct e1000_hw *hw) + 2014. { + 2015. > bool blocked = false; + 2016. int i = 0; + 2017. + +sound/core/seq/seq_clientmgr.c:2032: error: DEAD_STORE + The value written to &port is never used. + 2030. struct snd_seq_port_info *info = arg; + 2031. struct snd_seq_client *cptr; + 2032. > struct snd_seq_client_port *port = NULL; + 2033. + 2034. cptr = snd_seq_client_use_ptr(info->addr.client); + +net/wireless/trace.h:2029: error: DEAD_STORE + The value written to &p is never used. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/ipv4/tcp_output.c:2036: error: NULL_DEREFERENCE + pointer `skb` last assigned on line 2035 could be null and is dereferenced at line 2036, column 2. + 2034. + 2035. skb = tcp_send_head(sk); + 2036. > tcp_for_write_queue_from_safe(skb, next, sk) { + 2037. if (len <= skb->len) + 2038. break; + +net/ipv4/tcp_ipv4.c:2038: error: DEAD_STORE + The value written to &net is never used. + 2036. struct hlist_nulls_node *node; + 2037. struct tcp_iter_state *st = seq->private; + 2038. > struct net *net = seq_file_net(seq); + 2039. + 2040. ++st->num; + +net/sunrpc/xprtsock.c:2042: error: DEAD_STORE + The value written to &status is never used. + 2040. struct rpc_xprt *xprt = &transport->xprt; + 2041. struct socket *sock; + 2042. > int status = -EIO; + 2043. + 2044. status = __sock_create(xprt->xprt_net, AF_LOCAL, + +security/selinux/ss/services.c:2051: error: DEAD_STORE + The value written to &rc is never used. + 2049. u32 seqno; + 2050. u16 map_size; + 2051. > int rc = 0; + 2052. struct policy_file file = { data, len }, *fp = &file; + 2053. + +net/wireless/trace.h:2047: error: DEAD_STORE + The value written to &p is never used. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +drivers/gpu/drm/drm_edid.c:2055: error: DEAD_STORE + The value written to &mode is never used. + 2053. { + 2054. struct drm_device *dev = connector->dev; + 2055. > struct drm_display_mode *m, *mode = NULL; + 2056. int hsize, vsize; + 2057. int vrefresh_rate; + +net/xfrm/xfrm_policy.c:2055: error: DEAD_STORE + The value written to &num_pols is never used. + 2053. { + 2054. struct xfrm_policy *pols[XFRM_POLICY_TYPE_MAX]; + 2055. > int num_pols = 0, num_xfrms = 0, err; + 2056. struct xfrm_dst *xdst; + 2057. + +drivers/scsi/sd.c:2063: error: DEAD_STORE + The value written to &spintime_expire is never used. + 2061. { + 2062. unsigned char cmd[10]; + 2063. > unsigned long spintime_expire = 0; + 2064. int retries, spintime; + 2065. unsigned int the_result; + +drivers/scsi/sd.c:2139: error: DEAD_STORE + The value written to &spintime_expire is never used. + 2137. SD_TIMEOUT, SD_MAX_RETRIES, + 2138. NULL); + 2139. > spintime_expire = jiffies + 100 * HZ; + 2140. spintime = 1; + 2141. } + +drivers/scsi/sd.c:2155: error: DEAD_STORE + The value written to &spintime_expire is never used. + 2153. sshdr.asc == 0x28) { + 2154. if (!spintime) { + 2155. > spintime_expire = jiffies + 5 * HZ; + 2156. spintime = 1; + 2157. } + +drivers/net/ethernet/intel/e1000e/ethtool.c:2072: error: DEAD_STORE + The value written to &p is never used. + 2070. struct rtnl_link_stats64 net_stats; + 2071. int i; + 2072. > char *p = NULL; + 2073. + 2074. pm_runtime_get_sync(netdev->dev.parent); + +drivers/ata/libata-core.c:2073: error: DEAD_STORE + The value written to &dma is never used. + 2071. struct ata_taskfile tf; + 2072. unsigned int err_mask; + 2073. > bool dma = false; + 2074. + 2075. DPRINTK("read log page - log 0x%x, page 0x%x\n", log, page); + +net/wireless/trace.h:2067: error: DEAD_STORE + The value written to &p is never used. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/sunrpc/auth_gss/auth_gss.c:2073: error: DEAD_STORE + The value written to &err is never used. + 2071. static int __init init_rpcsec_gss(void) + 2072. { + 2073. > int err = 0; + 2074. + 2075. err = rpcauth_register(&authgss_ops); + +kernel/time/timekeeping.c:2080: error: DEAD_STORE + The value written to &shift is never used. + 2078. struct timekeeper *tk = &shadow_timekeeper; + 2079. u64 offset; + 2080. > int shift = 0, maxshift; + 2081. unsigned int clock_set = 0; + 2082. unsigned long flags; + +net/xfrm/xfrm_user.c:2084: error: DEAD_STORE + The value written to &err is never used. + 2082. struct xfrm_userpolicy_info *p = &up->pol; + 2083. u8 type = XFRM_POLICY_TYPE_MAIN; + 2084. > int err = -ENOENT; + 2085. struct xfrm_mark m; + 2086. u32 mark = xfrm_mark_get(attrs, &m); + +drivers/hid/hid-sony.c:2126: error: DEAD_STORE + The value written to &offset is never used. + 2124. /* If both delay values are zero the DualShock 4 disables blinking. */ + 2125. buf[offset++] = sc->led_delay_on[3]; + 2126. > buf[offset++] = sc->led_delay_off[3]; + 2127. + 2128. if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) + +drivers/net/ethernet/nvidia/forcedeth.c:2085: error: DEAD_STORE + The value written to &tx_status is never used. + 2083. u32 reg; + 2084. u32 low; + 2085. > int tx_status = 0; + 2086. + 2087. reg = readl(base + NvRegSlotTime) & ~NVREG_SLOTTIME_MASK; + +drivers/gpu/drm/i915/i915_irq.c:2098: error: DEAD_STORE + The value written to &ier is never used. + 2096. u32 pipe_stats[I915_MAX_PIPES] = {}; + 2097. u32 hotplug_status = 0; + 2098. > u32 ier = 0; + 2099. + 2100. master_ctl = I915_READ(GEN8_MASTER_IRQ) & ~GEN8_MASTER_IRQ_CONTROL; + +drivers/usb/core/hub.c:2088: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2083 could be null and is dereferenced at line 2088, column 7. + 2086. /* Free up all the children before we remove this device */ + 2087. for (i = 0; i < udev->maxchild; i++) { + 2088. > if (hub->ports[i]->child) + 2089. usb_disconnect(&hub->ports[i]->child); + 2090. } + +net/wireless/reg.c:2085: error: DEAD_STORE + The value written to &bw_flags is never used. + 2083. const struct ieee80211_regdomain *regd) + 2084. { + 2085. > u32 bw_flags = 0; + 2086. const struct ieee80211_reg_rule *reg_rule = NULL; + 2087. const struct ieee80211_power_rule *power_rule = NULL; + +net/wireless/reg.c:2087: error: DEAD_STORE + The value written to &power_rule is never used. + 2085. u32 bw_flags = 0; + 2086. const struct ieee80211_reg_rule *reg_rule = NULL; + 2087. > const struct ieee80211_power_rule *power_rule = NULL; + 2088. u32 bw; + 2089. + +net/wireless/trace.h:2087: error: DEAD_STORE + The value written to &p is never used. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +drivers/net/ethernet/broadcom/tg3.c:2106: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2103 could be null and is dereferenced by call to `phydev_name()` at line 2106, column 32. + 2104. + 2105. /* Attach the MAC to the PHY. */ + 2106. > phydev = phy_connect(tp->dev, phydev_name(phydev), + 2107. tg3_adjust_link, phydev->interface); + 2108. if (IS_ERR(phydev)) { + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &p is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &ret is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +drivers/tty/n_tty.c:2168: error: DEAD_STORE + The value written to &nr is never used. + 2166. } + 2167. b++; + 2168. > nr--; + 2169. break; + 2170. } + +drivers/usb/core/devio.c:2116: error: DEAD_STORE + The value written to &intf is never used. + 2114. void *buf = NULL; + 2115. int retval = 0; + 2116. > struct usb_interface *intf = NULL; + 2117. struct usb_driver *driver = NULL; + 2118. + +net/core/ethtool.c:2121: error: DEAD_STORE + The value written to &data is never used. + 2119. struct ethtool_dump dump, tmp; + 2120. const struct ethtool_ops *ops = dev->ethtool_ops; + 2121. > void *data = NULL; + 2122. + 2123. if (!ops->get_dump_data || !ops->get_dump_flag) + +kernel/cgroup/cpuset.c:2119: error: DEAD_STORE + The value written to &err is never used. + 2117. int __init cpuset_init(void) + 2118. { + 2119. > int err = 0; + 2120. + 2121. BUG_ON(!alloc_cpumask_var(&top_cpuset.cpus_allowed, GFP_KERNEL)); + +net/ipv4/route.c:2154: error: NULL_DEREFERENCE + pointer `in_dev` last assigned on line 2132 could be null and is dereferenced at line 2154, column 8. + 2152. || + 2153. (!ipv4_is_local_multicast(daddr) && + 2154. > IN_DEV_MFORWARD(in_dev)) + 2155. #endif + 2156. ) { + +drivers/net/ethernet/intel/e1000e/netdev.c:2122: error: DEAD_STORE + The value written to &err is never used. + 2120. { + 2121. struct net_device *netdev = adapter->netdev; + 2122. > int err = 0, vector = 0; + 2123. + 2124. if (strlen(netdev->name) < (IFNAMSIZ - 5)) + +drivers/gpu/drm/drm_fb_helper.c:2128: error: DEAD_STORE + The value written to &i is never used. + 2126. bool any_enabled = false; + 2127. struct drm_connector *connector; + 2128. > int i = 0; + 2129. + 2130. drm_fb_helper_for_each_connector(fb_helper, i) { + +drivers/md/md.c:2148: error: DEAD_STORE + The value written to &bi_rdev is never used. + 2146. return 0; + 2147. + 2148. > bi_rdev = bdev_get_integrity(rdev->bdev); + 2149. bi_mddev = blk_get_integrity(mddev->gendisk); + 2150. + +net/wireless/trace.h:2139: error: DEAD_STORE + The value written to &p is never used. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +drivers/net/ethernet/broadcom/tg3.c:2154: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced at line 2154, column 3. + 2152. if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) { + 2153. tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER; + 2154. > phydev->speed = tp->link_config.speed; + 2155. phydev->duplex = tp->link_config.duplex; + 2156. phydev->autoneg = tp->link_config.autoneg; + +drivers/net/ethernet/broadcom/tg3.c:2160: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced by call to `phy_start()` at line 2160, column 2. + 2158. } + 2159. + 2160. > phy_start(phydev); + 2161. + 2162. phy_start_aneg(phydev); + +drivers/tty/serial/serial_core.c:2155: error: NULL_DEREFERENCE + pointer `tty_dev` last assigned on line 2154 could be null and is dereferenced by call to `device_may_wakeup()` at line 2155, column 27. + 2153. + 2154. tty_dev = device_find_child(uport->dev, &match, serial_match_port); + 2155. > if (!uport->suspended && device_may_wakeup(tty_dev)) { + 2156. if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) + 2157. disable_irq_wake(uport->irq); + +drivers/gpu/drm/drm_fb_helper.c:2154: error: DEAD_STORE + The value written to &can_clone is never used. + 2152. { + 2153. int count, i, j; + 2154. > bool can_clone = false; + 2155. struct drm_fb_helper_connector *fb_helper_conn; + 2156. struct drm_display_mode *dmt_mode, *mode; + +kernel/cgroup/cpuset.c:2160: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 2157 could be null and is dereferenced by call to `parent_cs()` at line 2160, column 12. + 2158. while (cpumask_empty(parent->cpus_allowed) || + 2159. nodes_empty(parent->mems_allowed)) + 2160. > parent = parent_cs(parent); + 2161. + 2162. if (cgroup_transfer_tasks(parent->css.cgroup, cs->css.cgroup)) { + +net/wireless/trace.h:2157: error: DEAD_STORE + The value written to &p is never used. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +block/blk-mq.c:2172: error: NULL_DEREFERENCE + pointer `hctx` last assigned on line 2171 could be null and is dereferenced at line 2172, column 25. + 2170. + 2171. hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead); + 2172. > ctx = __blk_mq_get_ctx(hctx->queue, cpu); + 2173. + 2174. spin_lock(&ctx->lock); + +net/xfrm/xfrm_user.c:2214: error: DEAD_STORE + The value written to &err is never used. + 2212. t->ealgos = ua->ealgos; + 2213. t->calgos = ua->calgos; + 2214. > err = km_query(x, t, xp); + 2215. + 2216. } + +net/wireless/trace.h:2175: error: DEAD_STORE + The value written to &p is never used. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +kernel/rcu/tree.c:2230: error: DEAD_STORE + The value written to &ret is never used. + 2228. TPS("fqswait")); + 2229. rsp->gp_state = RCU_GP_WAIT_FQS; + 2230. > ret = swait_event_idle_timeout(rsp->gp_wq, + 2231. rcu_gp_fqs_check_wake(rsp, &gf), j); + 2232. rsp->gp_state = RCU_GP_DOING_FQS; + +net/core/dev.c:2231: error: DEAD_STORE + The value written to &map is never used. + 2229. for (i = tc, tci = cpu * num_tc; dev_maps && i--; tci++) { + 2230. /* fill in the new device map from the old device map */ + 2231. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2232. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2233. } + +net/core/dev.c:2258: error: DEAD_STORE + The value written to &map is never used. + 2256. } else if (dev_maps) { + 2257. /* fill in the new device map from the old device map */ + 2258. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2259. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2260. } + +net/core/dev.c:2265: error: DEAD_STORE + The value written to &map is never used. + 2263. for (i = num_tc - tc, tci++; dev_maps && --i; tci++) { + 2264. /* fill in the new device map from the old device map */ + 2265. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2266. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2267. } + +drivers/clk/clk.c:2197: error: DEAD_STORE + The value written to &ret is never used. + 2195. struct clk_core *parent) + 2196. { + 2197. > int ret = 0; + 2198. int p_index = 0; + 2199. unsigned long p_rate = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2197: error: DEAD_STORE + The value written to &ret_val is never used. + 2195. static s32 e1000_k1_gig_workaround_hv(struct e1000_hw *hw, bool link) + 2196. { + 2197. > s32 ret_val = 0; + 2198. u16 status_reg = 0; + 2199. bool k1_enable = hw->dev_spec.ich8lan.nvm_k1_enabled; + +block/cfq-iosched.c:2213: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced at line 2213, column 12. + 2211. if (cfq_class_idle(cfqq)) { + 2212. rb_key = CFQ_IDLE_DELAY; + 2213. > parent = st->rb_rightmost; + 2214. if (parent && parent != &cfqq->rb_node) { + 2215. __cfqq = rb_entry(parent, struct cfq_queue, rb_node); + +block/cfq-iosched.c:2231: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced by call to `cfq_rb_first()` at line 2231, column 12. + 2229. } else { + 2230. rb_key = -NSEC_PER_SEC; + 2231. > __cfqq = cfq_rb_first(st); + 2232. rb_key += __cfqq ? __cfqq->rb_key : now; + 2233. } + +net/wireless/trace.h:2200: error: DEAD_STORE + The value written to &p is never used. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +drivers/gpu/drm/drm_dp_mst_topology.c:2210: error: DEAD_STORE + The value written to &ret is never used. + 2208. int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr) + 2209. { + 2210. > int ret = 0; + 2211. + 2212. mutex_lock(&mgr->lock); + +drivers/gpu/drm/drm_atomic.c:2234: error: DEAD_STORE + The value written to &ret is never used. + 2232. struct drm_out_fence_state *fence_state; + 2233. unsigned plane_mask; + 2234. > int ret = 0; + 2235. unsigned int i, j, num_fences; + 2236. + +net/wireless/trace.h:2220: error: DEAD_STORE + The value written to &p is never used. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +drivers/usb/host/ehci-sched.c:2270: error: DEAD_STORE + The value written to &dev is never used. + 2268. + 2269. /* give urb back to the driver; completion often (re)submits */ + 2270. > dev = urb->dev; + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + +drivers/usb/host/ehci-sched.c:2273: error: DEAD_STORE + The value written to &urb is never used. + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + 2273. > urb = NULL; + 2274. + 2275. --ehci->isoc_count; + +drivers/iommu/intel-iommu.c:2234: error: DEAD_STORE + The value written to &lvl_pages is never used. + 2232. unsigned long sg_res = 0; + 2233. unsigned int largepage_lvl = 0; + 2234. > unsigned long lvl_pages = 0; + 2235. + 2236. BUG_ON(!domain_pfn_supported(domain, iov_pfn + nr_pages - 1)); + +net/core/rtnetlink.c:2441: error: DEAD_STORE + The value written to &err is never used. + 2439. } + 2440. } + 2441. > err = 0; + 2442. + 2443. if (tb[IFLA_VF_PORTS]) { + +net/core/rtnetlink.c:2474: error: DEAD_STORE + The value written to &err is never used. + 2472. } + 2473. } + 2474. > err = 0; + 2475. + 2476. if (tb[IFLA_PORT_SELF]) { + +security/selinux/hooks.c:2245: error: DEAD_STORE + The value written to &rc is never used. + 2243. { + 2244. const struct cred *cred = current_cred(); + 2245. > int rc = 0; + 2246. + 2247. if (!sb) + +drivers/net/ethernet/intel/e1000e/phy.c:2245: error: DEAD_STORE + The value written to &phy_type is never used. + 2243. enum e1000_phy_type e1000e_get_phy_type_from_id(u32 phy_id) + 2244. { + 2245. > enum e1000_phy_type phy_type = e1000_phy_unknown; + 2246. + 2247. switch (phy_id) { + +net/wireless/trace.h:2244: error: DEAD_STORE + The value written to &p is never used. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/unix/af_unix.c:2365: error: DEAD_STORE + The value written to &sunaddr is never used. + 2363. /* Copy address just once */ + 2364. if (state->msg && state->msg->msg_name) { + 2365. > DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + +net/unix/af_unix.c:2368: error: DEAD_STORE + The value written to &sunaddr is never used. + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + 2368. > sunaddr = NULL; + 2369. } + 2370. + +drivers/gpu/drm/drm_dp_mst_topology.c:2276: error: DEAD_STORE + The value written to &origlen is never used. + 2274. replylen = msg->curchunk_len + msg->curchunk_hdrlen; + 2275. + 2276. > origlen = replylen; + 2277. replylen -= len; + 2278. curreply = len; + +net/ipv4/igmp.c:2259: error: DEAD_STORE + The value written to &in_dev is never used. + 2257. __be32 addr = mreqs->imr_multiaddr; + 2258. struct ip_mc_socklist *pmc; + 2259. > struct in_device *in_dev = NULL; + 2260. struct inet_sock *inet = inet_sk(sk); + 2261. struct ip_sf_socklist *psl; + +net/wireless/trace.h:2262: error: DEAD_STORE + The value written to &ret is never used. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +kernel/cgroup/cgroup.c:2279: error: DEAD_STORE + The value written to &ssid is never used. + 2277. /* check that we can legitimately attach to the cgroup */ + 2278. if (tset->nr_tasks) { + 2279. > do_each_subsys_mask(ss, ssid, mgctx->ss_mask) { + 2280. if (ss->can_attach) { + 2281. tset->ssid = ssid; + +kernel/cgroup/cgroup.c:2319: error: DEAD_STORE + The value written to &ssid is never used. + 2317. + 2318. if (tset->nr_tasks) { + 2319. > do_each_subsys_mask(ss, ssid, mgctx->ss_mask) { + 2320. if (ss->attach) { + 2321. tset->ssid = ssid; + +kernel/cgroup/cgroup.c:2332: error: DEAD_STORE + The value written to &ssid is never used. + 2330. out_cancel_attach: + 2331. if (tset->nr_tasks) { + 2332. > do_each_subsys_mask(ss, ssid, mgctx->ss_mask) { + 2333. if (ssid == failed_ssid) + 2334. break; + +kernel/kprobes.c:2271: error: DEAD_STORE + The value written to &err is never used. + 2269. static int __init init_kprobes(void) + 2270. { + 2271. > int i, err = 0; + 2272. + 2273. /* FIXME allocate the probe table, currently defined statically */ + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2276: error: DEAD_STORE + The value written to &ctrl_ext is never used. + 2274. s32 ret_val; + 2275. u32 ctrl_reg = 0; + 2276. > u32 ctrl_ext = 0; + 2277. u32 reg = 0; + 2278. u16 kmrn_reg = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2275: error: DEAD_STORE + The value written to &ctrl_reg is never used. + 2273. { + 2274. s32 ret_val; + 2275. > u32 ctrl_reg = 0; + 2276. u32 ctrl_ext = 0; + 2277. u32 reg = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2277: error: DEAD_STORE + The value written to ® is never used. + 2275. u32 ctrl_reg = 0; + 2276. u32 ctrl_ext = 0; + 2277. > u32 reg = 0; + 2278. u16 kmrn_reg = 0; + 2279. + +security/selinux/ss/policydb.c:2338: error: DEAD_STORE + The value written to &policydb_str is never used. + 2336. /* Done with policydb_str. */ + 2337. kfree(policydb_str); + 2338. > policydb_str = NULL; + 2339. + 2340. /* Read the version and table sizes. */ + +security/selinux/ss/policydb.c:2447: error: DEAD_STORE + The value written to &rc is never used. + 2445. goto bad; + 2446. + 2447. > rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + +kernel/sysctl.c:2291: error: DEAD_STORE + The value written to &kbuf is never used. + 2289. size_t left; + 2290. bool neg; + 2291. > char *kbuf = NULL, *p; + 2292. + 2293. left = *lenp; + +kernel/sysctl.c:2325: error: DEAD_STORE + The value written to &left is never used. + 2323. + 2324. if (!err && left) + 2325. > left -= proc_skip_spaces(&p); + 2326. + 2327. out_free: + +drivers/scsi/scsi_error.c:2291: error: DEAD_STORE + The value written to &error is never used. + 2289. struct request *rq; + 2290. unsigned long flags; + 2291. > int error = 0, rtn, val; + 2292. + 2293. if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO)) + +include/linux/pci.h:2314: error: DEAD_STORE + The value written to &idx is never used. + 2312. + 2313. if (idx > 0) { + 2314. > envp[idx++] = NULL; + 2315. kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp); + 2316. } + +drivers/gpu/drm/i915/intel_ddi.c:2303: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2298 could be null and is dereferenced at line 2303, column 2. + 2301. intel_disable_ddi_buf(encoder); + 2302. + 2303. > dig_port->set_infoframes(&encoder->base, false, + 2304. old_crtc_state, old_conn_state); + 2305. + +net/wireless/nl80211.c:2298: error: DEAD_STORE + The value written to &rem_txq_params is never used. + 2296. struct net_device *netdev = NULL; + 2297. struct wireless_dev *wdev; + 2298. > int result = 0, rem_txq_params = 0; + 2299. struct nlattr *nl_txq_params; + 2300. u32 changed; + +drivers/net/ethernet/intel/e1000e/phy.c:2301: error: DEAD_STORE + The value written to &phy_addr is never used. + 2299. s32 e1000e_determine_phy_address(struct e1000_hw *hw) + 2300. { + 2301. > u32 phy_addr = 0; + 2302. u32 i; + 2303. enum e1000_phy_type phy_type = e1000_phy_unknown; + +drivers/gpu/drm/drm_dp_mst_topology.c:2314: error: DEAD_STORE + The value written to &slot is never used. + 2312. struct drm_dp_sideband_msg_tx *txmsg; + 2313. struct drm_dp_mst_branch *mstb; + 2314. > int slot = -1; + 2315. mstb = drm_dp_get_mst_branch_device(mgr, + 2316. mgr->down_rep_recv.initial_hdr.lct, + +net/wireless/trace.h:2301: error: DEAD_STORE + The value written to &p is never used. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/sunrpc/clnt.c:2375: error: DEAD_STORE + The value written to &len is never used. + 2373. goto out_err; + 2374. } + 2375. > if (--len < 0) + 2376. goto out_overflow; + 2377. switch ((n = ntohl(*p++))) { + +net/sunrpc/clnt.c:2377: error: DEAD_STORE + The value written to &p is never used. + 2375. if (--len < 0) + 2376. goto out_overflow; + 2377. > switch ((n = ntohl(*p++))) { + 2378. case RPC_AUTH_REJECTEDCRED: + 2379. case RPC_AUTH_REJECTEDVERF: + +net/wireless/trace.h:2326: error: DEAD_STORE + The value written to &p is never used. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/ipv4/route.c:2337: error: DEAD_STORE + The value written to &err is never used. + 2335. unsigned int flags = 0; + 2336. struct rtable *rth; + 2337. > int err = -ENETUNREACH; + 2338. + 2339. if (fl4->saddr) { + +drivers/iommu/amd_iommu.c:2342: error: DEAD_STORE + The value written to &prot is never used. + 2340. dma_addr_t address, start, ret; + 2341. unsigned int pages; + 2342. > int prot = 0; + 2343. int i; + 2344. + +block/blk-mq.c:2338: error: DEAD_STORE + The value written to &ret is never used. + 2336. static bool __blk_mq_alloc_rq_map(struct blk_mq_tag_set *set, int hctx_idx) + 2337. { + 2338. > int ret = 0; + 2339. + 2340. set->tags[hctx_idx] = blk_mq_alloc_rq_map(set, hctx_idx, + +net/xfrm/xfrm_policy.c:2349: error: DEAD_STORE + The value written to &idx is never used. + 2347. for (; idx < sp->len; idx++) { + 2348. if (xfrm_state_ok(tmpl, sp->xvec[idx], family)) + 2349. > return ++idx; + 2350. if (sp->xvec[idx]->props.mode != XFRM_MODE_TRANSPORT) { + 2351. if (start == -1) + +net/wireless/trace.h:2338: error: DEAD_STORE + The value written to &p is never used. + 2336. ); + 2337. + 2338. > DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, + 2339. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2340. TP_ARGS(netdev, macaddr), + +kernel/sysctl.c:2348: error: DEAD_STORE + The value written to &err is never used. + 2346. { + 2347. unsigned long lval; + 2348. > int err = 0; + 2349. size_t left; + 2350. + +drivers/usb/core/hub.c:2360: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2354 could be null and is dereferenced at line 2360, column 10. + 2358. * use that to determine whether it's removable. + 2359. */ + 2360. > switch (hub->ports[udev->portnum - 1]->connect_type) { + 2361. case USB_PORT_CONNECT_TYPE_HOT_PLUG: + 2362. udev->removable = USB_DEVICE_REMOVABLE; + +drivers/net/ethernet/nvidia/forcedeth.c:2363: error: DEAD_STORE + The value written to &start_tx_ctx is never used. + 2361. struct ring_desc_ex *prev_tx; + 2362. struct nv_skb_map *prev_tx_ctx; + 2363. > struct nv_skb_map *start_tx_ctx = NULL; + 2364. struct nv_skb_map *tmp_tx_ctx = NULL; + 2365. unsigned long flags; + +net/core/skbuff.c:2354: error: DEAD_STORE + The value written to &ret is never used. + 2352. int skb_send_sock(struct sock *sk, struct sk_buff *skb, int offset, int len) + 2353. { + 2354. > int ret = 0; + 2355. + 2356. lock_sock(sk); + +net/wireless/trace.h:2358: error: DEAD_STORE + The value written to &p is never used. + 2356. ); + 2357. + 2358. > DECLARE_EVENT_CLASS(netdev_evt_only, + 2359. TP_PROTO(struct net_device *netdev), + 2360. TP_ARGS(netdev), + +net/wireless/reg.c:2365: error: DEAD_STORE + The value written to &last_wiphy is never used. + 2363. struct regulatory_request *country_ie_request) + 2364. { + 2365. > struct wiphy *last_wiphy = NULL; + 2366. struct regulatory_request *lr = get_last_request(); + 2367. + +kernel/kprobes.c:2376: error: DEAD_STORE + The value written to &sym is never used. + 2374. struct hlist_head *head; + 2375. struct kprobe *p, *kp; + 2376. > const char *sym = NULL; + 2377. unsigned int i = *(loff_t *) v; + 2378. unsigned long offset = 0; + +net/core/ethtool.c:2379: error: DEAD_STORE + The value written to &backup is never used. + 2377. int i, ret = 0; + 2378. int n_queue; + 2379. > struct ethtool_coalesce *backup = NULL, *tmp = NULL; + 2380. DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE); + 2381. + +net/core/ethtool.c:2379: error: DEAD_STORE + The value written to &tmp is never used. + 2377. int i, ret = 0; + 2378. int n_queue; + 2379. > struct ethtool_coalesce *backup = NULL, *tmp = NULL; + 2380. DECLARE_BITMAP(queue_mask, MAX_NUM_QUEUE); + 2381. + +net/wireless/trace.h:2375: error: DEAD_STORE + The value written to &p is never used. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +drivers/cpufreq/cpufreq.c:2381: error: DEAD_STORE + The value written to &ret is never used. + 2379. { + 2380. unsigned long flags; + 2381. > int ret = 0; + 2382. + 2383. if (cpufreq_driver->boost_enabled == state) + +drivers/gpu/drm/i915/i915_drv.c:2388: error: DEAD_STORE + The value written to &timeout__ is never used. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/i915_drv.c:2388: error: DEAD_STORE + The value written to &wait__ is never used. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/intel_ddi.c:2408: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2396 could be null and is dereferenced at line 2408, column 2. + 2406. * enabling the port. + 2407. */ + 2408. > I915_WRITE(DDI_BUF_CTL(port), + 2409. dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE); + 2410. + +net/wireless/trace.h:2392: error: DEAD_STORE + The value written to &p is never used. + 2390. ); + 2391. + 2392. > DECLARE_EVENT_CLASS(netdev_frame_event, + 2393. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2394. TP_ARGS(netdev, buf, len), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2407: error: DEAD_STORE + The value written to &ctrl is never used. + 2405. u16 phy_data; + 2406. + 2407. > ctrl = er32(CTRL); + 2408. status = er32(STATUS); + 2409. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2468: error: DEAD_STORE + The value written to &ret_val is never used. + 2466. hw->forced_speed_duplex == e1000_10_half)) { + 2467. ew32(IMC, 0xffffffff); + 2468. > ret_val = + 2469. e1000_polarity_reversal_workaround(hw); + 2470. icr = er32(ICR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2398: error: DEAD_STORE + The value written to &rxcw is never used. + 2396. s32 e1000_check_for_link(struct e1000_hw *hw) + 2397. { + 2398. > u32 rxcw = 0; + 2399. u32 ctrl; + 2400. u32 status; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2416: error: DEAD_STORE + The value written to &rxcw is never used. + 2414. if ((hw->media_type == e1000_media_type_fiber) || + 2415. (hw->media_type == e1000_media_type_internal_serdes)) { + 2416. > rxcw = er32(RXCW); + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2403: error: DEAD_STORE + The value written to &signal is never used. + 2401. u32 rctl; + 2402. u32 icr; + 2403. > u32 signal = 0; + 2404. s32 ret_val; + 2405. u16 phy_data; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2419: error: DEAD_STORE + The value written to &signal is never used. + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + 2419. > signal = + 2420. (hw->mac_type > + 2421. e1000_82544) ? E1000_CTRL_SWDPIN1 : 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2409: error: DEAD_STORE + The value written to &ret_val is never used. + 2407. static s32 e1000_hv_phy_workarounds_ich8lan(struct e1000_hw *hw) + 2408. { + 2409. > s32 ret_val = 0; + 2410. u16 phy_data; + 2411. + +drivers/iommu/amd_iommu_init.c:2546: error: DEAD_STORE + The value written to &ivrs_base is never used. + 2544. /* Don't leak any ACPI memory */ + 2545. acpi_put_table(ivrs_base); + 2546. > ivrs_base = NULL; + 2547. + 2548. return ret; + +drivers/iommu/amd_iommu_init.c:2413: error: DEAD_STORE + The value written to &ret is never used. + 2411. struct acpi_table_header *ivrs_base; + 2412. acpi_status status; + 2413. > int i, remap_cache_sz, ret = 0; + 2414. + 2415. if (!amd_iommu_detected) + +drivers/gpu/drm/i915/i915_debugfs.c:2417: error: DEAD_STORE + The value written to &i is never used. + 2415. struct drm_i915_gem_object *obj = NULL; + 2416. u32 *log; + 2417. > int i = 0; + 2418. + 2419. if (!HAS_GUC(dev_priv)) + +net/sunrpc/xprtsock.c:2419: error: DEAD_STORE + The value written to &status is never used. + 2417. struct socket *sock = transport->sock; + 2418. struct rpc_xprt *xprt = &transport->xprt; + 2419. > int status = -EIO; + 2420. + 2421. if (!sock) { + +kernel/trace/trace.c:2419: error: DEAD_STORE + The value written to &size is never used. + 2417. { + 2418. struct trace_entry *entry; + 2419. > unsigned int size = 0; + 2420. + 2421. entry = ring_buffer_event_data(event); + +net/wireless/trace.h:2418: error: DEAD_STORE + The value written to &p is never used. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/ipv4/tcp_input.c:2431: error: DEAD_STORE + The value written to &sndcnt is never used. + 2429. { + 2430. struct tcp_sock *tp = tcp_sk(sk); + 2431. > int sndcnt = 0; + 2432. int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp); + 2433. + +net/wireless/trace.h:2434: error: DEAD_STORE + The value written to &p is never used. + 2432. ); + 2433. + 2434. > DECLARE_EVENT_CLASS(netdev_mac_evt, + 2435. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2436. TP_ARGS(netdev, mac), + +drivers/net/ethernet/intel/e1000/e1000_main.c:2461: error: DEAD_STORE + The value written to &txb2b is never used. + 2459. if (!netif_carrier_ok(netdev)) { + 2460. u32 ctrl; + 2461. > bool txb2b = true; + 2462. /* update snapshot of PHY registers on LSC */ + 2463. e1000_get_speed_and_duplex(hw, + +drivers/net/ethernet/intel/e1000/e1000_main.c:2483: error: DEAD_STORE + The value written to &txb2b is never used. + 2481. switch (adapter->link_speed) { + 2482. case SPEED_10: + 2483. > txb2b = false; + 2484. adapter->tx_timeout_factor = 16; + 2485. break; + +drivers/net/ethernet/intel/e1000/e1000_main.c:2487: error: DEAD_STORE + The value written to &txb2b is never used. + 2485. break; + 2486. case SPEED_100: + 2487. > txb2b = false; + 2488. /* maybe add some timeout factor ? */ + 2489. break; + +net/wireless/reg.c:2452: error: DEAD_STORE + The value written to &cfg80211_regd is never used. + 2450. const struct ieee80211_regdomain *wiphy1_regd = NULL; + 2451. const struct ieee80211_regdomain *wiphy2_regd = NULL; + 2452. > const struct ieee80211_regdomain *cfg80211_regd = NULL; + 2453. bool dfs_domain_same; + 2454. + +net/wireless/reg.c:2450: error: DEAD_STORE + The value written to &wiphy1_regd is never used. + 2448. bool reg_dfs_domain_same(struct wiphy *wiphy1, struct wiphy *wiphy2) + 2449. { + 2450. > const struct ieee80211_regdomain *wiphy1_regd = NULL; + 2451. const struct ieee80211_regdomain *wiphy2_regd = NULL; + 2452. const struct ieee80211_regdomain *cfg80211_regd = NULL; + +net/wireless/reg.c:2451: error: DEAD_STORE + The value written to &wiphy2_regd is never used. + 2449. { + 2450. const struct ieee80211_regdomain *wiphy1_regd = NULL; + 2451. > const struct ieee80211_regdomain *wiphy2_regd = NULL; + 2452. const struct ieee80211_regdomain *cfg80211_regd = NULL; + 2453. bool dfs_domain_same; + +net/wireless/trace.h:2459: error: DEAD_STORE + The value written to &p is never used. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +drivers/net/ethernet/intel/e100.c:2464: error: DEAD_STORE + The value written to &nic is never used. + 2462. static int e100_get_regs_len(struct net_device *netdev) + 2463. { + 2464. > struct nic *nic = netdev_priv(netdev); + 2465. return 1 + E100_PHY_REGS + sizeof(nic->mem->dump_buf); + 2466. } + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2474: error: DEAD_STORE + The value written to &exec2_list is never used. + 2472. struct drm_i915_gem_execbuffer2 exec2; + 2473. struct drm_i915_gem_exec_object *exec_list = NULL; + 2474. > struct drm_i915_gem_exec_object2 *exec2_list = NULL; + 2475. const size_t count = args->buffer_count; + 2476. unsigned int i; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2473: error: DEAD_STORE + The value written to &exec_list is never used. + 2471. struct drm_i915_gem_execbuffer *args = data; + 2472. struct drm_i915_gem_execbuffer2 exec2; + 2473. > struct drm_i915_gem_exec_object *exec_list = NULL; + 2474. struct drm_i915_gem_exec_object2 *exec2_list = NULL; + 2475. const size_t count = args->buffer_count; + +net/ipv4/igmp.c:2511: error: DEAD_STORE + The value written to &len is never used. + 2509. psl = rtnl_dereference(pmc->sflist); + 2510. if (!psl) { + 2511. > len = 0; + 2512. count = 0; + 2513. } else { + +net/wireless/trace.h:2483: error: DEAD_STORE + The value written to &p is never used. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +drivers/iommu/amd_iommu.c:2497: error: DEAD_STORE + The value written to &npages is never used. + 2495. unsigned long attrs) + 2496. { + 2497. > int mapped_pages = 0, npages = 0, prot = 0, i; + 2498. struct protection_domain *domain; + 2499. struct dma_ops_domain *dma_dom; + +drivers/iommu/amd_iommu.c:2497: error: DEAD_STORE + The value written to &prot is never used. + 2495. unsigned long attrs) + 2496. { + 2497. > int mapped_pages = 0, npages = 0, prot = 0, i; + 2498. struct protection_domain *domain; + 2499. struct dma_ops_domain *dma_dom; + +security/selinux/hooks.c:2504: error: DEAD_STORE + The value written to &devnull is never used. + 2502. struct files_struct *files) + 2503. { + 2504. > struct file *file, *devnull = NULL; + 2505. struct tty_struct *tty; + 2506. int drop_tty = 0; + +net/wireless/trace.h:2505: error: DEAD_STORE + The value written to &p is never used. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +drivers/gpu/drm/i915/i915_debugfs.c:2517: error: DEAD_STORE + The value written to &psrperf is never used. + 2515. { + 2516. struct drm_i915_private *dev_priv = node_to_i915(m->private); + 2517. > u32 psrperf = 0; + 2518. u32 stat[3]; + 2519. enum pipe pipe; + +net/wireless/trace.h:2523: error: DEAD_STORE + The value written to &p is never used. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +drivers/iommu/intel-iommu.c:2531: error: DEAD_STORE + The value written to &info is never used. + 2529. static struct dmar_domain *find_or_alloc_domain(struct device *dev, int gaw) + 2530. { + 2531. > struct device_domain_info *info = NULL; + 2532. struct dmar_domain *domain = NULL; + 2533. struct intel_iommu *iommu; + +drivers/iommu/intel-iommu.c:2542: error: DEAD_STORE + The value written to &req_id is never used. + 2540. return NULL; + 2541. + 2542. > req_id = ((u16)bus << 8) | devfn; + 2543. + 2544. if (dev_is_pci(dev)) { + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2532: error: DEAD_STORE + The value written to &ret_val is never used. + 2530. s32 e1000_lv_jumbo_workaround_ich8lan(struct e1000_hw *hw, bool enable) + 2531. { + 2532. > s32 ret_val = 0; + 2533. u16 phy_reg, data; + 2534. u32 mac_reg; + +drivers/gpu/drm/i915/intel_ddi.c:2585: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 2583 could be null and is dereferenced at line 2585, column 7. + 2583. intel_dig_port = enc_to_dig_port(&encoder->base); + 2584. + 2585. > if (intel_dig_port->infoframe_enabled(&encoder->base, pipe_config)) + 2586. pipe_config->has_infoframe = true; + 2587. + +drivers/gpu/drm/drm_dp_mst_topology.c:2546: error: DEAD_STORE + The value written to &edid is never used. + 2544. struct edid *drm_dp_mst_get_edid(struct drm_connector *connector, struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port) + 2545. { + 2546. > struct edid *edid = NULL; + 2547. + 2548. /* we need to search for the port in the mgr in case its gone */ + +net/core/neighbour.c:2550: error: DEAD_STORE + The value written to &bucket is never used. + 2548. struct neigh_hash_table *nht = state->nht; + 2549. struct neighbour *n = NULL; + 2550. > int bucket = state->bucket; + 2551. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + +net/wireless/trace.h:2546: error: DEAD_STORE + The value written to &p is never used. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +drivers/hid/hid-sony.c:2727: error: DEAD_STORE + The value written to &ret is never used. + 2725. sony_init_output_report(sc, motion_send_output_report); + 2726. } else { + 2727. > ret = 0; + 2728. } + 2729. + +drivers/net/ethernet/intel/e1000e/netdev.c:2559: error: DEAD_STORE + The value written to ¤t_itr is never used. + 2557. /* for non-gigabit speeds, just fix the interrupt rate at 4000 */ + 2558. if (adapter->link_speed != SPEED_1000) { + 2559. > current_itr = 0; + 2560. new_itr = 4000; + 2561. goto set_itr_now; + +net/wireless/trace.h:2563: error: DEAD_STORE + The value written to &p is never used. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +kernel/kprobes.c:2571: error: DEAD_STORE + The value written to &ret is never used. + 2569. char buf[32]; + 2570. size_t buf_size; + 2571. > int ret = 0; + 2572. + 2573. buf_size = min(count, (sizeof(buf)-1)); + +drivers/gpu/drm/i915/i915_perf.c:2575: error: DEAD_STORE + The value written to &stream is never used. + 2573. { + 2574. struct i915_gem_context *specific_ctx = NULL; + 2575. > struct i915_perf_stream *stream = NULL; + 2576. unsigned long f_flags = 0; + 2577. bool privileged_op = true; + +kernel/events/core.c:2575: error: DEAD_STORE + The value written to &ret is never used. + 2573. .restart = restart, + 2574. }; + 2575. > int ret = 0; + 2576. + 2577. do { + +drivers/iommu/amd_iommu.c:2581: error: DEAD_STORE + The value written to &npages is never used. + 2579. struct dma_ops_domain *dma_dom; + 2580. unsigned long startaddr; + 2581. > int npages = 2; + 2582. + 2583. domain = get_domain(dev); + +net/ipv4/ipmr.c:2592: error: DEAD_STORE + The value written to &rtm is never used. + 2590. goto errout; + 2591. + 2592. > rtm = nlmsg_data(nlh); + 2593. + 2594. src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0; + +kernel/power/snapshot.c:2579: error: DEAD_STORE + The value written to &error is never used. + 2577. { + 2578. static struct chain_allocator ca; + 2579. > int error = 0; + 2580. + 2581. /* Check if we have already loaded the entire image */ + +drivers/md/dm.c:2581: error: DEAD_STORE + The value written to &map is never used. + 2579. int dm_suspend(struct mapped_device *md, unsigned suspend_flags) + 2580. { + 2581. > struct dm_table *map = NULL; + 2582. int r = 0; + 2583. + +drivers/md/dm.c:2582: error: DEAD_STORE + The value written to &r is never used. + 2580. { + 2581. struct dm_table *map = NULL; + 2582. > int r = 0; + 2583. + 2584. retry: + +net/wireless/trace.h:2580: error: DEAD_STORE + The value written to &p is never used. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +drivers/gpu/drm/drm_atomic_helper.c:2596: error: DEAD_STORE + The value written to &ret is never used. + 2594. struct drm_atomic_state *state; + 2595. struct drm_plane_state *plane_state; + 2596. > int ret = 0; + 2597. + 2598. state = drm_atomic_state_alloc(plane->dev); + +net/ipv4/route.c:2599: error: DEAD_STORE + The value written to &expires is never used. + 2597. struct rtmsg *r; + 2598. struct nlmsghdr *nlh; + 2599. > unsigned long expires = 0; + 2600. u32 error; + 2601. u32 metrics[RTAX_MAX]; + +drivers/iommu/amd_iommu.c:2601: error: DEAD_STORE + The value written to &dma_mask is never used. + 2599. unsigned long attrs) + 2600. { + 2601. > u64 dma_mask = dev->coherent_dma_mask; + 2602. struct protection_domain *domain; + 2603. struct dma_ops_domain *dma_dom; + +drivers/gpu/drm/i915/i915_debugfs.c:2604: error: DEAD_STORE + The value written to &intel_dp is never used. + 2602. struct intel_connector *connector; + 2603. struct drm_connector_list_iter conn_iter; + 2604. > struct intel_dp *intel_dp = NULL; + 2605. struct drm_modeset_acquire_ctx ctx; + 2606. int ret; + +net/wireless/trace.h:2599: error: DEAD_STORE + The value written to &p is never used. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/unix/af_unix.c:2618: error: DEAD_STORE + The value written to &amount is never used. + 2616. { + 2617. struct sock *sk = sock->sk; + 2618. > long amount = 0; + 2619. int err; + 2620. + +net/sunrpc/clnt.c:2657: error: NULL_DEREFERENCE + pointer `xprt` last assigned on line 2627 could be null and is dereferenced at line 2657, column 2. + 2655. xprt_put(xprt); + 2656. xprt_switch_put(xps); + 2657. > pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n", + 2658. status, xprt->address_strings[RPC_DISPLAY_ADDR]); + 2659. return status; + +drivers/net/ethernet/intel/e100.c:2631: error: DEAD_STORE + The value written to &err is never used. + 2629. + 2630. /* save speed, duplex & autoneg settings */ + 2631. > err = mii_ethtool_gset(&nic->mii, &cmd); + 2632. + 2633. if (netif_running(netdev)) + +drivers/net/ethernet/intel/e100.c:2640: error: DEAD_STORE + The value written to &err is never used. + 2638. + 2639. /* restore speed, duplex & autoneg settings */ + 2640. > err = mii_ethtool_sset(&nic->mii, &cmd); + 2641. + 2642. if (netif_running(netdev)) + +net/packet/af_packet.c:2634: error: DEAD_STORE + The value written to &status is never used. + 2632. void *data; + 2633. int len_sum = 0; + 2634. > int status = TP_STATUS_AVAILABLE; + 2635. int hlen, tlen, copylen = 0; + 2636. + +net/wireless/trace.h:2620: error: DEAD_STORE + The value written to &p is never used. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +drivers/base/core.c:2625: error: DEAD_STORE + The value written to &old_device_name is never used. + 2623. { + 2624. struct kobject *kobj = &dev->kobj; + 2625. > char *old_device_name = NULL; + 2626. int error; + 2627. + +drivers/md/md.c:2625: error: DEAD_STORE + The value written to &err is never used. + 2623. { + 2624. struct mddev *mddev = rdev->mddev; + 2625. > int err = 0; + 2626. bool add_journal = test_bit(Journal, &rdev->flags); + 2627. + +net/wireless/trace.h:2635: error: DEAD_STORE + The value written to &p is never used. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +drivers/gpu/drm/i915/intel_display.c:2642: error: DEAD_STORE + The value written to &obj is never used. + 2640. struct drm_device *dev = crtc->base.dev; + 2641. struct drm_i915_private *dev_priv = to_i915(dev); + 2642. > struct drm_i915_gem_object *obj = NULL; + 2643. struct drm_mode_fb_cmd2 mode_cmd = { 0 }; + 2644. struct drm_framebuffer *fb = &plane_config->fb->base; + +drivers/md/dm.c:2640: error: DEAD_STORE + The value written to &map is never used. + 2638. { + 2639. int r; + 2640. > struct dm_table *map = NULL; + 2641. + 2642. retry: + +drivers/gpu/drm/drm_atomic_helper.c:2647: error: DEAD_STORE + The value written to &ret is never used. + 2645. struct drm_atomic_state *state; + 2646. struct drm_plane_state *plane_state; + 2647. > int ret = 0; + 2648. + 2649. state = drm_atomic_state_alloc(plane->dev); + +drivers/net/ethernet/intel/e1000/e1000_main.c:2657: error: DEAD_STORE + The value written to ¤t_itr is never used. + 2655. /* for non-gigabit speeds, just fix the interrupt rate at 4000 */ + 2656. if (unlikely(adapter->link_speed != SPEED_1000)) { + 2657. > current_itr = 0; + 2658. new_itr = 4000; + 2659. goto set_itr_now; + +net/core/neighbour.c:2652: error: DEAD_STORE + The value written to &bucket is never used. + 2650. struct neigh_table *tbl = state->tbl; + 2651. struct pneigh_entry *pn = NULL; + 2652. > int bucket = state->bucket; + 2653. + 2654. state->flags |= NEIGH_SEQ_IS_PNEIGH; + +net/wireless/trace.h:2651: error: DEAD_STORE + The value written to &p is never used. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +drivers/scsi/sd.c:2657: error: DEAD_STORE + The value written to &len is never used. + 2655. sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer) + 2656. { + 2657. > int len = 0, res; + 2658. struct scsi_device *sdp = sdkp->device; + 2659. + +drivers/tty/tty_io.c:2669: error: DEAD_STORE + The value written to &retval is never used. + 2667. struct tty_struct *tty = file_tty(file); + 2668. struct tty_ldisc *ld; + 2669. > int retval = -ENOIOCTLCMD; + 2670. + 2671. if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl")) + +net/wireless/trace.h:2667: error: DEAD_STORE + The value written to &p is never used. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +kernel/cgroup/cgroup.c:2685: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2684 could be null and is dereferenced at line 2685, column 7. + 2683. percpu_up_write(&cgroup_threadgroup_rwsem); + 2684. for_each_subsys(ss, ssid) + 2685. > if (ss->post_attach) + 2686. ss->post_attach(); + 2687. } + +drivers/md/dm.c:2681: error: DEAD_STORE + The value written to &map is never used. + 2679. static void __dm_internal_suspend(struct mapped_device *md, unsigned suspend_flags) + 2680. { + 2681. > struct dm_table *map = NULL; + 2682. + 2683. lockdep_assert_held(&md->suspend_lock); + +drivers/ata/libata-eh.c:2839: error: DEAD_STORE + The value written to &failed_link is never used. + 2837. rc = ata_do_reset(link, reset, classes, deadline, true); + 2838. if (rc && rc != -EAGAIN) { + 2839. > failed_link = link; + 2840. goto fail; + 2841. } + +drivers/ata/libata-eh.c:2859: error: DEAD_STORE + The value written to &failed_link is never used. + 2857. break; + 2858. default: + 2859. > failed_link = slave; + 2860. rc = tmp; + 2861. goto fail; + +drivers/ata/libata-eh.c:2873: error: DEAD_STORE + The value written to &failed_link is never used. + 2871. ata_link_err(link, + 2872. "follow-up softreset required but no softreset available\n"); + 2873. > failed_link = link; + 2874. rc = -EINVAL; + 2875. goto fail; + +drivers/ata/libata-eh.c:2881: error: DEAD_STORE + The value written to &failed_link is never used. + 2879. rc = ata_do_reset(link, reset, classes, deadline, true); + 2880. if (rc) { + 2881. > failed_link = link; + 2882. goto fail; + 2883. } + +drivers/ata/libata-eh.c:2988: error: DEAD_STORE + The value written to &failed_link is never used. + 2986. "link online but %d devices misclassified, retrying\n", + 2987. nr_unknown); + 2988. > failed_link = link; + 2989. rc = -EAGAIN; + 2990. goto fail; + +net/wireless/trace.h:2682: error: DEAD_STORE + The value written to &p is never used. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +kernel/cgroup/cgroup.c:2695: error: DEAD_STORE + The value written to &ssid is never used. + 2693. int ssid; + 2694. + 2695. > do_each_subsys_mask(ss, ssid, ss_mask) { + 2696. if (printed) + 2697. seq_putc(seq, ' '); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2698: error: DEAD_STORE + The value written to &ret_val is never used. + 2696. static s32 e1000_lv_phy_workarounds_ich8lan(struct e1000_hw *hw) + 2697. { + 2698. > s32 ret_val = 0; + 2699. + 2700. if (hw->mac.type != e1000_pch2lan) + +net/wireless/trace.h:2697: error: DEAD_STORE + The value written to &p is never used. + 2695. ); + 2696. + 2697. > DECLARE_EVENT_CLASS(cfg80211_rx_evt, + 2698. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2699. TP_ARGS(netdev, addr), + +block/blk-core.c:2709: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 2709, column 31. + 2707. { + 2708. struct request *rq; + 2709. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 2710. + 2711. WARN_ON_ONCE(q->mq_ops); + +net/ipv4/route.c:2716: error: DEAD_STORE + The value written to &dst is never used. + 2714. struct rtable *rt = NULL; + 2715. struct flowi4 fl4; + 2716. > __be32 dst = 0; + 2717. __be32 src = 0; + 2718. u32 iif; + +net/ipv4/route.c:2714: error: DEAD_STORE + The value written to &rt is never used. + 2712. struct nlattr *tb[RTA_MAX+1]; + 2713. struct fib_result res = {}; + 2714. > struct rtable *rt = NULL; + 2715. struct flowi4 fl4; + 2716. __be32 dst = 0; + +net/ipv4/route.c:2717: error: DEAD_STORE + The value written to &src is never used. + 2715. struct flowi4 fl4; + 2716. __be32 dst = 0; + 2717. > __be32 src = 0; + 2718. u32 iif; + 2719. int err; + +sound/pci/hda/hda_codec.c:2712: error: DEAD_STORE + The value written to &end_time is never used. + 2710. unsigned int power_state) + 2711. { + 2712. > unsigned long end_time = jiffies + msecs_to_jiffies(500); + 2713. unsigned int state, actual_state; + 2714. + +drivers/net/ethernet/intel/e100.c:2732: error: DEAD_STORE + The value written to &i is never used. + 2730. data[i++] = nic->rx_tco_frames; + 2731. data[i++] = nic->rx_short_frame_errors; + 2732. > data[i++] = nic->rx_over_length_errors; + 2733. } + 2734. + +net/core/filter.c:2729: error: DEAD_STORE + The value written to &err is never used. + 2727. struct net_device *fwd = NULL; + 2728. u32 index = ri->ifindex; + 2729. > int err = 0; + 2730. + 2731. ri->ifindex = 0; + +net/wireless/trace.h:2721: error: DEAD_STORE + The value written to &p is never used. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/ipv6/addrconf.c:2731: error: DEAD_STORE + The value written to &err is never used. + 2729. struct in6_ifreq ireq; + 2730. struct net_device *dev; + 2731. > int err = -EINVAL; + 2732. + 2733. rtnl_lock(); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2732: error: DEAD_STORE + The value written to &ret_val is never used. + 2730. static s32 e1000_k1_workaround_lv(struct e1000_hw *hw) + 2731. { + 2732. > s32 ret_val = 0; + 2733. u16 status_reg = 0; + 2734. + +net/ipv4/tcp_output.c:2737: error: NULL_DEREFERENCE + pointer `next_skb` last assigned on line 2733 could be null and is dereferenced at line 2737, column 18. + 2735. + 2736. skb_size = skb->len; + 2737. > next_skb_size = next_skb->len; + 2738. + 2739. BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1); + +net/wireless/trace.h:2739: error: DEAD_STORE + The value written to &p is never used. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +kernel/sched/fair.c:2753: error: DEAD_STORE + The value written to &res is never used. + 2751. cfs_rq->runnable_weight -= se->runnable_weight; + 2752. + 2753. > sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + +kernel/sched/fair.c:2754: error: DEAD_STORE + The value written to &res is never used. + 2752. + 2753. sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. > sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + 2756. } + +kernel/workqueue.c:2757: error: DEAD_STORE + The value written to &flush_cnt is never used. + 2755. void drain_workqueue(struct workqueue_struct *wq) + 2756. { + 2757. > unsigned int flush_cnt = 0; + 2758. struct pool_workqueue *pwq; + 2759. + +drivers/iommu/amd_iommu.c:2758: error: DEAD_STORE + The value written to &err is never used. + 2756. int __init amd_iommu_init_api(void) + 2757. { + 2758. > int ret, err = 0; + 2759. + 2760. ret = iova_cache_get(); + +drivers/iommu/intel-iommu.c:2758: error: DEAD_STORE + The value written to &ret is never used. + 2756. static int __init si_domain_init(int hw) + 2757. { + 2758. > int nid, ret = 0; + 2759. + 2760. si_domain = alloc_domain(DOMAIN_FLAG_STATIC_IDENTITY); + +drivers/scsi/scsi_lib.c:2793: error: DEAD_STORE + The value written to &idx is never used. + 2791. } + 2792. + 2793. > envp[idx++] = NULL; + 2794. + 2795. kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); + +net/wireless/trace.h:2760: error: DEAD_STORE + The value written to &p is never used. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2764: error: DEAD_STORE + The value written to &data is never used. + 2762. { + 2763. u32 ctrl; + 2764. > u16 data = 0; + 2765. u8 i; + 2766. + +net/core/filter.c:2769: error: DEAD_STORE + The value written to &err is never used. + 2767. u32 index = ri->ifindex; + 2768. struct net_device *fwd; + 2769. > int err = 0; + 2770. + 2771. if (ri->map) + +kernel/sched/fair.c:2768: error: DEAD_STORE + The value written to &res is never used. + 2766. dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) + 2767. { + 2768. > sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + +kernel/sched/fair.c:2769: error: DEAD_STORE + The value written to &res is never used. + 2767. { + 2768. sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. > sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + 2771. #else + +net/ipv6/mcast.c:2777: error: DEAD_STORE + The value written to &im is never used. + 2775. { + 2776. struct ip6_sf_list *psf = NULL; + 2777. > struct ifmcaddr6 *im = NULL; + 2778. struct igmp6_mcf_iter_state *state = igmp6_mcf_seq_private(seq); + 2779. struct net *net = seq_file_net(seq); + +drivers/gpu/drm/drm_atomic_helper.c:2784: error: DEAD_STORE + The value written to &ret is never used. + 2782. struct drm_atomic_state *state; + 2783. struct drm_crtc *crtc = set->crtc; + 2784. > int ret = 0; + 2785. + 2786. state = drm_atomic_state_alloc(crtc->dev); + +net/wireless/trace.h:2782: error: DEAD_STORE + The value written to &p is never used. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +drivers/net/ethernet/intel/e100.c:2798: error: DEAD_STORE + The value written to &err is never used. + 2796. { + 2797. struct nic *nic = netdev_priv(netdev); + 2798. > int err = 0; + 2799. + 2800. netif_carrier_off(netdev); + +net/wireless/trace.h:2803: error: DEAD_STORE + The value written to &p is never used. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2821: error: DEAD_STORE + The value written to &p is never used. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2832: error: DEAD_STORE + The value written to &ret_val is never used. + 2830. static s32 e1000_post_phy_reset_ich8lan(struct e1000_hw *hw) + 2831. { + 2832. > s32 ret_val = 0; + 2833. u16 reg; + 2834. + +drivers/cdrom/cdrom.c:2838: error: DEAD_STORE + The value written to &ret is never used. + 2836. track_information ti; + 2837. __u32 last_track; + 2838. > int ret = -1, ti_size; + 2839. + 2840. if (!CDROM_CAN(CDC_GENERIC_PACKET)) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2844: error: DEAD_STORE + The value written to &mdic is never used. + 2842. { + 2843. u32 i; + 2844. > u32 mdic = 0; + 2845. const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1; + 2846. + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &p is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &ret is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +drivers/input/mouse/alps.c:2895: error: DEAD_STORE + The value written to &protocol is never used. + 2893. protocol = &alps_v8_protocol_data; + 2894. } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0xc8) { + 2895. > protocol = &alps_v9_protocol_data; + 2896. psmouse_warn(psmouse, + 2897. "Unsupported ALPS V9 touchpad: E7=%3ph, EC=%3ph\n", + +net/ipv4/igmp.c:2858: error: DEAD_STORE + The value written to &im is never used. + 2856. struct net *net = seq_file_net(seq); + 2857. struct ip_sf_list *psf = NULL; + 2858. > struct ip_mc_list *im = NULL; + 2859. struct igmp_mcf_iter_state *state = igmp_mcf_seq_private(seq); + 2860. + +net/wireless/reg.c:2860: error: DEAD_STORE + The value written to &request is never used. + 2858. char alpha2[2]; + 2859. enum environment_cap env = ENVIRON_ANY; + 2860. > struct regulatory_request *request = NULL, *lr; + 2861. + 2862. /* IE len must be evenly divisible by 2 */ + +net/ipv4/ipmr.c:2875: error: DEAD_STORE + The value written to &nlh is never used. + 2873. { + 2874. struct net *net = sock_net(skb->sk); + 2875. > struct nlmsghdr *nlh = NULL; + 2876. unsigned int t = 0, s_t; + 2877. unsigned int e = 0, s_e; + +drivers/gpu/drm/i915/i915_debugfs.c:2879: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 2877 could be null and is dereferenced at line 2879, column 36. + 2877. struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base); + 2878. + 2879. > seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]); + 2880. seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio)); + 2881. if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) + +net/wireless/trace.h:2884: error: DEAD_STORE + The value written to &p is never used. + 2882. ); + 2883. + 2884. > DECLARE_EVENT_CLASS(wiphy_id_evt, + 2885. TP_PROTO(struct wiphy *wiphy, u64 id), + 2886. TP_ARGS(wiphy, id), + +drivers/tty/serial/8250/8250_port.c:2899: error: DEAD_STORE + The value written to &i is never used. + 2897. if (bytes < conf_type->rxtrig_bytes[i]) + 2898. /* Use the nearest lower value */ + 2899. > return (--i) << UART_FCR_R_TRIG_SHIFT; + 2900. } + 2901. + +lib/vsprintf.c:2911: error: DEAD_STORE + The value written to &fmt is never used. + 2909. */ + 2910. if (isspace(*fmt)) { + 2911. > fmt = skip_spaces(++fmt); + 2912. str = skip_spaces(str); + 2913. } + +kernel/trace/trace.c:2900: error: DEAD_STORE + The value written to &len is never used. + 2898. unsigned long flags; + 2899. char *tbuffer; + 2900. > int len = 0, size, pc; + 2901. + 2902. if (unlikely(tracing_selftest_running || tracing_disabled)) + +drivers/video/fbdev/core/fbcon.c:2896: error: DEAD_STORE + The value written to &vc is never used. + 2894. static void fbcon_suspended(struct fb_info *info) + 2895. { + 2896. > struct vc_data *vc = NULL; + 2897. struct fbcon_ops *ops = info->fbcon_par; + 2898. + +kernel/cgroup/cgroup.c:2912: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2907 could be null and is dereferenced at line 2912, column 39. + 2910. WARN_ON_ONCE(css && percpu_ref_is_dying(&css->refcnt)); + 2911. + 2912. > if (!(cgroup_ss_mask(dsct) & (1 << ss->id))) + 2913. continue; + 2914. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2902: error: DEAD_STORE + The value written to &ret_val is never used. + 2900. static s32 e1000_phy_hw_reset_ich8lan(struct e1000_hw *hw) + 2901. { + 2902. > s32 ret_val = 0; + 2903. + 2904. /* Gate automatic PHY configuration by hardware on non-managed 82579 */ + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &p is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &ret is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/unix/af_unix.c:2920: error: DEAD_STORE + The value written to &rc is never used. + 2918. static int __init af_unix_init(void) + 2919. { + 2920. > int rc = -1; + 2921. + 2922. BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb)); + +drivers/gpu/drm/i915/i915_gem.c:2922: error: DEAD_STORE + The value written to &request is never used. + 2920. i915_gem_reset_prepare_engine(struct intel_engine_cs *engine) + 2921. { + 2922. > struct drm_i915_gem_request *request = NULL; + 2923. + 2924. /* + +net/netfilter/nf_conntrack_netlink.c:2931: error: NULL_DEREFERENCE + pointer `m_help` last assigned on line 2929 could be null and is dereferenced at line 2931, column 16. + 2929. m_help = nfct_help(exp->master); + 2930. + 2931. > return strcmp(m_help->helper->name, name) == 0; + 2932. } + 2933. + +drivers/net/ethernet/nvidia/forcedeth.c:2930: error: DEAD_STORE + The value written to &vlanflags is never used. + 2928. struct fe_priv *np = netdev_priv(dev); + 2929. u32 flags; + 2930. > u32 vlanflags = 0; + 2931. int rx_work = 0; + 2932. struct sk_buff *skb; + +net/socket.c:2940: error: DEAD_STORE + The value written to &r is never used. + 2938. { + 2939. int ret; + 2940. > void *r = NULL; + 2941. struct in6_rtmsg r6; + 2942. struct rtentry r4; + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &p is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &ret is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +kernel/cgroup/cgroup.c:2966: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2953 could be null and is dereferenced at line 2966, column 9. + 2964. } else if (!css_visible(css)) { + 2965. css_clear_dir(css); + 2966. > if (ss->css_reset) + 2967. ss->css_reset(css); + 2968. } + +kernel/trace/trace.c:2956: error: DEAD_STORE + The value written to &len is never used. + 2954. struct trace_event_call *call = &event_print; + 2955. struct ring_buffer_event *event; + 2956. > int len = 0, size, pc; + 2957. struct print_entry *entry; + 2958. unsigned long flags; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:2964: error: DEAD_STORE + The value written to &ret_val is never used. + 2962. struct e1000_phy_info *phy = &hw->phy; + 2963. u32 phy_ctrl; + 2964. > s32 ret_val = 0; + 2965. u16 data; + 2966. + +drivers/pci/probe.c:2967: error: DEAD_STORE + The value written to &available_buses is never used. + 2965. struct pci_bus *parent = dev->bus; + 2966. int busnr, start = parent->busn_res.start; + 2967. > unsigned int available_buses = 0; + 2968. int end = parent->busn_res.end; + 2969. + +drivers/tty/vt/vt.c:2972: error: DEAD_STORE + The value written to &currcons is never used. + 2970. const char *display_desc = NULL; + 2971. struct vc_data *vc; + 2972. > unsigned int currcons = 0, i; + 2973. + 2974. console_lock(); + +drivers/gpu/drm/drm_dp_mst_topology.c:3016: error: DEAD_STORE + The value written to &ret is never used. + 3014. int ret; + 3015. + 3016. > ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + +drivers/gpu/drm/drm_dp_mst_topology.c:3018: error: DEAD_STORE + The value written to &ret is never used. + 3016. ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. > ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + +drivers/gpu/drm/drm_dp_mst_topology.c:3020: error: DEAD_STORE + The value written to &ret is never used. + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. > ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + 3021. seq_printf(m, "mst ctrl: %*ph\n", 1, buf); + 3022. + +drivers/gpu/drm/drm_dp_mst_topology.c:3024: error: DEAD_STORE + The value written to &ret is never used. + 3022. + 3023. /* dump the standard OUI branch header */ + 3024. > ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE); + 3025. seq_printf(m, "branch oui: %*phN devid: ", 3, buf); + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + +net/wireless/trace.h:2970: error: DEAD_STORE + The value written to &p is never used. + 2968. ); + 2969. + 2970. > DECLARE_EVENT_CLASS(cfg80211_bss_evt, + 2971. TP_PROTO(struct cfg80211_bss *pub), + 2972. TP_ARGS(pub), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2982: error: DEAD_STORE + The value written to &mdic is never used. + 2980. { + 2981. u32 i; + 2982. > u32 mdic = 0; + 2983. const u32 phy_addr = (hw->mac_type == e1000_ce4100) ? hw->phy_addr : 1; + 2984. + +net/wireless/trace.h:2989: error: DEAD_STORE + The value written to &p is never used. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +kernel/sysctl.c:3065: error: DEAD_STORE + The value written to &first is never used. + 3063. + 3064. bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1); + 3065. > first = 0; + 3066. proc_skip_char(&p, &left, '\n'); + 3067. } + +net/wireless/trace.h:3001: error: DEAD_STORE + The value written to &p is never used. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +block/cfq-iosched.c:3007: error: DEAD_STORE + The value written to &rq is never used. + 3005. static struct request *cfq_check_fifo(struct cfq_queue *cfqq) + 3006. { + 3007. > struct request *rq = NULL; + 3008. + 3009. if (cfq_cfqq_fifo_expire(cfqq)) + +net/wireless/trace.h:3013: error: DEAD_STORE + The value written to &p is never used. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +drivers/net/ethernet/intel/e1000e/netdev.c:3046: error: DEAD_STORE + The value written to &pages is never used. + 3044. struct e1000_hw *hw = &adapter->hw; + 3045. u32 rctl, rfctl; + 3046. > u32 pages = 0; + 3047. + 3048. /* Workaround Si errata on PCHx - configure jumbo frame flow. + +net/ipv6/route.c:3047: error: DEAD_STORE + The value written to &nrt is never used. + 3045. { + 3046. struct netevent_redirect netevent; + 3047. > struct rt6_info *rt, *nrt = NULL; + 3048. struct ndisc_options ndopts; + 3049. struct inet6_dev *in6_dev; + +drivers/net/ethernet/intel/e1000e/phy.c:3048: error: DEAD_STORE + The value written to &ret_val is never used. + 3046. s32 e1000_link_stall_workaround_hv(struct e1000_hw *hw) + 3047. { + 3048. > s32 ret_val = 0; + 3049. u16 data; + 3050. + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &p is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &ret is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +drivers/scsi/scsi_lib.c:3078: error: DEAD_STORE + The value written to &err is never used. + 3076. struct request_queue *q = sdev->request_queue; + 3077. unsigned long flags; + 3078. > int err = 0; + 3079. + 3080. err = scsi_device_set_state(sdev, SDEV_BLOCK); + +net/core/rtnetlink.c:3082: error: DEAD_STORE + The value written to &dev is never used. + 3080. char ifname[IFNAMSIZ]; + 3081. struct nlattr *tb[IFLA_MAX+1]; + 3082. > struct net_device *dev = NULL; + 3083. struct sk_buff *nskb; + 3084. int netnsid = -1; + +net/wireless/trace.h:3077: error: DEAD_STORE + The value written to &p is never used. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3092: error: DEAD_STORE + The value written to &p is never used. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3115: error: DEAD_STORE + The value written to &p is never used. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/netfilter/nf_conntrack_netlink.c:3124: error: DEAD_STORE + The value written to &h is never used. + 3122. { + 3123. struct nf_conntrack_tuple tuple, mask, master_tuple; + 3124. > struct nf_conntrack_tuple_hash *h = NULL; + 3125. struct nf_conntrack_helper *helper = NULL; + 3126. struct nf_conntrack_expect *exp; + +net/wireless/reg.c:3141: error: DEAD_STORE + The value written to &freq_range is never used. + 3139. unsigned int i; + 3140. const struct ieee80211_reg_rule *reg_rule = NULL; + 3141. > const struct ieee80211_freq_range *freq_range = NULL; + 3142. const struct ieee80211_power_rule *power_rule = NULL; + 3143. char bw[32], cac_time[32]; + +net/wireless/reg.c:3142: error: DEAD_STORE + The value written to &power_rule is never used. + 3140. const struct ieee80211_reg_rule *reg_rule = NULL; + 3141. const struct ieee80211_freq_range *freq_range = NULL; + 3142. > const struct ieee80211_power_rule *power_rule = NULL; + 3143. char bw[32], cac_time[32]; + 3144. + +net/wireless/reg.c:3140: error: DEAD_STORE + The value written to ®_rule is never used. + 3138. { + 3139. unsigned int i; + 3140. > const struct ieee80211_reg_rule *reg_rule = NULL; + 3141. const struct ieee80211_freq_range *freq_range = NULL; + 3142. const struct ieee80211_power_rule *power_rule = NULL; + +net/wireless/trace.h:3138: error: DEAD_STORE + The value written to &p is never used. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +security/selinux/ss/services.c:3148: error: DEAD_STORE + The value written to &rc is never used. + 3146. struct user_datum *userdatum; + 3147. struct selinux_audit_rule **rule = (struct selinux_audit_rule **)vrule; + 3148. > int rc = 0; + 3149. + 3150. *rule = NULL; + +net/socket.c:3159: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced at line 3159, column 2. + 3157. } + 3158. + 3159. > (*newsock)->ops = sock->ops; + 3160. __module_get((*newsock)->ops->owner); + 3161. + +net/socket.c:3154: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced by call to `sock_release()` at line 3154, column 3. + 3152. err = sock->ops->accept(sock, *newsock, flags, true); + 3153. if (err < 0) { + 3154. > sock_release(*newsock); + 3155. *newsock = NULL; + 3156. goto done; + +drivers/usb/core/hub.c:3146: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3145 could be null and is dereferenced at line 3146, column 30. + 3144. { + 3145. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3146. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3147. int port1 = udev->portnum; + 3148. int status; + +drivers/ata/libata-eh.c:3154: error: DEAD_STORE + The value written to &rc is never used. + 3152. unsigned int new_mask = 0; + 3153. unsigned long flags; + 3154. > int rc = 0; + 3155. + 3156. DPRINTK("ENTER\n"); + +security/selinux/hooks.c:3163: error: DEAD_STORE + The value written to &rc is never used. + 3161. struct common_audit_data ad; + 3162. u32 newsid, sid = current_sid(); + 3163. > int rc = 0; + 3164. + 3165. if (strcmp(name, XATTR_NAME_SELINUX)) { + +net/wireless/trace.h:3158: error: DEAD_STORE + The value written to &p is never used. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +drivers/gpu/drm/drm_atomic_helper.c:3176: error: DEAD_STORE + The value written to &ret is never used. + 3174. struct drm_plane_state *plane_state; + 3175. struct drm_crtc_state *crtc_state; + 3176. > int ret = 0; + 3177. + 3178. crtc_state = drm_atomic_get_crtc_state(state, crtc); + +block/blk-mq.c:3196: error: NULL_DEREFERENCE + pointer `rq` last assigned on line 3183 could be null and is dereferenced by call to `__blk_mq_poll()` at line 3196, column 9. + 3194. } + 3195. + 3196. > return __blk_mq_poll(hctx, rq); + 3197. } + 3198. + +kernel/cgroup/cgroup.c:3177: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 3176 could be null and is dereferenced at line 3177, column 28. + 3175. { + 3176. struct cgroup *parent = cgroup_parent(cgrp); + 3177. > struct cgroup *dom_cgrp = parent->dom_cgrp; + 3178. int ret; + 3179. + +net/ipv4/tcp_output.c:3206: error: DEAD_STORE + The value written to &md5 is never used. + 3204. struct inet_request_sock *ireq = inet_rsk(req); + 3205. const struct tcp_sock *tp = tcp_sk(sk); + 3206. > struct tcp_md5sig_key *md5 = NULL; + 3207. struct tcp_out_options opts; + 3208. struct sk_buff *skb; + +drivers/gpu/drm/drm_atomic_helper.c:3230: error: DEAD_STORE + The value written to &ret is never used. + 3228. struct drm_plane *plane = crtc->primary; + 3229. struct drm_atomic_state *state; + 3230. > int ret = 0; + 3231. + 3232. state = drm_atomic_state_alloc(plane->dev); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3232: error: DEAD_STORE + The value written to &ret_val is never used. + 3230. struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan; + 3231. u32 act_offset; + 3232. > s32 ret_val = 0; + 3233. u32 bank = 0; + 3234. u32 dword = 0; + +net/wireless/reg.c:3255: error: DEAD_STORE + The value written to &intersected_rd is never used. + 3253. struct regulatory_request *user_request) + 3254. { + 3255. > const struct ieee80211_regdomain *intersected_rd = NULL; + 3256. + 3257. if (!regdom_changes(rd->alpha2)) + +net/wireless/reg.c:3277: error: DEAD_STORE + The value written to &rd is never used. + 3275. + 3276. kfree(rd); + 3277. > rd = NULL; + 3278. reset_regdomains(false, intersected_rd); + 3279. + +drivers/gpu/drm/drm_atomic_helper.c:3275: error: DEAD_STORE + The value written to &ret is never used. + 3273. struct drm_atomic_state *state; + 3274. struct drm_crtc_state *crtc_state; + 3275. > int ret = 0; + 3276. + 3277. state = drm_atomic_state_alloc(plane->dev); + +net/wireless/reg.c:3287: error: DEAD_STORE + The value written to &intersected_rd is never used. + 3285. { + 3286. const struct ieee80211_regdomain *regd; + 3287. > const struct ieee80211_regdomain *intersected_rd = NULL; + 3288. const struct ieee80211_regdomain *tmp; + 3289. struct wiphy *request_wiphy; + +net/wireless/reg.c:3334: error: DEAD_STORE + The value written to &rd is never used. + 3332. rcu_free_regdom(tmp); + 3333. + 3334. > rd = NULL; + 3335. + 3336. reset_regdomains(false, intersected_rd); + +drivers/tty/vt/vt.c:3299: error: DEAD_STORE + The value written to &csw is never used. + 3297. static int vt_bind(struct con_driver *con) + 3298. { + 3299. > const struct consw *defcsw = NULL, *csw = NULL; + 3300. int i, more = 1, first = -1, last = -1, deflt = 0; + 3301. + +drivers/net/ethernet/nvidia/forcedeth.c:3321: error: DEAD_STORE + The value written to &newdup is never used. + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. int newls = np->linkspeed; + 3321. > int newdup = np->duplex; + 3322. int mii_status; + 3323. u32 bmcr; + +drivers/net/ethernet/nvidia/forcedeth.c:3320: error: DEAD_STORE + The value written to &newls is never used. + 3318. int lpa = 0; + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. > int newls = np->linkspeed; + 3321. int newdup = np->duplex; + 3322. int mii_status; + +drivers/net/ethernet/nvidia/forcedeth.c:3324: error: DEAD_STORE + The value written to &retval is never used. + 3322. int mii_status; + 3323. u32 bmcr; + 3324. > int retval = 0; + 3325. u32 control_1000, status_1000, phyreg, pause_flags, txreg; + 3326. u32 txrxFlags = 0; + +drivers/net/ethernet/intel/e1000/e1000_main.c:3322: error: DEAD_STORE + The value written to &i is never used. + 3320. u32 regs[NUM_REGS]; + 3321. u32 *regs_buff = regs; + 3322. > int i = 0; + 3323. + 3324. static const char * const reg_name[] = { + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3325: error: DEAD_STORE + The value written to &ret_val is never used. + 3323. struct e1000_dev_spec_ich8lan *dev_spec = &hw->dev_spec.ich8lan; + 3324. u32 act_offset; + 3325. > s32 ret_val = 0; + 3326. u32 bank = 0; + 3327. u16 i, word; + +drivers/gpu/drm/i915/i915_debugfs.c:3333: error: DEAD_STORE + The value written to &vrefresh is never used. + 3331. struct drm_i915_private *dev_priv = to_i915(dev); + 3332. struct i915_drrs *drrs = &dev_priv->drrs; + 3333. > int vrefresh = 0; + 3334. struct drm_connector *connector; + 3335. struct drm_connector_list_iter conn_iter; + +drivers/tty/vt/vt.c:3349: error: DEAD_STORE + The value written to &csw is never used. + 3347. static int vt_unbind(struct con_driver *con) + 3348. { + 3349. > const struct consw *csw = NULL; + 3350. int i, more = 1, first = -1, last = -1, deflt = 0; + 3351. int ret; + +kernel/events/core.c:3378: error: DEAD_STORE + The value written to &ctx is never used. + 3376. static int perf_rotate_context(struct perf_cpu_context *cpuctx) + 3377. { + 3378. > struct perf_event_context *ctx = NULL; + 3379. int rotate = 0; + 3380. + +kernel/cgroup/cgroup.c:3382: error: DEAD_STORE + The value written to &ret is never used. + 3380. { + 3381. struct cgroup __maybe_unused *cgrp = seq_css(seq)->cgroup; + 3382. > int ret = 0; + 3383. + 3384. cgroup_stat_show_cputime(seq); + +kernel/trace/trace.c:3393: error: DEAD_STORE + The value written to &name is never used. + 3391. unsigned long entries; + 3392. unsigned long total; + 3393. > const char *name = "preemption"; + 3394. + 3395. name = type->name; + +net/ipv4/tcp_input.c:3407: error: DEAD_STORE + The value written to &half is never used. + 3405. if (now != challenge_timestamp) { + 3406. u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit; + 3407. > u32 half = (ack_limit + 1) >> 1; + 3408. + 3409. challenge_timestamp = now; + +net/ipv4/tcp_output.c:3413: error: DEAD_STORE + The value written to &err is never used. + 3411. struct tcp_sock *tp = tcp_sk(sk); + 3412. struct tcp_fastopen_request *fo = tp->fastopen_req; + 3413. > int space, err = 0; + 3414. struct sk_buff *syn_data; + 3415. + +drivers/usb/core/hub.c:3415: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3414 could be null and is dereferenced at line 3415, column 30. + 3413. { + 3414. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3415. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3416. int port1 = udev->portnum; + 3417. int status; + +net/core/rtnetlink.c:3461: error: NULL_DEREFERENCE + pointer `br_dev` last assigned on line 3460 could be null and is dereferenced at line 3461, column 38. + 3459. (dev->priv_flags & IFF_BRIDGE_PORT)) { + 3460. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + 3461. > const struct net_device_ops *ops = br_dev->netdev_ops; + 3462. + 3463. err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, + +drivers/gpu/drm/drm_edid.c:3424: error: DEAD_STORE + The value written to &hdmi_3d_len is never used. + 3422. struct drm_display_info *info = &connector->display_info; + 3423. int modes = 0, offset = 0, i, multi_present = 0, multi_len; + 3424. > u8 vic_len, hdmi_3d_len = 0; + 3425. u16 mask; + 3426. u16 structure_all; + +drivers/gpu/drm/drm_edid.c:3505: error: DEAD_STORE + The value written to &newmode is never used. + 3503. for (i = 0; i < (hdmi_3d_len - multi_len); i++) { + 3504. int vic_index; + 3505. > struct drm_display_mode *newmode = NULL; + 3506. unsigned int newflag = 0; + 3507. bool detail_present; + +drivers/gpu/drm/i915/i915_debugfs.c:3442: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 3441 could be null and is dereferenced at line 3442, column 8. + 3440. + 3441. intel_dig_port = enc_to_dig_port(&intel_encoder->base); + 3442. > if (!intel_dig_port->dp.can_mst) + 3443. continue; + 3444. + +drivers/gpu/drm/i915/i915_debugfs.c:3499: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3499, column 5. + 3497. */ + 3498. if (val == 1) + 3499. > intel_dp->compliance.test_active = 1; + 3500. else + 3501. intel_dp->compliance.test_active = 0; + +drivers/gpu/drm/i915/i915_debugfs.c:3501: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3501, column 5. + 3499. intel_dp->compliance.test_active = 1; + 3500. else + 3501. > intel_dp->compliance.test_active = 0; + 3502. } + 3503. } + +drivers/iommu/intel-iommu.c:3459: error: DEAD_STORE + The value written to &iova_pfn is never used. + 3457. unsigned long nrpages, uint64_t dma_mask) + 3458. { + 3459. > unsigned long iova_pfn = 0; + 3460. + 3461. /* Restrict dma_mask to the width that the iommu can handle */ + +kernel/sched/fair.c:3492: error: DEAD_STORE + The value written to &res is never used. + 3490. + 3491. /* Update parent cfs_rq utilization */ + 3492. > add_positive(&cfs_rq->avg.util_avg, delta); + 3493. cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX; + 3494. } + +kernel/trace/ring_buffer.c:3486: error: DEAD_STORE + The value written to &reader is never used. + 3484. rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer) + 3485. { + 3486. > struct buffer_page *reader = NULL; + 3487. unsigned long overwrite; + 3488. unsigned long flags; + +kernel/sched/fair.c:3547: error: DEAD_STORE + The value written to &res is never used. + 3545. se->avg.load_sum = runnable_sum; + 3546. se->avg.load_avg = load_avg; + 3547. > add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + +kernel/sched/fair.c:3548: error: DEAD_STORE + The value written to &res is never used. + 3546. se->avg.load_avg = load_avg; + 3547. add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. > add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + 3550. runnable_load_sum = (s64)se_runnable(se) * runnable_sum; + +kernel/sched/fair.c:3559: error: DEAD_STORE + The value written to &res is never used. + 3557. + 3558. if (se->on_rq) { + 3559. > add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + +kernel/sched/fair.c:3560: error: DEAD_STORE + The value written to &res is never used. + 3558. if (se->on_rq) { + 3559. add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. > add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + 3562. } + +security/selinux/hooks.c:3507: error: DEAD_STORE + The value written to &error is never used. + 3505. { + 3506. const struct cred *cred = current_cred(); + 3507. > int error = 0; + 3508. + 3509. switch (cmd) { + +drivers/pci/quirks.c:3508: error: DEAD_STORE + The value written to &sibling is never used. + 3506. static void quirk_apple_wait_for_thunderbolt(struct pci_dev *dev) + 3507. { + 3508. > struct pci_dev *sibling = NULL; + 3509. struct pci_dev *nhi = NULL; + 3510. + +drivers/gpu/drm/i915/i915_debugfs.c:3534: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3533 could be null and is dereferenced at line 3534, column 8. + 3532. if (encoder && connector->status == connector_status_connected) { + 3533. intel_dp = enc_to_intel_dp(&encoder->base); + 3534. > if (intel_dp->compliance.test_active) + 3535. seq_puts(m, "1"); + 3536. else + +net/core/rtnetlink.c:3525: error: DEAD_STORE + The value written to &err is never used. + 3523. struct nlattr *tb[NDA_MAX+1]; + 3524. struct net_device *dev; + 3525. > int err = -EINVAL; + 3526. __u8 *addr; + 3527. u16 vid; + +drivers/clk/clk.c:3548: error: DEAD_STORE + The value written to &cn is never used. + 3546. int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb) + 3547. { + 3548. > struct clk_notifier *cn = NULL; + 3549. int ret = -EINVAL; + 3550. + +drivers/clk/clk.c:3549: error: DEAD_STORE + The value written to &ret is never used. + 3547. { + 3548. struct clk_notifier *cn = NULL; + 3549. > int ret = -EINVAL; + 3550. + 3551. if (!clk || !nb) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3568: error: DEAD_STORE + The value written to &flash_data is never used. + 3566. union ich8_hws_flash_ctrl hsflctl; + 3567. u32 flash_linear_addr; + 3568. > u32 flash_data = 0; + 3569. s32 ret_val = -E1000_ERR_NVM; + 3570. u8 count = 0; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3569: error: DEAD_STORE + The value written to &ret_val is never used. + 3567. u32 flash_linear_addr; + 3568. u32 flash_data = 0; + 3569. > s32 ret_val = -E1000_ERR_NVM; + 3570. u8 count = 0; + 3571. + +drivers/gpu/drm/i915/i915_debugfs.c:3585: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3584 could be null and is dereferenced at line 3585, column 8. + 3583. if (encoder && connector->status == connector_status_connected) { + 3584. intel_dp = enc_to_intel_dp(&encoder->base); + 3585. > if (intel_dp->compliance.test_type == + 3586. DP_TEST_LINK_EDID_READ) + 3587. seq_printf(m, "%lx", + +drivers/gpu/drm/i915/i915_gem.c:3571: error: DEAD_STORE + The value written to &timeout__ is never used. + 3569. static int wait_for_engines(struct drm_i915_private *i915) + 3570. { + 3571. > if (wait_for(intel_engines_are_idle(i915), I915_IDLE_ENGINES_TIMEOUT)) { + 3572. dev_err(i915->drm.dev, + 3573. "Failed to idle engines, declaring wedged!\n"); + +drivers/gpu/drm/i915/i915_gem.c:3571: error: DEAD_STORE + The value written to &wait__ is never used. + 3569. static int wait_for_engines(struct drm_i915_private *i915) + 3570. { + 3571. > if (wait_for(intel_engines_are_idle(i915), I915_IDLE_ENGINES_TIMEOUT)) { + 3572. dev_err(i915->drm.dev, + 3573. "Failed to idle engines, declaring wedged!\n"); + +drivers/usb/core/hub.c:3611: error: DEAD_STORE + The value written to &status is never used. + 3609. /* Enable hub to send remote wakeup for all ports. */ + 3610. for (port1 = 1; port1 <= hdev->maxchild; port1++) { + 3611. > status = set_port_feature(hdev, + 3612. port1 | + 3613. USB_PORT_FEAT_REMOTE_WAKE_CONNECT | + +drivers/video/fbdev/core/fbcon.c:3588: error: DEAD_STORE + The value written to &pending is never used. + 3586. + 3587. for (i = 0; i < FB_MAX; i++) { + 3588. > int pending = 0; + 3589. + 3590. mapped = 0; + +drivers/video/fbdev/core/fbcon.c:3597: error: DEAD_STORE + The value written to &pending is never used. + 3595. + 3596. if (info->queue.func) + 3597. > pending = cancel_work_sync(&info->queue); + 3598. DPRINTK("fbcon: %s pending work\n", (pending ? "canceled" : + 3599. "no")); + +net/wireless/reg.c:3587: error: DEAD_STORE + The value written to ®d is never used. + 3585. bool regulatory_pre_cac_allowed(struct wiphy *wiphy) + 3586. { + 3587. > const struct ieee80211_regdomain *regd = NULL; + 3588. const struct ieee80211_regdomain *wiphy_regd = NULL; + 3589. bool pre_cac_allowed = false; + +net/wireless/reg.c:3588: error: DEAD_STORE + The value written to &wiphy_regd is never used. + 3586. { + 3587. const struct ieee80211_regdomain *regd = NULL; + 3588. > const struct ieee80211_regdomain *wiphy_regd = NULL; + 3589. bool pre_cac_allowed = false; + 3590. + +sound/core/pcm_native.c:3604: error: DEAD_STORE + The value written to &oparams is never used. + 3602. { + 3603. struct snd_pcm_hw_params *params; + 3604. > struct snd_pcm_hw_params_old *oparams = NULL; + 3605. int err; + 3606. + +drivers/gpu/drm/i915/i915_debugfs.c:3643: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3642 could be null and is dereferenced at line 3643, column 27. + 3641. if (encoder && connector->status == connector_status_connected) { + 3642. intel_dp = enc_to_intel_dp(&encoder->base); + 3643. > seq_printf(m, "%02lx", intel_dp->compliance.test_type); + 3644. } else + 3645. seq_puts(m, "0"); + +sound/core/pcm_native.c:3639: error: DEAD_STORE + The value written to &oparams is never used. + 3637. { + 3638. struct snd_pcm_hw_params *params; + 3639. > struct snd_pcm_hw_params_old *oparams = NULL; + 3640. int err; + 3641. + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3644: error: DEAD_STORE + The value written to &ret_val is never used. + 3642. union ich8_hws_flash_ctrl hsflctl; + 3643. u32 flash_linear_addr; + 3644. > s32 ret_val = -E1000_ERR_NVM; + 3645. u8 count = 0; + 3646. + +net/core/rtnetlink.c:3660: error: DEAD_STORE + The value written to &brport_idx is never used. + 3658. struct net *net = sock_net(skb->sk); + 3659. struct hlist_head *head; + 3660. > int brport_idx = 0; + 3661. int br_idx = 0; + 3662. int h, s_h; + +net/core/rtnetlink.c:3664: error: DEAD_STORE + The value written to &err is never used. + 3662. int h, s_h; + 3663. int idx = 0, s_idx; + 3664. > int err = 0; + 3665. int fidx = 0; + 3666. + +kernel/sched/fair.c:3672: error: DEAD_STORE + The value written to &res is never used. + 3670. + 3671. r = removed_load; + 3672. > sub_positive(&sa->load_avg, r); + 3673. sub_positive(&sa->load_sum, r * divider); + 3674. + +kernel/sched/fair.c:3673: error: DEAD_STORE + The value written to &res is never used. + 3671. r = removed_load; + 3672. sub_positive(&sa->load_avg, r); + 3673. > sub_positive(&sa->load_sum, r * divider); + 3674. + 3675. r = removed_util; + +kernel/sched/fair.c:3676: error: DEAD_STORE + The value written to &res is never used. + 3674. + 3675. r = removed_util; + 3676. > sub_positive(&sa->util_avg, r); + 3677. sub_positive(&sa->util_sum, r * divider); + 3678. + +kernel/sched/fair.c:3677: error: DEAD_STORE + The value written to &res is never used. + 3675. r = removed_util; + 3676. sub_positive(&sa->util_avg, r); + 3677. > sub_positive(&sa->util_sum, r * divider); + 3678. + 3679. add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum); + +drivers/ata/libata-scsi.c:3697: error: DEAD_STORE + The value written to &fp is never used. + 3695. struct scsi_cmnd *scmd = qc->scsicmd; + 3696. const u8 *cdb = scmd->cmnd; + 3697. > u16 sect, fp = (u16)-1; + 3698. u8 sa, options, bp = 0xff; + 3699. u64 block; + +drivers/ata/libata-core.c:3726: error: DEAD_STORE + The value written to &nodev_deadline is never used. + 3724. + 3725. if (time_after(nodev_deadline, deadline)) + 3726. > nodev_deadline = deadline; + 3727. + 3728. while (1) { + +drivers/ata/libata-core.c:3729: error: DEAD_STORE + The value written to &now is never used. + 3727. + 3728. while (1) { + 3729. > unsigned long now = jiffies; + 3730. int ready, tmp; + 3731. + +drivers/ata/libata-core.c:3766: error: DEAD_STORE + The value written to &warned is never used. + 3764. "link is slow to respond, please be patient " + 3765. "(ready=%d)\n", tmp); + 3766. > warned = 1; + 3767. } + 3768. + +drivers/pci/quirks.c:3743: error: DEAD_STORE + The value written to &timeout is never used. + 3741. iowrite32(val, mmio_base + PCH_PP_CONTROL); + 3742. + 3743. > timeout = jiffies + msecs_to_jiffies(IGD_OPERATION_TIMEOUT); + 3744. do { + 3745. val = ioread32(mmio_base + PCH_PP_STATUS); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3821: error: DEAD_STORE + The value written to &act_offset is never used. + 3819. + 3820. /* Convert offset to bytes. */ + 3821. > act_offset = (i + new_bank_offset) << 1; + 3822. + 3823. usleep_range(100, 200); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3867: error: DEAD_STORE + The value written to &act_offset is never used. + 3865. * to 1's. We can write 1's to 0's without an erase + 3866. */ + 3867. > act_offset = (old_bank_offset + E1000_ICH_NVM_SIG_WORD) * 2 + 1; + 3868. + 3869. /* offset in words but we read dword */ + +kernel/sched/fair.c:3755: error: DEAD_STORE + The value written to &res is never used. + 3753. { + 3754. dequeue_load_avg(cfs_rq, se); + 3755. > sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + +kernel/sched/fair.c:3756: error: DEAD_STORE + The value written to &res is never used. + 3754. dequeue_load_avg(cfs_rq, se); + 3755. sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. > sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + 3758. add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum); + +drivers/ata/libata-scsi.c:3784: error: DEAD_STORE + The value written to &fp is never used. + 3782. u64 block; + 3783. u32 n_block; + 3784. > u16 fp = (u16)-1; + 3785. + 3786. if (unlikely(scmd->cmd_len < 16)) { + +kernel/events/core.c:3783: error: DEAD_STORE + The value written to &clone_ctx is never used. + 3781. struct perf_event *event) + 3782. { + 3783. > struct perf_event_context *ctx, *clone_ctx = NULL; + 3784. struct perf_cpu_context *cpuctx; + 3785. void *task_ctx_data = NULL; + +drivers/gpu/drm/drm_atomic_helper.c:3800: error: DEAD_STORE + The value written to &blob is never used. + 3798. struct drm_atomic_state *state; + 3799. struct drm_crtc_state *crtc_state; + 3800. > struct drm_property_blob *blob = NULL; + 3801. struct drm_color_lut *blob_data; + 3802. int i, ret = 0; + +drivers/gpu/drm/drm_atomic_helper.c:3802: error: DEAD_STORE + The value written to &ret is never used. + 3800. struct drm_property_blob *blob = NULL; + 3801. struct drm_color_lut *blob_data; + 3802. > int i, ret = 0; + 3803. bool replaced; + 3804. + +kernel/rcu/tree.c:3834: error: DEAD_STORE + The value written to &nbits is never used. + 3832. rnp->expmaskinitnext |= mask; + 3833. oldmask ^= rnp->expmaskinitnext; + 3834. > nbits = bitmap_weight(&oldmask, BITS_PER_LONG); + 3835. /* Allow lockless access for expedited grace periods. */ + 3836. smp_store_release(&rsp->ncpus, rsp->ncpus + nbits); /* ^^^ */ + +drivers/net/ethernet/intel/e1000e/netdev.c:3820: error: DEAD_STORE + The value written to &tx_desc is never used. + 3818. struct e1000_hw *hw = &adapter->hw; + 3819. struct e1000_ring *tx_ring = adapter->tx_ring; + 3820. > struct e1000_tx_desc *tx_desc = NULL; + 3821. u32 tdt, tctl, txd_lower = E1000_TXD_CMD_IFCS; + 3822. u16 size = 512; + +drivers/ata/libata-core.c:3828: error: DEAD_STORE + The value written to &deadline is never used. + 3826. t = ata_deadline(jiffies, params[2]); + 3827. if (time_before(t, deadline)) + 3828. > deadline = t; + 3829. + 3830. if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) + +drivers/ata/libata-core.c:3834: error: DEAD_STORE + The value written to &last is never used. + 3832. cur &= 0xf; + 3833. + 3834. > last = cur; + 3835. last_jiffies = jiffies; + 3836. + +drivers/ata/libata-core.c:3835: error: DEAD_STORE + The value written to &last_jiffies is never used. + 3833. + 3834. last = cur; + 3835. > last_jiffies = jiffies; + 3836. + 3837. while (1) { + +drivers/net/ethernet/intel/e1000/e1000_main.c:3828: error: DEAD_STORE + The value written to &tx_clean_complete is never used. + 3826. struct e1000_adapter *adapter = container_of(napi, struct e1000_adapter, + 3827. napi); + 3828. > int tx_clean_complete = 0, work_done = 0; + 3829. + 3830. tx_clean_complete = e1000_clean_tx_irq(adapter, &adapter->tx_ring[0]); + +kernel/workqueue.c:3831: error: DEAD_STORE + The value written to &old_pwq is never used. + 3829. int node = cpu_to_node(cpu); + 3830. int cpu_off = online ? -1 : cpu; + 3831. > struct pool_workqueue *old_pwq = NULL, *pwq; + 3832. struct workqueue_attrs *target_attrs; + 3833. cpumask_t *cpumask; + +net/packet/af_packet.c:3875: error: DEAD_STORE + The value written to &val is never used. + 3873. break; + 3874. case PACKET_AUXDATA: + 3875. > val = po->auxdata; + 3876. break; + 3877. case PACKET_ORIGDEV: + +net/packet/af_packet.c:3878: error: DEAD_STORE + The value written to &val is never used. + 3876. break; + 3877. case PACKET_ORIGDEV: + 3878. > val = po->origdev; + 3879. break; + 3880. case PACKET_VNET_HDR: + +net/packet/af_packet.c:3881: error: DEAD_STORE + The value written to &val is never used. + 3879. break; + 3880. case PACKET_VNET_HDR: + 3881. > val = po->has_vnet_hdr; + 3882. break; + 3883. case PACKET_VERSION: + +net/packet/af_packet.c:3884: error: DEAD_STORE + The value written to &val is never used. + 3882. break; + 3883. case PACKET_VERSION: + 3884. > val = po->tp_version; + 3885. break; + 3886. case PACKET_HDRLEN: + +net/packet/af_packet.c:3895: error: DEAD_STORE + The value written to &val is never used. + 3893. switch (val) { + 3894. case TPACKET_V1: + 3895. > val = sizeof(struct tpacket_hdr); + 3896. break; + 3897. case TPACKET_V2: + +net/packet/af_packet.c:3898: error: DEAD_STORE + The value written to &val is never used. + 3896. break; + 3897. case TPACKET_V2: + 3898. > val = sizeof(struct tpacket2_hdr); + 3899. break; + 3900. case TPACKET_V3: + +net/packet/af_packet.c:3901: error: DEAD_STORE + The value written to &val is never used. + 3899. break; + 3900. case TPACKET_V3: + 3901. > val = sizeof(struct tpacket3_hdr); + 3902. break; + 3903. default: + +net/packet/af_packet.c:3908: error: DEAD_STORE + The value written to &val is never used. + 3906. break; + 3907. case PACKET_RESERVE: + 3908. > val = po->tp_reserve; + 3909. break; + 3910. case PACKET_LOSS: + +net/packet/af_packet.c:3911: error: DEAD_STORE + The value written to &val is never used. + 3909. break; + 3910. case PACKET_LOSS: + 3911. > val = po->tp_loss; + 3912. break; + 3913. case PACKET_TIMESTAMP: + +net/packet/af_packet.c:3914: error: DEAD_STORE + The value written to &val is never used. + 3912. break; + 3913. case PACKET_TIMESTAMP: + 3914. > val = po->tp_tstamp; + 3915. break; + 3916. case PACKET_FANOUT: + +net/packet/af_packet.c:3917: error: DEAD_STORE + The value written to &val is never used. + 3915. break; + 3916. case PACKET_FANOUT: + 3917. > val = (po->fanout ? + 3918. ((u32)po->fanout->id | + 3919. ((u32)po->fanout->type << 16) | + +net/packet/af_packet.c:3933: error: DEAD_STORE + The value written to &val is never used. + 3931. break; + 3932. case PACKET_TX_HAS_OFF: + 3933. > val = po->tp_tx_has_off; + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + +net/packet/af_packet.c:3936: error: DEAD_STORE + The value written to &val is never used. + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + 3936. > val = packet_use_direct_xmit(po); + 3937. break; + 3938. default: + +drivers/net/ethernet/intel/e1000/e1000_hw.c:3842: error: DEAD_STORE + The value written to &retry_count is never used. + 3840. static s32 e1000_spi_eeprom_ready(struct e1000_hw *hw) + 3841. { + 3842. > u16 retry_count = 0; + 3843. u8 spi_stat_reg; + 3844. + +drivers/net/ethernet/intel/e1000/e1000_main.c:3856: error: DEAD_STORE + The value written to &hw is never used. + 3854. struct e1000_tx_ring *tx_ring) + 3855. { + 3856. > struct e1000_hw *hw = &adapter->hw; + 3857. struct net_device *netdev = adapter->netdev; + 3858. struct e1000_tx_desc *tx_desc, *eop_desc; + +drivers/gpu/drm/i915/intel_dp.c:3872: error: DEAD_STORE + The value written to &count is never used. + 3870. u8 buf; + 3871. int ret = 0; + 3872. > int count = 0; + 3873. int attempts = 10; + 3874. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:3896: error: DEAD_STORE + The value written to &i is never used. + 3894. { + 3895. struct e1000_eeprom_info *eeprom = &hw->eeprom; + 3896. > u32 i = 0; + 3897. + 3898. if (hw->mac_type == e1000_ce4100) { + +net/core/rtnetlink.c:3947: error: DEAD_STORE + The value written to &err is never used. + 3945. struct net *net = dev_net(dev); + 3946. struct sk_buff *skb; + 3947. > int err = -EOPNOTSUPP; + 3948. + 3949. if (!dev->netdev_ops->ndo_bridge_getlink) + +drivers/gpu/drm/i915/intel_dp.c:4004: error: DEAD_STORE + The value written to &status is never used. + 4002. static uint8_t intel_dp_autotest_link_training(struct intel_dp *intel_dp) + 4003. { + 4004. > int status = 0; + 4005. int test_link_rate; + 4006. uint8_t test_lane_count, test_link_bw; + +drivers/gpu/drm/i915/intel_pm.c:4012: error: DEAD_STORE + The value written to &height is never used. + 4010. struct intel_plane_state *intel_pstate = to_intel_plane_state(pstate); + 4011. uint32_t data_rate; + 4012. > uint32_t width = 0, height = 0; + 4013. struct drm_framebuffer *fb; + 4014. u32 format; + +drivers/gpu/drm/i915/intel_pm.c:4012: error: DEAD_STORE + The value written to &width is never used. + 4010. struct intel_plane_state *intel_pstate = to_intel_plane_state(pstate); + 4011. uint32_t data_rate; + 4012. > uint32_t width = 0, height = 0; + 4013. struct drm_framebuffer *fb; + 4014. u32 format; + +drivers/iommu/intel-iommu.c:4015: error: DEAD_STORE + The value written to &iommu is never used. + 4013. { + 4014. struct dmar_drhd_unit *drhd; + 4015. > struct intel_iommu *iommu = NULL; + 4016. + 4017. for_each_active_iommu(iommu, drhd) + +drivers/gpu/drm/i915/intel_dp.c:4044: error: DEAD_STORE + The value written to &status is never used. + 4042. uint8_t test_misc; + 4043. __be16 h_width, v_height; + 4044. > int status = 0; + 4045. + 4046. /* Read the TEST_PATTERN (DP CTS 3.1.5) */ + +drivers/tty/vt/vt.c:4060: error: DEAD_STORE + The value written to &rc is never used. + 4058. { + 4059. struct console_font font; + 4060. > int rc = -EINVAL; + 4061. int c; + 4062. + +drivers/iommu/intel-iommu.c:4062: error: DEAD_STORE + The value written to &iommu is never used. + 4060. { + 4061. struct dmar_drhd_unit *drhd; + 4062. > struct intel_iommu *iommu = NULL; + 4063. unsigned long flag; + 4064. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4069: error: DEAD_STORE + The value written to &status is never used. + 4067. { + 4068. struct e1000_eeprom_info *eeprom = &hw->eeprom; + 4069. > s32 status = 0; + 4070. + 4071. if (hw->mac_type == e1000_ce4100) { + +net/ipv6/route.c:4144: error: DEAD_STORE + The value written to &err_nh is never used. + 4142. info->skip_notify = 1; + 4143. + 4144. > err_nh = NULL; + 4145. list_for_each_entry(nh, &rt6_nh_list, next) { + 4146. rt_last = nh->rt6_info; + +net/ipv6/route.c:4123: error: DEAD_STORE + The value written to &rt is never used. + 4121. if (IS_ERR(rt)) { + 4122. err = PTR_ERR(rt); + 4123. > rt = NULL; + 4124. goto cleanup; + 4125. } + +drivers/gpu/drm/i915/intel_pm.c:4131: error: DEAD_STORE + The value written to &src_h is never used. + 4129. if (fb->format->format == DRM_FORMAT_NV12 && !y) { + 4130. src_w /= 2; + 4131. > src_h /= 2; + 4132. } + 4133. + +drivers/iommu/intel-iommu.c:4102: error: DEAD_STORE + The value written to &iommu is never used. + 4100. { + 4101. struct dmar_drhd_unit *drhd; + 4102. > struct intel_iommu *iommu = NULL; + 4103. unsigned long flag; + 4104. + +drivers/ata/libata-eh.c:4112: error: DEAD_STORE + The value written to &rc is never used. + 4110. { + 4111. unsigned long flags; + 4112. > int rc = 0; + 4113. struct ata_device *dev; + 4114. + +drivers/tty/vt/vt.c:4114: error: DEAD_STORE + The value written to &rc is never used. + 4112. { + 4113. struct console_font font; + 4114. > int rc = -EINVAL; + 4115. int size; + 4116. + +net/ipv6/addrconf.c:4133: error: DEAD_STORE + The value written to &ifa is never used. + 4131. struct if6_iter_state *state = seq->private; + 4132. struct net *net = seq_file_net(seq); + 4133. > struct inet6_ifaddr *ifa = NULL; + 4134. int p = 0; + 4135. + +drivers/gpu/drm/i915/i915_gem.c:4158: error: DEAD_STORE + The value written to &recent_enough is never used. + 4156. struct drm_i915_private *dev_priv = to_i915(dev); + 4157. struct drm_i915_file_private *file_priv = file->driver_priv; + 4158. > unsigned long recent_enough = jiffies - DRM_I915_THROTTLE_JIFFIES; + 4159. struct drm_i915_gem_request *request, *target = NULL; + 4160. long ret; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:4162: error: DEAD_STORE + The value written to &flash_data is never used. + 4160. union ich8_hws_flash_ctrl hsflctl; + 4161. u32 flash_linear_addr; + 4162. > u32 flash_data = 0; + 4163. s32 ret_val; + 4164. u8 count = 0; + +kernel/sched/fair.c:4184: error: NULL_DEREFERENCE + pointer `se` last assigned on line 4183 could be null and is dereferenced at line 4184, column 27. + 4182. + 4183. se = __pick_first_entity(cfs_rq); + 4184. > delta = curr->vruntime - se->vruntime; + 4185. + 4186. if (delta < 0) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4184: error: DEAD_STORE + The value written to &i is never used. + 4182. u32 eecd; + 4183. u16 words_written = 0; + 4184. > u16 i = 0; + 4185. + 4186. /* Send the write enable command to the EEPROM (3-bit opcode plus + +drivers/gpu/drm/i915/intel_pm.c:4262: error: DEAD_STORE + The value written to &y_plane_blocks is never used. + 4260. for_each_plane_id_on_crtc(intel_crtc, plane_id) { + 4261. unsigned int data_rate, y_data_rate; + 4262. > uint16_t plane_blocks, y_plane_blocks = 0; + 4263. + 4264. if (plane_id == PLANE_CURSOR) + +drivers/gpu/drm/i915/intel_dp.c:4200: error: DEAD_STORE + The value written to &ret is never used. + 4198. if (intel_dp->is_mst) { + 4199. u8 esi[DP_DPRX_ESI_LEN] = { 0 }; + 4200. > int ret = 0; + 4201. int retry; + 4202. bool handled; + +net/packet/af_packet.c:4209: error: DEAD_STORE + The value written to &err is never used. + 4207. struct sk_buff_head *rb_queue; + 4208. __be16 num; + 4209. > int err = -EINVAL; + 4210. /* Added to avoid minimal code churn */ + 4211. struct tpacket_req *req = &req_u->req; + +net/ipv6/route.c:4211: error: DEAD_STORE + The value written to &err is never used. + 4209. int remaining; + 4210. int attrlen; + 4211. > int err = 1, last_err = 0; + 4212. + 4213. remaining = cfg->fc_mp_len; + +drivers/usb/core/hub.c:4212: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 4210 could be null and is dereferenced by call to `hub_port_disable()` at line 4212, column 9. + 4210. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 4211. + 4212. > return hub_port_disable(hub, udev->portnum, 0); + 4213. } + 4214. + +drivers/net/ethernet/marvell/sky2.c:4282: error: DEAD_STORE + The value written to &start is never used. + 4280. static int sky2_vpd_wait(const struct sky2_hw *hw, int cap, u16 busy) + 4281. { + 4282. > unsigned long start = jiffies; + 4283. + 4284. while ( (sky2_pci_read16(hw, cap + PCI_VPD_ADDR) & PCI_VPD_ADDR_F) == busy) { + +drivers/iommu/intel-iommu.c:4290: error: DEAD_STORE + The value written to &ret is never used. + 4288. static int intel_iommu_add(struct dmar_drhd_unit *dmaru) + 4289. { + 4290. > int sp, ret = 0; + 4291. struct intel_iommu *iommu = dmaru->iommu; + 4292. + +drivers/ata/libata-scsi.c:4314: error: DEAD_STORE + The value written to &xlat_func is never used. + 4312. goto bad_cdb_len; + 4313. + 4314. > xlat_func = NULL; + 4315. if (likely((scsi_op != ATA_16) || !atapi_passthru16)) { + 4316. /* relay SCSI command to ATAPI device */ + +kernel/trace/trace.c:4311: error: DEAD_STORE + The value written to &opts is never used. + 4309. struct tracer *trace = tr->current_trace; + 4310. struct tracer_flags *tracer_flags = trace->flags; + 4311. > struct tracer_opt *opts = NULL; + 4312. int i; + 4313. + +kernel/cgroup/cgroup.c:4330: error: NULL_DEREFERENCE + pointer `com_cgrp` last assigned on line 4331 could be null and is dereferenced by call to `cgroup_is_descendant()` at line 4330, column 10. + 4328. + 4329. /* find the common ancestor */ + 4330. > while (!cgroup_is_descendant(dst_cgrp, com_cgrp)) + 4331. com_cgrp = cgroup_parent(com_cgrp); + 4332. + +drivers/net/ethernet/broadcom/tg3.c:4327: error: DEAD_STORE + The value written to &err is never used. + 4325. static int tg3_phy_autoneg_cfg(struct tg3 *tp, u32 advertise, u32 flowctrl) + 4326. { + 4327. > int err = 0; + 4328. u32 val, new_adv; + 4329. + +net/wireless/nl80211.c:4340: error: DEAD_STORE + The value written to &i is never used. + 4338. { + 4339. void *attr; + 4340. > int i = 0; + 4341. + 4342. if (!mask) + +drivers/net/ethernet/intel/e1000e/netdev.c:4365: error: DEAD_STORE + The value written to &temp is never used. + 4363. temp = time_delta; + 4364. /* VMWare users have seen incvalue of zero, don't div / 0 */ + 4365. > rem = incvalue ? do_div(temp, incvalue) : (time_delta != 0); + 4366. + 4367. systim = systim_next; + +drivers/usb/core/hub.c:4619: error: DEAD_STORE + The value written to &retval is never used. + 4617. u32 delay; + 4618. + 4619. > retval = 0; + 4620. + 4621. delay = udev->parent->hub_delay; + +net/core/filter.c:4375: error: DEAD_STORE + The value written to &insn is never used. + 4373. struct bpf_prog *prog, u32 *target_size) + 4374. { + 4375. > struct bpf_insn *insn = insn_buf; + 4376. + 4377. switch (si->off) { + +net/core/filter.c:4379: error: NULL_DEREFERENCE + pointer `insn` last assigned on line 4379 could be null and is dereferenced at line 4379, column 13. + 4377. switch (si->off) { + 4378. case offsetof(struct __sk_buff, ifindex): + 4379. > *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, dev), + 4380. si->dst_reg, si->src_reg, + 4381. offsetof(struct sk_buff, dev)); + +net/core/rtnetlink.c:4433: error: DEAD_STORE + The value written to &dev is never used. + 4431. { + 4432. struct net *net = sock_net(skb->sk); + 4433. > struct net_device *dev = NULL; + 4434. int idxattr = 0, prividx = 0; + 4435. struct if_stats_msg *ifsm; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4438: error: DEAD_STORE + The value written to &vfta_value is never used. + 4436. { + 4437. u32 offset; + 4438. > u32 vfta_value = 0; + 4439. u32 vfta_offset = 0; + 4440. u32 vfta_bit_in_reg = 0; + +drivers/md/md.c:4482: error: DEAD_STORE + The value written to &namelen is never used. + 4480. mddev->metadata_type[namelen] = 0; + 4481. if (namelen && mddev->metadata_type[namelen-1] == '\n') + 4482. > mddev->metadata_type[--namelen] = 0; + 4483. mddev->persistent = 0; + 4484. mddev->external = 1; + +drivers/iommu/intel-iommu.c:4454: error: DEAD_STORE + The value written to &ret is never used. + 4452. int dmar_iommu_notify_scope_dev(struct dmar_pci_notify_info *info) + 4453. { + 4454. > int ret = 0; + 4455. struct dmar_rmrr_unit *rmrru; + 4456. struct dmar_atsr_unit *atsru; + +net/core/rtnetlink.c:4482: error: DEAD_STORE + The value written to &filter_mask is never used. + 4480. struct hlist_head *head; + 4481. struct net_device *dev; + 4482. > u32 filter_mask = 0; + 4483. int idx = 0; + 4484. + +security/selinux/hooks.c:4534: error: DEAD_STORE + The value written to &addr4 is never used. + 4532. struct common_audit_data ad; + 4533. struct lsm_network_audit net = {0,}; + 4534. > struct sockaddr_in *addr4 = NULL; + 4535. struct sockaddr_in6 *addr6 = NULL; + 4536. unsigned short snum; + +security/selinux/hooks.c:4535: error: DEAD_STORE + The value written to &addr6 is never used. + 4533. struct lsm_network_audit net = {0,}; + 4534. struct sockaddr_in *addr4 = NULL; + 4535. > struct sockaddr_in6 *addr6 = NULL; + 4536. unsigned short snum; + 4537. u32 sid, perm; + +drivers/gpu/drm/i915/i915_gem.c:4562: error: NULL_DEREFERENCE + pointer `obj->base.filp` last assigned on line 4551 could be null and is dereferenced at line 4562, column 12. + 4560. } + 4561. + 4562. > mapping = obj->base.filp->f_mapping; + 4563. mapping_set_gfp_mask(mapping, mask); + 4564. GEM_BUG_ON(!(mapping_gfp_mask(mapping) & __GFP_RECLAIM)); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4531: error: DEAD_STORE + The value written to &ret_val is never used. + 4529. { + 4530. u32 ledctl; + 4531. > s32 ret_val = E1000_SUCCESS; + 4532. + 4533. switch (hw->mac_type) { + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &preferred_lft is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &valid_lft is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4581: error: DEAD_STORE + The value written to &ret_val is never used. + 4579. s32 e1000_cleanup_led(struct e1000_hw *hw) + 4580. { + 4581. > s32 ret_val = E1000_SUCCESS; + 4582. + 4583. switch (hw->mac_type) { + +net/wireless/nl80211.c:4608: error: DEAD_STORE + The value written to &mac_addr is never used. + 4606. struct station_info sinfo; + 4607. struct sk_buff *msg; + 4608. > u8 *mac_addr = NULL; + 4609. int err; + 4610. + +kernel/workqueue.c:4656: error: DEAD_STORE + The value written to &worker_flags is never used. + 4654. WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND)); + 4655. worker_flags |= WORKER_REBOUND; + 4656. > worker_flags &= ~WORKER_UNBOUND; + 4657. WRITE_ONCE(worker->flags, worker_flags); + 4658. } + +drivers/gpu/drm/i915/intel_display.c:4618: error: DEAD_STORE + The value written to &temp is never used. + 4616. u32 temp; + 4617. + 4618. > temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + +drivers/gpu/drm/i915/intel_display.c:4620: error: DEAD_STORE + The value written to &timeout__ is never used. + 4618. temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4621: error: DEAD_STORE + The value written to &timeout__ is never used. + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4623. } + +drivers/gpu/drm/i915/intel_display.c:4620: error: DEAD_STORE + The value written to &wait__ is never used. + 4618. temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4621: error: DEAD_STORE + The value written to &wait__ is never used. + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4623. } + +drivers/iommu/intel-iommu.c:4634: error: DEAD_STORE + The value written to &iommu is never used. + 4632. static void intel_disable_iommus(void) + 4633. { + 4634. > struct intel_iommu *iommu = NULL; + 4635. struct dmar_drhd_unit *drhd; + 4636. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4705: error: DEAD_STORE + The value written to &temp is never used. + 4703. volatile u32 temp; + 4704. + 4705. > temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4706: error: DEAD_STORE + The value written to &temp is never used. + 4704. + 4705. temp = er32(CRCERRS); + 4706. > temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4707: error: DEAD_STORE + The value written to &temp is never used. + 4705. temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. > temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4708: error: DEAD_STORE + The value written to &temp is never used. + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. > temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4709: error: DEAD_STORE + The value written to &temp is never used. + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. > temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4710: error: DEAD_STORE + The value written to &temp is never used. + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. > temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4711: error: DEAD_STORE + The value written to &temp is never used. + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. > temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4712: error: DEAD_STORE + The value written to &temp is never used. + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. > temp = er32(COLC); + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4713: error: DEAD_STORE + The value written to &temp is never used. + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. > temp = er32(DC); + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4714: error: DEAD_STORE + The value written to &temp is never used. + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + 4714. > temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4715: error: DEAD_STORE + The value written to &temp is never used. + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + 4715. > temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4716: error: DEAD_STORE + The value written to &temp is never used. + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. > temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4717: error: DEAD_STORE + The value written to &temp is never used. + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. > temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4718: error: DEAD_STORE + The value written to &temp is never used. + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. > temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4719: error: DEAD_STORE + The value written to &temp is never used. + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. > temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + 4721. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4720: error: DEAD_STORE + The value written to &temp is never used. + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. > temp = er32(FCRUC); + 4721. + 4722. temp = er32(PRC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4722: error: DEAD_STORE + The value written to &temp is never used. + 4720. temp = er32(FCRUC); + 4721. + 4722. > temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4723: error: DEAD_STORE + The value written to &temp is never used. + 4721. + 4722. temp = er32(PRC64); + 4723. > temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4724: error: DEAD_STORE + The value written to &temp is never used. + 4722. temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. > temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4725: error: DEAD_STORE + The value written to &temp is never used. + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. > temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4726: error: DEAD_STORE + The value written to &temp is never used. + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. > temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + 4728. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4727: error: DEAD_STORE + The value written to &temp is never used. + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. > temp = er32(PRC1522); + 4728. + 4729. temp = er32(GPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4729: error: DEAD_STORE + The value written to &temp is never used. + 4727. temp = er32(PRC1522); + 4728. + 4729. > temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4730: error: DEAD_STORE + The value written to &temp is never used. + 4728. + 4729. temp = er32(GPRC); + 4730. > temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4731: error: DEAD_STORE + The value written to &temp is never used. + 4729. temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. > temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4732: error: DEAD_STORE + The value written to &temp is never used. + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. > temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4733: error: DEAD_STORE + The value written to &temp is never used. + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. > temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4734: error: DEAD_STORE + The value written to &temp is never used. + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. > temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4735: error: DEAD_STORE + The value written to &temp is never used. + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. > temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4736: error: DEAD_STORE + The value written to &temp is never used. + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. > temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4737: error: DEAD_STORE + The value written to &temp is never used. + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. > temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4738: error: DEAD_STORE + The value written to &temp is never used. + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. > temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4739: error: DEAD_STORE + The value written to &temp is never used. + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. > temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4740: error: DEAD_STORE + The value written to &temp is never used. + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. > temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4741: error: DEAD_STORE + The value written to &temp is never used. + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. > temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4742: error: DEAD_STORE + The value written to &temp is never used. + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. > temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4743: error: DEAD_STORE + The value written to &temp is never used. + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. > temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4744: error: DEAD_STORE + The value written to &temp is never used. + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. > temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4745: error: DEAD_STORE + The value written to &temp is never used. + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. > temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. temp = er32(TPT); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4746: error: DEAD_STORE + The value written to &temp is never used. + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. > temp = er32(TPR); + 4747. temp = er32(TPT); + 4748. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4747: error: DEAD_STORE + The value written to &temp is never used. + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. > temp = er32(TPT); + 4748. + 4749. temp = er32(PTC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4749: error: DEAD_STORE + The value written to &temp is never used. + 4747. temp = er32(TPT); + 4748. + 4749. > temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4750: error: DEAD_STORE + The value written to &temp is never used. + 4748. + 4749. temp = er32(PTC64); + 4750. > temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4751: error: DEAD_STORE + The value written to &temp is never used. + 4749. temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. > temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4752: error: DEAD_STORE + The value written to &temp is never used. + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. > temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4753: error: DEAD_STORE + The value written to &temp is never used. + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. > temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + 4755. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4754: error: DEAD_STORE + The value written to &temp is never used. + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. > temp = er32(PTC1522); + 4755. + 4756. temp = er32(MPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4756: error: DEAD_STORE + The value written to &temp is never used. + 4754. temp = er32(PTC1522); + 4755. + 4756. > temp = er32(MPTC); + 4757. temp = er32(BPTC); + 4758. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4757: error: DEAD_STORE + The value written to &temp is never used. + 4755. + 4756. temp = er32(MPTC); + 4757. > temp = er32(BPTC); + 4758. + 4759. if (hw->mac_type < e1000_82543) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4762: error: DEAD_STORE + The value written to &temp is never used. + 4760. return; + 4761. + 4762. > temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4763: error: DEAD_STORE + The value written to &temp is never used. + 4761. + 4762. temp = er32(ALGNERRC); + 4763. > temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4764: error: DEAD_STORE + The value written to &temp is never used. + 4762. temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. > temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4765: error: DEAD_STORE + The value written to &temp is never used. + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. > temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4766: error: DEAD_STORE + The value written to &temp is never used. + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. > temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + 4768. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4767: error: DEAD_STORE + The value written to &temp is never used. + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. > temp = er32(TSCTFC); + 4768. + 4769. if (hw->mac_type <= e1000_82544) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4772: error: DEAD_STORE + The value written to &temp is never used. + 4770. return; + 4771. + 4772. > temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4773: error: DEAD_STORE + The value written to &temp is never used. + 4771. + 4772. temp = er32(MGTPRC); + 4773. > temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + 4775. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4774: error: DEAD_STORE + The value written to &temp is never used. + 4772. temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. > temp = er32(MGTPTC); + 4775. } + 4776. + +drivers/pci/quirks.c:4792: error: DEAD_STORE + The value written to &i is never used. + 4790. pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &cap[i++]); + 4791. pcie_capability_read_word(pdev, PCI_EXP_LNKCTL2, &cap[i++]); + 4792. > pcie_capability_read_word(pdev, PCI_EXP_SLTCTL2, &cap[i++]); + 4793. hlist_add_head(&state->next, &pdev->saved_cap_space); + 4794. } + +security/selinux/hooks.c:4724: error: DEAD_STORE + The value written to &err is never used. + 4722. u16 family) + 4723. { + 4724. > int err = 0; + 4725. struct sk_security_struct *sksec = sk->sk_security; + 4726. u32 sk_sid = sksec->sid; + +drivers/gpu/drm/i915/i915_gem.c:4780: error: DEAD_STORE + The value written to &kernel_context is never used. + 4778. static void assert_kernel_context_is_current(struct drm_i915_private *i915) + 4779. { + 4780. > struct i915_gem_context *kernel_context = i915->kernel_context; + 4781. struct intel_engine_cs *engine; + 4782. enum intel_engine_id id; + +security/selinux/hooks.c:4826: error: DEAD_STORE + The value written to &err is never used. + 4824. int __user *optlen, unsigned len) + 4825. { + 4826. > int err = 0; + 4827. char *scontext; + 4828. u32 scontext_len; + +net/ipv6/addrconf.c:4937: error: DEAD_STORE + The value written to &addr is never used. + 4935. struct ifaddrmsg *ifm; + 4936. struct nlattr *tb[IFA_MAX+1]; + 4937. > struct in6_addr *addr = NULL, *peer; + 4938. struct net_device *dev = NULL; + 4939. struct inet6_ifaddr *ifa; + +drivers/gpu/drm/i915/intel_dp.c:4944: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 4941 could be null and is dereferenced by call to `intel_dp_mst_encoder_cleanup()` at line 4944, column 2. + 4942. struct intel_dp *intel_dp = &intel_dig_port->dp; + 4943. + 4944. > intel_dp_mst_encoder_cleanup(intel_dig_port); + 4945. if (intel_dp_is_edp(intel_dp)) { + 4946. cancel_delayed_work_sync(&intel_dp->panel_vdd_work); + +drivers/md/md.c:4981: error: DEAD_STORE + The value written to &backwards is never used. + 4979. reshape_direction_store(struct mddev *mddev, const char *buf, size_t len) + 4980. { + 4981. > int backwards = 0; + 4982. int err; + 4983. + +drivers/gpu/drm/i915/intel_dp.c:5025: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5025, column 18. + 5023. + 5024. if (!HAS_DDI(dev_priv)) + 5025. > intel_dp->DP = I915_READ(intel_dp->output_reg); + 5026. + 5027. if (lspcon->active) + +drivers/gpu/drm/i915/intel_dp.c:5030: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5030, column 2. + 5028. lspcon_resume(lspcon); + 5029. + 5030. > intel_dp->reset_link_params = true; + 5031. + 5032. pps_lock(intel_dp); + +net/wireless/nl80211.c:5070: error: DEAD_STORE + The value written to &mac_addr is never used. + 5068. struct net_device *dev = info->user_ptr[1]; + 5069. struct station_parameters params; + 5070. > u8 *mac_addr = NULL; + 5071. u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) | + 5072. BIT(NL80211_STA_FLAG_ASSOCIATED); + +drivers/iommu/intel-iommu.c:5074: error: DEAD_STORE + The value written to &freelist is never used. + 5072. { + 5073. struct dmar_domain *dmar_domain = to_dmar_domain(domain); + 5074. > struct page *freelist = NULL; + 5075. struct intel_iommu *iommu; + 5076. unsigned long start_pfn, last_pfn; + +drivers/iommu/intel-iommu.c:5095: error: DEAD_STORE + The value written to &iommu is never used. + 5093. + 5094. for_each_domain_iommu(iommu_id, dmar_domain) { + 5095. > iommu = g_iommus[iommu_id]; + 5096. + 5097. iommu_flush_iotlb_psi(g_iommus[iommu_id], dmar_domain, + +drivers/net/ethernet/intel/e1000/e1000_main.c:5090: error: DEAD_STORE + The value written to &retval is never used. + 5088. u32 wufc = adapter->wol; + 5089. #ifdef CONFIG_PM + 5090. > int retval = 0; + 5091. #endif + 5092. + +security/selinux/hooks.c:5103: error: DEAD_STORE + The value written to &err is never used. + 5101. static int selinux_nlmsg_perm(struct sock *sk, struct sk_buff *skb) + 5102. { + 5103. > int err = 0; + 5104. u32 perm; + 5105. struct nlmsghdr *nlh; + +drivers/ata/libata-core.c:5126: error: NULL_DEREFERENCE + pointer `qc` last assigned on line 5125 could be null and is dereferenced at line 5126, column 2. + 5124. + 5125. qc = __ata_qc_from_tag(ap, tag); + 5126. > qc->tag = tag; + 5127. qc->scsicmd = NULL; + 5128. qc->ap = ap; + +kernel/cgroup/cgroup.c:5125: error: DEAD_STORE + The value written to &ret is never used. + 5123. { + 5124. struct cgroup *cgrp; + 5125. > int ret = 0; + 5126. + 5127. cgrp = cgroup_kn_lock_live(kn, false); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:5141: error: DEAD_STORE + The value written to &ret_val is never used. + 5139. * stability + 5140. */ + 5141. > ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); + 5142. if (!link) + 5143. return 0; + +drivers/gpu/drm/drm_edid.c:5134: error: DEAD_STORE + The value written to &displayid is never used. + 5132. struct edid *edid) + 5133. { + 5134. > void *displayid = NULL; + 5135. int ret; + 5136. connector->has_tile = false; + +kernel/cgroup/cgroup.c:5219: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5218 could be null and is dereferenced at line 5219, column 3. + 5217. + 5218. for_each_subsys(ss, i) { + 5219. > WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id, + 5220. "invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p id:name=%d:%s\n", + 5221. i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free, + +drivers/gpu/drm/i915/intel_dp.c:5215: error: DEAD_STORE + The value written to &pp_ctl is never used. + 5213. { + 5214. struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp)); + 5215. > u32 pp_on, pp_off, pp_div = 0, pp_ctl = 0; + 5216. struct pps_registers regs; + 5217. + +kernel/trace/trace.c:5245: error: DEAD_STORE + The value written to &ret is never used. + 5243. unsigned long size, int cpu_id) + 5244. { + 5245. > int ret = size; + 5246. + 5247. mutex_lock(&trace_types_lock); + +kernel/sched/core.c:5248: error: DEAD_STORE + The value written to &free is never used. + 5246. void sched_show_task(struct task_struct *p) + 5247. { + 5248. > unsigned long free = 0; + 5249. int ppid; + 5250. + +net/ipv4/tcp_input.c:5397: error: DEAD_STORE + The value written to &eaten is never used. + 5395. } + 5396. } else { + 5397. > int eaten = 0; + 5398. bool fragstolen = false; + 5399. + +net/core/skbuff.c:5347: error: DEAD_STORE + The value written to &insp is never used. + 5345. struct sk_buff *list = shinfo->frag_list; + 5346. struct sk_buff *clone = NULL; + 5347. > struct sk_buff *insp = NULL; + 5348. + 5349. do { + +net/wireless/nl80211.c:5430: error: DEAD_STORE + The value written to &dst is never used. + 5428. struct mpath_info pinfo; + 5429. struct sk_buff *msg; + 5430. > u8 *dst = NULL; + 5431. u8 next_hop[ETH_ALEN]; + 5432. + +net/wireless/nl80211.c:5467: error: DEAD_STORE + The value written to &dst is never used. + 5465. struct cfg80211_registered_device *rdev = info->user_ptr[0]; + 5466. struct net_device *dev = info->user_ptr[1]; + 5467. > u8 *dst = NULL; + 5468. u8 *next_hop = NULL; + 5469. + +net/wireless/nl80211.c:5468: error: DEAD_STORE + The value written to &next_hop is never used. + 5466. struct net_device *dev = info->user_ptr[1]; + 5467. u8 *dst = NULL; + 5468. > u8 *next_hop = NULL; + 5469. + 5470. if (!info->attrs[NL80211_ATTR_MAC]) + +kernel/cgroup/cgroup.c:5483: error: DEAD_STORE + The value written to &i is never used. + 5481. int i, j, ret; + 5482. + 5483. > do_each_subsys_mask(ss, i, have_canfork_callback) { + 5484. ret = ss->can_fork(child); + 5485. if (ret) + +drivers/gpu/drm/i915/intel_dp.c:5484: error: DEAD_STORE + The value written to &dig_port is never used. + 5482. { + 5483. struct intel_encoder *encoder; + 5484. > struct intel_digital_port *dig_port = NULL; + 5485. struct intel_dp *intel_dp = dev_priv->drrs.dp; + 5486. struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc); + +drivers/gpu/drm/i915/intel_dp.c:5500: error: DEAD_STORE + The value written to &encoder is never used. + 5498. + 5499. dig_port = dp_to_dig_port(intel_dp); + 5500. > encoder = &dig_port->base; + 5501. + 5502. if (!intel_crtc) { + +drivers/usb/core/hub.c:5487: error: DEAD_STORE + The value written to &ret is never used. + 5485. struct usb_device_descriptor descriptor = udev->descriptor; + 5486. struct usb_host_bos *bos; + 5487. > int i, j, ret = 0; + 5488. int port1 = udev->portnum; + 5489. + +net/wireless/nl80211.c:5492: error: DEAD_STORE + The value written to &dst is never used. + 5490. struct cfg80211_registered_device *rdev = info->user_ptr[0]; + 5491. struct net_device *dev = info->user_ptr[1]; + 5492. > u8 *dst = NULL; + 5493. u8 *next_hop = NULL; + 5494. + +net/wireless/nl80211.c:5493: error: DEAD_STORE + The value written to &next_hop is never used. + 5491. struct net_device *dev = info->user_ptr[1]; + 5492. u8 *dst = NULL; + 5493. > u8 *next_hop = NULL; + 5494. + 5495. if (!info->attrs[NL80211_ATTR_MAC]) + +drivers/net/ethernet/broadcom/tg3.c:5510: error: DEAD_STORE + The value written to &expected_sg_dig_ctrl is never used. + 5508. + 5509. serdes_cfg = 0; + 5510. > expected_sg_dig_ctrl = 0; + 5511. workaround = 0; + 5512. port_a = 1; + +kernel/cgroup/cgroup.c:5515: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5514 could be null and is dereferenced at line 5515, column 7. + 5513. + 5514. for_each_subsys(ss, i) + 5515. > if (ss->cancel_fork) + 5516. ss->cancel_fork(child); + 5517. } + +net/wireless/nl80211.c:5535: error: DEAD_STORE + The value written to &dst is never used. + 5533. struct mpath_info pinfo; + 5534. struct sk_buff *msg; + 5535. > u8 *dst = NULL; + 5536. u8 mpp[ETH_ALEN]; + 5537. + +kernel/cgroup/cgroup.c:5573: error: DEAD_STORE + The value written to &i is never used. + 5571. * and addition to css_set. + 5572. */ + 5573. > do_each_subsys_mask(ss, i, have_fork_callback) { + 5574. ss->fork(child); + 5575. } while_each_subsys_mask(); + +drivers/net/ethernet/realtek/r8169.c:5572: error: DEAD_STORE + The value written to &tmp is never used. + 5570. u32 mc_filter[2]; /* Multicast hash filter */ + 5571. int rx_mode; + 5572. > u32 tmp = 0; + 5573. + 5574. if (dev->flags & IFF_PROMISC) { + +kernel/cgroup/cgroup.c:5619: error: DEAD_STORE + The value written to &i is never used. + 5617. + 5618. /* see cgroup_post_fork() for details */ + 5619. > do_each_subsys_mask(ss, i, have_exit_callback) { + 5620. ss->exit(tsk); + 5621. } while_each_subsys_mask(); + +kernel/cgroup/cgroup.c:5630: error: DEAD_STORE + The value written to &ssid is never used. + 5628. int ssid; + 5629. + 5630. > do_each_subsys_mask(ss, ssid, have_free_callback) { + 5631. ss->free(task); + 5632. } while_each_subsys_mask(); + +drivers/gpu/drm/i915/intel_pm.c:5657: error: DEAD_STORE + The value written to &timeout__ is never used. + 5655. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5656. + 5657. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5658. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5659. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +drivers/gpu/drm/i915/intel_pm.c:5657: error: DEAD_STORE + The value written to &wait__ is never used. + 5655. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5656. + 5657. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5658. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5659. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +drivers/net/ethernet/intel/e1000e/netdev.c:5635: error: DEAD_STORE + The value written to &tx_desc is never used. + 5633. { + 5634. struct e1000_adapter *adapter = tx_ring->adapter; + 5635. > struct e1000_tx_desc *tx_desc = NULL; + 5636. struct e1000_buffer *buffer_info; + 5637. u32 txd_upper = 0, txd_lower = E1000_TXD_CMD_IFCS; + +drivers/usb/core/hub.c:5674: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5659 could be null and is dereferenced at line 5674, column 13. + 5672. } + 5673. + 5674. > port_dev = hub->ports[udev->portnum - 1]; + 5675. + 5676. /* + +net/wireless/nl80211.c:5700: error: DEAD_STORE + The value written to &data is never used. + 5698. static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info) + 5699. { + 5700. > char *data = NULL; + 5701. bool is_indoor; + 5702. enum nl80211_user_reg_hint_type user_reg_hint_type; + +drivers/net/ethernet/broadcom/tg3.c:5754: error: DEAD_STORE + The value written to ¤t_link_up is never used. + 5752. udelay(40); + 5753. + 5754. > current_link_up = false; + 5755. tp->link_config.rmt_adv = 0; + 5756. mac_status = tr32(MAC_STATUS); + +net/core/dev.c:5751: error: DEAD_STORE + The value written to &time_limit is never used. + 5749. { + 5750. struct softnet_data *sd = this_cpu_ptr(&softnet_data); + 5751. > unsigned long time_limit = jiffies + + 5752. usecs_to_jiffies(netdev_budget_usecs); + 5753. int budget = netdev_budget; + +net/ipv6/addrconf.c:5779: error: DEAD_STORE + The value written to &ret is never used. + 5777. loff_t *ppos) + 5778. { + 5779. > int ret = 0; + 5780. int new_val; + 5781. struct inet6_dev *idev = (struct inet6_dev *)ctl->extra1; + +drivers/usb/core/hub.c:5795: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5791 could be null and is dereferenced at line 5795, column 9. + 5793. if (port1 < 1 || port1 > hdev->maxchild) + 5794. return NULL; + 5795. > return hub->ports[port1 - 1]->child; + 5796. } + 5797. EXPORT_SYMBOL_GPL(usb_hub_find_child); + +drivers/gpu/drm/i915/intel_dp.c:5807: error: DEAD_STORE + The value written to &downclock_mode is never used. + 5805. { + 5806. struct drm_i915_private *dev_priv = to_i915(connector->base.dev); + 5807. > struct drm_display_mode *downclock_mode = NULL; + 5808. + 5809. INIT_DELAYED_WORK(&dev_priv->drrs.work, intel_edp_drrs_downclock_work); + +security/selinux/hooks.c:5873: error: DEAD_STORE + The value written to &av is never used. + 5871. static int selinux_ipc_permission(struct kern_ipc_perm *ipcp, short flag) + 5872. { + 5873. > u32 av = 0; + 5874. + 5875. av = 0; + +kernel/sched/core.c:5918: error: DEAD_STORE + The value written to &ptr is never used. + 5916. + 5917. root_task_group.cfs_rq = (struct cfs_rq **)ptr; + 5918. > ptr += nr_cpu_ids * sizeof(void **); + 5919. + 5920. #endif /* CONFIG_FAIR_GROUP_SCHED */ + +kernel/cgroup/cgroup.c:5913: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5912 could be null and is dereferenced at line 5913, column 33. + 5911. + 5912. for_each_subsys(ss, ssid) + 5913. > ret += show_delegatable_files(ss->dfl_cftypes, buf + ret, + 5914. PAGE_SIZE - ret, + 5915. cgroup_subsys_name[ssid]); + +kernel/trace/trace.c:5936: error: DEAD_STORE + The value written to &r is never used. + 5934. int cpu = tracing_get_cpu(inode); + 5935. char buf[64]; + 5936. > int r = 0; + 5937. ssize_t ret; + 5938. + +security/selinux/hooks.c:6040: error: DEAD_STORE + The value written to &error is never used. + 6038. + 6039. /* Only allow single threaded processes to change context */ + 6040. > error = -EPERM; + 6041. if (!current_is_single_threaded()) { + 6042. error = security_bounded_transition(tsec->sid, sid); + +security/selinux/hooks.c:6124: error: DEAD_STORE + The value written to &len is never used. + 6122. static int selinux_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen) + 6123. { + 6124. > int len = 0; + 6125. len = selinux_inode_getsecurity(inode, XATTR_SELINUX_SUFFIX, + 6126. ctx, true); + +drivers/net/ethernet/broadcom/tg3.c:6186: error: DEAD_STORE + The value written to &correction is never used. + 6184. struct tg3 *tp = container_of(ptp, struct tg3, ptp_info); + 6185. bool neg_adj = false; + 6186. > u32 correction = 0; + 6187. + 6188. if (ppb < 0) { + +drivers/md/md.c:6245: error: DEAD_STORE + The value written to &file is never used. + 6243. static int get_bitmap_file(struct mddev *mddev, void __user * arg) + 6244. { + 6245. > mdu_bitmap_file_t *file = NULL; /* too big for stack allocation */ + 6246. char *ptr; + 6247. int err; + +drivers/net/ethernet/intel/e1000e/netdev.c:6420: error: DEAD_STORE + The value written to &retval is never used. + 6418. lpi_ctrl |= I82579_LPI_CTRL_1000_ENABLE; + 6419. + 6420. > retval = e1e_wphy_locked(hw, I82579_LPI_CTRL, + 6421. lpi_ctrl); + 6422. } + +net/wireless/nl80211.c:6377: error: DEAD_STORE + The value written to ®dom is never used. + 6375. struct netlink_callback *cb) + 6376. { + 6377. > const struct ieee80211_regdomain *regdom = NULL; + 6378. struct cfg80211_registered_device *rdev; + 6379. int err, reg_idx, start = cb->args[2]; + +net/core/dev.c:6408: error: DEAD_STORE + The value written to &ret is never used. + 6406. }; + 6407. struct net_device *master_dev; + 6408. > int ret = 0; + 6409. + 6410. ASSERT_RTNL(); + +kernel/sched/core.c:6399: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6397 could be null and is dereferenced by call to `sched_offline_group()` at line 6399, column 2. + 6397. struct task_group *tg = css_tg(css); + 6398. + 6399. > sched_offline_group(tg); + 6400. } + 6401. + +kernel/sched/core.c:6485: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6483 could be null and is dereferenced at line 6485, column 15. + 6483. struct task_group *tg = css_tg(css); + 6484. + 6485. > return (u64) scale_load_down(tg->shares); + 6486. } + 6487. + +net/core/dev.c:6645: error: DEAD_STORE + The value written to &lower is never used. + 6643. int dev_get_nest_level(struct net_device *dev) + 6644. { + 6645. > struct net_device *lower = NULL; + 6646. struct list_head *iter; + 6647. int max_nest = -1; + +drivers/ata/libata-core.c:6705: error: DEAD_STORE + The value written to &tmp is never used. + 6703. int pci_test_config_bits(struct pci_dev *pdev, const struct pci_bits *bits) + 6704. { + 6705. > unsigned long tmp = 0; + 6706. + 6707. switch (bits->width) { + +drivers/ata/libata-core.c:6767: error: DEAD_STORE + The value written to &rc is never used. + 6765. { + 6766. struct ata_host *host = pci_get_drvdata(pdev); + 6767. > int rc = 0; + 6768. + 6769. rc = ata_host_suspend(host, mesg); + +kernel/sched/core.c:6831: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6830 could be null and is dereferenced at line 6831, column 15. + 6829. { + 6830. struct task_group *tg = css_tg(css); + 6831. > u64 weight = scale_load_down(tg->shares); + 6832. + 6833. return DIV_ROUND_CLOSEST_ULL(weight * CGROUP_WEIGHT_DFL, 1024); + +kernel/events/core.c:6874: error: DEAD_STORE + The value written to &flags is never used. + 6872. int maj = 0, min = 0; + 6873. u64 ino = 0, gen = 0; + 6874. > u32 prot = 0, flags = 0; + 6875. unsigned int size; + 6876. char tmp[16]; + +drivers/ata/libata-core.c:7104: error: DEAD_STORE + The value written to &deadline is never used. + 7102. * eat away the timeout. + 7103. */ + 7104. > deadline = ata_deadline(jiffies, timeout); + 7105. + 7106. while ((tmp & mask) == val && time_before(jiffies, deadline)) { + +drivers/ata/libata-core.c:7128: error: DEAD_STORE + The value written to &lpm_timeout is never used. + 7126. bool sata_lpm_ignore_phy_events(struct ata_link *link) + 7127. { + 7128. > unsigned long lpm_timeout = link->last_lpm_change + + 7129. msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY); + 7130. + +kernel/events/core.c:7386: error: DEAD_STORE + The value written to &ret is never used. + 7384. { + 7385. int events = atomic_read(&event->event_limit); + 7386. > int ret = 0; + 7387. + 7388. /* + +drivers/gpu/drm/i915/intel_display.c:7480: error: DEAD_STORE + The value written to &offset is never used. + 7478. + 7479. if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) { + 7480. > offset = I915_READ(DSPOFFSET(i9xx_plane)); + 7481. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + +drivers/gpu/drm/i915/intel_display.c:7484: error: DEAD_STORE + The value written to &offset is never used. + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + 7483. if (plane_config->tiling) + 7484. > offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. offset = I915_READ(DSPLINOFF(i9xx_plane)); + +drivers/gpu/drm/i915/intel_display.c:7486: error: DEAD_STORE + The value written to &offset is never used. + 7484. offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. > offset = I915_READ(DSPLINOFF(i9xx_plane)); + 7487. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7488. } else { + +net/wireless/nl80211.c:7487: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced at line 7487, column 11. + 7485. */ + 7486. if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) { + 7487. > while (!sched_scan_req->reqid) + 7488. sched_scan_req->reqid = rdev->wiphy.cookie_counter++; + 7489. } + +net/wireless/nl80211.c:7491: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced by call to `rdev_sched_scan_start()` at line 7491, column 8. + 7489. } + 7490. + 7491. > err = rdev_sched_scan_start(rdev, dev, sched_scan_req); + 7492. if (err) + 7493. goto out_free; + +drivers/gpu/drm/i915/intel_display.c:7669: error: DEAD_STORE + The value written to &can_ssc is never used. + 7667. bool has_panel = false; + 7668. bool has_ck505 = false; + 7669. > bool can_ssc = false; + 7670. bool using_ssc_source = false; + 7671. + +drivers/gpu/drm/i915/intel_display.c:7668: error: DEAD_STORE + The value written to &has_ck505 is never used. + 7666. bool has_cpu_edp = false; + 7667. bool has_panel = false; + 7668. > bool has_ck505 = false; + 7669. bool can_ssc = false; + 7670. bool using_ssc_source = false; + +net/core/dev.c:7695: error: DEAD_STORE + The value written to &err is never used. + 7693. struct netdev_rx_queue *rx; + 7694. size_t sz = count * sizeof(*rx); + 7695. > int err = 0; + 7696. + 7697. BUG_ON(count < 1); + +drivers/md/md.c:7750: error: DEAD_STORE + The value written to &l is never used. + 7748. } + 7749. spin_unlock(&all_mddevs_lock); + 7750. > if (!l--) + 7751. return (void*)2;/* tail */ + 7752. return NULL; + +drivers/net/ethernet/broadcom/tg3.c:7800: error: DEAD_STORE + The value written to &new_addr is never used. + 7798. struct tg3 *tp = tnapi->tp; + 7799. struct sk_buff *new_skb, *skb = *pskb; + 7800. > dma_addr_t new_addr = 0; + 7801. int ret = 0; + 7802. + +drivers/gpu/drm/i915/intel_display.c:7835: error: DEAD_STORE + The value written to &timeout__ is never used. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: DEAD_STORE + The value written to &timeout__ is never used. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: DEAD_STORE + The value written to &wait__ is never used. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: DEAD_STORE + The value written to &wait__ is never used. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/net/ethernet/broadcom/tg3.c:8153: error: DEAD_STORE + The value written to &i is never used. + 8151. + 8152. dma_error: + 8153. > tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, --i); + 8154. tnapi->tx_buffers[tnapi->tx_prod].skb = NULL; + 8155. drop: + +net/core/dev.c:8049: error: DEAD_STORE + The value written to &rebroadcast_time is never used. + 8047. linkwatch_forget_dev(dev); + 8048. + 8049. > rebroadcast_time = warning_time = jiffies; + 8050. refcnt = netdev_refcnt_read(dev); + 8051. + +net/core/dev.c:8087: error: DEAD_STORE + The value written to &warning_time is never used. + 8085. pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n", + 8086. dev->name, refcnt); + 8087. > warning_time = jiffies; + 8088. } + 8089. } + +kernel/events/core.c:8277: error: DEAD_STORE + The value written to &mm is never used. + 8275. struct task_struct *task = READ_ONCE(event->ctx->task); + 8276. struct perf_addr_filter *filter; + 8277. > struct mm_struct *mm = NULL; + 8278. unsigned int count = 0; + 8279. unsigned long flags; + +kernel/trace/trace.c:8289: error: DEAD_STORE + The value written to &ret is never used. + 8287. { + 8288. char *kbuf, *buf, *tmp; + 8289. > int ret = 0; + 8290. size_t done = 0; + 8291. size_t size; + +net/wireless/nl80211.c:8294: error: DEAD_STORE + The value written to &ssid_len is never used. + 8292. struct cfg80211_assoc_request req = {}; + 8293. const u8 *bssid, *ssid; + 8294. > int err, ssid_len = 0; + 8295. + 8296. if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE])) + +drivers/gpu/drm/i915/intel_display.c:8444: error: DEAD_STORE + The value written to &ps_ctrl is never used. + 8442. struct drm_i915_private *dev_priv = to_i915(dev); + 8443. struct intel_crtc_scaler_state *scaler_state = &pipe_config->scaler_state; + 8444. > uint32_t ps_ctrl = 0; + 8445. int id = -1; + 8446. int i; + +drivers/gpu/drm/i915/intel_display.c:8540: error: DEAD_STORE + The value written to &offset is never used. + 8538. plane_config->base = base; + 8539. + 8540. > offset = I915_READ(PLANE_OFFSET(pipe, plane_id)); + 8541. + 8542. val = I915_READ(PLANE_SIZE(pipe, plane_id)); + +net/core/dev.c:8562: error: DEAD_STORE + The value written to &err is never used. + 8560. + 8561. /* And unlink it from device chain */ + 8562. > err = -ENODEV; + 8563. unlist_netdevice(dev); + 8564. + +net/core/dev.c:8637: error: DEAD_STORE + The value written to &remsd is never used. + 8635. struct sk_buff *skb; + 8636. unsigned int cpu; + 8637. > struct softnet_data *sd, *oldsd, *remsd = NULL; + 8638. + 8639. local_irq_disable(); + +drivers/gpu/drm/i915/intel_display.c:8765: error: DEAD_STORE + The value written to &timeout__ is never used. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8784: error: DEAD_STORE + The value written to &timeout__ is never used. + 8782. ndelay(100); + 8783. + 8784. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8785. 1)) + 8786. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: DEAD_STORE + The value written to &wait__ is never used. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8784: error: DEAD_STORE + The value written to &wait__ is never used. + 8782. ndelay(100); + 8783. + 8784. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8785. 1)) + 8786. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +kernel/sched/fair.c:8785: error: DEAD_STORE + The value written to &curr_cost is never used. + 8783. struct sched_domain *sd; + 8784. int pulled_task = 0; + 8785. > u64 curr_cost = 0; + 8786. + 8787. /* + +kernel/sched/fair.c:8781: error: DEAD_STORE + The value written to &next_balance is never used. + 8779. static int idle_balance(struct rq *this_rq, struct rq_flags *rf) + 8780. { + 8781. > unsigned long next_balance = jiffies + HZ; + 8782. int this_cpu = this_rq->cpu; + 8783. struct sched_domain *sd; + +kernel/sched/fair.c:8784: error: DEAD_STORE + The value written to &pulled_task is never used. + 8782. int this_cpu = this_rq->cpu; + 8783. struct sched_domain *sd; + 8784. > int pulled_task = 0; + 8785. u64 curr_cost = 0; + 8786. + +drivers/gpu/drm/i915/intel_display.c:8841: error: DEAD_STORE + The value written to &timeout__ is never used. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: DEAD_STORE + The value written to &wait__ is never used. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/md/md.c:9161: error: DEAD_STORE + The value written to &ret is never used. + 9159. if (rdev2->raid_disk == -1 && role != 0xffff) { + 9160. rdev2->saved_raid_disk = role; + 9161. > ret = remove_and_add_spares(mddev, rdev2); + 9162. pr_info("Activated spare: %s\n", + 9163. bdevname(rdev2->bdev,b)); + +kernel/sched/fair.c:9134: error: DEAD_STORE + The value written to &continue_balancing is never used. + 9132. static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle) + 9133. { + 9134. > int continue_balancing = 1; + 9135. int cpu = rq->cpu; + 9136. unsigned long interval; + +drivers/gpu/drm/i915/intel_pm.c:9249: error: DEAD_STORE + The value written to &timeout__ is never used. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/gpu/drm/i915/intel_pm.c:9249: error: DEAD_STORE + The value written to &wait__ is never used. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/gpu/drm/i915/intel_display.c:9260: error: NULL_DEREFERENCE + pointer `obj` last assigned on line 9256 could be null and is dereferenced at line 9260, column 10. + 9258. + 9259. if (INTEL_INFO(dev_priv)->cursor_needs_physical) + 9260. > base = obj->phys_handle->busaddr; + 9261. else + 9262. base = intel_plane_ggtt_offset(plane_state); + +kernel/sched/fair.c:9316: error: DEAD_STORE + The value written to &kick is never used. + 9314. struct sched_domain *sd; + 9315. int nr_busy, i, cpu = rq->cpu; + 9316. > bool kick = false; + 9317. + 9318. if (unlikely(rq->idle_balance)) + +kernel/sched/fair.c:9312: error: DEAD_STORE + The value written to &now is never used. + 9310. static inline bool nohz_kick_needed(struct rq *rq) + 9311. { + 9312. > unsigned long now = jiffies; + 9313. struct sched_domain_shared *sds; + 9314. struct sched_domain *sd; + +drivers/gpu/drm/i915/intel_pm.c:9381: error: DEAD_STORE + The value written to &loop is never used. + 9379. _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH)); + 9380. upper = I915_READ_FW(reg); + 9381. > } while (upper != tmp && --loop); + 9382. + 9383. /* Everywhere else we always use VLV_COUNTER_CONTROL with the + +kernel/events/core.c:9529: error: DEAD_STORE + The value written to &pmu is never used. + 9527. perf_event__state_init(event); + 9528. + 9529. > pmu = NULL; + 9530. + 9531. hwc = &event->hw; + +drivers/gpu/drm/i915/intel_display.c:9894: error: DEAD_STORE + The value written to &restore_state is never used. + 9892. if (restore_state) { + 9893. drm_atomic_state_put(restore_state); + 9894. > restore_state = NULL; + 9895. } + 9896. + +drivers/gpu/drm/i915/intel_display.c:9890: error: DEAD_STORE + The value written to &state is never used. + 9888. if (state) { + 9889. drm_atomic_state_put(state); + 9890. > state = NULL; + 9891. } + 9892. if (restore_state) { + +kernel/events/core.c:10552: error: DEAD_STORE + The value written to &clone_ctx is never used. + 10550. static void perf_event_exit_task_context(struct task_struct *child, int ctxn) + 10551. { + 10552. > struct perf_event_context *child_ctx, *clone_ctx = NULL; + 10553. struct perf_event *child_event, *next; + 10554. + +drivers/net/ethernet/broadcom/tg3.c:10778: error: DEAD_STORE + The value written to &off is never used. + 10776. + 10777. tg3_ape_scratchpad_read(tp, (u32 *) ocir, off, len); + 10778. > off += len; + 10779. + 10780. if (ocir->signature != TG3_OCIR_SIG_MAGIC || + +net/wireless/nl80211.c:11313: error: DEAD_STORE + The value written to &err is never used. + 11311. struct sk_buff *msg = NULL; + 11312. void *hdr = NULL; + 11313. > int err = 0; + 11314. + 11315. if (wdev->iftype != NL80211_IFTYPE_NAN) + +drivers/gpu/drm/i915/intel_display.c:11843: error: DEAD_STORE + The value written to &ret is never used. + 11841. struct drm_crtc *crtc; + 11842. struct drm_crtc_state *old_crtc_state, *new_crtc_state; + 11843. > int ret = 0, i; + 11844. + 11845. if (!check_digital_port_conflicts(state)) { + +drivers/net/ethernet/broadcom/tg3.c:12197: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 12196 could be null and is dereferenced by call to `phy_ethtool_ksettings_set()` at line 12197, column 10. + 12195. return -EAGAIN; + 12196. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 12197. > return phy_ethtool_ksettings_set(phydev, cmd); + 12198. } + 12199. + +drivers/gpu/drm/i915/intel_display.c:12416: error: DEAD_STORE + The value written to &ret is never used. + 12414. struct intel_atomic_state *intel_state = to_intel_atomic_state(state); + 12415. struct drm_i915_private *dev_priv = to_i915(dev); + 12416. > int ret = 0; + 12417. + 12418. drm_atomic_state_get(state); + +drivers/net/ethernet/broadcom/tg3.c:12866: error: DEAD_STORE + The value written to &err is never used. + 12864. u32 csum, magic, len; + 12865. __be32 *buf; + 12866. > int i, j, k, err = 0, size; + 12867. + 12868. if (tg3_flag(tp, NO_NVRAM)) + +drivers/gpu/drm/i915/intel_display.c:13118: error: DEAD_STORE + The value written to &primary is never used. + 13116. intel_primary_plane_create(struct drm_i915_private *dev_priv, enum pipe pipe) + 13117. { + 13118. > struct intel_plane *primary = NULL; + 13119. struct intel_plane_state *state = NULL; + 13120. const uint32_t *intel_primary_formats; + +drivers/gpu/drm/i915/intel_display.c:13261: error: DEAD_STORE + The value written to &cursor is never used. + 13259. enum pipe pipe) + 13260. { + 13261. > struct intel_plane *cursor = NULL; + 13262. struct intel_plane_state *state = NULL; + 13263. int ret; + +drivers/gpu/drm/i915/intel_display.c:13359: error: DEAD_STORE + The value written to &crtc_state is never used. + 13357. { + 13358. struct intel_crtc *intel_crtc; + 13359. > struct intel_crtc_state *crtc_state = NULL; + 13360. struct intel_plane *primary = NULL; + 13361. struct intel_plane *cursor = NULL; + +drivers/gpu/drm/i915/intel_display.c:13361: error: DEAD_STORE + The value written to &cursor is never used. + 13359. struct intel_crtc_state *crtc_state = NULL; + 13360. struct intel_plane *primary = NULL; + 13361. > struct intel_plane *cursor = NULL; + 13362. int sprite, ret; + 13363. + +drivers/gpu/drm/i915/intel_display.c:13360: error: DEAD_STORE + The value written to &primary is never used. + 13358. struct intel_crtc *intel_crtc; + 13359. struct intel_crtc_state *crtc_state = NULL; + 13360. > struct intel_plane *primary = NULL; + 13361. struct intel_plane *cursor = NULL; + 13362. int sprite, ret; + +drivers/gpu/drm/i915/intel_display.c:13562: error: DEAD_STORE + The value written to &dpd_is_edp is never used. + 13560. { + 13561. struct intel_encoder *encoder; + 13562. > bool dpd_is_edp = false; + 13563. + 13564. intel_pps_init(dev_priv); + +drivers/net/ethernet/broadcom/tg3.c:15611: error: DEAD_STORE + The value written to &i is never used. + 15609. unsigned int block_end, rosize, len; + 15610. u32 vpdlen; + 15611. > int j, i = 0; + 15612. + 15613. vpd_data = (u8 *)tg3_vpd_readblock(tp, &vpdlen); + +Summary of the reports + + DEAD_STORE: 2063 + NULL_DEREFERENCE: 187 + QUANDARY_TAINT_ERROR: 8 + RESOURCE_LEAK: 7 + MEMORY_LEAK: 2 \ No newline at end of file diff --git a/infer/results/v416/infer0131/inferconfig b/infer/results/v416/infer0131/inferconfig new file mode 100644 index 0000000..c603e2d --- /dev/null +++ b/infer/results/v416/infer0131/inferconfig @@ -0,0 +1 @@ +{"skip-analysis-in-path": ["linux/arch/x86/entry/vdso", "linux/arch/x86/kernel", "linux/arch/x86/mm", "linux/arch/x86/boot", "linux/drivers/acpi", "linux/fs", "linux/kernel/bpf", "linux/mm", "linux/net/mac80211"]} diff --git a/infer/results/v416/infer0140/defconfig/bugs.txt b/infer/results/v416/infer0140/defconfig/bugs.txt new file mode 100644 index 0000000..2c466b4 --- /dev/null +++ b/infer/results/v416/infer0140/defconfig/bugs.txt @@ -0,0 +1,31217 @@ +Found 3901 issues + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +block/blk-lib.c:19: error: NULL_DEREFERENCE + pointer `new` last assigned on line 16 could be null and is dereferenced by call to `bio_chain()` at line 19, column 3. + 17. + 18. if (bio) { + 19. > bio_chain(bio, new); + 20. submit_bio(bio); + 21. } + +block/ioctl.c:146: error: UNINITIALIZED_VALUE + The value read from p.length was never initialized. + 144. disk_part_iter_exit(&piter); + 145. part_nr_sects_write(part, (sector_t)length); + 146. > i_size_write(bdevp->bd_inode, p.length); + 147. mutex_unlock(&bdevp->bd_mutex); + 148. mutex_unlock(&bdev->bd_mutex); + +block/ioctl.c:33: error: UNINITIALIZED_VALUE + The value read from p.pno was never initialized. + 31. if (bdev != bdev->bd_contains) + 32. return -EINVAL; + 33. > partno = p.pno; + 34. if (partno <= 0) + 35. return -EINVAL; + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +tools/include/asm-generic/bitops/fls.h:36: error: DEAD_STORE + The value written to &x (type int) is never used. + 34. } + 35. if (!(x & 0x80000000u)) { + 36. > x <<= 1; + 37. r -= 1; + 38. } + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +block/blk-merge.c:50: error: DEAD_STORE + The value written to &tmp (type unsigned long) is never used. + 48. + 49. tmp = bio->bi_iter.bi_sector + split_sectors - alignment; + 50. > tmp = sector_div(tmp, granularity); + 51. + 52. if (split_sectors > tmp) + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +tools/lib/subcmd/help.c:20: error: NULL_DEREFERENCE + pointer `ent` last assigned on line 18 could be null and is dereferenced at line 20, column 2. + 18. struct cmdname *ent = malloc(sizeof(*ent) + len + 1); + 19. + 20. > ent->len = len; + 21. memcpy(ent->name, name, len); + 22. ent->name[len] = 0; + +lib/list_sort.c:27: error: MEMORY_LEAK + `tail->next` is not reachable after line 27, column 4. + 25. /* if equal, take 'a' -- important for sort stability */ + 26. if ((*cmp)(priv, a, b) <= 0) { + 27. > tail->next = a; + 28. a = a->next; + 29. } else { + +lib/list_sort.c:30: error: MEMORY_LEAK + `tail->next` is not reachable after line 30, column 4. + 28. a = a->next; + 29. } else { + 30. > tail->next = b; + 31. b = b->next; + 32. } + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +lib/dynamic_queue_limits.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. bool all_prev_completed; + 23. + 24. > num_queued = READ_ONCE(dql->num_queued); + 25. + 26. /* Can't complete more than what's in queue */ + +sound/hda/trace.h:19: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +arch/x86/include/asm/atomic64_64.h:22: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 20. static inline long atomic64_read(const atomic64_t *v) + 21. { + 22. > return READ_ONCE((v)->counter); + 23. } + 24. + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +lib/assoc_array.c:101: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr const *) is never used. + 99. if (assoc_array_ptr_is_shortcut(parent)) { + 100. shortcut = assoc_array_ptr_to_shortcut(parent); + 101. > cursor = parent; + 102. parent = READ_ONCE(shortcut->back_pointer); /* Address dependency. */ + 103. slot = shortcut->parent_slot; + +tools/include/tools/be_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val >> 8; + 26. > *p++ = val; + 27. } + 28. + +tools/include/tools/le_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val; + 26. > *p++ = val >> 8; + 27. } + 28. + +drivers/dma-buf/seqno-fence.c:28: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 26 could be null and is dereferenced at line 28, column 9. + 26. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 27. + 28. > return seqno_fence->ops->get_driver_name(fence); + 29. } + 30. + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +arch/x86/include/asm/atomic.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. static __always_inline int atomic_read(const atomic_t *v) + 26. { + 27. > return READ_ONCE((v)->counter); + 28. } + 29. + +arch/x86/include/asm/preempt.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. + 30. do { + 31. > old = raw_cpu_read_4(__preempt_count); + 32. new = (old & PREEMPT_NEED_RESCHED) | + 33. (pc & ~PREEMPT_NEED_RESCHED); + +security/selinux/ss/conditional.c:80: error: UNINITIALIZED_VALUE + The value read from s.[_] was never initialized. + 78. } + 79. } + 80. > return s[0]; + 81. } + 82. + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/pci/proc.c:100: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 98. pci_user_read_config_byte(dev, pos, &val); + 99. __put_user(val, buf); + 100. > buf++; + 101. pos++; + 102. cnt--; + +drivers/pci/proc.c:102: error: DEAD_STORE + The value written to &cnt (type unsigned int) is never used. + 100. buf++; + 101. pos++; + 102. > cnt--; + 103. } + 104. + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +drivers/thermal/thermal_helpers.c:42: error: UNINITIALIZED_VALUE + The value read from trend was never initialized. + 40. } + 41. + 42. > return trend; + 43. } + 44. EXPORT_SYMBOL(get_tz_trend); + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +lib/ratelimit.c:42: error: DEAD_STORE + The value written to &flags (type unsigned long) is never used. + 40. * the entity that is holding the lock already: + 41. */ + 42. > if (!raw_spin_trylock_irqsave(&rs->lock, flags)) + 43. return 0; + 44. + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +block/partitions/amiga.c:36: error: DEAD_STORE + The value written to &blksize (type int) is never used. + 34. struct PartitionBlock *pb; + 35. int start_sect, nr_sects, blk, part, res = 0; + 36. > int blksize = 1; /* Multiplier for disk block size */ + 37. int slot = 1; + 38. char b[BDEVNAME_SIZE]; + +block/partitions/amiga.c:123: error: UNINITIALIZED_VALUE + The value read from dostype.[_] was never initialized. + 121. *dt = pb->pb_Environment[16]; + 122. if (dostype[3] < ' ') + 123. > snprintf(tmp, sizeof(tmp), " (%c%c%c^%c)", + 124. dostype[0], dostype[1], + 125. dostype[2], dostype[3] + '@' ); + +block/partitions/amiga.c:127: error: UNINITIALIZED_VALUE + The value read from dostype.[_] was never initialized. + 125. dostype[2], dostype[3] + '@' ); + 126. else + 127. > snprintf(tmp, sizeof(tmp), " (%c%c%c%c)", + 128. dostype[0], dostype[1], + 129. dostype[2], dostype[3]); + +drivers/pci/setup-res.c:121: error: UNINITIALIZED_VALUE + The value read from cmd was never initialized. + 119. + 120. if (disable) + 121. > pci_write_config_word(dev, PCI_COMMAND, cmd); + 122. } + 123. + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +kernel/irq_work.c:40: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 38. for (;;) { + 39. nflags = flags | IRQ_WORK_CLAIMED; + 40. > oflags = cmpxchg(&work->flags, flags, nflags); + 41. if (oflags == flags) + 42. break; + +tools/lib/subcmd/run-command.c:96: error: UNINITIALIZED_VALUE + The value read from fderr.[_] was never initialized. + 94. dup_devnull(2); + 95. else if (need_err) { + 96. > dup2(fderr[1], 2); + 97. close_pair(fderr); + 98. } + +tools/lib/subcmd/run-command.c:161: error: UNINITIALIZED_VALUE + The value read from fderr.[_] was never initialized. + 159. + 160. if (need_err) + 161. > close(fderr[1]); + 162. + 163. return 0; + +tools/lib/subcmd/run-command.c:86: error: UNINITIALIZED_VALUE + The value read from fdin.[_] was never initialized. + 84. dup_devnull(0); + 85. else if (need_in) { + 86. > dup2(fdin[0], 0); + 87. close_pair(fdin); + 88. } else if (cmd->in) { + +tools/lib/subcmd/run-command.c:151: error: UNINITIALIZED_VALUE + The value read from fdin.[_] was never initialized. + 149. + 150. if (need_in) + 151. > close(fdin[0]); + 152. else if (cmd->in) + 153. close(cmd->in); + +tools/lib/subcmd/run-command.c:105: error: UNINITIALIZED_VALUE + The value read from fdout.[_] was never initialized. + 103. dup2(2, 1); + 104. else if (need_out) { + 105. > dup2(fdout[1], 1); + 106. close_pair(fdout); + 107. } else if (cmd->out > 1) { + +tools/lib/subcmd/run-command.c:156: error: UNINITIALIZED_VALUE + The value read from fdout.[_] was never initialized. + 154. + 155. if (need_out) + 156. > close(fdout[1]); + 157. else if (cmd->out) + 158. close(cmd->out); + +kernel/locking/qrwlock.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. * without waiting in the queue. + 41. */ + 42. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 43. return; + 44. } + +kernel/locking/qrwlock.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. * section in the case that the lock is currently held for write. + 57. */ + 58. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 59. + 60. /* + +lib/zlib_inflate/inffast.c:38: error: UNINITIALIZED_VALUE + The value read from mm.us was never initialized. + 36. mm.b[0] = b[0]; + 37. mm.b[1] = b[1]; + 38. > return mm.us; + 39. } + 40. + +tools/objtool/warn.h:48: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 48, column 3. + 46. + 47. if (func) + 48. > sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. sprintf(str, "%s+0x%lx", name, name_off); + +tools/objtool/warn.h:50: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 50, column 3. + 48. sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. > sprintf(str, "%s+0x%lx", name, name_off); + 51. + 52. return str; + +drivers/dma-buf/seqno-fence.c:35: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 33 could be null and is dereferenced at line 35, column 9. + 33. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 34. + 35. > return seqno_fence->ops->get_timeline_name(fence); + 36. } + 37. + +drivers/edac/edac_pci.c:40: error: DEAD_STORE + The value written to &pci (type edac_pci_ctl_info*) is never used. + 38. edac_dbg(1, "\n"); + 39. + 40. > pci = edac_align_ptr(&p, sizeof(*pci), 1); + 41. pvt = edac_align_ptr(&p, 1, sz_pvt); + 42. size = ((unsigned long)pvt) + sz_pvt; + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +kernel/power/process.c:44: error: DEAD_STORE + The value written to &end_time (type unsigned long) is never used. + 42. start = ktime_get_boottime(); + 43. + 44. > end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs); + 45. + 46. if (!user_only) + +kernel/power/process.c:40: error: DEAD_STORE + The value written to &sleep_usecs (type int) is never used. + 38. unsigned int elapsed_msecs; + 39. bool wakeup = false; + 40. > int sleep_usecs = USEC_PER_MSEC; + 41. + 42. start = ktime_get_boottime(); + +kernel/power/process.c:81: error: DEAD_STORE + The value written to &sleep_usecs (type int) is never used. + 79. usleep_range(sleep_usecs / 2, sleep_usecs); + 80. if (sleep_usecs < 8 * USEC_PER_MSEC) + 81. > sleep_usecs *= 2; + 82. } + 83. + +sound/hda/trace.h:31: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +drivers/base/module.c:62: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 60. + 61. /* Don't check return codes; these calls are idempotent */ + 62. > no_warn = sysfs_create_link(&drv->p->kobj, &mk->kobj, "module"); + 63. driver_name = make_driver_name(drv); + 64. if (driver_name) { + +drivers/base/module.c:66: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 64. if (driver_name) { + 65. module_create_drivers_dir(mk); + 66. > no_warn = sysfs_create_link(mk->drivers_dir, &drv->p->kobj, + 67. driver_name); + 68. kfree(driver_name); + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +init/calibrate.c:138: error: UNINITIALIZED_VALUE + The value read from measured_times.[_] was never initialized. + 136. if ((measured_times[max] - estimate) < + 137. (estimate - measured_times[min])) { + 138. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 139. "min bogoMips estimate %d = %lu\n", + 140. min, measured_times[min]); + +init/calibrate.c:144: error: UNINITIALIZED_VALUE + The value read from measured_times.[_] was never initialized. + 142. min = max; + 143. } else { + 144. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 145. "max bogoMips estimate %d = %lu\n", + 146. max, measured_times[max]); + +net/compat.c:58: error: UNINITIALIZED_VALUE + The value read from msg.msg_control was never initialized. + 56. kmsg->msg_namelen = sizeof(struct sockaddr_storage); + 57. + 58. > kmsg->msg_control = compat_ptr(msg.msg_control); + 59. kmsg->msg_controllen = msg.msg_controllen; + 60. + +net/compat.c:83: error: UNINITIALIZED_VALUE + The value read from msg.msg_iov was never initialized. + 81. + 82. return compat_import_iovec(save_addr ? READ : WRITE, + 83. > compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + 85. } + +net/compat.c:82: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 80. kmsg->msg_iocb = NULL; + 81. + 82. > return compat_import_iovec(save_addr ? READ : WRITE, + 83. compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + +net/compat.c:62: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 60. + 61. if (save_addr) + 62. > *save_addr = compat_ptr(msg.msg_name); + 63. + 64. if (msg.msg_name && kmsg->msg_namelen) { + +net/compat.c:66: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 64. if (msg.msg_name && kmsg->msg_namelen) { + 65. if (!save_addr) { + 66. > err = move_addr_to_kernel(compat_ptr(msg.msg_name), + 67. kmsg->msg_namelen, + 68. kmsg->msg_name); + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +net/core/sysctl_net_core.c:41: error: UNINITIALIZED_VALUE + The value read from size was never initialized. + 39. unsigned int orig_size, size; + 40. int ret, i; + 41. > struct ctl_table tmp = { + 42. .data = &size, + 43. .maxlen = sizeof(size), + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +lib/mpi/mpi-pow.c:56: error: DEAD_STORE + The value written to &esign (type int) is never used. + 54. msize = mod->nlimbs; + 55. size = 2 * msize; + 56. > esign = exp->sign; + 57. msign = mod->sign; + 58. + +drivers/dma-buf/seqno-fence.c:42: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 40 could be null and is dereferenced at line 42, column 9. + 40. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 41. + 42. > return seqno_fence->ops->enable_signaling(fence); + 43. } + 44. + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +kernel/irq/spurious.c:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. bool irq_wait_for_poll(struct irq_desc *desc) + 39. { + 40. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 41. "irq poll in progress on cpu %d for irq %d\n", + 42. smp_processor_id(), desc->irq_data.irq)) + +kernel/irq/spurious.c:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. bool irq_wait_for_poll(struct irq_desc *desc) + 39. { + 40. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 41. "irq poll in progress on cpu %d for irq %d\n", + 42. smp_processor_id(), desc->irq_data.irq)) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +tools/objtool/builtin-orc.c:47: error: SHELL_INJECTION + EnvironmentVariable(getenv()) in procedure setup_pager() at line 66, column 22 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 45. + 46. if (!strncmp(argv[0], "gen", 3)) { + 47. > argc = parse_options(argc, argv, check_options, orc_usage, 0); + 48. if (argc != 1) + 49. usage_with_options(orc_usage, check_options); + +tools/objtool/builtin-orc.c:49: error: SHELL_INJECTION + EnvironmentVariable(getenv()) in procedure setup_pager() at line 66, column 22 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 47. argc = parse_options(argc, argv, check_options, orc_usage, 0); + 48. if (argc != 1) + 49. > usage_with_options(orc_usage, check_options); + 50. + 51. objname = argv[0]; + +tools/objtool/builtin-orc.c:58: error: SHELL_INJECTION + EnvironmentVariable(getenv()) in procedure setup_pager() at line 66, column 22 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 56. if (!strcmp(argv[0], "dump")) { + 57. if (argc != 2) + 58. > usage_with_options(orc_usage, check_options); + 59. + 60. objname = argv[1]; + +tools/objtool/builtin-orc.c:65: error: SHELL_INJECTION + EnvironmentVariable(getenv()) in procedure setup_pager() at line 66, column 22 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 63. } + 64. + 65. > usage_with_options(orc_usage, check_options); + 66. + 67. return 0; + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +kernel/smpboot.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. void __init idle_thread_set_boot_cpu(void) + 40. { + 41. > per_cpu(idle_threads, smp_processor_id()) = current; + 42. } + 43. + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/percpu-rwsem.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. * release in percpu_up_write(). + 63. */ + 64. > if (likely(!smp_load_acquire(&sem->readers_block))) + 65. return 1; + 66. + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +drivers/clk/clk-gate.c:46: error: DEAD_STORE + The value written to &flags (type unsigned long) is never used. + 44. struct clk_gate *gate = to_clk_gate(hw); + 45. int set = gate->flags & CLK_GATE_SET_TO_DISABLE ? 1 : 0; + 46. > unsigned long uninitialized_var(flags); + 47. u32 reg; + 48. + +sound/hda/trace.h:43: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +lib/genalloc.c:54: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 52. return -EBUSY; + 53. cpu_relax(); + 54. > } while ((nval = cmpxchg(addr, val, val | mask_to_set)) != val); + 55. + 56. return 0; + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +drivers/dma-buf/seqno-fence.c:49: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 47 could be null and is dereferenced at line 49, column 9. + 47. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 48. + 49. > return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence); + 50. } + 51. + +drivers/usb/core/otg_whitelist.h:47: error: DEAD_STORE + The value written to &id (type usb_device_id*) is never used. + 45. static int is_targeted(struct usb_device *dev) + 46. { + 47. > struct usb_device_id *id = whitelist_table; + 48. + 49. /* HNP test device is _never_ targeted (see OTG spec 6.6.6) */ + +kernel/time/tick-broadcast-hrtimer.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. if (bc_moved) { + 70. /* Bind the "device" to the cpu */ + 71. > bc->bound_on = smp_processor_id(); + 72. } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + +kernel/time/tick-broadcast-hrtimer.c:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. /* Bind the "device" to the cpu */ + 71. bc->bound_on = smp_processor_id(); + 72. > } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + 74. } + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +kernel/power/user.c:79: error: DEAD_STORE + The value written to &nr_calls (type int) is never used. + 77. error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls); + 78. if (error) + 79. > __pm_notifier_call_chain(PM_POST_HIBERNATION, --nr_calls, NULL); + 80. } else { + 81. /* + +tools/objtool/builtin-check.c:54: error: SHELL_INJECTION + EnvironmentVariable(getenv()) in procedure setup_pager() at line 66, column 22 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 52. + 53. if (argc != 1) + 54. > usage_with_options(check_usage, check_options); + 55. + 56. objname = argv[0]; + +drivers/gpu/drm/i915/i915_ioc32.c:59: error: UNINITIALIZED_VALUE + The value read from req32.param was never initialized. + 57. request = compat_alloc_user_space(sizeof(*request)); + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. > || __put_user(req32.param, &request->param) + 60. || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + +drivers/gpu/drm/i915/i915_ioc32.c:60: error: UNINITIALIZED_VALUE + The value read from req32.value was never initialized. + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. || __put_user(req32.param, &request->param) + 60. > || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + 62. return -EFAULT; + +drivers/usb/core/message.c:64: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 62. if (!wait_for_completion_timeout(&ctx.done, expire)) { + 63. usb_kill_urb(urb); + 64. > retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status); + 65. + 66. dev_dbg(&urb->dev->dev, + +drivers/usb/core/message.c:74: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 72. urb->transfer_buffer_length); + 73. } else + 74. > retval = ctx.status; + 75. out: + 76. if (actual_length) + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/thermal/step_wise.c:63: error: UNINITIALIZED_VALUE + The value read from cur_state was never initialized. + 61. cdev->ops->get_cur_state(cdev, &cur_state); + 62. next_target = instance->target; + 63. > dev_dbg(&cdev->device, "cur_state=%ld\n", cur_state); + 64. + 65. if (!instance->initialized) { + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +kernel/sched/membarrier.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. * iteration. + 85. */ + 86. > if (cpu == raw_smp_processor_id()) + 87. continue; + 88. rcu_read_lock(); + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +drivers/edac/edac_device.c:78: error: DEAD_STORE + The value written to &dev_ctl (type edac_device_ctl_info*) is never used. + 76. */ + 77. p = NULL; + 78. > dev_ctl = edac_align_ptr(&p, sizeof(*dev_ctl), 1); + 79. + 80. /* Calc the 'end' offset past end of ONE ctl_info structure + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +kernel/futex_compat.c:103: error: DEAD_STORE + The value written to &uentry (type unsigned int) is never used. + 101. if (rc) + 102. return; + 103. > uentry = next_uentry; + 104. entry = next_entry; + 105. pi = next_pi; + +net/ipv6/ping.c:118: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 116. fl6.flowi6_uid = sk->sk_uid; + 117. fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. > fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + 120. + +net/ipv6/ping.c:135: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 133. + 134. pfh.icmph.type = user_icmph.icmp6_type; + 135. > pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + 137. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv6/ping.c:117: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 115. fl6.flowi6_mark = sk->sk_mark; + 116. fl6.flowi6_uid = sk->sk_uid; + 117. > fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + +net/ipv6/ping.c:134: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 132. fl6.flowi6_oif = np->ucast_oif; + 133. + 134. > pfh.icmph.type = user_icmph.icmp6_type; + 135. pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. * counter for this CPU. + 78. */ + 79. > if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. cpu = smp_processor_id(); + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +drivers/dma-buf/seqno-fence.c:56: error: NULL_DEREFERENCE + pointer `f` last assigned on line 54 could be null and is dereferenced at line 56, column 14. + 54. struct seqno_fence *f = to_seqno_fence(fence); + 55. + 56. > dma_buf_put(f->sync_buf); + 57. if (f->ops->release) + 58. f->ops->release(fence); + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +drivers/hid/hid-generic.c:57: error: DEAD_STORE + The value written to &ret (type int) is never used. + 55. int ret; + 56. + 57. > ret = driver_attach(&hid_generic.driver); + 58. } + 59. + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +net/ipv6/inet6_hashtables.c:63: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 61. struct sock *sk; + 62. const struct hlist_nulls_node *node; + 63. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 64. /* Optimize here for direct hit, only listening connections can + 65. * have wildcards anyways. + +drivers/gpu/drm/drm_lock.c:71: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 69. _DRM_LOCK_CONT : 0); + 70. } + 71. > prev = cmpxchg(lock, old, new); + 72. } while (prev != old); + 73. spin_unlock_bh(&lock_data->spinlock); + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +drivers/dma-buf/dma-fence-array.c:61: error: NULL_DEREFERENCE + pointer `array` last assigned on line 57 could be null and is dereferenced at line 61, column 18. + 59. unsigned i; + 60. + 61. > for (i = 0; i < array->num_fences; ++i) { + 62. cb[i].array = array; + 63. /* + +sound/hda/trace.h:55: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 53. ); + 54. + 55. > DECLARE_EVENT_CLASS(hdac_stream, + 56. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 57. + +lib/decompress_unlzo.c:82: error: DEAD_STORE + The value written to &level (type unsigned char) is never used. + 80. parse += 7; + 81. if (version >= 0x0940) + 82. > level = *parse++; + 83. if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) + 84. parse += 8; /* flags + filter info */ + +kernel/rcu/rcu_segcblist.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. static inline long rcu_segcblist_n_cbs(struct rcu_segcblist *rsclp) + 57. { + 58. > return READ_ONCE(rsclp->len); + 59. } + 60. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +kernel/time/tick-sched.c:88: error: DEAD_STORE + The value written to &ticks (type unsigned long) is never used. + 86. incr * ticks); + 87. } + 88. > do_timer(++ticks); + 89. + 90. /* Keep the tick_next_period variable up to date */ + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/connector/cn_proc.c:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. + 62. msg->seq = __this_cpu_inc_return(proc_event_counts) - 1; + 63. > ((struct proc_event *)msg->data)->cpu = smp_processor_id(); + 64. + 65. /* + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +lib/errseq.c:94: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 92. + 93. /* Try to swap the new value into place */ + 94. > cur = cmpxchg(eseq, old, new); + 95. + 96. /* + +lib/errseq.c:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. * previous error. + 70. */ + 71. > old = READ_ONCE(*eseq); + 72. + 73. if (WARN(unlikely(err == 0 || (unsigned int)-err > MAX_ERRNO), + +lib/errseq.c:106: error: UNINITIALIZED_VALUE + The value read from cur was never initialized. + 104. old = cur; + 105. } + 106. > return cur; + 107. } + 108. EXPORT_SYMBOL(errseq_set); + +lib/genalloc.c:69: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 67. return -EBUSY; + 68. cpu_relax(); + 69. > } while ((nval = cmpxchg(addr, val, val & ~mask_to_clear)) != val); + 70. + 71. return 0; + +arch/x86/pci/amd_bus.c:128: error: DEAD_STORE + The value written to &info (type pci_root_info*) is never used. + 126. link = (reg >> 8) & 0x03; + 127. + 128. > info = alloc_pci_root_info(min_bus, max_bus, node, link); + 129. } + 130. + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +sound/core/pcm_lib.c:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. if (runtime->silence_size < runtime->boundary) { + 67. snd_pcm_sframes_t noise_dist, n; + 68. > snd_pcm_uframes_t appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 69. if (runtime->silence_start != appl_ptr) { + 70. n = appl_ptr - runtime->silence_start; + +block/badblocks.c:76: error: DEAD_STORE + The value written to §ors (type int) is never used. + 74. target += (1<shift) - 1; + 75. target >>= bb->shift; + 76. > sectors = target - s; + 77. } + 78. /* 'target' is now the first block after the bad range */ + +drivers/char/agp/compat_ioctl.c:75: error: UNINITIALIZED_VALUE + The value read from ureserve.pid was never initialized. + 73. return -EFAULT; + 74. + 75. > kreserve.pid = ureserve.pid; + 76. kreserve.seg_count = ureserve.seg_count; + 77. + +drivers/char/agp/compat_ioctl.c:76: error: UNINITIALIZED_VALUE + The value read from ureserve.seg_count was never initialized. + 74. + 75. kreserve.pid = ureserve.pid; + 76. > kreserve.seg_count = ureserve.seg_count; + 77. + 78. client = agp_find_client_by_pid(kreserve.pid); + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +sound/core/vmaster.c:70: error: DEAD_STORE + The value written to &err (type int) is never used. + 68. return -ENOMEM; + 69. uctl->id = slave->slave.id; + 70. > err = slave->slave.get(&slave->slave, uctl); + 71. for (ch = 0; ch < slave->info.count; ch++) + 72. slave->vals[ch] = uctl->value.integer.value[ch]; + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +drivers/dma-buf/seqno-fence.c:68: error: NULL_DEREFERENCE + pointer `f` last assigned on line 66 could be null and is dereferenced at line 68, column 9. + 66. struct seqno_fence *f = to_seqno_fence(fence); + 67. + 68. > return f->ops->wait(fence, intr, timeout); + 69. } + 70. + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +drivers/char/agp/isoch.c:140: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 138. dev = cur->dev; + 139. + 140. > mcapndx = cur->capndx; + 141. + 142. pci_read_config_dword(dev, cur->capndx+AGPNISTAT, &mnistat); + +drivers/char/agp/isoch.c:253: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 251. dev = cur->dev; + 252. + 253. > mcapndx = cur->capndx; + 254. + 255. master[cdev].rq += (cdev == ndevs - 1) + +include/linux/idr.h:66: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 64. static inline unsigned int idr_get_cursor(const struct idr *idr) + 65. { + 66. > return READ_ONCE(idr->idr_next); + 67. } + 68. + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +tools/lib/subcmd/pager.c:92: error: SHELL_INJECTION + EnvironmentVariable(getenv()) at line 66, column 22 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 90. pager_process.preexec_cb = pager_preexec; + 91. + 92. > if (start_command(&pager_process)) + 93. return; + 94. + +tools/lib/subcmd/pager.c:92: error: SHELL_INJECTION + EnvironmentVariable(getenv()) at line 74, column 11 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 90. pager_process.preexec_cb = pager_preexec; + 91. + 92. > if (start_command(&pager_process)) + 93. return; + 94. + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +kernel/events/core.c:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. if (p) { + 73. /* -EAGAIN */ + 74. > if (task_cpu(p) != smp_processor_id()) + 75. return; + 76. + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +lib/earlycpio.c:140: error: UNINITIALIZED_VALUE + The value read from ch.[_] was never initialized. + 138. + 139. cd.data = (void *)dptr; + 140. > cd.size = ch[C_FILESIZE]; + 141. return cd; /* Found it! */ + 142. } + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +kernel/locking/rtmutex.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. * still set. + 132. */ + 133. > owner = READ_ONCE(*p); + 134. if (owner & RT_MUTEX_HAS_WAITERS) + 135. WRITE_ONCE(*p, owner & ~RT_MUTEX_HAS_WAITERS); + +net/ipv6/xfrm6_mode_transport.c:77: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 74 could be null and is dereferenced at line 77, column 8. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +crypto/sha256_generic.c:230: error: DEAD_STORE + The value written to &a (type unsigned int) is never used. + 228. + 229. /* clear any sensitive info... */ + 230. > a = b = c = d = e = f = g = h = t1 = t2 = 0; + 231. memzero_explicit(W, 64 * sizeof(u32)); + 232. } + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +kernel/locking/qrwlock.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. /* When no more readers or writers, set the locked flag */ + 85. do { + 86. > atomic_cond_read_acquire(&lock->cnts, VAL == _QW_WAITING); + 87. } while (atomic_cmpxchg_relaxed(&lock->cnts, _QW_WAITING, + 88. _QW_LOCKED) != _QW_WAITING); + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +arch/x86/platform/efi/efi_64.c:104: error: DEAD_STORE + The value written to &vaddr (type unsigned long) is never used. + 102. for (pgd = 0; pgd < n_pgds; pgd++) { + 103. addr_pgd = (unsigned long)(pgd * PGDIR_SIZE); + 104. > vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. save_pgd[pgd] = *pgd_efi; + +arch/x86/platform/efi/efi_64.c:106: error: NULL_DEREFERENCE + pointer `save_pgd` last assigned on line 92 could be null and is dereferenced at line 106, column 3. + 104. vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. > save_pgd[pgd] = *pgd_efi; + 107. + 108. p4d = p4d_alloc(&init_mm, pgd_efi, addr_pgd); + +drivers/clk/clk-fractional-divider.c:89: error: UNINITIALIZED_VALUE + The value read from n was never initialized. + 87. + 88. ret = (u64)*parent_rate * m; + 89. > do_div(ret, n); + 90. + 91. return ret; + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +tools/objtool/orc_dump.c:102: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 102, column 3. + 100. elf = elf_begin(fd, ELF_C_READ_MMAP, NULL); + 101. if (!elf) { + 102. > WARN_ELF("elf_begin"); + 103. return -1; + 104. } + +tools/objtool/orc_dump.c:107: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 107, column 3. + 105. + 106. if (elf_getshdrnum(elf, &nr_sections)) { + 107. > WARN_ELF("elf_getshdrnum"); + 108. return -1; + 109. } + +tools/objtool/orc_dump.c:112: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 112, column 3. + 110. + 111. if (elf_getshdrstrndx(elf, &shstrtab_idx)) { + 112. > WARN_ELF("elf_getshdrstrndx"); + 113. return -1; + 114. } + +tools/objtool/orc_dump.c:119: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 119, column 4. + 117. scn = elf_getscn(elf, i); + 118. if (!scn) { + 119. > WARN_ELF("elf_getscn"); + 120. return -1; + 121. } + +tools/objtool/orc_dump.c:124: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 124, column 4. + 122. + 123. if (!gelf_getshdr(scn, &sh)) { + 124. > WARN_ELF("gelf_getshdr"); + 125. return -1; + 126. } + +tools/objtool/orc_dump.c:130: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 130, column 4. + 128. name = elf_strptr(elf, shstrtab_idx, sh.sh_name); + 129. if (!name) { + 130. > WARN_ELF("elf_strptr"); + 131. return -1; + 132. } + +tools/objtool/orc_dump.c:136: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 136, column 4. + 134. data = elf_getdata(scn, NULL); + 135. if (!data) { + 136. > WARN_ELF("elf_getdata"); + 137. return -1; + 138. } + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +drivers/ptp/ptp_sysfs.c:101: error: UNINITIALIZED_VALUE + The value read from event.index was never initialized. + 99. goto out; + 100. + 101. > cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n", + 102. event.index, event.t.sec, event.t.nsec); + 103. out: + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +drivers/power/supply/power_supply_sysfs.c:122: error: UNINITIALIZED_VALUE + The value read from value.strval was never initialized. + 120. power_supply_scope_text[value.intval]); + 121. else if (off >= POWER_SUPPLY_PROP_MODEL_NAME) + 122. > return sprintf(buf, "%s\n", value.strval); + 123. + 124. return sprintf(buf, "%d\n", value.intval); + +kernel/cgroup/stat.c:96: error: NULL_DEREFERENCE + pointer `pos` last assigned on line 92 could be null and is dereferenced by call to `cgroup_cpu_stat()` at line 96, column 11. + 94. /* walk down to the first leaf */ + 95. while (true) { + 96. > cstat = cgroup_cpu_stat(pos, cpu); + 97. if (cstat->updated_children == pos) + 98. break; + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +drivers/pps/kapi.c:88: error: DEAD_STORE + The value written to &err (type int) is never used. + 86. pr_err("%s: unsupported default parameters\n", + 87. info->name); + 88. > err = -EINVAL; + 89. goto pps_register_source_exit; + 90. } + +drivers/pps/kapi.c:94: error: DEAD_STORE + The value written to &err (type int) is never used. + 92. pr_err("%s: unspecified time format\n", + 93. info->name); + 94. > err = -EINVAL; + 95. goto pps_register_source_exit; + 96. } + +drivers/pps/kapi.c:101: error: DEAD_STORE + The value written to &err (type int) is never used. + 99. pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL); + 100. if (pps == NULL) { + 101. > err = -ENOMEM; + 102. goto pps_register_source_exit; + 103. } + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:90: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 84 could be null and is dereferenced at line 90, column 6. + 88. + 89. /* Write the MSB and/or LSB */ + 90. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) { + 91. vals[0] = (level & 0xFF00) >> 8; + 92. vals[1] = (level & 0xFF); + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +net/core/net-sysfs.c:87: error: DEAD_STORE + The value written to &ret (type int) is never used. + 85. struct net *net = dev_net(netdev); + 86. unsigned long new; + 87. > int ret = -EINVAL; + 88. + 89. if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) + +drivers/thermal/thermal_hwmon.c:97: error: UNINITIALIZED_VALUE + The value read from temperature was never initialized. + 95. return ret; + 96. + 97. > return sprintf(buf, "%d\n", temperature); + 98. } + 99. + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +lib/sbitmap.c:111: error: UNINITIALIZED_VALUE + The value read from nr was never initialized. + 109. } + 110. + 111. > return nr; + 112. } + 113. + +net/ipv6/icmp.c:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline struct sock *icmpv6_sk(struct net *net) + 83. { + 84. > return net->ipv6.icmp_sk[smp_processor_id()]; + 85. } + 86. + +drivers/base/devtmpfs.c:119: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 117. kfree(tmp); + 118. + 119. > return req.err; + 120. } + 121. + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +lib/percpu_counter.c:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. + 87. preempt_disable(); + 88. > count = __this_cpu_read(*fbc->counters) + amount; + 89. if (count >= batch || count <= -batch) { + 90. unsigned long flags; + +sound/core/hwdep.c:158: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 156. module_put(hw->card->module); + 157. snd_card_unref(hw->card); + 158. > return err; + 159. } + 160. + +drivers/i2c/algos/i2c-algo-bit.c:94: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 92. goto done; + 93. + 94. > start = jiffies; + 95. while (!getscl(adap)) { + 96. /* This hw knows how to read the clock line, so we wait + +drivers/usb/core/usb-acpi.c:100: error: DEAD_STORE + The value written to &status (type unsigned int) is never used. + 98. * no connectable, the port would be not used. + 99. */ + 100. > status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer); + 101. upc = buffer.pointer; + 102. if (!upc || (upc->type != ACPI_TYPE_PACKAGE) + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +sound/hda/hdac_controller.c:88: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 86. unsigned long timeout; + 87. + 88. > timeout = jiffies + msecs_to_jiffies(100); + 89. while ((snd_hdac_chip_readb(bus, RIRBCTL) & AZX_RBCTL_DMA_EN) + 90. && time_before(jiffies, timeout)) + +sound/hda/hdac_controller.c:93: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 91. udelay(10); + 92. + 93. > timeout = jiffies + msecs_to_jiffies(100); + 94. while ((snd_hdac_chip_readb(bus, CORBCTL) & AZX_CORBCTL_RUN) + 95. && time_before(jiffies, timeout)) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/zlib_inflate/inffast.c:257: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 255. PUP(out) = PUP(from); + 256. if (len > 1) + 257. > PUP(out) = PUP(from); + 258. } + 259. } + +lib/zlib_inflate/inffast.c:304: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 302. } + 303. if (len & 1) + 304. > PUP(out) = PUP(from); + 305. } + 306. } + +sound/hda/hdac_bus.c:115: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 113. trace_hda_get_response(bus, addr, *res); + 114. } + 115. > return err; + 116. } + 117. EXPORT_SYMBOL_GPL(snd_hdac_bus_exec_verb_unlocked); + +drivers/gpu/drm/drm_ioc32.c:103: error: UNINITIALIZED_VALUE + The value read from v32.date was never initialized. + 101. .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. > .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. .desc = compat_ptr(v32.desc), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.date_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:105: error: UNINITIALIZED_VALUE + The value read from v32.desc was never initialized. + 103. .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. > .desc = compat_ptr(v32.desc), + 106. }; + 107. err = drm_ioctl_kernel(file, drm_version, &v, + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.desc_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:101: error: UNINITIALIZED_VALUE + The value read from v32.name was never initialized. + 99. v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. > .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. .date = compat_ptr(v32.date), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.name_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +security/keys/permission.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int key_validate(const struct key *key) + 90. { + 91. > unsigned long flags = READ_ONCE(key->flags); + 92. time64_t expiry = READ_ONCE(key->expiry); + 93. + +security/keys/permission.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. { + 91. unsigned long flags = READ_ONCE(key->flags); + 92. > time64_t expiry = READ_ONCE(key->expiry); + 93. + 94. if (flags & (1 << KEY_FLAG_INVALIDATED)) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/dma-buf/dma-fence-array.c:95: error: NULL_DEREFERENCE + pointer `array` last assigned on line 92 could be null and is dereferenced at line 95, column 18. + 93. unsigned i; + 94. + 95. > for (i = 0; i < array->num_fences; ++i) + 96. dma_fence_put(array->fences[i]); + 97. + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +kernel/locking/osq_lock.c:169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 167. * true. + 168. */ + 169. > if (smp_load_acquire(&node->locked)) + 170. return true; + 171. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +net/netfilter/nf_nat_sip.c:112: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 99 could be null and is dereferenced at line 112, column 13. + 110. ct->tuplehash[dir].tuple.dst.u.udp.port == port) { + 111. newaddr = ct->tuplehash[!dir].tuple.src.u3; + 112. > newport = ct_sip_info->forced_dport ? : + 113. ct->tuplehash[!dir].tuple.src.u.udp.port; + 114. } else + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +drivers/tty/tty_jobctrl.c:105: error: MEMORY_LEAK + `tty->pgrp` is not reachable after line 105, column 2. + 103. put_pid(tty->session); + 104. put_pid(tty->pgrp); + 105. > tty->pgrp = get_pid(task_pgrp(current)); + 106. spin_unlock_irqrestore(&tty->ctrl_lock, flags); + 107. tty->session = get_pid(task_session(current)); + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +security/keys/request_key.c:99: error: DEAD_STORE + The value written to &cred (type cred const *) is never used. + 97. { + 98. static char const request_key[] = "/sbin/request-key"; + 99. > const struct cred *cred = current_cred(); + 100. key_serial_t prkey, sskey; + 101. struct key *key = cons->key, *authkey = cons->authkey, *keyring, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +drivers/scsi/scsi_logging.c:115: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 113. if (!WARN_ON(off >= logbuf_len)) { + 114. va_start(args, fmt); + 115. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 116. va_end(args); + 117. } + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +net/ipv6/inet6_hashtables.c:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. score++; + 120. } + 121. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 122. score++; + 123. } + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +net/netfilter/nf_conntrack_core.c:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. * It pairs with the smp_store_release() in nf_conntrack_all_unlock() + 104. */ + 105. > if (likely(smp_load_acquire(&nf_conntrack_locks_all) == false)) + 106. return; + 107. + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +include/net/busy_poll.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. { + 101. #ifdef CONFIG_NET_RX_BUSY_POLL + 102. > unsigned long bp_usec = READ_ONCE(sk->sk_ll_usec); + 103. + 104. if (bp_usec) { + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +drivers/char/agp/frontend.c:112: error: DEAD_STORE + The value written to &num_segments (type int) is never used. + 110. pg_count = size / 4096; + 111. seg = *(client->segments); + 112. > num_segments = client->num_segments; + 113. + 114. for (i = 0; i < client->num_segments; i++) { + +drivers/md/dm-kcopyd.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. spin_lock_irq(&throttle_spinlock); + 109. + 110. > throttle = READ_ONCE(t->throttle); + 111. + 112. if (likely(throttle >= 100)) + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +kernel/rcu/rcu.h:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. static inline unsigned long rcu_seq_current(unsigned long *sp) + 100. { + 101. > return READ_ONCE(*sp); + 102. } + 103. + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +drivers/gpu/drm/i915/intel_dp_mst.c:110: error: NULL_DEREFERENCE + pointer `old_conn_state` last assigned on line 109 could be null and is dereferenced at line 110, column 13. + 108. + 109. old_conn_state = drm_atomic_get_old_connector_state(state, connector); + 110. > old_crtc = old_conn_state->crtc; + 111. if (!old_crtc) + 112. return ret; + +kernel/sched/cpuacct.c:104: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 102 could be null and is dereferenced at line 104, column 14. + 102. struct cpuacct *ca = css_ca(css); + 103. + 104. > free_percpu(ca->cpustat); + 105. free_percpu(ca->cpuusage); + 106. kfree(ca); + +drivers/pci/vc.c:150: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 148. if (ctrl2 & PCI_VC_RES_CTRL_ENABLE) { + 149. ctrl2 &= ~PCI_VC_RES_CTRL_ENABLE; + 150. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 151. } + 152. + +drivers/pci/vc.c:155: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 153. /* Enable on both ends */ + 154. ctrl2 |= PCI_VC_RES_CTRL_ENABLE; + 155. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 156. enable: + 157. ctrl |= PCI_VC_RES_CTRL_ENABLE; + +drivers/pci/vc.c:163: error: UNINITIALIZED_VALUE + The value read from status_pos2 was never initialized. + 161. pci_err(dev, "VC%d negotiation stuck pending\n", id); + 162. + 163. > if (link && !pci_wait_for_pending(link, status_pos2, + 164. PCI_VC_RES_STATUS_NEGO)) + 165. pci_err(link, "VC%d negotiation stuck pending\n", id); + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +net/ipv4/netfilter/nf_reject_ipv4.c:128: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 126. + 127. skb_reserve(nskb, LL_MAX_HEADER); + 128. > niph = nf_reject_iphdr_put(nskb, oldskb, IPPROTO_TCP, + 129. ip4_dst_hoplimit(skb_dst(nskb))); + 130. nf_reject_ip_tcphdr_put(nskb, oldskb, oth); + +net/ipv4/netfilter/nf_reject_ipv4.c:135: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 133. goto free_nskb; + 134. + 135. > niph = ip_hdr(nskb); + 136. + 137. /* "Never happens" */ + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/gpu/drm/drm_lock.c:114: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 112. old = *lock; + 113. new = context | _DRM_LOCK_HELD; + 114. > prev = cmpxchg(lock, old, new); + 115. } while (prev != old); + 116. return 1; + +drivers/pps/pps.c:227: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 225. /* Check for supported capabilities */ + 226. if ((bind_args.edge & ~pps->info.mode) != 0) { + 227. > dev_err(pps->dev, "unsupported capabilities (%x)\n", + 228. bind_args.edge); + 229. return -EINVAL; + +drivers/pps/pps.c:236: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 234. (bind_args.edge & ~PPS_CAPTUREBOTH) != 0 || + 235. bind_args.consumer != PPS_KC_HARDPPS) { + 236. > dev_err(pps->dev, "invalid kernel consumer bind" + 237. " parameters (%x)\n", bind_args.edge); + 238. return -EINVAL; + +drivers/pps/pps.c:141: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 139. return -EFAULT; + 140. if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) { + 141. > dev_dbg(pps->dev, "capture mode unspecified (%x)\n", + 142. params.mode); + 143. return -EINVAL; + +drivers/pps/pps.c:148: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 146. /* Check for supported capabilities */ + 147. if ((params.mode & ~pps->info.mode) != 0) { + 148. > dev_dbg(pps->dev, "unsupported capabilities (%x)\n", + 149. params.mode); + 150. return -EINVAL; + +drivers/pps/pps.c:161: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 159. if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + 160. /* section 3.3 of RFC 2783 interpreted */ + 161. > dev_dbg(pps->dev, "time format unspecified (%x)\n", + 162. params.mode); + 163. pps->params.mode |= PPS_TSFMT_TSPEC; + +drivers/pnp/support.c:126: error: DEAD_STORE + The value written to &len (type int) is never used. + 124. case IORESOURCE_IO: + 125. port = &option->u.port; + 126. > len += scnprintf(buf + len, sizeof(buf) - len, "io min %#llx " + 127. "max %#llx align %lld size %lld flags %#x", + 128. (unsigned long long) port->min, + +drivers/pnp/support.c:135: error: DEAD_STORE + The value written to &len (type int) is never used. + 133. case IORESOURCE_MEM: + 134. mem = &option->u.mem; + 135. > len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx " + 136. "max %#llx align %lld size %lld flags %#x", + 137. (unsigned long long) mem->min, + +drivers/pnp/support.c:158: error: DEAD_STORE + The value written to &len (type int) is never used. + 156. irq->flags); + 157. if (irq->flags & IORESOURCE_IRQ_OPTIONAL) + 158. > len += scnprintf(buf + len, sizeof(buf) - len, + 159. " (optional)"); + 160. break; + +drivers/pnp/support.c:174: error: DEAD_STORE + The value written to &len (type int) is never used. + 172. " %d", i); + 173. } + 174. > len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) " + 175. "flags %#x", dma->map, dma->flags); + 176. break; + +kernel/cgroup/freezer.c:108: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 107 could be null and is dereferenced by call to `parent_freezer()` at line 108, column 27. + 106. { + 107. struct freezer *freezer = css_freezer(css); + 108. > struct freezer *parent = parent_freezer(freezer); + 109. + 110. mutex_lock(&freezer_mutex); + +net/ipv4/sysctl_net_ipv4.c:113: error: UNINITIALIZED_VALUE + The value read from pports was never initialized. + 111. int pports; + 112. int range[2]; + 113. > struct ctl_table tmp = { + 114. .data = &pports, + 115. .maxlen = sizeof(pports), + +drivers/tty/serial/serial_core.c:115: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 113. if (port) + 114. port->ops->stop_tx(port); + 115. > uart_port_unlock(port, flags); + 116. } + 117. + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +kernel/smp.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. static __always_inline void csd_lock_wait(call_single_data_t *csd) + 107. { + 108. > smp_cond_load_acquire(&csd->flags, !(VAL & CSD_FLAG_LOCK)); + 109. } + 110. + +kernel/smpboot.c:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. preempt_enable(); + 127. if (ht->park && td->status == HP_THREAD_ACTIVE) { + 128. > BUG_ON(td->cpu != smp_processor_id()); + 129. ht->park(td->cpu); + 130. td->status = HP_THREAD_PARKED; + +kernel/smpboot.c:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. } + 136. + 137. > BUG_ON(td->cpu != smp_processor_id()); + 138. + 139. /* Check for state change setup */ + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +drivers/pci/pci-acpi.c:119: error: UNINITIALIZED_VALUE + The value read from mcfg_addr was never initialized. + 117. return 0; + 118. + 119. > return (phys_addr_t)mcfg_addr; + 120. } + 121. + +include/linux/seqlock.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. + 112. repeat: + 113. > ret = READ_ONCE(s->sequence); + 114. if (unlikely(ret & 1)) { + 115. cpu_relax(); + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/pci/proc.c:173: error: DEAD_STORE + The value written to &buf (type char const *) is never used. + 171. __get_user(val, buf); + 172. pci_user_write_config_byte(dev, pos, val); + 173. > buf++; + 174. pos++; + 175. cnt--; + +drivers/pci/proc.c:175: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 173. buf++; + 174. pos++; + 175. > cnt--; + 176. } + 177. + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +kernel/time/tick-oneshot.c:117: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 115. + 116. local_irq_save(flags); + 117. > ret = __this_cpu_read(tick_cpu_device.mode) == TICKDEV_MODE_ONESHOT; + 118. local_irq_restore(flags); + 119. + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +net/ipv6/xfrm6_mode_tunnel.c:116: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 114 could be null and is dereferenced at line 116, column 6. + 114. struct xfrm_offload *xo = xfrm_offload(skb); + 115. + 116. > if (xo->flags & XFRM_GSO_SEGMENT) + 117. skb->transport_header = skb->network_header + sizeof(struct ipv6hdr); + 118. + +net/sched/act_api.c:121: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 119. struct idr *idr = &idrinfo->action_idr; + 120. struct tc_action *p; + 121. > unsigned long id = 1; + 122. + 123. spin_lock_bh(&idrinfo->lock); + +arch/x86/include/asm/syscall.h:138: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 136. case 5: + 137. if (!n--) break; + 138. > *args++ = regs->bp; + 139. case 6: + 140. if (!n--) break; + +arch/x86/include/asm/syscall.h:165: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 163. case 5: + 164. if (!n--) break; + 165. > *args++ = regs->r9; + 166. case 6: + 167. if (!n--) break; + +arch/x86/include/asm/syscall.h:140: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 138. *args++ = regs->bp; + 139. case 6: + 140. > if (!n--) break; + 141. default: + 142. BUG(); + +arch/x86/include/asm/syscall.h:167: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 165. *args++ = regs->r9; + 166. case 6: + 167. > if (!n--) break; + 168. default: + 169. BUG(); + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +net/ipv6/udp.c:157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 155. } + 156. + 157. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 158. score++; + 159. + +include/net/busy_poll.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. { + 116. #ifdef CONFIG_NET_RX_BUSY_POLL + 117. > unsigned int napi_id = READ_ONCE(sk->sk_napi_id); + 118. + 119. if (napi_id >= MIN_NAPI_ID) + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgtyp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +kernel/events/ring_buffer.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. + 159. do { + 160. > tail = READ_ONCE(rb->user_page->data_tail); + 161. offset = head = local_read(&rb->head); + 162. if (!rb->overwrite) { + +kernel/sched/membarrier.c:165: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 163. * iteration. + 164. */ + 165. > if (cpu == raw_smp_processor_id()) + 166. continue; + 167. rcu_read_lock(); + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +block/partition-generic.c:130: error: UNINITIALIZED_VALUE + The value read from inflight.[_] was never initialized. + 128. part_stat_unlock(); + 129. part_in_flight(q, p, inflight); + 130. > return sprintf(buf, + 131. "%8lu %8lu %8llu %8u " + 132. "%8lu %8lu %8llu %8u " + +block/partition-generic.c:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. int cpu; + 125. + 126. > cpu = part_stat_lock(); + 127. part_round_stats(q, cpu, p); + 128. part_stat_unlock(); + +block/partition-generic.c:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. int cpu; + 125. + 126. > cpu = part_stat_lock(); + 127. part_round_stats(q, cpu, p); + 128. part_stat_unlock(); + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/gpu/drm/i915/intel_dsi.c:136: error: DEAD_STORE + The value written to &data (type unsigned char const *) is never used. + 134. + 135. header = packet.header; + 136. > data = packet.payload; + 137. + 138. if (msg->flags & MIPI_DSI_MSG_USE_LPM) { + +drivers/gpu/drm/drm_lock.c:137: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 135. old = *lock; + 136. new = _DRM_LOCKING_CONTEXT(old); + 137. > prev = cmpxchg(lock, old, new); + 138. } while (prev != old); + 139. + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.chan was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.func was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:245: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 243. break; + 244. } + 245. > pin_index = pd.index; + 246. if (pin_index >= ops->n_pins) { + 247. err = -EINVAL; + +drivers/ptp/ptp_chardev.c:263: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 261. break; + 262. } + 263. > pin_index = pd.index; + 264. if (pin_index >= ops->n_pins) { + 265. err = -EINVAL; + +drivers/ptp/ptp_chardev.c:197: error: UNINITIALIZED_VALUE + The value read from xtstamp.device was never initialized. + 195. + 196. memset(&precise_offset, 0, sizeof(precise_offset)); + 197. > ts = ktime_to_timespec64(xtstamp.device); + 198. precise_offset.device.sec = ts.tv_sec; + 199. precise_offset.device.nsec = ts.tv_nsec; + +drivers/ptp/ptp_chardev.c:203: error: UNINITIALIZED_VALUE + The value read from xtstamp.sys_monoraw was never initialized. + 201. precise_offset.sys_realtime.sec = ts.tv_sec; + 202. precise_offset.sys_realtime.nsec = ts.tv_nsec; + 203. > ts = ktime_to_timespec64(xtstamp.sys_monoraw); + 204. precise_offset.sys_monoraw.sec = ts.tv_sec; + 205. precise_offset.sys_monoraw.nsec = ts.tv_nsec; + +drivers/ptp/ptp_chardev.c:200: error: UNINITIALIZED_VALUE + The value read from xtstamp.sys_realtime was never initialized. + 198. precise_offset.device.sec = ts.tv_sec; + 199. precise_offset.device.nsec = ts.tv_nsec; + 200. > ts = ktime_to_timespec64(xtstamp.sys_realtime); + 201. precise_offset.sys_realtime.sec = ts.tv_sec; + 202. precise_offset.sys_realtime.nsec = ts.tv_nsec; + +drivers/thermal/thermal_helpers.c:143: error: UNINITIALIZED_VALUE + The value read from trip_temp was never initialized. + 141. + 142. if (trip_temp > tz->temperature && trip_temp < high) + 143. > high = trip_temp; + 144. } + 145. + +kernel/irq/spurious.c:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. goto out; + 126. + 127. > irq_poll_cpu = smp_processor_id(); + 128. + 129. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. goto out; + 126. + 127. > irq_poll_cpu = smp_processor_id(); + 128. + 129. for_each_irq_desc(i, desc) { + +lib/errseq.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. errseq_t errseq_sample(errseq_t *eseq) + 120. { + 121. > errseq_t old = READ_ONCE(*eseq); + 122. errseq_t new = old; + 123. + +drivers/scsi/scsi_transport_spi.c:143: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 141. break; + 142. } + 143. > return result; + 144. } + 145. + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +sound/core/info.c:130: error: DEAD_STORE + The value written to &offset (type long long) is never used. + 128. mutex_lock(&entry->access); + 129. if (entry->c.ops->llseek) { + 130. > offset = entry->c.ops->llseek(entry, + 131. data->file_private_data, + 132. file, offset, orig); + +block/blk-mq.h:129: error: DEAD_STORE + The value written to &new_val (type unsigned long long) is never used. + 127. if (state == MQ_RQ_IN_FLIGHT) { + 128. WARN_ON_ONCE((old_val & MQ_RQ_STATE_MASK) != MQ_RQ_IDLE); + 129. > new_val += MQ_RQ_GEN_INC; + 130. } + 131. + +block/blk-mq.h:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. enum mq_rq_state state) + 123. { + 124. > u64 old_val = READ_ONCE(rq->gstate); + 125. u64 new_val = (old_val & ~MQ_RQ_STATE_MASK) | state; + 126. + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +drivers/base/devtmpfs.c:148: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 146. + 147. kfree(tmp); + 148. > return req.err; + 149. } + 150. + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +drivers/scsi/scsi_logging.c:140: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 138. if (off < logbuf_len) { + 139. va_start(args, fmt); + 140. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 141. va_end(args); + 142. } + +net/ipv6/xfrm6_policy.c:165: error: DEAD_STORE + The value written to &exthdr (type ipv6_opt_hdr*) is never used. + 163. offset += ipv6_optlen(exthdr); + 164. nexthdr = exthdr->nexthdr; + 165. > exthdr = (struct ipv6_opt_hdr *)(nh + offset); + 166. break; + 167. + +drivers/input/ff-memless.c:127: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 125. { + 126. struct ml_effect_state *state; + 127. > unsigned long now = jiffies; + 128. unsigned long earliest = 0; + 129. unsigned long next_at; + +net/sched/cls_api.c:135: error: DEAD_STORE + The value written to &err (type int) is never used. + 133. return ERR_PTR(-ENOBUFS); + 134. + 135. > err = -ENOENT; + 136. tp->ops = tcf_proto_lookup_ops(kind); + 137. if (!tp->ops) { + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +drivers/base/power/runtime.c:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. goto out; + 136. + 137. > autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); + 138. if (autosuspend_delay < 0) + 139. goto out; + +drivers/base/power/runtime.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. goto out; + 140. + 141. > last_busy = READ_ONCE(dev->power.last_busy); + 142. elapsed = jiffies - last_busy; + 143. if (elapsed < 0) + +drivers/tty/serial/serial_core.c:135: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 133. port = uart_port_lock(state, flags); + 134. __uart_start(tty); + 135. > uart_port_unlock(port, flags); + 136. } + 137. + +drivers/usb/storage/sierra_ms.c:197: error: DEAD_STORE + The value written to &result (type int) is never used. + 195. } + 196. complete: + 197. > result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); + 198. + 199. return 0; + +drivers/usb/storage/sierra_ms.c:134: error: DEAD_STORE + The value written to &retries (type int) is never used. + 132. struct Scsi_Host *sh; + 133. + 134. > retries = 3; + 135. result = 0; + 136. udev = us->pusb_dev; + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +init/do_mounts_md.c:213: error: UNINITIALIZED_VALUE + The value read from ainfo was never initialized. + 211. ainfo.layout = 0; + 212. ainfo.chunk_size = md_setup_args[ent].chunk; + 213. > err = sys_ioctl(fd, SET_ARRAY_INFO, (long)&ainfo); + 214. for (i = 0; !err && i <= MD_SB_DISKS; i++) { + 215. dev = devices[i]; + +init/do_mounts_md.c:223: error: UNINITIALIZED_VALUE + The value read from dinfo was never initialized. + 221. dinfo.major = MAJOR(dev); + 222. dinfo.minor = MINOR(dev); + 223. > err = sys_ioctl(fd, ADD_NEW_DISK, (long)&dinfo); + 224. } + 225. } else { + +init/do_mounts_md.c:233: error: UNINITIALIZED_VALUE + The value read from dinfo was never initialized. + 231. dinfo.major = MAJOR(dev); + 232. dinfo.minor = MINOR(dev); + 233. > sys_ioctl(fd, ADD_NEW_DISK, (long)&dinfo); + 234. } + 235. } + +drivers/gpu/drm/drm_ioc32.c:139: error: UNINITIALIZED_VALUE + The value read from uq32.unique was never initialized. + 137. uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. > .unique = compat_ptr(uq32.unique), + 140. }; + 141. + +drivers/gpu/drm/drm_ioc32.c:137: error: UNINITIALIZED_VALUE + The value read from uq32.unique_len was never initialized. + 135. if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32))) + 136. return -EFAULT; + 137. > uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. .unique = compat_ptr(uq32.unique), + +drivers/thermal/step_wise.c:152: error: UNINITIALIZED_VALUE + The value read from trip_temp was never initialized. + 150. } + 151. + 152. > dev_dbg(&tz->device, "Trip%d[type=%d,temp=%d]:trend=%d,throttle=%d\n", + 153. trip, trip_type, trip_temp, trend, throttle); + 154. + +drivers/thermal/step_wise.c:149: error: UNINITIALIZED_VALUE + The value read from trip_type was never initialized. + 147. if (tz->temperature >= trip_temp) { + 148. throttle = true; + 149. > trace_thermal_zone_trip(tz, trip, trip_type); + 150. } + 151. + +drivers/thermal/step_wise.c:152: error: UNINITIALIZED_VALUE + The value read from trip_type was never initialized. + 150. } + 151. + 152. > dev_dbg(&tz->device, "Trip%d[type=%d,temp=%d]:trend=%d,throttle=%d\n", + 153. trip, trip_type, trip_temp, trend, throttle); + 154. + +drivers/thermal/step_wise.c:172: error: UNINITIALIZED_VALUE + The value read from trip_type was never initialized. + 170. if (old_target == THERMAL_NO_TARGET && + 171. instance->target != THERMAL_NO_TARGET) + 172. > update_passive_instance(tz, trip_type, 1); + 173. /* Deactivate a passive thermal instance */ + 174. else if (old_target != THERMAL_NO_TARGET && + +drivers/thermal/step_wise.c:176: error: UNINITIALIZED_VALUE + The value read from trip_type was never initialized. + 174. else if (old_target != THERMAL_NO_TARGET && + 175. instance->target == THERMAL_NO_TARGET) + 176. > update_passive_instance(tz, trip_type, -1); + 177. + 178. instance->initialized = true; + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +drivers/char/hw_random/via-rng.c:177: error: DEAD_STORE + The value written to &hi (type unsigned int) is never used. + 175. /* perhaps-unnecessary sanity check; remove after testing if + 176. unneeded */ + 177. > rdmsr(MSR_VIA_RNG, lo, hi); + 178. if ((lo & VIA_RNG_ENABLE) == 0) { + 179. pr_err(PFX "cannot enable VIA C3 RNG, aborting\n"); + +include/linux/seqlock.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. static inline unsigned raw_read_seqcount(const seqcount_t *s) + 131. { + 132. > unsigned ret = READ_ONCE(s->sequence); + 133. smp_rmb(); + 134. return ret; + +kernel/cgroup/freezer.c:136: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 132 could be null and is dereferenced at line 136, column 6. + 134. mutex_lock(&freezer_mutex); + 135. + 136. > if (freezer->state & CGROUP_FREEZING) + 137. atomic_dec(&system_freezing_cnt); + 138. + +init/initramfs.c:137: error: NULL_DEREFERENCE + pointer `de` last assigned on line 133 could be null and is dereferenced at line 137, column 2. + 135. panic("can't allocate dir_entry buffer"); + 136. INIT_LIST_HEAD(&de->list); + 137. > de->name = kstrdup(name, GFP_KERNEL); + 138. de->mtime = mtime; + 139. list_add(&de->list, &dir_list); + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +net/core/gen_stats.c:149: error: UNINITIALIZED_VALUE + The value read from seq was never initialized. + 147. bstats->bytes = b->bytes; + 148. bstats->packets = b->packets; + 149. > } while (running && read_seqcount_retry(running, seq)); + 150. } + 151. EXPORT_SYMBOL(__gnet_stats_copy_basic); + +net/ipv6/netfilter/nf_reject_ipv6.c:187: error: DEAD_STORE + The value written to &ip6h (type ipv6hdr*) is never used. + 185. + 186. skb_reserve(nskb, hh_len + dst->header_len); + 187. > ip6h = nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP, + 188. ip6_dst_hoplimit(dst)); + 189. nf_reject_ip6_tcphdr_put(nskb, oldskb, otcph, otcplen); + +drivers/gpu/drm/i915/intel_lspcon.c:154: error: UNINITIALIZED_VALUE + The value read from adaptor_type was never initialized. + 152. + 153. if (adaptor_type != DRM_DP_DUAL_MODE_LSPCON) { + 154. > DRM_DEBUG_KMS("No LSPCON detected, found %s\n", + 155. drm_dp_get_dual_mode_type_name(adaptor_type)); + 156. return false; + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +net/netlabel/netlabel_cipso_v4.c:137: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 135. struct netlbl_audit *audit_info) + 136. { + 137. > int ret_val = -EINVAL; + 138. struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + +drivers/tty/sysrq.c:147: error: NULL_DEREFERENCE + pointer `killer` last assigned on line 137 could be null and is dereferenced at line 147, column 2. + 145. panic_on_oops = 1; /* force panic */ + 146. wmb(); + 147. > *killer = 1; + 148. } + 149. static struct sysrq_key_op sysrq_crash_op = { + +drivers/usb/core/devio.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. u64 lim; + 139. + 140. > lim = READ_ONCE(usbfs_memory_mb); + 141. lim <<= 20; + 142. + +include/linux/percpu-refcount.h:152: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 150. * with smp_store_release() in __percpu_ref_switch_to_percpu(). + 151. */ + 152. > percpu_ptr = READ_ONCE(ref->percpu_count_ptr); + 153. + 154. /* + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +arch/x86/entry/common.c:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. local_irq_disable(); + 174. + 175. > cached_flags = READ_ONCE(current_thread_info()->flags); + 176. + 177. if (!(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/linux/page-flags.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. static inline struct page *compound_head(struct page *page) + 141. { + 142. > unsigned long head = READ_ONCE(page->compound_head); + 143. + 144. if (unlikely(head & 1)) + +kernel/smp.c:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. smp_call_func_t func, void *info) + 143. { + 144. > if (cpu == smp_processor_id()) { + 145. unsigned long flags; + 146. + +net/ipv6/ipv6_sockglue.c:821: error: DEAD_STORE + The value written to &retv (type int) is never used. + 819. goto e_inval; + 820. + 821. > retv = -EINVAL; + 822. + 823. /* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */ + +net/ipv6/ipv6_sockglue.c:685: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 683. psin6 = (struct sockaddr_in6 *)&greq.gr_group; + 684. if (optname == MCAST_JOIN_GROUP) + 685. > retv = ipv6_sock_mc_join(sk, greq.gr_interface, + 686. &psin6->sin6_addr); + 687. else + +net/ipv6/ipv6_sockglue.c:688: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 686. &psin6->sin6_addr); + 687. else + 688. > retv = ipv6_sock_mc_drop(sk, greq.gr_interface, + 689. &psin6->sin6_addr); + 690. break; + +net/ipv6/ipv6_sockglue.c:721: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 719. + 720. psin6 = (struct sockaddr_in6 *)&greqs.gsr_group; + 721. > retv = ipv6_sock_mc_join(sk, greqs.gsr_interface, + 722. &psin6->sin6_addr); + 723. /* prior join w/ different source is ok */ + +net/ipv6/ipv6_sockglue.c:644: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 642. + 643. if (optname == IPV6_ADD_MEMBERSHIP) + 644. > retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + +net/ipv6/ipv6_sockglue.c:646: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 644. retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. > retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 647. break; + 648. } + +net/ipv6/ipv6_sockglue.c:662: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 660. + 661. if (optname == IPV6_JOIN_ANYCAST) + 662. > retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + +net/ipv6/ipv6_sockglue.c:664: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 662. retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. > retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 665. break; + 666. } + +drivers/char/hpet.c:167: error: DEAD_STORE + The value written to &m (type unsigned long) is never used. + 165. + 166. t = devp->hd_ireqfreq; + 167. > m = read_counter(&devp->hd_timer->hpet_compare); + 168. mc = read_counter(&hpet->hpet_mc); + 169. /* The time for the next interrupt would logically be t + m, + +drivers/clk/clk.c:159: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 157. if (!IS_ENABLED(CONFIG_SMP)) + 158. local_save_flags(flags); + 159. > return flags; + 160. } + 161. spin_lock_irqsave(&enable_lock, flags); + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/rtc/rtc-dev.c:194: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 192. sizeof(unsigned long); + 193. } + 194. > return ret; + 195. } + 196. + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +net/netfilter/nf_queue.c:146: error: DEAD_STORE + The value written to &status (type int) is never used. + 144. unsigned int index, unsigned int queuenum) + 145. { + 146. > int status = -ENOENT; + 147. struct nf_queue_entry *entry = NULL; + 148. const struct nf_queue_handler *qh; + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +crypto/scompress.c:149: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 147. struct crypto_scomp *scomp = *tfm_ctx; + 148. void **ctx = acomp_request_ctx(req); + 149. > const int cpu = get_cpu(); + 150. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 151. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +crypto/scompress.c:149: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 147. struct crypto_scomp *scomp = *tfm_ctx; + 148. void **ctx = acomp_request_ctx(req); + 149. > const int cpu = get_cpu(); + 150. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 151. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +drivers/gpu/drm/drm_modes.c:252: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 250. vsyncandback_porch = tmp1; + 251. /* 10. Find number of lines in back porch */ + 252. > vback_porch = vsyncandback_porch - vsync; + 253. drm_mode->vtotal = vdisplay_rnd + 2 * vmargin + + 254. vsyncandback_porch + CVT_MIN_V_PORCH; + +drivers/gpu/drm/drm_sysfs.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. enum drm_connector_status status; + 149. + 150. > status = READ_ONCE(connector->status); + 151. + 152. return snprintf(buf, PAGE_SIZE, "%s\n", + +drivers/hid/hid-ntrig.c:162: error: DEAD_STORE + The value written to &ret (type int) is never used. + 160. + 161. if (ret == 8) { + 162. > ret = ntrig_version_string(&data[2], buf); + 163. + 164. hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n", + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +kernel/irq/spurious.c:152: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 150. if (atomic_inc_return(&irq_poll_active) != 1) + 151. goto out; + 152. > irq_poll_cpu = smp_processor_id(); + 153. + 154. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:152: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 150. if (atomic_inc_return(&irq_poll_active) != 1) + 151. goto out; + 152. > irq_poll_cpu = smp_processor_id(); + 153. + 154. for_each_irq_desc(i, desc) { + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +arch/x86/platform/efi/efi_64.c:183: error: DEAD_STORE + The value written to &p4d (type p4d_t*) is never used. + 181. } + 182. + 183. > p4d = (p4d_t *)pgd_page_vaddr(*pgd); + 184. p4d_free(&init_mm, p4d); + 185. } + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +block/blk-mq.h:150: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 148. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 149. { + 150. > return __blk_mq_get_ctx(q, get_cpu()); + 151. } + 152. + +block/blk-mq.h:150: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 148. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 149. { + 150. > return __blk_mq_get_ctx(q, get_cpu()); + 151. } + 152. + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +net/sunrpc/auth_gss/gss_rpc_xdr.c:158: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 156. if (unlikely(p == NULL)) + 157. return -ENOSPC; + 158. > count = be32_to_cpup(p++); + 159. memset(&dummy, 0, sizeof(dummy)); + 160. for (i = 0; i < count; i++) { + +drivers/thermal/thermal_sysfs.c:168: error: UNINITIALIZED_VALUE + The value read from temperature was never initialized. + 166. return ret; + 167. + 168. > return sprintf(buf, "%d\n", temperature); + 169. } + 170. + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +lib/errseq.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. int errseq_check(errseq_t *eseq, errseq_t since) + 150. { + 151. > errseq_t cur = READ_ONCE(*eseq); + 152. + 153. if (likely(cur == since)) + +net/core/dst.c:153: error: DEAD_STORE + The value written to &dst (type dst_entry*) is never used. + 151. struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head); + 152. + 153. > dst = dst_destroy(dst); + 154. } + 155. + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +drivers/gpu/drm/drm_drv.c:158: error: NULL_DEREFERENCE + pointer `slot` last assigned on line 157 could be null and is dereferenced at line 158, column 10. + 156. + 157. slot = drm_minor_get_slot(dev, type); + 158. > minor = *slot; + 159. if (!minor) + 160. return; + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/ksysfs.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. struct kobj_attribute *attr, char *buf) + 155. { + 156. > return sprintf(buf, "%d\n", READ_ONCE(rcu_expedited)); + 157. } + 158. static ssize_t rcu_expedited_store(struct kobject *kobj, + +drivers/dma-buf/reservation.c:207: error: UNINITIALIZED_VALUE + The value read from k was never initialized. + 205. + 206. /* Drop the references to the signaled fences */ + 207. > for (i = k; i < fobj->shared_max; ++i) { + 208. struct dma_fence *f; + 209. + +kernel/printk/printk.c:183: error: UNINITIALIZED_VALUE + The value read from old was never initialized. + 181. + 182. /* ... and restore old setting. */ + 183. > devkmsg_log = old; + 184. strncpy(devkmsg_log_str, old_str, DEVKMSG_STR_MAX_SIZE); + 185. + +drivers/gpu/drm/drm_framebuffer.c:184: error: NULL_DEREFERENCE + pointer `info` last assigned on line 172 could be null and is dereferenced at line 184, column 18. + 182. } + 183. + 184. > for (i = 0; i < info->num_planes; i++) { + 185. unsigned int width = fb_plane_width(r->width, info, i); + 186. unsigned int height = fb_plane_height(r->height, info, i); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:166: error: DEAD_STORE + The value written to &ret_val (type unsigned int) is never used. + 164. * at the end of this routine. + 165. */ + 166. > ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data); + 167. + 168. /* Disabled the PHY transmitter */ + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +lib/decompress_bunzip2.c:271: error: UNINITIALIZED_VALUE + The value read from length.[_] was never initialized. + 269. } + 270. /* Find largest and smallest lengths in this group */ + 271. > minLen = maxLen = length[0]; + 272. + 273. for (i = 1; i < symCount; i++) { + +lib/decompress_bunzip2.c:275: error: UNINITIALIZED_VALUE + The value read from length.[_] was never initialized. + 273. for (i = 1; i < symCount; i++) { + 274. if (length[i] > maxLen) + 275. > maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. minLen = length[i]; + +lib/decompress_bunzip2.c:277: error: UNINITIALIZED_VALUE + The value read from length.[_] was never initialized. + 275. maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. > minLen = length[i]; + 278. } + 279. + +drivers/gpu/drm/drm_sysfs.c:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. int dpms; + 162. + 163. > dpms = READ_ONCE(connector->dpms); + 164. + 165. return snprintf(buf, PAGE_SIZE, "%s\n", + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.addr was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.fd was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.flags was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.len was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.prot was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +net/ipv4/inet_fragment.c:170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 168. local_bh_disable(); + 169. + 170. > for (i = READ_ONCE(f->next_bucket); budget; --budget) { + 171. evicted += inet_evict_bucket(f, &f->hash[i]); + 172. i = (i + 1) & (INETFRAGS_HASHSZ - 1); + +kernel/softirq.c:177: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 175. preempt_count_sub(cnt - 1); + 176. + 177. > if (unlikely(!in_interrupt() && local_softirq_pending())) { + 178. /* + 179. * Run softirq if any pending. And do it in its own stack + +lib/ioremap.c:170: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 168. BUG_ON(addr >= end); + 169. + 170. > start = addr; + 171. phys_addr -= addr; + 172. pgd = pgd_offset_k(addr); + +tools/lib/subcmd/exec-cmd.c:169: error: NULL_DEREFERENCE + pointer `nargv` last assigned on line 167 could be null and is dereferenced at line 169, column 2. + 167. nargv = malloc(sizeof(*nargv) * (argc + 2)); + 168. + 169. > nargv[0] = subcmd_config.exec_name; + 170. for (argc = 0; argv[argc]; argc++) + 171. nargv[argc + 1] = argv[argc]; + +arch/x86/lib/msr-smp.c:174: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 172. *h = rv.reg.h; + 173. + 174. > return err ? err : rv.err; + 175. } + 176. EXPORT_SYMBOL(rdmsr_safe_on_cpu); + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +drivers/net/ethernet/intel/e1000e/netdev.c:189: error: UNINITIALIZED_VALUE + The value read from regs.[_] was never initialized. + 187. + 188. snprintf(rname, 16, "%s%s", reginfo->name, "[0-1]"); + 189. > pr_info("%-15s %08x %08x\n", rname, regs[0], regs[1]); + 190. } + 191. + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +init/initramfs.c:175: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 173. parsed[i] = simple_strtoul(buf, NULL, 16); + 174. } + 175. > ino = parsed[0]; + 176. mode = parsed[1]; + 177. uid = parsed[2]; + +init/initramfs.c:176: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 174. } + 175. ino = parsed[0]; + 176. > mode = parsed[1]; + 177. uid = parsed[2]; + 178. gid = parsed[3]; + +init/initramfs.c:177: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 175. ino = parsed[0]; + 176. mode = parsed[1]; + 177. > uid = parsed[2]; + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + +init/initramfs.c:178: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 176. mode = parsed[1]; + 177. uid = parsed[2]; + 178. > gid = parsed[3]; + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + +init/initramfs.c:179: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 177. uid = parsed[2]; + 178. gid = parsed[3]; + 179. > nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + +init/initramfs.c:180: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + 180. > mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. major = parsed[7]; + +init/initramfs.c:181: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. > body_len = parsed[6]; + 182. major = parsed[7]; + 183. minor = parsed[8]; + +init/initramfs.c:182: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. > major = parsed[7]; + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + +init/initramfs.c:183: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 181. body_len = parsed[6]; + 182. major = parsed[7]; + 183. > minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. name_len = parsed[11]; + +init/initramfs.c:185: error: UNINITIALIZED_VALUE + The value read from parsed.[_] was never initialized. + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. > name_len = parsed[11]; + 186. } + 187. + +arch/x86/lib/delay.c:175: error: DEAD_STORE + The value written to &xloops (type unsigned long) is never used. + 173. :"1" (xloops), "0" (lpj * (HZ / 4))); + 174. + 175. > __delay(++xloops); + 176. } + 177. EXPORT_SYMBOL(__const_udelay); + +arch/x86/lib/delay.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. void __const_udelay(unsigned long xloops) + 166. { + 167. > unsigned long lpj = this_cpu_read(cpu_info.loops_per_jiffy) ? : loops_per_jiffy; + 168. int d0; + 169. + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +kernel/sched/cpuacct.c:174: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 169 could be null and is dereferenced by call to `cpuacct_cpuusage_read()` at line 174, column 20. + 172. + 173. for_each_possible_cpu(i) + 174. > totalcpuusage += cpuacct_cpuusage_read(ca, i, index); + 175. + 176. return totalcpuusage; + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +drivers/gpu/drm/drm_ioc32.c:179: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 177. return -EFAULT; + 178. + 179. > map.offset = m32.offset; + 180. err = drm_ioctl_kernel(file, drm_legacy_getmap_ioctl, &map, DRM_UNLOCKED); + 181. if (err) + +drivers/gpu/drm/drm_ioc32.c:187: error: UNINITIALIZED_VALUE + The value read from map.flags was never initialized. + 185. m32.size = map.size; + 186. m32.type = map.type; + 187. > m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. m32.mtrr = map.mtrr; + +drivers/gpu/drm/drm_ioc32.c:189: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. > m32.mtrr = map.mtrr; + 190. if (copy_to_user(argp, &m32, sizeof(m32))) + 191. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:185: error: UNINITIALIZED_VALUE + The value read from map.size was never initialized. + 183. + 184. m32.offset = map.offset; + 185. > m32.size = map.size; + 186. m32.type = map.type; + 187. m32.flags = map.flags; + +drivers/gpu/drm/drm_ioc32.c:186: error: UNINITIALIZED_VALUE + The value read from map.type was never initialized. + 184. m32.offset = map.offset; + 185. m32.size = map.size; + 186. > m32.type = map.type; + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +net/core/dev_ioctl.c:184: error: UNINITIALIZED_VALUE + The value read from cfg.rx_filter was never initialized. + 182. + 183. tx_type = cfg.tx_type; + 184. > rx_filter = cfg.rx_filter; + 185. + 186. switch (tx_type) { + +net/core/dev_ioctl.c:183: error: UNINITIALIZED_VALUE + The value read from cfg.tx_type was never initialized. + 181. return -EINVAL; + 182. + 183. > tx_type = cfg.tx_type; + 184. rx_filter = cfg.rx_filter; + 185. + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/md/dm.c:172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 170. static int __dm_get_module_param_int(int *module_param, int min, int max) + 171. { + 172. > int param = READ_ONCE(*module_param); + 173. int modified_param = 0; + 174. bool modified = true; + +kernel/ksysfs.c:173: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 171. struct kobj_attribute *attr, char *buf) + 172. { + 173. > return sprintf(buf, "%d\n", READ_ONCE(rcu_normal)); + 174. } + 175. static ssize_t rcu_normal_store(struct kobject *kobj, + +net/sched/act_api.c:178: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 176. struct idr *idr = &idrinfo->action_idr; + 177. struct tc_action *p; + 178. > unsigned long id = 1; + 179. + 180. nest = nla_nest_start(skb, 0); + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +lib/asn1_decoder.c:400: error: UNINITIALIZED_VALUE + The value read from cons_datalen_stack.[_] was never initialized. + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. > datalen = cons_datalen_stack[csp]; + 401. pr_debug("- end cons t=%zu dp=%zu l=%zu/%zu\n", + 402. tdp, dp, len, datalen); + +lib/asn1_decoder.c:397: error: UNINITIALIZED_VALUE + The value read from cons_dp_stack.[_] was never initialized. + 395. goto cons_stack_underflow; + 396. csp--; + 397. > tdp = cons_dp_stack[csp]; + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + +lib/asn1_decoder.c:398: error: UNINITIALIZED_VALUE + The value read from cons_hdrlen_stack.[_] was never initialized. + 396. csp--; + 397. tdp = cons_dp_stack[csp]; + 398. > hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. datalen = cons_datalen_stack[csp]; + +lib/asn1_decoder.c:463: error: UNINITIALIZED_VALUE + The value read from jump_stack.[_] was never initialized. + 461. if (unlikely(jsp <= 0)) + 462. goto jump_stack_underflow; + 463. > pc = jump_stack[--jsp]; + 464. flags |= FLAG_MATCHED | FLAG_LAST_MATCHED; + 465. goto next_op; + +drivers/ata/libata-scsi.c:197: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 195. + 196. link = dev->link; + 197. > now = jiffies; + 198. if (ap->pflags & ATA_PFLAG_EH_IN_PROGRESS && + 199. link->eh_context.unloaded_mask & (1 << dev->devno) && + +drivers/char/agp/compat_ioctl.c:181: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 179. return -EFAULT; + 180. + 181. > memory = agp_find_mem_by_key(bind_info.key); + 182. + 183. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:186: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 184. return -EINVAL; + 185. + 186. > return agp_bind_memory(memory, bind_info.pg_start); + 187. } + 188. + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +arch/x86/include/asm/atomic64_64.h:177: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 175. static inline long atomic64_cmpxchg(atomic64_t *v, long old, long new) + 176. { + 177. > return cmpxchg(&v->counter, old, new); + 178. } + 179. + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +net/sched/sch_mq.c:179: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 177 could be null and is dereferenced at line 179, column 9. + 177. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 178. + 179. > return dev_queue->qdisc_sleeping; + 180. } + 181. + +drivers/hwmon/hwmon.c:188: error: UNINITIALIZED_VALUE + The value read from val was never initialized. + 186. return ret; + 187. + 188. > return sprintf(buf, "%ld\n", val); + 189. } + 190. + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +security/keys/proc.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. /* come up with a suitable timeout value */ + 222. > expiry = READ_ONCE(key->expiry); + 223. if (expiry == 0) { + 224. memcpy(xbuf, "perm", 5); + +security/keys/proc.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. ((FLAGS & (1 << FLAG)) ? LETTER : '-') + 246. + 247. > flags = READ_ONCE(key->flags); + 248. seq_printf(m, "%08x %c%c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ", + 249. key->serial, + +arch/x86/lib/msr-smp.c:190: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 188. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 189. + 190. > return err ? err : rv.err; + 191. } + 192. EXPORT_SYMBOL(wrmsr_safe_on_cpu); + +drivers/firmware/dmi-id.c:206: error: DEAD_STORE + The value written to &i (type int) is never used. + 204. ADD_DMI_ATTR(chassis_serial, DMI_CHASSIS_SERIAL); + 205. ADD_DMI_ATTR(chassis_asset_tag, DMI_CHASSIS_ASSET_TAG); + 206. > sys_dmi_attributes[i++] = &sys_dmi_modalias_attr.attr; + 207. } + 208. + +drivers/gpu/drm/i915/intel_hdmi.c:189: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 183 could be null and is dereferenced at line 189, column 37. + 187. return false; + 188. + 189. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 190. return false; + 191. + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +lib/errseq.c:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. * to take the lock that protects the "since" value. + 188. */ + 189. > old = READ_ONCE(*eseq); + 190. if (old != *since) { + 191. /* + +drivers/pci/probe.c:254: error: UNINITIALIZED_VALUE + The value read from orig_cmd was never initialized. + 252. + 253. if (!dev->mmio_always_on && (orig_cmd & PCI_COMMAND_DECODE_ENABLE)) + 254. > pci_write_config_word(dev, PCI_COMMAND, orig_cmd); + 255. + 256. if (!sz64) + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +include/linux/seqlock.h:184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 182. static inline unsigned raw_seqcount_begin(const seqcount_t *s) + 183. { + 184. > unsigned ret = READ_ONCE(s->sequence); + 185. smp_rmb(); + 186. return ret & ~1; + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +arch/x86/entry/common.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. lockdep_sys_exit(); + 192. + 193. > cached_flags = READ_ONCE(ti->flags); + 194. + 195. if (unlikely(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +arch/x86/include/asm/atomic.h:187: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 185. static __always_inline int atomic_cmpxchg(atomic_t *v, int old, int new) + 186. { + 187. > return cmpxchg(&v->counter, old, new); + 188. } + 189. + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +scripts/mod/file2alias.c:196: error: DEAD_STORE + The value written to &bcdDevice_lo (type unsigned short) is never used. + 194. DEF_FIELD(symval, usb_device_id, idVendor); + 195. DEF_FIELD(symval, usb_device_id, idProduct); + 196. > DEF_FIELD(symval, usb_device_id, bcdDevice_lo); + 197. DEF_FIELD(symval, usb_device_id, bDeviceClass); + 198. DEF_FIELD(symval, usb_device_id, bDeviceSubClass); + +drivers/video/fbdev/core/fbcvt.c:192: error: DEAD_STORE + The value written to &aspect (type unsigned int) is never used. + 190. u32 xres = cvt->xres; + 191. u32 yres = cvt->yres; + 192. > u32 aspect = -1; + 193. + 194. if (xres == (yres * 4)/3 && !((yres * 4) % 3)) + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +drivers/char/agp/compat_ioctl.c:198: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 196. return -EFAULT; + 197. + 198. > memory = agp_find_mem_by_key(unbind.key); + 199. + 200. if (memory == NULL) + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +security/selinux/hooks.c:199: error: NULL_DEREFERENCE + pointer `tsec` last assigned on line 195 could be null and is dereferenced at line 199, column 15. + 197. panic("SELinux: Failed to initialize initial task.\n"); + 198. + 199. > tsec->osid = tsec->sid = SECINITSID_KERNEL; + 200. cred->security = tsec; + 201. } + +drivers/md/dm.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. unsigned def, unsigned max) + 193. { + 194. > unsigned param = READ_ONCE(*module_param); + 195. unsigned modified_param = 0; + 196. + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +net/sched/sch_mq.c:198: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 194 could be null and is dereferenced at line 198, column 18. + 196. tcm->tcm_parent = TC_H_ROOT; + 197. tcm->tcm_handle |= TC_H_MIN(cl); + 198. > tcm->tcm_info = dev_queue->qdisc_sleeping->handle; + 199. return 0; + 200. } + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +scripts/kconfig/menu.c:195: error: MEMORY_LEAK + memory dynamically allocated by call to `expr_alloc_symbol()` at line 195, column 28 is not reachable after line 195, column 2. + 193. void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep) + 194. { + 195. > menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep); + 196. } + 197. + +arch/x86/lib/msr-smp.c:206: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 204. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 205. + 206. > return err ? err : rv.err; + 207. } + 208. EXPORT_SYMBOL(wrmsrl_safe_on_cpu); + +net/ipv6/proc.c:206: error: UNINITIALIZED_VALUE + The value read from buff.[_] was never initialized. + 204. snmp_get_cpu_field_batch(buff, itemlist, pcpumib); + 205. for (i = 0; itemlist[i].name; i++) + 206. > seq_printf(seq, "%-32s\t%lu\n", + 207. itemlist[i].name, buff[i]); + 208. } else { + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +kernel/ucount.c:204: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 202. int max; + 203. tns = iter->ns; + 204. > max = READ_ONCE(tns->ucount_max[type]); + 205. if (!atomic_inc_below(&iter->ucount[type], max)) + 206. goto fail; + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +drivers/gpu/drm/drm_ioc32.c:210: error: UNINITIALIZED_VALUE + The value read from m32.flags was never initialized. + 208. map.size = m32.size; + 209. map.type = m32.type; + 210. > map.flags = m32.flags; + 211. + 212. err = drm_ioctl_kernel(file, drm_legacy_addmap_ioctl, &map, + +drivers/gpu/drm/drm_ioc32.c:207: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 205. return -EFAULT; + 206. + 207. > map.offset = m32.offset; + 208. map.size = m32.size; + 209. map.type = m32.type; + +drivers/gpu/drm/drm_ioc32.c:208: error: UNINITIALIZED_VALUE + The value read from m32.size was never initialized. + 206. + 207. map.offset = m32.offset; + 208. > map.size = m32.size; + 209. map.type = m32.type; + 210. map.flags = m32.flags; + +drivers/gpu/drm/drm_ioc32.c:209: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 207. map.offset = m32.offset; + 208. map.size = m32.size; + 209. > map.type = m32.type; + 210. map.flags = m32.flags; + 211. + +drivers/gpu/drm/drm_ioc32.c:221: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + 221. > pr_err_ratelimited("compat_drm_addmap truncated handle %p for type %d offset %x\n", + 222. map.handle, m32.type, m32.offset); + 223. + +drivers/gpu/drm/drm_ioc32.c:218: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 216. + 217. m32.offset = map.offset; + 218. > m32.mtrr = map.mtrr; + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + +kernel/sched/cpuacct.c:209: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 199 could be null and is dereferenced by call to `cpuacct_cpuusage_write()` at line 209, column 3. + 207. + 208. for_each_possible_cpu(cpu) + 209. > cpuacct_cpuusage_write(ca, cpu, 0); + 210. + 211. return 0; + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/kthread.c:219: error: NULL_DEREFERENCE + pointer `done` last assigned on line 211 could be null and is dereferenced by call to `complete()` at line 219, column 3. + 217. if (!self) { + 218. create->result = ERR_PTR(-ENOMEM); + 219. > complete(done); + 220. do_exit(-ENOMEM); + 221. } + +kernel/power/user.c:373: error: UNINITIALIZED_VALUE + The value read from swap_area.dev was never initialized. + 371. * so we need to recode them + 372. */ + 373. > swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. offset = swap_area.offset; + +kernel/power/user.c:375: error: UNINITIALIZED_VALUE + The value read from swap_area.offset was never initialized. + 373. swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. > offset = swap_area.offset; + 376. data->swap = swap_type_of(swdev, offset, NULL); + 377. if (data->swap < 0) + +block/ioctl.c:218: error: UNINITIALIZED_VALUE + The value read from range.[_] was never initialized. + 216. return -EFAULT; + 217. + 218. > start = range[0]; + 219. len = range[1]; + 220. + +block/ioctl.c:219: error: UNINITIALIZED_VALUE + The value read from range.[_] was never initialized. + 217. + 218. start = range[0]; + 219. > len = range[1]; + 220. + 221. if (start & 511) + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +drivers/thermal/thermal_sysfs.c:217: error: UNINITIALIZED_VALUE + The value read from temperature was never initialized. + 215. ret = tz->ops->get_trip_hyst(tz, trip, &temperature); + 216. + 217. > return ret ? ret : sprintf(buf, "%d\n", temperature); + 218. } + 219. + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +crypto/rsa.c:218: error: DEAD_STORE + The value written to &ret (type int) is never used. + 216. } + 217. + 218. > ret = -ENOMEM; + 219. s = mpi_read_raw_from_sgl(req->src, req->src_len); + 220. if (!s) { + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/tty/tty_audit.c:209: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 207. dev_t dev; + 208. + 209. > audit_tty = READ_ONCE(current->signal->audit_tty); + 210. if (~audit_tty & AUDIT_TTY_ENABLE) + 211. return; + +net/sched/sch_mq.c:207: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 205 could be null and is dereferenced at line 207, column 8. + 205. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 206. + 207. > sch = dev_queue->qdisc_sleeping; + 208. if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || + 209. gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) + +drivers/input/mouse/synaptics.c:215: error: UNINITIALIZED_VALUE + The value read from resp.be_val was never initialized. + 213. return error; + 214. + 215. > *val = be32_to_cpu(resp.be_val); + 216. return 0; + 217. } + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +kernel/cgroup/freezer.c:221: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 220 could be null and is dereferenced at line 221, column 6. + 219. + 220. freezer = task_freezer(task); + 221. > if (freezer->state & CGROUP_FREEZING) + 222. freeze_task(task); + 223. + +drivers/gpu/drm/i915/intel_dp_mst.c:245: error: DEAD_STORE + The value written to &ret (type int) is never used. + 243. I915_WRITE(DP_TP_STATUS(port), temp); + 244. + 245. > ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); + 246. } + 247. + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +drivers/pci/pcie/aspm.c:256: error: DEAD_STORE + The value written to &start_jiffies (type unsigned long) is never used. + 254. + 255. /* Wait for link training end. Break out after waiting for timeout */ + 256. > start_jiffies = jiffies; + 257. for (;;) { + 258. pcie_capability_read_word(parent, PCI_EXP_LNKSTA, ®16); + +drivers/pci/pcie/aspm.c:271: error: UNINITIALIZED_VALUE + The value read from child_reg.[_] was never initialized. + 269. pci_err(parent, "ASPM: Could not configure common clock\n"); + 270. list_for_each_entry(child, &linkbus->devices, bus_list) + 271. > pcie_capability_write_word(child, PCI_EXP_LNKCTL, + 272. child_reg[PCI_FUNC(child->devfn)]); + 273. pcie_capability_write_word(parent, PCI_EXP_LNKCTL, parent_reg); + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +kernel/rcu/tree.c:211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 209. unsigned long rcu_rnp_online_cpus(struct rcu_node *rnp) + 210. { + 211. > return READ_ONCE(rnp->qsmaskinitnext); + 212. } + 213. + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +arch/x86/lib/msr-smp.c:221: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 219. *q = rv.reg.q; + 220. + 221. > return err ? err : rv.err; + 222. } + 223. EXPORT_SYMBOL(rdmsrl_safe_on_cpu); + +crypto/algboss.c:213: error: DEAD_STORE + The value written to &type (type unsigned int) is never used. + 211. { + 212. struct crypto_test_param *param = data; + 213. > u32 type = param->type; + 214. int err = 0; + 215. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:224: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 222. */ + 223. ret = wait_for(guc_ready(guc, &status), 100); + 224. > DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + 226. if ((status & GS_BOOTROM_MASK) == GS_BOOTROM_RSA_FAILED) { + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +net/core/dst.c:222: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 220. + 221. new = (unsigned long) p; + 222. > prev = cmpxchg(&dst->_metrics, old, new); + 223. + 224. if (prev != old) { + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/video/fbdev/core/fbcvt.c:261: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 259. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. > cnt -= read; + 262. offset += read; + 263. } + +drivers/video/fbdev/core/fbcvt.c:262: error: DEAD_STORE + The value written to &offset (type int) is never used. + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. cnt -= read; + 262. > offset += read; + 263. } + 264. } + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +drivers/ata/libata-sff.c:223: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 221. status = ata_sff_busy_wait(ap, ATA_BUSY, 300); + 222. timer_start = jiffies; + 223. > timeout = ata_deadline(timer_start, tmout_pat); + 224. while (status != 0xff && (status & ATA_BUSY) && + 225. time_before(jiffies, timeout)) { + +drivers/ata/libata-sff.c:235: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 233. status); + 234. + 235. > timeout = ata_deadline(timer_start, tmout); + 236. while (status != 0xff && (status & ATA_BUSY) && + 237. time_before(jiffies, timeout)) { + +net/ipv6/proc.c:225: error: UNINITIALIZED_VALUE + The value read from buff64.[_] was never initialized. + 223. snmp_get_cpu_field64_batch(buff64, itemlist, mib, syncpoff); + 224. for (i = 0; itemlist[i].name; i++) + 225. > seq_printf(seq, "%-32s\t%llu\n", itemlist[i].name, buff64[i]); + 226. } + 227. + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +net/wireless/trace.h:217: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +net/core/sock_reuseport.c:236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 234. + 235. prog = rcu_dereference(reuse->prog); + 236. > socks = READ_ONCE(reuse->num_socks); + 237. if (likely(socks)) { + 238. /* paired with smp_wmb() in reuseport_add_sock() */ + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +drivers/scsi/scsi_logging.c:249: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 247. if (cmd->cmd_len > 16) { + 248. /* Print opcode in one line and use separate lines for CDB */ + 249. > off += scnprintf(logbuf + off, logbuf_len - off, "\n"); + 250. dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf); + 251. scsi_log_release_buffer(logbuf); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +security/selinux/ss/conditional.c:245: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 243. goto err; + 244. + 245. > len = le32_to_cpu(buf[2]); + 246. if (((len == 0) || (len == (u32)-1))) + 247. goto err; + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +arch/x86/events/intel/bts.c:232: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 229 could be null and is dereferenced at line 232, column 7. + 230. u64 config = 0; + 231. + 232. > if (!buf->snapshot) + 233. config |= ARCH_PERFMON_EVENTSEL_INT; + 234. if (!event->attr.exclude_kernel) + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +net/ipv4/inet_hashtables.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. score += 4; + 250. } + 251. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 252. score++; + 253. } + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = READ_ONCE(table->private); /* Address dependency. */ + 264. > cpu = smp_processor_id(); + 265. table_base = private->entries; + 266. jumpstack = (struct ipt_entry **)private->jumpstack[cpu]; + +net/ipv4/netfilter/ip_tables.c:276: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 274. */ + 275. if (static_key_false(&xt_tee_enabled)) + 276. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 277. + 278. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = READ_ONCE(table->private); /* Address dependency. */ + 264. > cpu = smp_processor_id(); + 265. table_base = private->entries; + 266. jumpstack = (struct ipt_entry **)private->jumpstack[cpu]; + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:233: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 230 could be null and is dereferenced at line 233, column 6. + 231. struct intel_panel *panel = &connector->panel; + 232. + 233. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) + 234. panel->backlight.max = 0xFFFF; + 235. else + +lib/rhashtable.c:261: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 259. + 260. spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING); + 261. > head = rht_dereference_bucket(new_tbl->buckets[new_hash], + 262. new_tbl, new_hash); + 263. + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +kernel/rcu/tree.c:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. { + 232. RCU_LOCKDEP_WARN(preemptible(), "rcu_sched_qs() invoked with preemption enabled!!!"); + 233. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + +kernel/rcu/tree.c:236: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + 236. > __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + 239. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 240. return; + 241. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.exp, false); + +kernel/rcu/tree.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. > trace_rcu_grace_period(TPS("rcu_sched"), + 236. __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + +block/blk-lib.c:253: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 252 could be null and is dereferenced at line 253, column 3. + 251. while (nr_sects) { + 252. bio = next_bio(bio, 0, gfp_mask); + 253. > bio->bi_iter.bi_sector = sector; + 254. bio_set_dev(bio, bdev); + 255. bio->bi_opf = REQ_OP_WRITE_ZEROES; + +drivers/video/backlight/backlight.c:234: error: DEAD_STORE + The value written to &rc (type int) is never used. + 232. struct device_attribute *attr, char *buf) + 233. { + 234. > int rc = -ENXIO; + 235. struct backlight_device *bd = to_backlight_device(dev); + 236. + +sound/hda/hdac_controller.c:239: error: DEAD_STORE + The value written to &loopcounter (type unsigned long) is never used. + 237. timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. > for (loopcounter = 0;; loopcounter++) { + 240. spin_lock_irq(&bus->reg_lock); + 241. if (!bus->rirb.cmds[addr]) { + +sound/hda/hdac_controller.c:237: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 235. unsigned long loopcounter; + 236. + 237. > timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. for (loopcounter = 0;; loopcounter++) { + +kernel/rcu/srcutree.c:238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 236. WARN_ON_ONCE(rcu_scheduler_active == RCU_SCHEDULER_INIT); + 237. /* The smp_load_acquire() pairs with the smp_store_release(). */ + 238. > if (!rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq_needed))) /*^^^*/ + 239. return; /* Already initialized. */ + 240. spin_lock_irqsave_rcu_node(sp, flags); + +block/ioctl.c:246: error: UNINITIALIZED_VALUE + The value read from range.[_] was never initialized. + 244. return -EFAULT; + 245. + 246. > start = range[0]; + 247. len = range[1]; + 248. end = start + len - 1; + +block/ioctl.c:247: error: UNINITIALIZED_VALUE + The value read from range.[_] was never initialized. + 245. + 246. start = range[0]; + 247. > len = range[1]; + 248. end = start + len - 1; + 249. + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +drivers/gpu/drm/i915/i915_debugfs.c:245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 243. int ret; + 244. + 245. > total = READ_ONCE(dev_priv->mm.object_count); + 246. objects = kvmalloc_array(total, sizeof(*objects), GFP_KERNEL); + 247. if (!objects) + +security/selinux/ss/mls.c:366: error: DEAD_STORE + The value written to &p (type char*) is never used. + 364. goto out; + 365. } + 366. > *scontext = ++p; + 367. rc = 0; + 368. out: + +drivers/gpu/drm/i915/intel_hdmi.c:248: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 240 could be null and is dereferenced at line 248, column 37. + 246. return false; + 247. + 248. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 249. return false; + 250. + +drivers/video/fbdev/core/bitblit.c:252: error: DEAD_STORE + The value written to &mode (type int) is never used. + 250. if (softback_lines) { + 251. if (y + softback_lines >= vc->vc_rows) { + 252. > mode = CM_ERASE; + 253. ops->cursor_flash = 0; + 254. return; + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +drivers/firmware/efi/esrt.c:305: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_count was never initialized. + 303. */ + 304. if (tmpesrt.fw_resource_count > 128) { + 305. > pr_err("ESRT says fw_resource_count has very large value %d.\n", + 306. tmpesrt.fw_resource_count); + 307. goto err_memunmap; + +drivers/firmware/efi/esrt.c:286: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_version was never initialized. + 284. entry_size = sizeof (*v1_entries); + 285. } else { + 286. > pr_err("Unsupported ESRT version %lld.\n", + 287. tmpesrt.fw_resource_version); + 288. return; + +lib/sbitmap.c:246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 244. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. > unsigned long word = READ_ONCE(sb->map[i].word); + 247. unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + +lib/sbitmap.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. unsigned long word = READ_ONCE(sb->map[i].word); + 247. > unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + 249. while (word_bits > 0) { + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +net/core/dst.c:245: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 243. + 244. new = ((unsigned long) &dst_default_metrics) | DST_METRICS_READ_ONLY; + 245. > prev = cmpxchg(&dst->_metrics, old, new); + 246. if (prev == old) + 247. kfree(__DST_METRICS_PTR(old)); + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +kernel/kexec.c:265: error: UNINITIALIZED_VALUE + The value read from in.buf was never initialized. + 263. return -EFAULT; + 264. + 265. > out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + +kernel/kexec.c:266: error: UNINITIALIZED_VALUE + The value read from in.bufsz was never initialized. + 264. + 265. out.buf = compat_ptr(in.buf); + 266. > out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. out.memsz = in.memsz; + +kernel/kexec.c:267: error: UNINITIALIZED_VALUE + The value read from in.mem was never initialized. + 265. out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. > out.mem = in.mem; + 268. out.memsz = in.memsz; + 269. + +kernel/kexec.c:268: error: UNINITIALIZED_VALUE + The value read from in.memsz was never initialized. + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. > out.memsz = in.memsz; + 269. + 270. result = copy_to_user(&ksegments[i], &out, sizeof(out)); + +lib/random32.c:250: error: UNINITIALIZED_VALUE + The value read from seeds.[_] was never initialized. + 248. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. > state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + +lib/random32.c:251: error: UNINITIALIZED_VALUE + The value read from seeds.[_] was never initialized. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. state->s1 = __seed(seeds[0], 2U); + 251. > state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + +lib/random32.c:252: error: UNINITIALIZED_VALUE + The value read from seeds.[_] was never initialized. + 250. state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. > state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + 254. + +lib/random32.c:253: error: UNINITIALIZED_VALUE + The value read from seeds.[_] was never initialized. + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. > state->s4 = __seed(seeds[3], 128U); + 254. + 255. prandom_warmup(state); + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +net/sunrpc/auth_gss/gss_rpc_xdr.c:253: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 251. if (unlikely(p == NULL)) + 252. return -ENOSPC; + 253. > count = be32_to_cpup(p++); + 254. if (!count) + 255. return 0; + +kernel/softirq.c:244: error: DEAD_STORE + The value written to &end (type unsigned long) is never used. + 242. asmlinkage __visible void __softirq_entry __do_softirq(void) + 243. { + 244. > unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. int max_restart = MAX_SOFTIRQ_RESTART; + +kernel/softirq.c:246: error: DEAD_STORE + The value written to &max_restart (type int) is never used. + 244. unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. > int max_restart = MAX_SOFTIRQ_RESTART; + 247. struct softirq_action *h; + 248. bool in_hardirq; + +kernel/softirq.c:303: error: DEAD_STORE + The value written to &max_restart (type int) is never used. + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + 303. > --max_restart) + 304. goto restart; + 305. + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/md/dm-stripe.c:255: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 253. sector = *result; + 254. if (sc->chunk_size_shift < 0) + 255. > *result -= sector_div(sector, sc->chunk_size); + 256. else + 257. *result = sector & ~(sector_t)(sc->chunk_size - 1); + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +arch/x86/events/intel/uncore.c:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. box = container_of(hrtimer, struct intel_uncore_box, hrtimer); + 252. > if (!box->n_active || box->cpu != smp_processor_id()) + 253. return HRTIMER_NORESTART; + 254. /* + +init/main.c:254: error: DEAD_STORE + The value written to &val (type char*) is never used. + 252. val[-2] = '='; + 253. memmove(val-1, val, strlen(val)+1); + 254. > val--; + 255. } else + 256. BUG(); + +kernel/cgroup/freezer.c:253: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 246 could be null and is dereferenced at line 253, column 8. + 251. lockdep_assert_held(&freezer_mutex); + 252. + 253. > if (!(freezer->state & CGROUP_FREEZING) || + 254. (freezer->state & CGROUP_FROZEN)) + 255. return; + +net/ipv6/inet6_hashtables.c:255: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 253. struct net *net = sock_net(sk); + 254. const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + 257. inet->inet_dport); + +net/ipv6/inet6_hashtables.c:254: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 252. const int dif = sk->sk_bound_dev_if; + 253. struct net *net = sock_net(sk); + 254. > const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + +net/packet/af_packet.c:265: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 263. local_bh_disable(); + 264. + 265. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 266. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 267. ret = netdev_start_xmit(skb, dev, txq, false); + +net/packet/af_packet.c:265: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 263. local_bh_disable(); + 264. + 265. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 266. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 267. ret = netdev_start_xmit(skb, dev, txq, false); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:254: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 249 could be null and is dereferenced at line 254, column 6. + 252. * the panel can support backlight control over the aux channel + 253. */ + 254. > if (intel_dp->edp_dpcd[1] & DP_EDP_TCON_BACKLIGHT_ADJUSTMENT_CAP && + 255. (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP) && + 256. !(intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_PWM_PIN_CAP)) { + +kernel/profile.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. + 250. mutex_lock(&profile_flip_mutex); + 251. > j = per_cpu(cpu_profile_flip, get_cpu()); + 252. put_cpu(); + 253. on_each_cpu(__profile_flip_buffers, NULL, 1); + +kernel/rcu/tree.c:249: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 247. { + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. > if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + +kernel/rcu/tree.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. > __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + 253. __this_cpu_write(rcu_bh_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. > trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + +arch/x86/entry/common.c:249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 247. { + 248. struct thread_info *ti = current_thread_info(); + 249. > u32 cached_flags = READ_ONCE(ti->flags); + 250. + 251. CT_WARN_ON(ct_state() != CONTEXT_KERNEL); + +drivers/net/ethernet/intel/e1000e/ptp.c:256: error: UNINITIALIZED_VALUE + The value read from ts.tv_nsec was never initialized. + 254. adapter->ptp_clock_info.gettime64(&adapter->ptp_clock_info, &ts); + 255. + 256. > e_dbg("SYSTIM overflow check at %lld.%09lu\n", + 257. (long long) ts.tv_sec, ts.tv_nsec); + 258. + +drivers/net/ethernet/intel/e1000e/ptp.c:256: error: UNINITIALIZED_VALUE + The value read from ts.tv_sec was never initialized. + 254. adapter->ptp_clock_info.gettime64(&adapter->ptp_clock_info, &ts); + 255. + 256. > e_dbg("SYSTIM overflow check at %lld.%09lu\n", + 257. (long long) ts.tv_sec, ts.tv_nsec); + 258. + +drivers/gpu/drm/i915/intel_dp_mst.c:268: error: DEAD_STORE + The value written to &ret (type int) is never used. + 266. DRM_ERROR("Timed out waiting for ACT sent\n"); + 267. + 268. > ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + +drivers/gpu/drm/i915/intel_dp_mst.c:270: error: DEAD_STORE + The value written to &ret (type int) is never used. + 268. ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. > ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + 271. if (pipe_config->has_audio) + 272. intel_audio_codec_enable(encoder, pipe_config, conn_state); + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +kernel/kprobes.c:277: error: UNINITIALIZED_VALUE + The value read from idx was never initialized. + 275. collect_garbage_slots(c); + 276. } else { + 277. > collect_one_slot(kip, idx); + 278. } + 279. } + +lib/iomap.c:250: error: DEAD_STORE + The value written to &port (type unsigned long) is never used. + 248. void pci_iounmap(struct pci_dev *dev, void __iomem * addr) + 249. { + 250. > IO_COND(addr, /* nothing */, iounmap(addr)); + 251. } + 252. EXPORT_SYMBOL(pci_iounmap); + +sound/core/pcm_native.c:268: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 266. + 267. if (trace_hw_mask_param_enabled()) + 268. > old_mask = *m; + 269. + 270. changed = snd_mask_refine(m, constrs_mask(constrs, k)); + +net/sunrpc/auth_gss/gss_rpc_upcall.c:271: error: UNINITIALIZED_VALUE + The value read from arg was never initialized. + 269. .output_token = &data->out_token + 270. }; + 271. > struct rpc_message msg = { + 272. .rpc_proc = &gssp_procedures[GSSX_ACCEPT_SEC_CONTEXT], + 273. .rpc_argp = &arg, + +net/sunrpc/auth_gss/gss_rpc_upcall.c:271: error: UNINITIALIZED_VALUE + The value read from res was never initialized. + 269. .output_token = &data->out_token + 270. }; + 271. > struct rpc_message msg = { + 272. .rpc_proc = &gssp_procedures[GSSX_ACCEPT_SEC_CONTEXT], + 273. .rpc_argp = &arg, + +drivers/gpu/drm/i915/intel_guc_log.c:280: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.read_ptr was never initialized. + 278. sizeof(struct guc_log_buffer_state)); + 279. buffer_size = guc_get_log_buffer_size(type); + 280. > read_offset = log_buf_state_local.read_ptr; + 281. write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + +drivers/gpu/drm/i915/intel_guc_log.c:281: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.sampled_write_ptr was never initialized. + 279. buffer_size = guc_get_log_buffer_size(type); + 280. read_offset = log_buf_state_local.read_ptr; + 281. > write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + 283. + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +net/ipv6/netfilter/ip6_tables.c:286: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 284. addend = xt_write_recseq_begin(); + 285. private = READ_ONCE(table->private); /* Address dependency. */ + 286. > cpu = smp_processor_id(); + 287. table_base = private->entries; + 288. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +net/ipv6/netfilter/ip6_tables.c:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. */ + 297. if (static_key_false(&xt_tee_enabled)) + 298. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 299. + 300. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv6/netfilter/ip6_tables.c:286: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 284. addend = xt_write_recseq_begin(); + 285. private = READ_ONCE(table->private); /* Address dependency. */ + 286. > cpu = smp_processor_id(); + 287. table_base = private->entries; + 288. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +drivers/gpu/drm/drm_ioc32.c:263: error: UNINITIALIZED_VALUE + The value read from c32.idx was never initialized. + 261. return -EFAULT; + 262. + 263. > client.idx = c32.idx; + 264. + 265. err = drm_ioctl_kernel(file, drm_getclient, &client, DRM_UNLOCKED); + +drivers/gpu/drm/drm_ioc32.c:270: error: UNINITIALIZED_VALUE + The value read from client.auth was never initialized. + 268. + 269. c32.idx = client.idx; + 270. > c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + +drivers/gpu/drm/drm_ioc32.c:274: error: UNINITIALIZED_VALUE + The value read from client.iocs was never initialized. + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. > c32.iocs = client.iocs; + 275. + 276. if (copy_to_user(argp, &c32, sizeof(c32))) + +drivers/gpu/drm/drm_ioc32.c:273: error: UNINITIALIZED_VALUE + The value read from client.magic was never initialized. + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. > c32.magic = client.magic; + 274. c32.iocs = client.iocs; + 275. + +drivers/gpu/drm/drm_ioc32.c:271: error: UNINITIALIZED_VALUE + The value read from client.pid was never initialized. + 269. c32.idx = client.idx; + 270. c32.auth = client.auth; + 271. > c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + +drivers/gpu/drm/drm_ioc32.c:272: error: UNINITIALIZED_VALUE + The value read from client.uid was never initialized. + 270. c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. > c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. c32.iocs = client.iocs; + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +kernel/sched/core.c:257: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 255. struct rq_flags rf; + 256. + 257. > WARN_ON_ONCE(cpu_of(rq) != smp_processor_id()); + 258. + 259. rq_lock(rq, &rf); + +net/netfilter/nf_conntrack_core.c:274: error: UNINITIALIZED_VALUE + The value read from protoff was never initialized. + 272. l4proto = __nf_ct_l4proto_find(l3num, protonum); + 273. + 274. > ret = nf_ct_get_tuple(skb, nhoff, protoff, l3num, protonum, net, tuple, + 275. l3proto, l4proto); + 276. + +net/netfilter/nf_conntrack_core.c:272: error: UNINITIALIZED_VALUE + The value read from protonum was never initialized. + 270. } + 271. + 272. > l4proto = __nf_ct_l4proto_find(l3num, protonum); + 273. + 274. ret = nf_ct_get_tuple(skb, nhoff, protoff, l3num, protonum, net, tuple, + +net/netfilter/nf_conntrack_core.c:274: error: UNINITIALIZED_VALUE + The value read from protonum was never initialized. + 272. l4proto = __nf_ct_l4proto_find(l3num, protonum); + 273. + 274. > ret = nf_ct_get_tuple(skb, nhoff, protoff, l3num, protonum, net, tuple, + 275. l3proto, l4proto); + 276. + +sound/hda/hdac_sysfs.c:264: error: UNINITIALIZED_VALUE + The value read from list.[_] was never initialized. + 262. return nconns; + 263. for (i = 0; i < nconns; i++) + 264. > ret += sprintf(buf + ret, "%s0x%02x", i ? " " : "", list[i]); + 265. ret += sprintf(buf + ret, "\n"); + 266. return ret; + +drivers/cpufreq/acpi-cpufreq.c:258: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 256. u32 val, dummy; + 257. + 258. > rdmsr(MSR_IA32_PERF_CTL, val, dummy); + 259. return val; + 260. } + +security/keys/request_key.c:272: error: NULL_DEREFERENCE + pointer `cred` last assigned on line 257 could be null and is dereferenced at line 272, column 11. + 270. /* use a default keyring; falling through the cases until we + 271. * find one that we actually have */ + 272. > switch (cred->jit_keyring) { + 273. case KEY_REQKEY_DEFL_DEFAULT: + 274. case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: + +net/ipv6/xfrm6_policy.c:274: error: NULL_DEREFERENCE + pointer `xdst` last assigned on line 273 could be null and is dereferenced at line 274, column 12. + 272. in6_dev_hold(loopback_idev); + 273. xdst = (struct xfrm_dst *)xfrm_dst_child(&xdst->u.dst); + 274. > } while (xdst->u.dst.xfrm); + 275. + 276. __in6_dev_put(loopback_idev); + +net/wireless/trace.h:255: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +arch/x86/include/asm/tlbflush.h:263: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 261. + 262. local_irq_save(flags); + 263. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 264. if ((cr4 | mask) != cr4) + 265. __cr4_set(cr4 | mask); + +arch/x86/include/asm/tlbflush.h:263: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 261. + 262. local_irq_save(flags); + 263. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 264. if ((cr4 | mask) != cr4) + 265. __cr4_set(cr4 | mask); + +net/ipv4/sysctl_net_ipv4.c:281: error: UNINITIALIZED_VALUE + The value read from user_key.[_] was never initialized. + 279. rcu_read_unlock(); + 280. + 281. > snprintf(tbl.data, tbl.maxlen, "%08x-%08x-%08x-%08x", + 282. user_key[0], user_key[1], user_key[2], user_key[3]); + 283. ret = proc_dostring(&tbl, write, buffer, lenp, ppos); + +net/ipv4/sysctl_net_ipv4.c:296: error: UNINITIALIZED_VALUE + The value read from user_key.[_] was never initialized. + 294. + 295. bad_key: + 296. > pr_debug("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n", + 297. user_key[0], user_key[1], user_key[2], user_key[3], + 298. (char *)tbl.data, ret); + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +drivers/gpu/drm/i915/intel_uc.c:359: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 357. ret = -EINVAL; + 358. + 359. > dev_err(dev_priv->drm.dev, "GuC initialization failed %d\n", ret); + 360. return ret; + 361. } + +drivers/gpu/drm/i915/intel_uc.c:360: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 358. + 359. dev_err(dev_priv->drm.dev, "GuC initialization failed %d\n", ret); + 360. > return ret; + 361. } + 362. + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +drivers/tty/serial/serial_core.c:283: error: NULL_DEREFERENCE + pointer `uport` last assigned on line 264 could be null and is dereferenced by call to `uart_port_dtr_rts()` at line 283, column 4. + 281. + 282. if (!tty || C_HUPCL(tty)) + 283. > uart_port_dtr_rts(uport, 0); + 284. + 285. uart_port_shutdown(port); + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +drivers/gpu/drm/i915/intel_opregion.c:330: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 328. /* Poll for the result. */ + 329. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 330. > if (wait_for(C, dslp)) { + 331. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 332. return -ETIMEDOUT; + +drivers/gpu/drm/i915/intel_opregion.c:330: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 328. /* Poll for the result. */ + 329. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 330. > if (wait_for(C, dslp)) { + 331. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 332. return -ETIMEDOUT; + +drivers/tty/vt/vt_ioctl.c:274: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 272. if (!perm) + 273. return -EPERM; + 274. > return con_set_unimap(vc, tmp.entry_ct, tmp.entries); + 275. case GIO_UNIMAP: + 276. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:278: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 276. if (!perm && fg_console != vc->vc_num) + 277. return -EPERM; + 278. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries); + 279. } + 280. return 0; + +sound/core/pcm_lib.c:408: error: DEAD_STORE + The value written to &hw_base (type unsigned long) is never used. + 406. /* move new_hw_ptr according jiffies not pos variable */ + 407. new_hw_ptr = old_hw_ptr; + 408. > hw_base = delta; + 409. /* use loop to avoid checks for delta overflows */ + 410. /* the delta value is small or zero in most cases */ + +kernel/power/swap.c:273: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 272 could be null and is dereferenced at line 273, column 2. + 271. + 272. bio = bio_alloc(__GFP_RECLAIM | __GFP_HIGH, 1); + 273. > bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >> 9); + 274. bio_set_dev(bio, hib_resume_bdev); + 275. bio_set_op_attrs(bio, op, op_flags); + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +kernel/sched/wait_bit.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. __sched int bit_wait_timeout(struct wait_bit_key *word, int mode) + 267. { + 268. > unsigned long now = READ_ONCE(jiffies); + 269. if (time_after_eq(now, word->timeout)) + 270. return -EAGAIN; + +kernel/irq/matrix.c:280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 278. cm->available--; + 279. m->global_available--; + 280. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 281. } + 282. + +kernel/irq/matrix.c:280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 278. cm->available--; + 279. m->global_available--; + 280. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 281. } + 282. + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +drivers/gpu/drm/drm_crtc_helper.c:281: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 279. bool saved_enabled; + 280. struct drm_encoder *encoder; + 281. > bool ret = true; + 282. + 283. drm_warn_on_modeset_not_all_locked(dev); + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/net/ethernet/intel/e1000e/ethtool.c:321: error: DEAD_STORE + The value written to &advertising (type unsigned int) is never used. + 319. hw->phy.autoneg_advertised = advertising | + 320. ADVERTISED_TP | ADVERTISED_Autoneg; + 321. > advertising = hw->phy.autoneg_advertised; + 322. if (adapter->fc_autoneg) + 323. hw->fc.requested_mode = e1000_fc_default; + +kernel/profile.c:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. + 273. mutex_lock(&profile_flip_mutex); + 274. > i = per_cpu(cpu_profile_flip, get_cpu()); + 275. put_cpu(); + 276. on_each_cpu(__profile_flip_buffers, NULL, 1); + +kernel/time/posix-cpu-timers.c:285: error: UNINITIALIZED_VALUE + The value read from rtn was never initialized. + 283. + 284. if (!err) + 285. > *tp = ns_to_timespec64(rtn); + 286. + 287. return err; + +net/wireless/trace.h:269: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +arch/x86/include/asm/tlbflush.h:275: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 273. + 274. local_irq_save(flags); + 275. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 276. if ((cr4 & ~mask) != cr4) + 277. __cr4_set(cr4 & ~mask); + +arch/x86/include/asm/tlbflush.h:275: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 273. + 274. local_irq_save(flags); + 275. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 276. if ((cr4 & ~mask) != cr4) + 277. __cr4_set(cr4 & ~mask); + +drivers/net/ethernet/intel/e1000/e1000_param.c:283: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 281. struct e1000_tx_ring *tx_ring = adapter->tx_ring; + 282. int i; + 283. > e1000_mac_type mac_type = adapter->hw.mac_type; + 284. + 285. opt = (struct e1000_option) { + +drivers/net/ethernet/intel/e1000/e1000_param.c:311: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 309. struct e1000_rx_ring *rx_ring = adapter->rx_ring; + 310. int i; + 311. > e1000_mac_type mac_type = adapter->hw.mac_type; + 312. + 313. opt = (struct e1000_option) { + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +drivers/cpufreq/acpi-cpufreq.c:275: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 273. u32 val, dummy; + 274. + 275. > rdmsr(MSR_AMD_PERF_CTL, val, dummy); + 276. return val; + 277. } + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +drivers/gpu/drm/i915/intel_uncore.c:278: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 276. * thread to wake up. + 277. */ + 278. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 279. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 280. DRM_ERROR("GT thread status wait timed out\n"); + +drivers/gpu/drm/i915/intel_uncore.c:278: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 276. * thread to wake up. + 277. */ + 278. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 279. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 280. DRM_ERROR("GT thread status wait timed out\n"); + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +drivers/cpufreq/cpufreq_governor.c:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. */ + 297. smp_rmb(); + 298. > lst = READ_ONCE(policy_dbs->last_sample_time); + 299. delta_ns = time - lst; + 300. if ((s64)delta_ns < policy_dbs->sample_delay_ns) + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +drivers/ata/libata-scsi.c:299: error: UNINITIALIZED_VALUE + The value read from ncq_prio_enable was never initialized. + 297. spin_unlock_irq(ap->lock); + 298. + 299. > return rc ? rc : snprintf(buf, 20, "%u\n", ncq_prio_enable); + 300. } + 301. + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +net/ipv6/calipso.c:278: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 276. const struct netlbl_lsm_secattr *secattr) + 277. { + 278. > int ret_val = -EPERM; + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + +drivers/gpu/drm/i915/i915_gem_request.h:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. i915_gem_request_global_seqno(const struct drm_i915_gem_request *request) + 280. { + 281. > return READ_ONCE(request->global_seqno); + 282. } + 283. + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +kernel/sched/wait_bit.c:280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 278. __sched int bit_wait_io_timeout(struct wait_bit_key *word, int mode) + 279. { + 280. > unsigned long now = READ_ONCE(jiffies); + 281. if (time_after_eq(now, word->timeout)) + 282. return -EAGAIN; + +scripts/kconfig/symbol.c:290: error: NULL_DEREFERENCE + pointer `def_sym` last assigned on line 289 could be null and is dereferenced at line 290, column 7. + 288. continue; + 289. def_sym = prop_get_symbol(prop); + 290. > if (def_sym->visible != no) + 291. return def_sym; + 292. } + +sound/hda/hdac_regmap.c:348: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 346. out: + 347. codec_pm_unlock(codec, pm_lock); + 348. > return err; + 349. } + 350. + +drivers/video/fbdev/core/fbmem.c:286: error: DEAD_STORE + The value written to &fg (type unsigned char) is never used. + 284. const u8 *src = logo->data; + 285. u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0; + 286. > u8 fg = 1, d; + 287. + 288. switch (fb_get_color_depth(&info->var, &info->fix)) { + +include/linux/seqlock.h:282: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 280. { + 281. /* Pairs with the first smp_wmb() in raw_write_seqcount_latch() */ + 282. > int seq = READ_ONCE(s->sequence); /* ^^^ */ + 283. return seq; + 284. } + +kernel/stop_machine.c:292: error: UNINITIALIZED_VALUE + The value read from msdata was never initialized. + 290. }; + 291. + 292. > work1 = work2 = (struct cpu_stop_work){ + 293. .fn = multi_cpu_stop, + 294. .arg = &msdata, + +kernel/sched/cpuacct.c:301: error: UNINITIALIZED_VALUE + The value read from val.[_] was never initialized. + 299. seq_printf(sf, "%s %lld\n", + 300. cpuacct_stat_desc[stat], + 301. > (long long)nsec_to_clock_t(val[stat])); + 302. } + 303. + +net/wireless/trace.h:281: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 279. ); + 280. + 281. > DECLARE_EVENT_CLASS(wiphy_only_evt, + 282. TP_PROTO(struct wiphy *wiphy), + 283. TP_ARGS(wiphy), + +drivers/cpuidle/governors/menu.c:294: error: NULL_DEREFERENCE + pointer `device` last assigned on line 286 could be null and is dereferenced by call to `dev_pm_qos_raw_read_value()` at line 294, column 23. + 292. unsigned int expected_interval; + 293. unsigned long nr_iowaiters, cpu_load; + 294. > int resume_latency = dev_pm_qos_raw_read_value(device); + 295. + 296. if (data->needs_update) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +sound/core/pcm_native.c:304: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 302. + 303. if (trace_hw_interval_param_enabled()) + 304. > old_interval = *i; + 305. + 306. changed = snd_interval_refine(i, constrs_interval(constrs, k)); + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +security/selinux/ss/services.c:456: error: UNINITIALIZED_VALUE + The value read from s.[_] was never initialized. + 454. + 455. BUG_ON(sp != 0); + 456. > return s[0]; + 457. } + 458. + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +block/blk-lib.c:305: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 303 could be null and is dereferenced at line 305, column 3. + 303. bio = next_bio(bio, __blkdev_sectors_to_bio_pages(nr_sects), + 304. gfp_mask); + 305. > bio->bi_iter.bi_sector = sector; + 306. bio_set_dev(bio, bdev); + 307. bio_set_op_attrs(bio, REQ_OP_WRITE, 0); + +drivers/dma-buf/reservation.c:343: error: DEAD_STORE + The value written to &new (type dma_fence*) is never used. + 341. } + 342. + 343. > new = dma_fence_get_rcu_safe(&src->fence_excl); + 344. rcu_read_unlock(); + 345. + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +drivers/gpu/drm/drm_fb_helper.c:291: error: DEAD_STORE + The value written to &helper (type drm_fb_helper*) is never used. + 289. int drm_fb_helper_debug_enter(struct fb_info *info) + 290. { + 291. > struct drm_fb_helper *helper = info->par; + 292. const struct drm_crtc_helper_funcs *funcs; + 293. int i; + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +net/netlabel/netlabel_calipso.c:295: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 293. static int netlbl_calipso_remove(struct sk_buff *skb, struct genl_info *info) + 294. { + 295. > int ret_val = -EINVAL; + 296. struct netlbl_domhsh_walk_arg cb_arg; + 297. struct netlbl_audit audit_info; + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +kernel/locking/qspinlock.c:467: error: UNINITIALIZED_VALUE + The value read from VAL was never initialized. + 465. goto locked; + 466. + 467. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 468. + 469. locked: + +kernel/locking/qspinlock.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. * implementations imply full barriers. + 361. */ + 362. > smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_MASK)); + 363. + 364. /* + +kernel/locking/qspinlock.c:430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 428. + 429. pv_wait_node(node, prev); + 430. > arch_mcs_spin_lock_contended(&node->locked); + 431. + 432. /* + +kernel/locking/qspinlock.c:467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 465. goto locked; + 466. + 467. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 468. + 469. locked: + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +arch/x86/platform/efi/efi.c:342: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 340. efi_systab.tables = data ? (unsigned long)data->tables : + 341. systab64->tables; + 342. > tmp |= data ? data->tables : systab64->tables; + 343. + 344. early_memunmap(systab64, sizeof(*systab64)); + +drivers/char/hw_random/core.c:297: error: DEAD_STORE + The value written to &ret (type int) is never used. + 295. static int enable_best_rng(void) + 296. { + 297. > int ret = -ENODEV; + 298. + 299. BUG_ON(!mutex_is_locked(&rng_mutex)); + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/intel_i2c.c:312: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_lpe_audio.c:302: error: DEAD_STORE + The value written to &desc (type irq_desc*) is never used. + 300. return; + 301. + 302. > desc = irq_to_desc(dev_priv->lpe_audio.irq); + 303. + 304. lpe_audio_platdev_destroy(dev_priv); + +drivers/md/dm-io.c:314: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 314, column 29. + 312. */ + 313. if (op == REQ_OP_DISCARD) + 314. > special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + +drivers/md/dm-io.c:316: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 316, column 29. + 314. special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. > special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. special_cmd_max_sectors = q->limits.max_write_same_sectors; + +drivers/md/dm-io.c:318: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 318, column 29. + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. > special_cmd_max_sectors = q->limits.max_write_same_sectors; + 319. if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES || + 320. op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) { + +drivers/md/dm-io.c:375: error: UNINITIALIZED_VALUE + The value read from len was never initialized. + 373. */ + 374. dp->get_page(dp, &page, &len, &offset); + 375. > len = min(len, to_bytes(remaining)); + 376. if (!bio_add_page(bio, page, len, offset)) + 377. break; + +drivers/md/dm-io.c:363: error: UNINITIALIZED_VALUE + The value read from offset was never initialized. + 361. */ + 362. dp->get_page(dp, &page, &len, &offset); + 363. > bio_add_page(bio, page, logical_block_size, offset); + 364. num_sectors = min_t(sector_t, special_cmd_max_sectors, remaining); + 365. bio->bi_iter.bi_size = num_sectors << SECTOR_SHIFT; + +drivers/md/dm-io.c:376: error: UNINITIALIZED_VALUE + The value read from offset was never initialized. + 374. dp->get_page(dp, &page, &len, &offset); + 375. len = min(len, to_bytes(remaining)); + 376. > if (!bio_add_page(bio, page, len, offset)) + 377. break; + 378. + +usr/gen_init_cpio.c:303: error: DEAD_STORE + The value written to &file (type int) is never used. + 301. struct stat buf; + 302. long size; + 303. > int file = -1; + 304. int retval; + 305. int rc = -1; + +net/ipv6/sit.c:329: error: DEAD_STORE + The value written to &ret (type int) is never used. + 327. kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC); + 328. if (!kp) { + 329. > ret = -ENOMEM; + 330. goto out; + 331. } + +drivers/char/hpet.c:335: error: UNINITIALIZED_VALUE + The value read from data was never initialized. + 333. } + 334. + 335. > retval = put_user(data, (unsigned long __user *)buf); + 336. if (!retval) + 337. retval = sizeof(unsigned long); + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +arch/x86/events/intel/bts.c:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 303. struct bts_buffer *buf = NULL; + 304. > int state = READ_ONCE(bts->state); + 305. + 306. if (state == BTS_STATE_ACTIVE) + +drivers/gpu/drm/i915/intel_uncore.c:311: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 309. + 310. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 311. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 312. GT_FIFO_NUM_RESERVED_ENTRIES, + 313. GT_FIFO_TIMEOUT_MS)) { + +drivers/gpu/drm/i915/intel_uncore.c:311: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 309. + 310. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 311. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 312. GT_FIFO_NUM_RESERVED_ENTRIES, + 313. GT_FIFO_TIMEOUT_MS)) { + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +net/sched/sch_generic.c:325: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 323. + 324. if (likely(skb)) { + 325. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 326. if (!netif_xmit_frozen_or_stopped(txq)) + 327. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +net/sched/sch_generic.c:325: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 323. + 324. if (likely(skb)) { + 325. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 326. if (!netif_xmit_frozen_or_stopped(txq)) + 327. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +include/net/inet_sock.h:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. { + 303. /* state change might impact lockless readers. */ + 304. > return smp_load_acquire(&sk->sk_state); + 305. } + 306. + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +scripts/kconfig/symbol.c:314: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 313 could be null and is dereferenced at line 314, column 2. + 312. flags = sym->flags; + 313. prop = sym_get_choice_prop(sym); + 314. > expr_list_for_each_sym(prop->expr, e, def_sym) { + 315. sym_calc_visibility(def_sym); + 316. if (def_sym->visible != no) + +drivers/edac/edac_mc.c:345: error: DEAD_STORE + The value written to &mci (type mem_ctl_info*) is never used. + 343. * hardcode everything into a single struct. + 344. */ + 345. > mci = edac_align_ptr(&ptr, sizeof(*mci), 1); + 346. layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers); + 347. for (i = 0; i < n_layers; i++) { + +drivers/edac/edac_mc.c:431: error: UNINITIALIZED_VALUE + The value read from pos.[_] was never initialized. + 429. for (i = 0; i < tot_dimms; i++) { + 430. chan = mci->csrows[row]->channels[chn]; + 431. > off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]); + 432. if (off < 0 || off >= tot_dimms) { + 433. edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n"); + +drivers/edac/edac_mc.c:452: error: UNINITIALIZED_VALUE + The value read from pos.[_] was never initialized. + 450. len -= n; + 451. for (j = 0; j < n_layers; j++) { + 452. > n = snprintf(p, len, "%s#%u", + 453. edac_layer_name[layers[j].type], + 454. pos[j]); + +drivers/gpu/drm/drm_lock.c:316: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 314. do { + 315. old = *lock; + 316. > prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT); + 317. } while (prev != old); + 318. wake_up_interruptible(&lock_data->lock_queue); + +kernel/printk/printk_safe.c:313: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 311. * the lock must be taken on another CPU and we could wait for it. + 312. */ + 313. > if ((this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) && + 314. raw_spin_is_locked(&logbuf_lock)) { + 315. this_cpu_or(printk_context, PRINTK_NMI_CONTEXT_MASK); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:316: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 314. if (unlikely(p == NULL)) + 315. return -ENOSPC; + 316. > p = xdr_decode_hyper(p, &status->major_status); + 317. + 318. /* status->mech */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:327: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 325. if (unlikely(p == NULL)) + 326. return -ENOSPC; + 327. > p = xdr_decode_hyper(p, &status->minor_status); + 328. + 329. /* status->major_status_string */ + +drivers/power/supply/power_supply_core.c:317: error: UNINITIALIZED_VALUE + The value read from ret.intval was never initialized. + 315. if (!epsy->desc->get_property(epsy, POWER_SUPPLY_PROP_ONLINE, + 316. &ret)) + 317. > return ret.intval; + 318. } + 319. + +kernel/reboot.c:315: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 310 could be null and is dereferenced at line 315, column 18. + 313. + 314. /* We only trust the superuser with rebooting the system. */ + 315. > if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT)) + 316. return -EPERM; + 317. + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +drivers/gpu/drm/i915/intel_pm.c:324: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 322. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 323. + 324. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 325. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 326. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +drivers/gpu/drm/i915/intel_pm.c:324: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 322. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 323. + 324. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 325. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 326. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +kernel/sched/loadavg.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. long delta, active, n; + 314. + 315. > sample_window = READ_ONCE(calc_load_update); + 316. if (!time_before(jiffies, sample_window + 10)) { + 317. /* + +net/ipv4/cipso_ipv4.c:314: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 312. const struct netlbl_lsm_secattr *secattr) + 313. { + 314. > int ret_val = -EPERM; + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + +net/packet/af_packet.c:313: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 311. static u16 __packet_pick_tx_queue(struct net_device *dev, struct sk_buff *skb) + 312. { + 313. > return (u16) raw_smp_processor_id() % dev->real_num_tx_queues; + 314. } + 315. + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.agp_start was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.count was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.flags was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.high_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.low_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.size was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/pci/pcie/portdrv_core.c:350: error: UNINITIALIZED_VALUE + The value read from irqs.[_] was never initialized. + 348. if (!(capabilities & service)) + 349. continue; + 350. > if (!pcie_device_init(dev, service, irqs[i])) + 351. nr_service++; + 352. } + +net/netfilter/nf_conntrack_core.c:318: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 316. + 317. /* add this conntrack to the (per cpu) dying list */ + 318. > ct->cpu = smp_processor_id(); + 319. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 320. + +net/wireless/trace.h:313: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 311. ); + 312. + 313. > DECLARE_EVENT_CLASS(wiphy_enabled_evt, + 314. TP_PROTO(struct wiphy *wiphy, bool enabled), + 315. TP_ARGS(wiphy, enabled), + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +kernel/params.c:322: error: UNINITIALIZED_VALUE + The value read from new_value was never initialized. + 320. struct kernel_param dummy_kp = *kp; + 321. + 322. > dummy_kp.arg = &new_value; + 323. + 324. err = param_set_bool(val, &dummy_kp); + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +drivers/char/agp/isoch.c:336: error: DEAD_STORE + The value written to &arqsz (type unsigned int) is never used. + 334. return -ENODEV; + 335. + 336. > arqsz = (tstatus >> 13) & 0x7; + 337. + 338. /* + +kernel/rcu/tree_exp.h:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. rnp = rdp->mynode; + 325. if (!(READ_ONCE(rnp->expmask) & rdp->grpmask) || + 326. > __this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 327. return; + 328. if (rcu_is_cpu_rrupt_from_idle()) { + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +net/core/netpoll.c:322: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 320. + 321. list_for_each_entry(napi, &dev->napi_list, dev_list) { + 322. > if (napi->poll_owner == smp_processor_id()) + 323. return 1; + 324. } + +drivers/char/hw_random/core.c:322: error: DEAD_STORE + The value written to &err (type int) is never used. + 320. const char *buf, size_t len) + 321. { + 322. > int err = -ENODEV; + 323. struct hwrng *rng; + 324. + +net/ipv6/mcast.c:427: error: DEAD_STORE + The value written to &rv (type int) is never used. + 425. pmc->sflist = psl = newpsl; + 426. } + 427. > rv = 1; /* > 0 for insert logic below if sl_count is 0 */ + 428. for (i = 0; i < psl->sl_count; i++) { + 429. rv = !ipv6_addr_equal(&psl->sl_addr[i], source); + +net/compat.c:330: error: UNINITIALIZED_VALUE + The value read from f32.filter was never initialized. + 328. memset(&f, 0, sizeof(f)); + 329. f.len = f32.len; + 330. > f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + 332. return NULL; + +net/compat.c:329: error: UNINITIALIZED_VALUE + The value read from f32.len was never initialized. + 327. return NULL; + 328. memset(&f, 0, sizeof(f)); + 329. > f.len = f32.len; + 330. f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +sound/core/pcm_native.c:397: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 395. if (trace_hw_interval_param_enabled()) { + 396. if (hw_is_interval(r->var)) + 397. > old_interval = *hw_param_interval(params, r->var); + 398. } + 399. + +sound/core/pcm_native.c:393: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 391. if (trace_hw_mask_param_enabled()) { + 392. if (hw_is_mask(r->var)) + 393. > old_mask = *hw_param_mask(params, r->var); + 394. } + 395. if (trace_hw_interval_param_enabled()) { + +net/netfilter/nf_log.c:327: error: DEAD_STORE + The value written to &net (type net*) is never used. + 325. static void *seq_start(struct seq_file *seq, loff_t *pos) + 326. { + 327. > struct net *net = seq_file_net(seq); + 328. + 329. mutex_lock(&nf_log_mutex); + +drivers/gpu/drm/drm_dp_mst_topology.c:373: error: DEAD_STORE + The value written to &crc4 (type unsigned char) is never used. + 371. if (msg->curchunk_idx >= msg->curchunk_len) { + 372. /* do CRC */ + 373. > crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1); + 374. /* copy chunk into bigger msg */ + 375. memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1); + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +kernel/events/ring_buffer.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. */ + 383. if (!rb->aux_overwrite) { + 384. > aux_tail = READ_ONCE(rb->user_page->aux_tail); + 385. handle->wakeup = rb->aux_wakeup + rb->aux_watermark; + 386. if (aux_head - aux_tail < perf_aux_size(rb)) + +net/netfilter/nf_conntrack_core.c:333: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 331. + 332. /* add this conntrack to the (per cpu) unconfirmed list */ + 333. > ct->cpu = smp_processor_id(); + 334. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 335. + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +drivers/gpu/drm/drm_dp_helper.c:341: error: UNINITIALIZED_VALUE + The value read from values.[_] was never initialized. + 339. + 340. link->revision = values[0]; + 341. > link->rate = drm_dp_bw_code_to_link_rate(values[1]); + 342. link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK; + 343. + +drivers/gpu/drm/i915/i915_gem_request.c:350: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 348. * noops - they are safe to be replayed on a reset. + 349. */ + 350. > tail = READ_ONCE(request->ring->tail); + 351. } else { + 352. tail = request->postfix; + +drivers/dma-buf/sync_file.c:352: error: UNINITIALIZED_VALUE + The value read from data.fd2 was never initialized. + 350. } + 351. + 352. > fence2 = sync_file_fdget(data.fd2); + 353. if (!fence2) { + 354. err = -ENOENT; + +drivers/tty/vt/vt_ioctl.c:814: error: DEAD_STORE + The value written to &arg (type unsigned long) is never used. + 812. vt_disallocate_all(); + 813. else + 814. > ret = vt_disallocate(--arg); + 815. break; + 816. + +drivers/tty/vt/vt_ioctl.c:881: error: UNINITIALIZED_VALUE + The value read from v.v_clin was never initialized. + 879. vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. > vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_cols was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_rows was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:879: error: UNINITIALIZED_VALUE + The value read from v.v_vlin was never initialized. + 877. console_lock(); + 878. if (v.v_vlin) + 879. > vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. vc_cons[i].d->vc_font.height = v.v_clin; + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_runtime_pm.c:335: error: DEAD_STORE + The value written to &id (type int) is never used. + 333. struct i915_power_well *power_well) + 334. { + 335. > enum i915_power_well_id id = power_well->id; + 336. bool disabled; + 337. u32 reqs; + +drivers/gpu/drm/i915/intel_runtime_pm.c:348: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 346. * diagnostic message. + 347. */ + 348. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 349. HSW_PWR_WELL_CTL_STATE(id))) || + 350. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +drivers/gpu/drm/i915/intel_runtime_pm.c:348: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 346. * diagnostic message. + 347. */ + 348. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 349. HSW_PWR_WELL_CTL_STATE(id))) || + 350. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +ipc/sem.c:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. + 366. /* pairs with smp_store_release() */ + 367. > if (!smp_load_acquire(&sma->use_global_lock)) { + 368. /* fast path successful! */ + 369. return sops->sem_num; + +arch/x86/events/intel/bts.c:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. { + 335. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 336. > int state = READ_ONCE(bts->state); + 337. + 338. /* + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &ret (type int) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +scripts/kconfig/symbol.c:352: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 351 could be null and is dereferenced by call to `prop_get_symbol()` at line 352, column 18. + 350. sym->flags &= ~SYMBOL_NEED_SET_CHOICE_VALUES; + 351. prop = sym_get_choice_prop(sym); + 352. > sym_calc_value(prop_get_symbol(prop)); + 353. } + 354. + +net/netfilter/nf_log.c:339: error: DEAD_STORE + The value written to &net (type net*) is never used. + 337. static void *seq_next(struct seq_file *s, void *v, loff_t *pos) + 338. { + 339. > struct net *net = seq_file_net(s); + 340. + 341. (*pos)++; + +drivers/input/ff-memless.c:354: error: DEAD_STORE + The value written to &effect (type ff_effect*) is never used. + 352. + 353. state = &ml->states[i]; + 354. > effect = state->effect; + 355. + 356. if (!test_bit(FF_EFFECT_STARTED, &state->flags)) + +include/net/ip.h:341: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 339. int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst) + 340. { + 341. > u8 pmtudisc = READ_ONCE(inet_sk(sk)->pmtudisc); + 342. + 343. return pmtudisc == IP_PMTUDISC_DO || + +sound/hda/hdmi_chmap.c:376: error: UNINITIALIZED_VALUE + The value read from non_pcm_mapping.[_] was never initialized. + 374. + 375. for (i = 0; i < 8; i++) { + 376. > int slotsetup = non_pcm ? non_pcm_mapping[i] : hdmi_channel_mapping[ca][i]; + 377. int hdmi_slot = slotsetup & 0x0f; + 378. int channel = (slotsetup & 0xf0) >> 4; + +block/badblocks.c:356: error: DEAD_STORE + The value written to §ors (type int) is never used. + 354. s >>= bb->shift; + 355. target >>= bb->shift; + 356. > sectors = target - s; + 357. } + 358. + +block/blk-sysfs.c:343: error: DEAD_STORE + The value written to &ret (type long) is never used. + 341. queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) + 342. { + 343. > ssize_t ret = -EINVAL; + 344. #ifdef CONFIG_SMP + 345. unsigned long val; + +drivers/power/supply/power_supply_core.c:350: error: UNINITIALIZED_VALUE + The value read from ret.intval was never initialized. + 348. if (!psy->desc->get_property(psy, POWER_SUPPLY_PROP_ONLINE, + 349. &ret)) + 350. > return ret.intval; + 351. + 352. return 0; + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/tty/vt/vt.c:356: error: UNINITIALIZED_VALUE + The value read from nxx was never initialized. + 354. int nxx, nyy; + 355. start = vc->vc_sw->con_getxy(vc, start, &nxx, &nyy); + 356. > xx = nxx; yy = nyy; + 357. } + 358. for(;;) { + +drivers/tty/vt/vt.c:356: error: UNINITIALIZED_VALUE + The value read from nyy was never initialized. + 354. int nxx, nyy; + 355. start = vc->vc_sw->con_getxy(vc, start, &nxx, &nyy); + 356. > xx = nxx; yy = nyy; + 357. } + 358. for(;;) { + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +drivers/gpu/drm/drm_ioc32.c:356: error: UNINITIALIZED_VALUE + The value read from b32.high_mark was never initialized. + 354. buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. > buf.high_mark = b32.high_mark; + 357. + 358. return drm_ioctl_kernel(file, drm_legacy_markbufs, &buf, + +drivers/gpu/drm/drm_ioc32.c:355: error: UNINITIALIZED_VALUE + The value read from b32.low_mark was never initialized. + 353. + 354. buf.size = b32.size; + 355. > buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + 357. + +drivers/gpu/drm/drm_ioc32.c:354: error: UNINITIALIZED_VALUE + The value read from b32.size was never initialized. + 352. return -EFAULT; + 353. + 354. > buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +security/selinux/ss/ebitmap.c:360: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 358. goto out; + 359. + 360. > mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. count = le32_to_cpu(buf[2]); + +security/selinux/ss/ebitmap.c:362: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 360. mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. > count = le32_to_cpu(buf[2]); + 363. + 364. if (mapunit != BITS_PER_U64) { + +kernel/params.c:353: error: UNINITIALIZED_VALUE + The value read from boolval was never initialized. + 351. struct kernel_param dummy; + 352. + 353. > dummy.arg = &boolval; + 354. ret = param_set_bool(val, &dummy); + 355. if (ret == 0) + +lib/assoc_array.c:413: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr*) is never used. + 411. shortcut = assoc_array_ptr_to_shortcut(parent); + 412. BUG_ON(shortcut->next_node != cursor); + 413. > cursor = parent; + 414. parent = shortcut->back_pointer; + 415. slot = shortcut->parent_slot; + +net/sunrpc/xprtsock.c:382: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 380. err = 0; + 381. } + 382. > return err; + 383. } + 384. + +scripts/kallsyms.c:472: error: UNINITIALIZED_VALUE + The value read from best_idx.[_] was never initialized. + 470. output_label("kallsyms_token_index"); + 471. for (i = 0; i < 256; i++) + 472. > printf("\t.short\t%d\n", best_idx[i]); + 473. printf("\n"); + 474. } + +net/sched/act_api.c:354: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 352. struct tc_action *p; + 353. int ret; + 354. > unsigned long id = 1; + 355. + 356. idr_for_each_entry_ul(idr, p, id) { + +drivers/gpu/drm/i915/intel_uncore.c:415: error: UNINITIALIZED_VALUE + The value read from irqflags was never initialized. + 413. assert_forcewakes_inactive(dev_priv); + 414. + 415. > spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags); + 416. } + 417. + +lib/sbitmap.c:355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 353. + 354. hint = this_cpu_read(*sbq->alloc_hint); + 355. > depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + 357. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +kernel/locking/rwsem-xadd.c:353: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 351. { + 352. struct task_struct *owner; + 353. > bool ret = true; + 354. + 355. if (need_resched()) + +net/ipv4/tcp_minisocks.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. + 362. mss = tcp_mss_clamp(tp, dst_metric_advmss(dst)); + 363. > window_clamp = READ_ONCE(tp->window_clamp); + 364. /* Set this up on the first call only */ + 365. req->rsk_window_clamp = window_clamp ? : dst_metric(dst, RTAX_WINDOW); + +net/wireless/trace.h:350: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 348. ); + 349. + 350. > DECLARE_EVENT_CLASS(wiphy_wdev_evt, + 351. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 352. TP_ARGS(wiphy, wdev), + +scripts/asn1_compiler.c:361: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 361, column 3. + 359. token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token)); + 360. if (!tokens) { + 361. > perror(NULL); + 362. exit(1); + 363. } + +arch/x86/include/asm/tlbflush.h:360: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 358. WARN_ON_ONCE(preemptible()); + 359. + 360. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 361. + 362. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +arch/x86/include/asm/tlbflush.h:360: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 358. WARN_ON_ONCE(preemptible()); + 359. + 360. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 361. + 362. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:378: error: DEAD_STORE + The value written to &err (type int) is never used. + 376. opt.value.data = LUCID_VALUE; + 377. opt.value.len = sizeof(LUCID_VALUE); + 378. > err = gssx_enc_option(xdr, &opt); + 379. + 380. /* ..and user creds */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:371: error: NULL_DEREFERENCE + pointer `p` last assigned on line 370 could be null and is dereferenced at line 371, column 2. + 369. /* ctx->options */ + 370. p = xdr_reserve_space(xdr, 4); + 371. > *p = cpu_to_be32(2); + 372. + 373. /* we want a lucid_v1 context */ + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +sound/hda/hdac_controller.c:360: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 358. snd_hdac_chip_updatel(bus, GCTL, AZX_GCTL_RESET, 0); + 359. + 360. > timeout = jiffies + msecs_to_jiffies(100); + 361. while ((snd_hdac_chip_readb(bus, GCTL) & AZX_GCTL_RESET) && + 362. time_before(jiffies, timeout)) + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +security/selinux/ss/conditional.c:368: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 366. return rc; + 367. + 368. > len = le32_to_cpu(buf[0]); + 369. if (len == 0) + 370. return 0; + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +kernel/sched/loadavg.c:361: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 359. long active, delta; + 360. + 361. > sample_window = READ_ONCE(calc_load_update); + 362. if (time_before(jiffies, sample_window + 10)) + 363. return; + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/sched/clock.c:371: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 369. scd = cpu_sdc(cpu); + 370. + 371. > if (cpu != smp_processor_id()) + 372. clock = sched_clock_remote(scd); + 373. else + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:394: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 392. + 393. /* ...and verify the command was successful. */ + 394. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 395. + 396. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +include/linux/key.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. { + 362. /* Barrier versus mark_key_instantiated(). */ + 363. > return smp_load_acquire(&key->state); + 364. } + 365. + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +include/linux/netfilter/x_tables.h:369: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 367. * called xt_write_recseq_begin(). + 368. */ + 369. > addend = (__this_cpu_read(xt_recseq.sequence) + 1) & 1; + 370. + 371. /* + +kernel/printk/printk_safe.c:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. { + 363. /* Use extra buffer in NMI when logbuf_lock is taken or in safe mode. */ + 364. > if (this_cpu_read(printk_context) & PRINTK_NMI_CONTEXT_MASK) + 365. return vprintk_nmi(fmt, args); + 366. + +kernel/printk/printk_safe.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Use extra buffer to prevent a recursion deadlock in safe mode. */ + 368. > if (this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) + 369. return vprintk_safe(fmt, args); + 370. + +kernel/printk/printk_safe.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. * But avoid calling console drivers that might have their own locks. + 374. */ + 375. > if (this_cpu_read(printk_context) & PRINTK_NMI_DEFERRED_CONTEXT_MASK) + 376. return vprintk_deferred(fmt, args); + 377. + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +drivers/scsi/scsi_logging.c:375: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 373. return; + 374. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 375. > off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr); + 376. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + 377. scsi_log_release_buffer(logbuf); + +drivers/scsi/scsi_logging.c:383: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 381. return; + 382. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 383. > off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, + 384. sshdr->asc, sshdr->ascq); + 385. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +drivers/gpu/drm/drm_modes.c:459: error: DEAD_STORE + The value written to &hperiod (type unsigned int) is never used. + 457. vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. > hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + 460. + 461. /* 13. Find the actual Vertical field frequency: */ + +drivers/gpu/drm/drm_modes.c:452: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 450. vsync_plus_bp = (vsync_plus_bp + 500) / 1000; + 451. /* 9. Find the number of lines in V back porch alone: */ + 452. > vback_porch = vsync_plus_bp - V_SYNC_RQD; + 453. /* 10. Find the total number of lines in Vertical field period: */ + 454. vtotal_lines = vdisplay_rnd + top_margin + bottom_margin + + +drivers/gpu/drm/drm_modes.c:457: error: DEAD_STORE + The value written to &vfieldrate_est (type unsigned int) is never used. + 455. vsync_plus_bp + GTF_MIN_V_PORCH; + 456. /* 11. Estimate the Vertical field frequency: */ + 457. > vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + +drivers/gpu/drm/drm_modes.c:465: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 463. /* 14. Find the Vertical frame frequency: */ + 464. if (interlaced) + 465. > vframe_rate = vfield_rate / 2; + 466. else + 467. vframe_rate = vfield_rate; + +drivers/gpu/drm/drm_modes.c:467: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 465. vframe_rate = vfield_rate / 2; + 466. else + 467. > vframe_rate = vfield_rate; + 468. /* 15. Find number of pixels in left margin: */ + 469. if (margins) + +include/net/ip.h:375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 373. return dst_mtu(dst); + 374. + 375. > return min(READ_ONCE(dst->dev->mtu), IP_MAX_MTU); + 376. } + 377. + +drivers/usb/core/message.c:455: error: DEAD_STORE + The value written to &i (type int) is never used. + 453. urb->transfer_buffer_length = len; + 454. } + 455. > io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; + 456. + 457. /* transaction state */ + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +drivers/md/dm-stripe.c:384: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 382. } + 383. buffer[i] = '\0'; + 384. > DMEMIT("1 %s", buffer); + 385. break; + 386. + +drivers/pcmcia/ti113x.h:417: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 415. dev_info(&socket->dev->dev, + 416. "TI: all-serial interrupts ok\n"); + 417. > mfunc_old = mfunc; + 418. goto out; + 419. } + +drivers/pcmcia/ti113x.h:462: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 460. pci_irq_status = yenta_probe_cb_irq(socket); + 461. if (pci_irq_status == 1) { + 462. > mfunc_old = mfunc; + 463. dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n"); + 464. } else { + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +arch/x86/include/asm/tlbflush.h:391: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 389. raw_local_irq_save(flags); + 390. + 391. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 392. /* toggle PGE */ + 393. native_write_cr4(cr4 ^ X86_CR4_PGE); + +arch/x86/include/asm/tlbflush.h:391: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 389. raw_local_irq_save(flags); + 390. + 391. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 392. /* toggle PGE */ + 393. native_write_cr4(cr4 ^ X86_CR4_PGE); + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +kernel/sched/cpuacct.c:377: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 376 could be null and is dereferenced at line 377, column 3. + 375. rcu_read_lock(); + 376. for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca)) + 377. > this_cpu_ptr(ca->cpustat)->cpustat[index] += val; + 378. rcu_read_unlock(); + 379. } + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +kernel/time/tick-common.c:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. void tick_handover_do_timer(void) + 373. { + 374. > if (tick_do_timer_cpu == smp_processor_id()) { + 375. int cpu = cpumask_first(cpu_online_mask); + 376. + +net/ipv4/udp.c:416: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 414. } + 415. + 416. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 417. score++; + 418. return score; + +kernel/params.c:380: error: UNINITIALIZED_VALUE + The value read from v was never initialized. + 378. int ret; + 379. + 380. > boolkp.arg = &v; + 381. + 382. ret = param_set_bool(val, &boolkp); + +sound/hda/hdac_controller.c:379: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 377. snd_hdac_chip_updateb(bus, GCTL, 0, AZX_GCTL_RESET); + 378. + 379. > timeout = jiffies + msecs_to_jiffies(100); + 380. while (!snd_hdac_chip_readb(bus, GCTL) && time_before(jiffies, timeout)) + 381. usleep_range(500, 1000); + +drivers/pci/access.c:378: error: DEAD_STORE + The value written to &max_sleep (type unsigned long) is never used. + 376. struct pci_vpd *vpd = dev->vpd; + 377. unsigned long timeout = jiffies + msecs_to_jiffies(125); + 378. > unsigned long max_sleep = 16; + 379. u16 status; + 380. int ret; + +drivers/pci/access.c:377: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 375. { + 376. struct pci_vpd *vpd = dev->vpd; + 377. > unsigned long timeout = jiffies + msecs_to_jiffies(125); + 378. unsigned long max_sleep = 16; + 379. u16 status; + +drivers/power/supply/power_supply_core.c:385: error: UNINITIALIZED_VALUE + The value read from ret.intval was never initialized. + 383. POWER_SUPPLY_PROP_CURRENT_MAX, + 384. &ret)) + 385. > return ret.intval; + 386. + 387. return 0; + +net/wireless/trace.h:374: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/ipv4/proc.c:396: error: UNINITIALIZED_VALUE + The value read from buff64.[_] was never initialized. + 394. offsetof(struct ipstats_mib, syncp)); + 395. for (i = 0; snmp4_ipstats_list[i].name; i++) + 396. > seq_printf(seq, " %llu", buff64[i]); + 397. + 398. return 0; + +kernel/rcu/srcutree.c:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. for_each_possible_cpu(cpu) + 386. flush_delayed_work(&per_cpu_ptr(sp->sda, cpu)->work); + 387. > if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 388. WARN_ON(srcu_readers_active(sp))) { + 389. pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + +kernel/rcu/srcutree.c:389: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 387. if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 388. WARN_ON(srcu_readers_active(sp))) { + 389. > pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + 390. return; /* Caller forgot to stop doing call_srcu()? */ + 391. } + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +lib/sbitmap.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. + 383. hint = this_cpu_read(*sbq->alloc_hint); + 384. > depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + 386. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +include/net/ip.h:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. } + 386. + 387. > return min(READ_ONCE(skb_dst(skb)->dev->mtu), IP_MAX_MTU); + 388. } + 389. + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +sound/pci/hda/hda_controller.c:391: error: DEAD_STORE + The value written to &timeout (type unsigned int) is never used. + 389. bool direction; + 390. u32 dma_select; + 391. > u32 timeout = 200; + 392. u32 retry_count = 0; + 393. + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +kernel/time/timer.c:382: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 380. unsigned long round_jiffies(unsigned long j) + 381. { + 382. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 383. } + 384. EXPORT_SYMBOL_GPL(round_jiffies); + +kernel/time/timer.c:382: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 380. unsigned long round_jiffies(unsigned long j) + 381. { + 382. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 383. } + 384. EXPORT_SYMBOL_GPL(round_jiffies); + +net/ipv4/inet_connection_sock.c:424: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 422. } + 423. finish_wait(sk_sleep(sk), &wait); + 424. > return err; + 425. } + 426. + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_base_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_top_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +kernel/sched/core.c:386: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 384. { + 385. struct thread_info *ti = task_thread_info(p); + 386. > return !(fetch_or(&ti->flags, _TIF_NEED_RESCHED) & _TIF_POLLING_NRFLAG); + 387. } + 388. + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +net/xfrm/xfrm_policy.c:413: error: DEAD_STORE + The value written to &entry0 (type hlist_node*) is never used. + 411. hlist_add_behind_rcu(&pol->bydst, entry0); + 412. } + 413. > entry0 = &pol->bydst; + 414. } + 415. if (!hlist_empty(list)) { + +net/xfrm/xfrm_policy.c:406: error: DEAD_STORE + The value written to &h0 (type unsigned int) is never used. + 404. hlist_del_rcu(&pol->bydst); + 405. hlist_add_head_rcu(&pol->bydst, ndsttable + h); + 406. > h0 = h; + 407. } else { + 408. if (h != h0) + +drivers/gpu/drm/drm_ioc32.c:402: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 400. return err; + 401. + 402. > if (put_user(req32.count, &argp->count)) + 403. return -EFAULT; + 404. + +drivers/gpu/drm/drm_mm.c:387: error: DEAD_STORE + The value written to &end (type unsigned long long) is never used. + 385. int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node) + 386. { + 387. > u64 end = node->start + node->size; + 388. struct drm_mm_node *hole; + 389. u64 hole_start, hole_end; + +kernel/cgroup/freezer.c:409: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 398 could be null and is dereferenced at line 409, column 10. + 407. else + 408. freezer_apply_state(pos_f, + 409. > parent->state & CGROUP_FREEZING, + 410. CGROUP_FREEZING_PARENT); + 411. + +net/ipv4/inet_hashtables.c:392: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 390. const int dif, const int sdif) + 391. { + 392. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + +net/ipv4/inet_hashtables.c:393: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 391. { + 392. INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + 395. const struct hlist_nulls_node *node; + +drivers/gpu/drm/i915/i915_gem_shrinker.c:392: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 390. int timeout_ms) + 391. { + 392. > unsigned long timeout = jiffies + msecs_to_jiffies_timeout(timeout_ms); + 393. + 394. do { + +drivers/net/ethernet/intel/e1000/e1000_main.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. struct e1000_rx_ring *ring = &adapter->rx_ring[i]; + 408. adapter->alloc_rx_buf(adapter, ring, + 409. > E1000_DESC_UNUSED(ring)); + 410. } + 411. } + +net/ipv4/tcp.c:391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 389. static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp) + 390. { + 391. > u32 rate = READ_ONCE(tp->rate_delivered); + 392. u32 intv = READ_ONCE(tp->rate_interval_us); + 393. u64 rate64 = 0; + +net/ipv4/tcp.c:392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 390. { + 391. u32 rate = READ_ONCE(tp->rate_delivered); + 392. > u32 intv = READ_ONCE(tp->rate_interval_us); + 393. u64 rate64 = 0; + 394. + +security/selinux/ss/avtab.c:489: error: DEAD_STORE + The value written to &items (type unsigned int) is never used. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:486: error: UNINITIALIZED_VALUE + The value read from buf16.[_] was never initialized. + 484. + 485. items = 0; + 486. > key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:487: error: UNINITIALIZED_VALUE + The value read from buf16.[_] was never initialized. + 485. items = 0; + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. > key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:488: error: UNINITIALIZED_VALUE + The value read from buf16.[_] was never initialized. + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. > key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + 490. + +security/selinux/ss/avtab.c:489: error: UNINITIALIZED_VALUE + The value read from buf16.[_] was never initialized. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:413: error: UNINITIALIZED_VALUE + The value read from buf32.[_] was never initialized. + 411. return rc; + 412. } + 413. > items2 = le32_to_cpu(buf32[0]); + 414. if (items2 > ARRAY_SIZE(buf32)) { + 415. printk(KERN_ERR "SELinux: avtab: entry overflow\n"); + +security/selinux/ss/avtab.c:426: error: UNINITIALIZED_VALUE + The value read from buf32.[_] was never initialized. + 424. items = 0; + 425. + 426. > val = le32_to_cpu(buf32[items++]); + 427. key.source_type = (u16)val; + 428. if (key.source_type != val) { + +security/selinux/ss/avtab.c:432: error: UNINITIALIZED_VALUE + The value read from buf32.[_] was never initialized. + 430. return -EINVAL; + 431. } + 432. > val = le32_to_cpu(buf32[items++]); + 433. key.target_type = (u16)val; + 434. if (key.target_type != val) { + +security/selinux/ss/avtab.c:438: error: UNINITIALIZED_VALUE + The value read from buf32.[_] was never initialized. + 436. return -EINVAL; + 437. } + 438. > val = le32_to_cpu(buf32[items++]); + 439. key.target_class = (u16)val; + 440. if (key.target_class != val) { + +security/selinux/ss/avtab.c:445: error: UNINITIALIZED_VALUE + The value read from buf32.[_] was never initialized. + 443. } + 444. + 445. > val = le32_to_cpu(buf32[items++]); + 446. enabled = (val & AVTAB_ENABLED_OLD) ? AVTAB_ENABLED : 0; + 447. + +security/selinux/ss/avtab.c:465: error: UNINITIALIZED_VALUE + The value read from buf32.[_] was never initialized. + 463. if (val & spec_order[i]) { + 464. key.specified = spec_order[i] | enabled; + 465. > datum.u.data = le32_to_cpu(buf32[items++]); + 466. rc = insertf(a, &key, &datum, p); + 467. if (rc) + +security/selinux/ss/avtab.c:532: error: UNINITIALIZED_VALUE + The value read from buf32.[_] was never initialized. + 530. } + 531. for (i = 0; i < ARRAY_SIZE(xperms.perms.p); i++) + 532. > xperms.perms.p[i] = le32_to_cpu(buf32[i]); + 533. datum.u.xperms = &xperms; + 534. } else { + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +init/main.c:411: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 409. rcu_read_lock(); + 410. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 411. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 412. rcu_read_unlock(); + 413. + +init/main.c:411: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 409. rcu_read_lock(); + 410. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 411. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 412. rcu_read_unlock(); + 413. + +net/wireless/trace.h:392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 390. ); + 391. + 392. > DECLARE_EVENT_CLASS(key_handle, + 393. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 394. bool pairwise, const u8 *mac_addr), + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +kernel/sched/core.c:405: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 403. if (val & _TIF_NEED_RESCHED) + 404. return true; + 405. > old = cmpxchg(&ti->flags, val, val | _TIF_NEED_RESCHED); + 406. if (old == val) + 407. break; + +kernel/sched/core.c:398: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 396. { + 397. struct thread_info *ti = task_thread_info(p); + 398. > typeof(ti->flags) old, val = READ_ONCE(ti->flags); + 399. + 400. for (;;) { + +kernel/softirq.c:404: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 402. account_irq_exit_time(current); + 403. preempt_count_sub(HARDIRQ_OFFSET); + 404. > if (!in_interrupt() && local_softirq_pending()) + 405. invoke_softirq(); + 406. + +drivers/cpuidle/sysfs.c:398: error: DEAD_STORE + The value written to &ret (type int) is never used. + 396. static int cpuidle_add_state_sysfs(struct cpuidle_device *device) + 397. { + 398. > int i, ret = -ENOMEM; + 399. struct cpuidle_state_kobj *kobj; + 400. struct cpuidle_device_kobj *kdev = device->kobj_dev; + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +usr/gen_init_cpio.c:448: error: MEMORY_LEAK + memory dynamically allocated by call to `malloc()` at line 422, column 11 is not reachable after line 448, column 6. + 446. mode, uid, gid, nlinks); + 447. fail: + 448. > if (dname_len) free(dname); + 449. return rc; + 450. } + +drivers/gpu/drm/i915/i915_gem_object.h:404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 402. i915_gem_object_is_framebuffer(const struct drm_i915_gem_object *obj) + 403. { + 404. > return READ_ONCE(obj->framebuffer_references); + 405. } + 406. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:530: error: DEAD_STORE + The value written to &icr (type unsigned int) is never used. + 528. + 529. /* Clear any pending interrupt events. */ + 530. > icr = er32(ICR); + 531. + 532. /* If MWI was previously enabled, reenable it. */ + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +kernel/time/timer.c:403: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 401. unsigned long round_jiffies_relative(unsigned long j) + 402. { + 403. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 404. } + 405. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +kernel/time/timer.c:403: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 401. unsigned long round_jiffies_relative(unsigned long j) + 402. { + 403. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 404. } + 405. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +net/ipv4/proc.c:419: error: UNINITIALIZED_VALUE + The value read from buff.[_] was never initialized. + 417. /* MaxConn field is signed, RFC 2012 */ + 418. if (snmp4_tcp_list[i].entry == TCP_MIB_MAXCONN) + 419. > seq_printf(seq, " %ld", buff[i]); + 420. else + 421. seq_printf(seq, " %lu", buff[i]); + +net/ipv4/proc.c:421: error: UNINITIALIZED_VALUE + The value read from buff.[_] was never initialized. + 419. seq_printf(seq, " %ld", buff[i]); + 420. else + 421. > seq_printf(seq, " %lu", buff[i]); + 422. } + 423. + +net/ipv4/proc.c:433: error: UNINITIALIZED_VALUE + The value read from buff.[_] was never initialized. + 431. seq_puts(seq, "\nUdp:"); + 432. for (i = 0; snmp4_udp_list[i].name; i++) + 433. > seq_printf(seq, " %lu", buff[i]); + 434. + 435. memset(buff, 0, TCPUDP_MIB_MAX * sizeof(unsigned long)); + +net/ipv4/proc.c:445: error: UNINITIALIZED_VALUE + The value read from buff.[_] was never initialized. + 443. seq_puts(seq, "\nUdpLite:"); + 444. for (i = 0; snmp4_udp_list[i].name; i++) + 445. > seq_printf(seq, " %lu", buff[i]); + 446. + 447. seq_putc(seq, '\n'); + +security/selinux/ss/conditional.c:415: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 413. + 414. /* expr */ + 415. > len = le32_to_cpu(buf[1]); + 416. + 417. for (i = 0; i < len; i++) { + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/power/user.c:420: error: UNINITIALIZED_VALUE + The value read from offset was never initialized. + 418. old_fs = get_fs(); + 419. set_fs(KERNEL_DS); + 420. > err = snapshot_ioctl(file, cmd, (unsigned long) &offset); + 421. set_fs(old_fs); + 422. if (!err && put_user(offset, uoffset)) + +kernel/power/user.c:422: error: UNINITIALIZED_VALUE + The value read from offset was never initialized. + 420. err = snapshot_ioctl(file, cmd, (unsigned long) &offset); + 421. set_fs(old_fs); + 422. > if (!err && put_user(offset, uoffset)) + 423. err = -EFAULT; + 424. return err; + +kernel/power/user.c:444: error: UNINITIALIZED_VALUE + The value read from swap_area was never initialized. + 442. old_fs = get_fs(); + 443. set_fs(KERNEL_DS); + 444. > err = snapshot_ioctl(file, SNAPSHOT_SET_SWAP_AREA, + 445. (unsigned long) &swap_area); + 446. set_fs(old_fs); + +kernel/seccomp.c:416: error: UNINITIALIZED_VALUE + The value read from fprog32.filter was never initialized. + 414. goto out; + 415. fprog.len = fprog32.len; + 416. > fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + 418. #endif + +kernel/seccomp.c:415: error: UNINITIALIZED_VALUE + The value read from fprog32.len was never initialized. + 413. if (copy_from_user(&fprog32, user_filter, sizeof(fprog32))) + 414. goto out; + 415. > fprog.len = fprog32.len; + 416. fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +crypto/api.c:439: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 437. } + 438. + 439. > return ERR_PTR(err); + 440. } + 441. EXPORT_SYMBOL_GPL(crypto_alloc_base); + +drivers/thermal/thermal_core.c:420: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 418. + 419. if (type == THERMAL_TRIP_CRITICAL || type == THERMAL_TRIP_HOT) + 420. > handle_critical_trips(tz, trip, type); + 421. else + 422. handle_non_critical_trips(tz, trip, type); + +drivers/thermal/thermal_core.c:422: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 420. handle_critical_trips(tz, trip, type); + 421. else + 422. > handle_non_critical_trips(tz, trip, type); + 423. /* + 424. * Alright, we handled this trip successfully. + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +drivers/base/cpu.c:416: error: DEAD_STORE + The value written to &retval (type int) is never used. + 414. { + 415. struct device *dev = NULL; + 416. > int retval = -ENODEV; + 417. + 418. dev = kzalloc(sizeof(*dev), GFP_KERNEL); + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +lib/kfifo.c:419: error: DEAD_STORE + The value written to &recsize (type unsigned long) is never used. + 417. l = __KFIFO_PEEK(data, fifo->out, mask); + 418. + 419. > if (--recsize) + 420. l |= __KFIFO_PEEK(data, fifo->out + 1, mask) << 8; + 421. + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +net/compat.c:435: error: UNINITIALIZED_VALUE + The value read from ktime.tv_sec was never initialized. + 433. if (put_user(sizeof(*up), optlen) || + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. > __put_user(ktime.tv_sec, &up->tv_sec) || + 436. __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + +net/compat.c:436: error: UNINITIALIZED_VALUE + The value read from ktime.tv_usec was never initialized. + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. __put_user(ktime.tv_sec, &up->tv_sec) || + 436. > __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + 438. } + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +net/ipv6/raw.c:430: error: NULL_DEREFERENCE + pointer `rp` last assigned on line 422 could be null and is dereferenced at line 430, column 7. + 428. } + 429. + 430. > if (!rp->checksum) + 431. skb->ip_summed = CHECKSUM_UNNECESSARY; + 432. + +kernel/time/posix-cpu-timers.c:424: error: DEAD_STORE + The value written to &head (type list_head*) is never used. + 422. cleanup_timers_list(head); + 423. cleanup_timers_list(++head); + 424. > cleanup_timers_list(++head); + 425. } + 426. + +crypto/jitterentropy.c:463: error: UNINITIALIZED_VALUE + The value read from mixer.u64 was never initialized. + 461. if ((entropy_collector->data >> i) & 1) + 462. mixer.u64 ^= constant.u64; + 463. > mixer.u64 = jent_rol64(mixer.u64, 1); + 464. } + 465. entropy_collector->data ^= mixer.u64; + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +kernel/events/core.c:428: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 426. tmp = div_u64(tmp, 100); + 427. if (!tmp) + 428. > tmp = 1; + 429. + 430. WRITE_ONCE(perf_sample_allowed_ns, tmp); + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +net/wireless/util.c:509: error: UNINITIALIZED_VALUE + The value read from payload.proto was never initialized. + 507. + 508. skb_copy_bits(skb, hdrlen, &payload, sizeof(payload)); + 509. > tmp.h_proto = payload.proto; + 510. + 511. if (likely((ether_addr_equal(payload.hdr, rfc1042_header) && + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +drivers/gpu/drm/i915/intel_guc_ct.c:426: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 424. int intel_guc_enable_ct(struct intel_guc *guc) + 425. { + 426. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 427. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 428. int err; + +block/blk-merge.c:444: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced at line 444, column 3. + 442. (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1; + 443. + 444. > sg->length += pad_len; + 445. rq->extra_len += pad_len; + 446. } + +block/blk-merge.c:452: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced by call to `sg_unmark_end()` at line 452, column 3. + 450. memset(q->dma_drain_buffer, 0, q->dma_drain_size); + 451. + 452. > sg_unmark_end(sg); + 453. sg = sg_next(sg); + 454. sg_set_page(sg, virt_to_page(q->dma_drain_buffer), + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:463: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 461. + 462. /* ...and verify the command was successful. */ + 463. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 464. + 465. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:437: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 435. if (unlikely(p == NULL)) + 436. return -ENOSPC; + 437. > count = be32_to_cpup(p++); + 438. for (i = 0; i < count; i++) { + 439. gssx_dec_name_attr(xdr, &dummy); + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/scsi/scsi_logging.c:476: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 474. + 475. if (db_string) + 476. > off += scnprintf(logbuf + off, logbuf_len - off, + 477. "driverbyte=%s", db_string); + 478. else + +drivers/scsi/scsi_logging.c:479: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 477. "driverbyte=%s", db_string); + 478. else + 479. > off += scnprintf(logbuf + off, logbuf_len - off, + 480. "driverbyte=0x%02x", driver_byte(cmd->result)); + 481. out_printk: + +lib/sbitmap.c:449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 447. wait_cnt = atomic_dec_return(&ws->wait_cnt); + 448. if (wait_cnt <= 0) { + 449. > wake_batch = READ_ONCE(sbq->wake_batch); + 450. /* + 451. * Pairs with the memory barrier in sbitmap_queue_resize() to + +drivers/gpu/drm/i915/i915_pmu.c:457: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 455. + 456. if (!locked) + 457. > spin_unlock_irqrestore(&i915->pmu.lock, flags); + 458. } else { + 459. struct pci_dev *pdev = i915->drm.pdev; + +drivers/gpu/drm/i915/i915_pmu.c:490: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 488. + 489. if (!locked) + 490. > spin_unlock_irqrestore(&i915->pmu.lock, flags); + 491. } + 492. + +drivers/gpu/drm/i915/intel_guc_submission.c:455: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 453. + 454. /* Free space is guaranteed. */ + 455. > wq_off = READ_ONCE(desc->tail); + 456. GEM_BUG_ON(CIRC_SPACE(wq_off, READ_ONCE(desc->head), + 457. GUC_WQ_SIZE) < wqi_size); + +net/wireless/trace.h:433: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/ipv4/inet_hashtables.c:446: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 444. struct net *net = sock_net(sk); + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + +net/ipv4/inet_hashtables.c:447: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + 449. saddr, inet->inet_dport); + +net/ipv4/inet_hashtables.c:445: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 443. int dif = sk->sk_bound_dev_if; + 444. struct net *net = sock_net(sk); + 445. > int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + +drivers/cpuidle/sysfs.c:441: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 438 could be null and is dereferenced at line 441, column 18. + 439. int i; + 440. + 441. > for (i = 0; i < drv->state_count; i++) + 442. cpuidle_free_state_kobj(device, i); + 443. } + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +kernel/cgroup/freezer.c:442: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 440 could be null and is dereferenced at line 442, column 16. + 440. struct freezer *freezer = css_freezer(css); + 441. + 442. > return (bool)(freezer->state & CGROUP_FREEZING_SELF); + 443. } + 444. + +kernel/rcu/srcutree.c:450: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 448. smp_mb(); /* Order prior store to ->srcu_gp_seq_needed vs. GP start. */ + 449. rcu_seq_start(&sp->srcu_gp_seq); + 450. > state = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 451. WARN_ON_ONCE(state != SRCU_STATE_SCAN1); + 452. } + +kernel/auditsc.c:632: error: UNINITIALIZED_VALUE + The value read from sid was never initialized. + 630. need_sid = 0; + 631. } + 632. > result = security_audit_rule_match(sid, f->type, + 633. f->op, + 634. f->lsm_rule, + +kernel/rcu/tree.c:447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 445. rcu_preempt_note_context_switch(preempt); + 446. /* Load rcu_urgent_qs before other flags. */ + 447. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) + 448. goto out; + 449. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + +kernel/rcu/tree.c:450: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 448. goto out; + 449. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 450. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) + 451. rcu_momentary_dyntick_idle(); + 452. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +net/netfilter/nf_conntrack_helper.c:449: error: NULL_DEREFERENCE + pointer `help` last assigned on line 442 could be null and is dereferenced at line 449, column 9. + 447. return true; + 448. + 449. > this = rcu_dereference_protected(help->helper, + 450. lockdep_is_held(&nf_conntrack_expect_lock)); + 451. return this == me; + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +net/ipv6/seg6.c:443: error: DEAD_STORE + The value written to &err (type int) is never used. + 441. int __init seg6_init(void) + 442. { + 443. > int err = -ENOMEM; + 444. + 445. err = genl_register_family(&seg6_genl_family); + +net/xfrm/xfrm_policy.c:456: error: DEAD_STORE + The value written to &odst (type hlist_head*) is never used. + 454. write_seqcount_begin(&xfrm_policy_hash_generation); + 455. + 456. > odst = rcu_dereference_protected(net->xfrm.policy_bydst[dir].table, + 457. lockdep_is_held(&net->xfrm.xfrm_policy_lock)); + 458. + +include/linux/tcp.h:445: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 443. { + 444. struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue; + 445. > int somaxconn = READ_ONCE(sock_net(sk)->core.sysctl_somaxconn); + 446. + 447. queue->fastopenq.max_qlen = min_t(unsigned int, backlog, somaxconn); + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +net/sched/sch_generic.c:461: error: DEAD_STORE + The value written to &trans_start (type unsigned long) is never used. + 459. + 460. txq = netdev_get_tx_queue(dev, i); + 461. > trans_start = txq->trans_start; + 462. if (netif_xmit_stopped(txq) && + 463. time_after(jiffies, (trans_start + + +kernel/cgroup/freezer.c:450: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 448 could be null and is dereferenced at line 450, column 16. + 448. struct freezer *freezer = css_freezer(css); + 449. + 450. > return (bool)(freezer->state & CGROUP_FREEZING_PARENT); + 451. } + 452. + +net/sunrpc/rpcb_clnt.c:453: error: UNINITIALIZED_VALUE + The value read from map was never initialized. + 451. .r_port = port, + 452. }; + 453. > struct rpc_message msg = { + 454. .rpc_argp = &map, + 455. }; + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +drivers/gpu/drm/i915/intel_guc_ct.c:449: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 447. void intel_guc_disable_ct(struct intel_guc *guc) + 448. { + 449. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 450. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 451. + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/drm_ioc32.c:465: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 463. return err; + 464. + 465. > if (put_user(req32.count, &argp->count) + 466. || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:466: error: UNINITIALIZED_VALUE + The value read from req32.virtual was never initialized. + 464. + 465. if (put_user(req32.count, &argp->count) + 466. > || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + 468. + +drivers/gpu/drm/i915/intel_sdvo.c:457: error: DEAD_STORE + The value written to &ret (type int) is never used. + 455. u8 *buf, status; + 456. struct i2c_msg *msgs; + 457. > int i, ret = true; + 458. + 459. /* Would be simpler to allocate both in one go ? */ + +kernel/time/timer.c:453: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 451. unsigned long round_jiffies_up(unsigned long j) + 452. { + 453. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 454. } + 455. EXPORT_SYMBOL_GPL(round_jiffies_up); + +kernel/time/timer.c:453: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 451. unsigned long round_jiffies_up(unsigned long j) + 452. { + 453. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 454. } + 455. EXPORT_SYMBOL_GPL(round_jiffies_up); + +net/sunrpc/auth.c:456: error: DEAD_STORE + The value written to &expired (type unsigned long) is never used. + 454. spinlock_t *cache_lock; + 455. struct rpc_cred *cred, *next; + 456. > unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; + 457. long freed = 0; + 458. + +net/sunrpc/auth.c:461: error: DEAD_STORE + The value written to &nr_to_scan (type int) is never used. + 459. list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { + 460. + 461. > if (nr_to_scan-- == 0) + 462. break; + 463. /* + +net/ipv4/igmp.c:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. return skb; + 468. + 469. > mtu = READ_ONCE(dev->mtu); + 470. if (mtu < IPV4_MIN_MTU) + 471. return skb; + +drivers/gpu/drm/drm_plane.c:466: error: DEAD_STORE + The value written to &config (type drm_mode_config*) is never used. + 464. return -EINVAL; + 465. + 466. > config = &dev->mode_config; + 467. plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr); + 468. + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +security/selinux/ss/conditional.c:466: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 464. return rc; + 465. + 466. > len = le32_to_cpu(buf[0]); + 467. + 468. rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel); + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +net/wireless/trace.h:457: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +include/linux/tcp.h:470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 468. * This happens for listeners. + 469. */ + 470. > u16 user_mss = READ_ONCE(tp->rx_opt.user_mss); + 471. + 472. return (user_mss && user_mss < mss) ? user_mss : mss; + +kernel/time/timer.c:468: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 466. unsigned long round_jiffies_up_relative(unsigned long j) + 467. { + 468. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 469. } + 470. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +kernel/time/timer.c:468: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 466. unsigned long round_jiffies_up_relative(unsigned long j) + 467. { + 468. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 469. } + 470. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +net/ipv4/tcp_fastopen.c:468: error: DEAD_STORE + The value written to &tfo_bh_timeout (type unsigned int) is never used. + 466. bool tcp_fastopen_active_should_disable(struct sock *sk) + 467. { + 468. > unsigned int tfo_bh_timeout = sock_net(sk)->ipv4.sysctl_tcp_fastopen_blackhole_timeout; + 469. int tfo_da_times = atomic_read(&sock_net(sk)->ipv4.tfo_active_disable_times); + 470. unsigned long timeout; + +drivers/gpu/drm/i915/i915_sysfs.c:483: error: UNINITIALIZED_VALUE + The value read from val was never initialized. + 481. BUG(); + 482. + 483. > return snprintf(buf, PAGE_SIZE, "%d\n", val); + 484. } + 485. + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +kernel/rcu/tree.c:482: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 480. preempt_disable(); + 481. /* Load rcu_urgent_qs before other flags. */ + 482. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) { + 483. preempt_enable(); + 484. return; + +kernel/rcu/tree.c:478: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 476. unsigned long flags; + 477. + 478. > if (!raw_cpu_read(rcu_dynticks.rcu_urgent_qs)) + 479. return; + 480. preempt_disable(); + +kernel/rcu/tree.c:488: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 486. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 487. barrier(); /* Avoid RCU read-side critical sections leaking down. */ + 488. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) { + 489. local_irq_save(flags); + 490. rcu_momentary_dyntick_idle(); + +kernel/rcu/tree.c:493: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 491. local_irq_restore(flags); + 492. } + 493. > if (unlikely(raw_cpu_read(rcu_sched_data.cpu_no_qs.b.exp))) + 494. rcu_sched_qs(); + 495. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +net/wireless/trace.h:474: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +drivers/gpu/drm/drm_ioc32.c:487: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 485. return -EFAULT; + 486. + 487. > request.count = req32.count; + 488. request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:488: error: UNINITIALIZED_VALUE + The value read from req32.list was never initialized. + 486. + 487. request.count = req32.count; + 488. > request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + 490. } + +lib/assoc_array.c:643: error: UNINITIALIZED_VALUE + The value read from j was never initialized. + 641. } + 642. found_slot_for_multiple_occupancy: + 643. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 644. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 645. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +lib/assoc_array.c:643: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 641. } + 642. found_slot_for_multiple_occupancy: + 643. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 644. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 645. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +drivers/cpuidle/cpuidle.c:484: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 482 could be null and is dereferenced at line 484, column 22. + 482. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 483. + 484. > if (!try_module_get(drv->owner)) + 485. return -EINVAL; + 486. + +kernel/sched/core.c:493: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 491. cpu = cpu_of(rq); + 492. + 493. > if (cpu == smp_processor_id()) { + 494. set_tsk_need_resched(curr); + 495. set_preempt_need_resched(); + +drivers/firmware/dmi_scan.c:502: error: DEAD_STORE + The value written to &c (type int) is never used. + 500. dmi_get_system_info(DMI_BIOS_VERSION)); + 501. c += scnprintf(buf + c, len - c, " "); + 502. > c += print_filtered(buf + c, len - c, + 503. dmi_get_system_info(DMI_BIOS_DATE)); + 504. } + +net/ipv6/exthdrs.c:496: error: DEAD_STORE + The value written to &accept_source_route (type int) is never used. + 494. idev = __in6_dev_get(skb->dev); + 495. if (idev && accept_source_route > idev->cnf.accept_source_route) + 496. > accept_source_route = idev->cnf.accept_source_route; + 497. + 498. if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) || + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +net/ipv4/ping.c:511: error: UNINITIALIZED_VALUE + The value read from family was never initialized. + 509. /* We assume the packet has already been checked by icmp_unreach */ + 510. + 511. > if (!ping_supported(family, icmph->type, icmph->code)) + 512. return; + 513. + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +net/ipv6/esp6.c:508: error: UNINITIALIZED_VALUE + The value read from nexthdr.[_] was never initialized. + 506. + 507. ret = -EINVAL; + 508. > padlen = nexthdr[0]; + 509. if (padlen + 2 + alen >= elen) { + 510. net_dbg_ratelimited("ipsec esp packet is garbage padlen=%d, elen=%d\n", + +net/ipv6/esp6.c:523: error: UNINITIALIZED_VALUE + The value read from nexthdr.[_] was never initialized. + 521. pskb_trim(skb, skb->len - trimlen); + 522. + 523. > ret = nexthdr[1]; + 524. + 525. out: + +drivers/gpu/drm/i915/intel_guc_submission.c:499: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 497. * we also need to treat 0 as a reserved value. + 498. */ + 499. > cookie = READ_ONCE(db->cookie); + 500. WARN_ON_ONCE(xchg(&db->cookie, cookie + 1 ?: cookie + 2) != cookie); + 501. + +kernel/time/tick-common.c:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. trace_suspend_resume(TPS("timekeeping_freeze"), + 492. > smp_processor_id(), true); + 493. timekeeping_suspend(); + 494. } else { + +kernel/time/tick-common.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. tick_freeze_depth++; + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. > trace_suspend_resume(TPS("timekeeping_freeze"), + 492. smp_processor_id(), true); + 493. timekeeping_suspend(); + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:525: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 523. * only the first byte of the word is being modified + 524. */ + 525. > ret_val = e1000_read_eeprom(hw, last_word, 1, + 526. &eeprom_buff[last_word - first_word]); + 527. } + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +lib/rhashtable.c:521: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 519. + 520. RCU_INIT_POINTER(list->next, plist); + 521. > head = rht_dereference_bucket(head->next, tbl, hash); + 522. RCU_INIT_POINTER(list->rhead.next, head); + 523. rcu_assign_pointer(*pprev, obj); + +lib/rhashtable.c:518: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 516. + 517. list = container_of(obj, struct rhlist_head, rhead); + 518. > plist = container_of(head, struct rhlist_head, rhead); + 519. + 520. RCU_INIT_POINTER(list->next, plist); + +drivers/pci/pcie/aer/aerdrv_core.c:491: error: DEAD_STORE + The value written to &result (type unsigned int) is never used. + 489. static void do_recovery(struct pci_dev *dev, int severity) + 490. { + 491. > pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED; + 492. enum pci_channel_state state; + 493. + +drivers/tty/tty_buffer.c:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. * tty_buffer_flush(); ensures we see the committed buffer data + 514. */ + 515. > count = smp_load_acquire(&head->commit) - head->read; + 516. if (!count) { + 517. if (next == NULL) + +drivers/gpu/drm/drm_lease.c:504: error: DEAD_STORE + The value written to &fd (type int) is never used. + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + 504. > int fd = -1; + 505. uint32_t *object_ids; + 506. + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/umh.c:535: error: UNINITIALIZED_VALUE + The value read from cap_array.[_] was never initialized. + 533. */ + 534. for (i = 0; i < _KERNEL_CAPABILITY_U32S; i++) + 535. > new_cap.cap[i] = cap_array[i]; + 536. + 537. /* + +net/ipv4/route.c:496: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 494. u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ; + 495. atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ; + 496. > u32 old = READ_ONCE(*p_tstamp); + 497. u32 now = (u32)jiffies; + 498. u32 new, delta = 0; + +kernel/locking/rwsem-xadd.c:504: error: DEAD_STORE + The value written to &count (type long) is never used. + 502. + 503. /* undo write bias from down_write operation, stop active locking */ + 504. > count = atomic_long_sub_return(RWSEM_ACTIVE_WRITE_BIAS, &sem->count); + 505. + 506. /* do optimistic spinning and steal lock if possible */ + +block/blk-core.c:535: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 535, column 33. + 533. */ + 534. if (drain_all) { + 535. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 536. drain |= !list_empty(&q->queue_head); + 537. for (i = 0; i < 2; i++) { + +drivers/usb/early/ehci-dbgp.c:572: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugInEndpoint was never initialized. + 570. } + 571. dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. > dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + 574. /* Move the device to 127 if it isn't already there */ + +drivers/usb/early/ehci-dbgp.c:571: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugOutEndpoint was never initialized. + 569. goto err; + 570. } + 571. > dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + +drivers/gpu/drm/drm_ioc32.c:507: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 505. return -EFAULT; + 506. + 507. > request.ctx_id = req32.ctx_id; + 508. request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + +drivers/gpu/drm/drm_ioc32.c:508: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 506. + 507. request.ctx_id = req32.ctx_id; + 508. > request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + 510. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +net/sched/ematch.c:529: error: UNINITIALIZED_VALUE + The value read from stack.[_] was never initialized. + 527. pop_stack: + 528. if (stackp > 0) { + 529. > match_idx = stack[--stackp]; + 530. cur_match = tcf_em_get_match(tree, match_idx); + 531. + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +net/ipv4/raw.c:527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 525. */ + 526. hdrincl = inet->hdrincl; + 527. > hdrincl = READ_ONCE(hdrincl); + 528. /* + 529. * Check the flags. + +kernel/events/core.c:506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 504. void perf_sample_event_took(u64 sample_len_ns) + 505. { + 506. > u64 max_len = READ_ONCE(perf_sample_allowed_ns); + 507. u64 running_len; + 508. u64 avg_len; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +arch/x86/events/intel/uncore.c:552: error: UNINITIALIZED_VALUE + The value read from assign.[_] was never initialized. + 550. if (hwc->idx != assign[i] || + 551. hwc->last_tag != box->tags[assign[i]]) + 552. > uncore_assign_hw_event(box, event, assign[i]); + 553. else if (i < box->n_events) + 554. continue; + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +kernel/sched/core.c:511: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 509. + 510. raw_spin_lock_irqsave(&rq->lock, flags); + 511. > if (cpu_online(cpu) || cpu == smp_processor_id()) + 512. resched_curr(rq); + 513. raw_spin_unlock_irqrestore(&rq->lock, flags); + +kernel/rcu/update.c:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. int rcu_jiffies_till_stall_check(void) + 507. { + 508. > int till_stall_check = READ_ONCE(rcu_cpu_stall_timeout); + 509. + 510. /* + +net/socket.c:528: error: DEAD_STORE + The value written to &buffer (type char*) is never used. + 526. return -ERANGE; + 527. memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len); + 528. > buffer += len; + 529. } + 530. + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +arch/x86/events/intel/pt.c:513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 511. { + 512. struct pt *pt = this_cpu_ptr(&pt_ctx); + 513. > u64 ctl = READ_ONCE(event->hw.config); + 514. + 515. /* may be already stopped by a PMI */ + +kernel/time/tick-common.c:517: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 515. timekeeping_resume(); + 516. trace_suspend_resume(TPS("timekeeping_freeze"), + 517. > smp_processor_id(), false); + 518. } else { + 519. tick_resume_local(); + +kernel/time/tick-common.c:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. if (tick_freeze_depth == num_online_cpus()) { + 515. timekeeping_resume(); + 516. > trace_suspend_resume(TPS("timekeeping_freeze"), + 517. smp_processor_id(), false); + 518. } else { + +block/blk-mq-sched.c:513: error: DEAD_STORE + The value written to &set (type blk_mq_tag_set*) is never used. + 511. static void blk_mq_sched_tags_teardown(struct request_queue *q) + 512. { + 513. > struct blk_mq_tag_set *set = q->tag_set; + 514. struct blk_mq_hw_ctx *hctx; + 515. int i; + +drivers/input/mouse/alps.c:521: error: UNINITIALIZED_VALUE + The value read from slot.[_] was never initialized. + 519. input_mt_assign_slots(dev, slot, f->mt, n, 0); + 520. for (i = 0; i < n; i++) + 521. > alps_set_slot(dev, slot[i], f->mt[i].x, f->mt[i].y); + 522. + 523. input_mt_sync_frame(dev); + +include/net/sock.h:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. { + 514. if (unlikely(flags & MSG_PEEK)) { + 515. > return READ_ONCE(sk->sk_peek_off); + 516. } + 517. + +drivers/gpu/drm/drm_ioc32.c:524: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 522. return -EFAULT; + 523. + 524. > req.ctx_id = req32.ctx_id; + 525. err = drm_ioctl_kernel(file, drm_legacy_getsareactx, &req, DRM_AUTH); + 526. if (err) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +lib/bitmap.c:525: error: DEAD_STORE + The value written to &group_size (type unsigned int) is never used. + 523. totaldigits = c = 0; + 524. old_a = old_b = 0; + 525. > group_size = used_size = 0; + 526. bitmap_zero(maskp, nmaskbits); + 527. do { + +drivers/md/dm-stats.c:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. preempt_disable(); + 542. #endif + 543. > p = &s->stat_percpu[smp_processor_id()][entry]; + 544. + 545. if (!end) { + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +net/ipv6/ip6_flowlabel.c:574: error: UNINITIALIZED_VALUE + The value read from freq.flr_label was never initialized. + 572. if (freq.flr_share == IPV6_FL_S_NONE && + 573. ns_capable(net->user_ns, CAP_NET_ADMIN)) { + 574. > fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +drivers/input/mouse/cypress_ps2.c:543: error: UNINITIALIZED_VALUE + The value read from slots.[_] was never initialized. + 541. for (i = 0; i < n; i++) { + 542. contact = &report_data.contacts[i]; + 543. > input_mt_slot(input, slots[i]); + 544. input_mt_report_slot_state(input, MT_TOOL_FINGER, true); + 545. input_report_abs(input, ABS_MT_POSITION_X, contact->x); + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &ret (type int) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +drivers/gpu/drm/i915/intel_cdclk.c:548: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 546. val |= (cmd << DSPFREQGUAR_SHIFT); + 547. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 548. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 549. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 550. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:569: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 567. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 568. + 569. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 570. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 571. 50)) + +drivers/gpu/drm/i915/intel_cdclk.c:548: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 546. val |= (cmd << DSPFREQGUAR_SHIFT); + 547. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 548. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 549. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 550. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:569: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 567. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 568. + 569. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 570. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 571. 50)) + +drivers/i2c/i2c-core-smbus.c:539: error: DEAD_STORE + The value written to &orig_jiffies (type unsigned long) is never used. + 537. + 538. /* Retry automatically on arbitration loss */ + 539. > orig_jiffies = jiffies; + 540. for (res = 0, try = 0; try <= adapter->retries; try++) { + 541. res = adapter->algo->smbus_xfer(adapter, addr, flags, + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +net/ipv6/netfilter/nf_conntrack_reasm.c:554: error: UNINITIALIZED_VALUE + The value read from hdr.nexthdr was never initialized. + 552. prev_nhoff = start; + 553. + 554. > nexthdr = hdr.nexthdr; + 555. len -= hdrlen; + 556. start += hdrlen; + +net/ipv6/tcp_ipv6.c:557: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 555. + 556. if (ipv6_addr_v4mapped(&sin6->sin6_addr)) + 557. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3], + 558. AF_INET, prefixlen, cmd.tcpm_key, + 559. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:561: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 559. cmd.tcpm_keylen, GFP_KERNEL); + 560. + 561. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr, + 562. AF_INET6, prefixlen, cmd.tcpm_key, + 563. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:537: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 535. if (optname == TCP_MD5SIG_EXT && + 536. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 537. > prefixlen = cmd.tcpm_prefixlen; + 538. if (prefixlen > 128 || (ipv6_addr_v4mapped(&sin6->sin6_addr) && + 539. prefixlen > 32)) + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +block/blk-flush.c:545: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 544 could be null and is dereferenced at line 545, column 2. + 543. + 544. bio = bio_alloc(gfp_mask, 0); + 545. > bio_set_dev(bio, bdev); + 546. bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; + 547. + +include/net/sock.h:526: error: DEAD_STORE + The value written to &off (type int) is never used. + 524. + 525. if (unlikely(off >= 0)) { + 526. > off = max_t(s32, off - val, 0); + 527. WRITE_ONCE(sk->sk_peek_off, off); + 528. } + +include/net/sock.h:523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 521. static inline void sk_peek_offset_bwd(struct sock *sk, int val) + 522. { + 523. > s32 off = READ_ONCE(sk->sk_peek_off); + 524. + 525. if (unlikely(off >= 0)) { + +usr/gen_init_cpio.c:568: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 568, column 9. + 566. } + 567. + 568. > while (fgets(line, LINE_SIZE, cpio_list)) { + 569. int type_idx; + 570. size_t slen = strlen(line); + +usr/gen_init_cpio.c:580: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 580, column 12. + 578. + 579. if (! (type = strtok(line, " \t"))) { + 580. > fprintf(stderr, + 581. "ERROR: incorrect format, could not locate file type line %d: '%s'\n", + 582. line_nr, line); + +drivers/gpu/drm/i915/intel_hotplug.c:535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 533. mutex_lock(&dev->mode_config.mutex); + 534. + 535. > enabled = READ_ONCE(dev_priv->hotplug.poll_enabled); + 536. + 537. drm_connector_list_iter_begin(dev, &conn_iter); + +crypto/api.c:556: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 554. } + 555. + 556. > return ERR_PTR(err); + 557. } + 558. EXPORT_SYMBOL_GPL(crypto_alloc_tfm); + +kernel/rcu/srcutree.c:558: error: DEAD_STORE + The value written to &idxnext (type int) is never used. + 556. /* Initiate callback invocation as needed. */ + 557. idx = rcu_seq_ctr(gpseq) % ARRAY_SIZE(snp->srcu_have_cbs); + 558. > idxnext = (idx + 1) % ARRAY_SIZE(snp->srcu_have_cbs); + 559. rcu_for_each_node_breadth_first(sp, snp) { + 560. spin_lock_irq_rcu_node(snp); + +kernel/sched/core.c:528: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 526. int get_nohz_timer_target(void) + 527. { + 528. > int i, cpu = smp_processor_id(); + 529. struct sched_domain *sd; + 530. + +kernel/sched/core.c:528: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 526. int get_nohz_timer_target(void) + 527. { + 528. > int i, cpu = smp_processor_id(); + 529. struct sched_domain *sd; + 530. + +drivers/tty/serial/serial_core.c:545: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 543. ret = 1; + 544. } + 545. > uart_port_unlock(port, flags); + 546. return ret; + 547. } + +block/blk-mq.c:549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 547. } + 548. + 549. > cpu = get_cpu(); + 550. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 551. shared = cpus_share_cache(cpu, ctx->cpu); + +block/blk-mq.c:549: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 547. } + 548. + 549. > cpu = get_cpu(); + 550. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 551. shared = cpus_share_cache(cpu, ctx->cpu); + +drivers/gpu/drm/i915/intel_hdmi.c:541: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 537 could be null and is dereferenced at line 541, column 13. + 539. i915_reg_t reg = VIDEO_DIP_CTL; + 540. u32 val = I915_READ(reg); + 541. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 542. + 543. assert_hdmi_port_disabled(intel_hdmi); + +kernel/power/swap.c:572: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 570. pr_info("Image saving done\n"); + 571. swsusp_show_speed(start, stop, nr_to_write, "Wrote"); + 572. > return ret; + 573. } + 574. + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +lib/rhashtable.c:567: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 565. return ERR_PTR(-ENOMEM); + 566. + 567. > head = rht_dereference_bucket(*pprev, tbl, hash); + 568. + 569. RCU_INIT_POINTER(obj->next, head); + +net/sched/act_api.c:537: error: DEAD_STORE + The value written to &err (type int) is never used. + 535. tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) + 536. { + 537. > int err = -EINVAL; + 538. unsigned char *b = skb_tail_pointer(skb); + 539. struct nlattr *nest; + +drivers/gpu/drm/i915/intel_fbdev.c:633: error: DEAD_STORE + The value written to &intel_crtc (type intel_crtc*) is never used. + 631. /* Final pass to check if any active pipes don't have fbs */ + 632. for_each_crtc(dev, crtc) { + 633. > intel_crtc = to_intel_crtc(crtc); + 634. + 635. if (!crtc->state->active) + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +lib/decompress_unlzma.c:592: error: UNINITIALIZED_VALUE + The value read from header.pos was never initialized. + 590. + 591. mi = 0; + 592. > lc = header.pos; + 593. while (lc >= 9) { + 594. mi++; + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +drivers/gpu/drm/drm_ioc32.c:553: error: UNINITIALIZED_VALUE + The value read from res32.contexts was never initialized. + 551. + 552. res.count = res32.count; + 553. > res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + 555. if (err) + +drivers/gpu/drm/drm_ioc32.c:552: error: UNINITIALIZED_VALUE + The value read from res32.count was never initialized. + 550. return -EFAULT; + 551. + 552. > res.count = res32.count; + 553. res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + +drivers/usb/core/config.c:701: error: UNINITIALIZED_VALUE + The value read from inums.[_] was never initialized. + 699. j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. > dev_warn(ddev, "too many alternate settings for " + 702. "config %d interface %d: %d, " + 703. "using maximum allowed: %d\n", + +drivers/usb/core/config.c:750: error: UNINITIALIZED_VALUE + The value read from inums.[_] was never initialized. + 748. } + 749. if (n >= intfc->num_altsetting) + 750. > dev_warn(ddev, "config %d interface %d has no " + 751. "altsetting %d\n", cfgno, inums[i], j); + 752. } + +drivers/usb/core/config.c:699: error: UNINITIALIZED_VALUE + The value read from nalts.[_] was never initialized. + 697. /* Allocate the usb_interface_caches and altsetting arrays */ + 698. for (i = 0; i < nintf; ++i) { + 699. > j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. dev_warn(ddev, "too many alternate settings for " + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +drivers/gpu/drm/drm_dp_helper.c:600: error: UNINITIALIZED_VALUE + The value read from rev.[_] was never initialized. + 598. len = drm_dp_dpcd_read(aux, DP_BRANCH_SW_REV, rev, 2); + 599. if (len > 0) + 600. > seq_printf(m, "\t\tSW: %d.%d\n", rev[0], rev[1]); + 601. + 602. if (detailed_cap_info) { + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/intel_guc_submission.c:568: error: DEAD_STORE + The value written to &cs (type unsigned int*) is never used. + 566. } + 567. *cs++ = MI_USER_INTERRUPT; + 568. > *cs++ = MI_NOOP; + 569. + 570. GEM_BUG_ON(!IS_ALIGNED(ring->size, + +net/netfilter/nf_conntrack_ftp.c:557: error: NULL_DEREFERENCE + pointer `ftp` last assigned on line 551 could be null and is dereferenced at line 557, column 2. + 555. * failover breaks. + 556. */ + 557. > ftp->flags[IP_CT_DIR_ORIGINAL] |= NF_CT_FTP_SEQ_PICKUP; + 558. ftp->flags[IP_CT_DIR_REPLY] |= NF_CT_FTP_SEQ_PICKUP; + 559. return 0; + +security/keys/keyring.c:555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 553. struct keyring_search_context *ctx = iterator_data; + 554. const struct key *key = keyring_ptr_to_key(object); + 555. > unsigned long kflags = READ_ONCE(key->flags); + 556. short state = READ_ONCE(key->state); + 557. + +security/keys/keyring.c:556: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 554. const struct key *key = keyring_ptr_to_key(object); + 555. unsigned long kflags = READ_ONCE(key->flags); + 556. > short state = READ_ONCE(key->state); + 557. + 558. kenter("{%d}", key->serial); + +security/keys/keyring.c:568: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 566. /* skip invalidated, revoked and expired keys */ + 567. if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) { + 568. > time64_t expiry = READ_ONCE(key->expiry); + 569. + 570. if (kflags & ((1 << KEY_FLAG_INVALIDATED) | + +drivers/gpu/drm/i915/i915_debugfs.c:565: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 563. int count, ret; + 564. + 565. > nobject = READ_ONCE(dev_priv->mm.object_count); + 566. objects = kvmalloc_array(nobject, sizeof(*objects), GFP_KERNEL); + 567. if (!objects) + +drivers/tty/serial/serial_core.c:591: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 589. + 590. __uart_start(tty); + 591. > uart_port_unlock(port, flags); + 592. return ret; + 593. } + +security/selinux/ss/avtab.c:568: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 566. goto bad; + 567. } + 568. > nel = le32_to_cpu(buf[0]); + 569. if (!nel) { + 570. printk(KERN_ERR "SELinux: avtab: table is empty\n"); + +drivers/input/mouse/alps.c:586: error: DEAD_STORE + The value written to &z (type int) is never used. + 584. x = (s8)(((packet[0] & 0x20) << 2) | (packet[1] & 0x7f)); + 585. y = (s8)(((packet[0] & 0x10) << 3) | (packet[2] & 0x7f)); + 586. > z = (packet[4] & 0x7c) >> 2; + 587. + 588. /* + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +drivers/gpu/drm/i915/i915_pmu.c:595: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 591 could be null and is dereferenced at line 595, column 3. + 593. engine_event_instance(event)); + 594. GEM_BUG_ON(!engine); + 595. > engine->pmu.enable |= BIT(sample); + 596. + 597. GEM_BUG_ON(sample >= I915_PMU_SAMPLE_BITS); + +kernel/exit.c:565: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 564 could be null and is dereferenced at line 565, column 31. + 563. { + 564. struct pid_namespace *pid_ns = task_active_pid_ns(father); + 565. > struct task_struct *reaper = pid_ns->child_reaper; + 566. + 567. if (likely(reaper != father)) + +block/scsi_ioctl.c:643: error: UNINITIALIZED_VALUE + The value read from cgc.buffer was never initialized. + 641. break; + 642. + 643. > hdr.dxferp = cgc.buffer; + 644. hdr.sbp = cgc.sense; + 645. if (hdr.sbp) + +block/scsi_ioctl.c:622: error: UNINITIALIZED_VALUE + The value read from cgc.buflen was never initialized. + 620. hdr.interface_id = 'S'; + 621. hdr.cmd_len = sizeof(cgc.cmd); + 622. > hdr.dxfer_len = cgc.buflen; + 623. err = 0; + 624. switch (cgc.data_direction) { + +block/scsi_ioctl.c:618: error: UNINITIALIZED_VALUE + The value read from cgc.timeout was never initialized. + 616. if (copy_from_user(&cgc, arg, sizeof(cgc))) + 617. break; + 618. > cgc.timeout = clock_t_to_jiffies(cgc.timeout); + 619. memset(&hdr, 0, sizeof(hdr)); + 620. hdr.interface_id = 'S'; + +net/wireless/trace.h:561: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 559. ); + 560. + 561. > DECLARE_EVENT_CLASS(wiphy_netdev_evt, + 562. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 563. TP_ARGS(wiphy, netdev), + +net/core/sock.c:566: error: DEAD_STORE + The value written to &ret (type int) is never used. + 564. int optlen) + 565. { + 566. > int ret = -ENOPROTOOPT; + 567. #ifdef CONFIG_NETDEVICES + 568. struct net *net = sock_net(sk); + +kernel/sched/core.c:568: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 566. struct rq *rq = cpu_rq(cpu); + 567. + 568. > if (cpu == smp_processor_id()) + 569. return; + 570. + +drivers/ata/ata_piix.c:638: error: UNINITIALIZED_VALUE + The value read from slave_data was never initialized. + 636. pci_write_config_word(dev, master_port, master_data); + 637. if (is_slave) + 638. > pci_write_config_byte(dev, slave_port, slave_data); + 639. + 640. /* Ensure the UDMA bit is off - it will be turned back on if + +drivers/gpu/drm/i915/i915_gem_stolen.c:625: error: DEAD_STORE + The value written to &ret (type int) is never used. + 623. vma = i915_vma_instance(obj, &ggtt->base, NULL); + 624. if (IS_ERR(vma)) { + 625. > ret = PTR_ERR(vma); + 626. goto err_pages; + 627. } + +net/sched/act_api.c:570: error: DEAD_STORE + The value written to &err (type int) is never used. + 568. { + 569. struct tc_action *a; + 570. > int err = -EINVAL; + 571. struct nlattr *nest; + 572. + +net/netfilter/nf_conntrack_proto.c:577: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 570 could be null and is dereferenced by call to `nf_ct_l4proto_register_sysctl()` at line 577, column 8. + 575. if (err < 0) + 576. return err; + 577. > err = nf_ct_l4proto_register_sysctl(net, + 578. pn, + 579. &nf_conntrack_l4proto_generic); + +arch/x86/events/intel/rapl.c:578: error: NULL_DEREFERENCE + pointer `pmu` last assigned on line 571 could be null and is dereferenced at line 578, column 2. + 576. return 0; + 577. + 578. > pmu->cpu = -1; + 579. /* Find a new cpu to collect rapl events */ + 580. target = cpumask_any_but(topology_core_cpumask(cpu), cpu); + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +kernel/cgroup/cpuset.c:577: error: MEMORY_LEAK + `pos_css` is not reachable after line 577, column 2. + 575. + 576. rcu_read_lock(); + 577. > cpuset_for_each_descendant_pre(cp, pos_css, root_cs) { + 578. /* skip the whole subtree if @cp doesn't have any CPU */ + 579. if (cpumask_empty(cp->cpus_allowed)) { + +drivers/gpu/drm/drm_vblank.c:674: error: UNINITIALIZED_VALUE + The value read from etime was never initialized. + 672. return true; + 673. + 674. > ts_etime = ktime_to_timespec64(etime); + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + +drivers/gpu/drm/drm_vblank.c:677: error: UNINITIALIZED_VALUE + The value read from hpos was never initialized. + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + 677. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 678. pipe, hpos, vpos, + 679. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/drm_vblank.c:677: error: UNINITIALIZED_VALUE + The value read from vpos was never initialized. + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + 677. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 678. pipe, hpos, vpos, + 679. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/scsi/sg.c:668: error: UNINITIALIZED_VALUE + The value read from cmnd.[_] was never initialized. + 666. */ + 667. if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) { + 668. > printk_ratelimited(KERN_WARNING + 669. "sg_write: data in/out %d/%d bytes " + 670. "for SCSI command 0x%x-- guessing " + +drivers/scsi/sg.c:632: error: UNINITIALIZED_VALUE + The value read from old_hdr.reply_len was never initialized. + 630. /* Determine buffer size. */ + 631. input_size = count - cmd_size; + 632. > mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len; + 633. mxsize -= SZ_SG_HEADER; + 634. input_size -= SZ_SG_HEADER; + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +kernel/trace/trace_events.c:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. + 579. /* Nothing to do if we are already tracing */ + 580. > if (!this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 581. return; + 582. + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +drivers/char/hpet.c:594: error: DEAD_STORE + The value written to &hpet (type hpet*) is never used. + 592. case HPET_IRQFREQ: + 593. timer = devp->hd_timer; + 594. > hpet = devp->hd_hpet; + 595. hpetp = devp->hd_hpets; + 596. break; + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +kernel/sched/core.c:588: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 586. return true; /* Don't try to wake offline CPUs. */ + 587. if (tick_nohz_full_cpu(cpu)) { + 588. > if (cpu != smp_processor_id() || + 589. tick_nohz_tick_stopped()) + 590. tick_nohz_full_kick_cpu(cpu); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:620: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 618. + 619. /* ctx->ctx_flags */ + 620. > p = xdr_encode_hyper(p, ctx->ctx_flags); + 621. + 622. /* ctx->locally_initiated */ + +arch/x86/events/amd/ibs.c:645: error: DEAD_STORE + The value written to &buf (type unsigned long long*) is never used. + 643. } + 644. if (ibs_caps & IBS_CAPS_OPDATA4) { + 645. > rdmsrl(MSR_AMD64_IBSOPDATA4, *buf++); + 646. size++; + 647. } + +drivers/char/hw_random/core.c:580: error: DEAD_STORE + The value written to &ret (type int) is never used. + 578. static int __init hwrng_modinit(void) + 579. { + 580. > int ret = -ENOMEM; + 581. + 582. /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ + +drivers/gpu/drm/drm_ioc32.c:602: error: UNINITIALIZED_VALUE + The value read from d.granted_count was never initialized. + 600. + 601. if (put_user(d.request_size, &argp->request_size) + 602. > || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + 604. + +drivers/gpu/drm/drm_ioc32.c:601: error: UNINITIALIZED_VALUE + The value read from d.request_size was never initialized. + 599. return err; + 600. + 601. > if (put_user(d.request_size, &argp->request_size) + 602. || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:589: error: UNINITIALIZED_VALUE + The value read from d32.context was never initialized. + 587. return -EFAULT; + 588. + 589. > d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + +drivers/gpu/drm/drm_ioc32.c:593: error: UNINITIALIZED_VALUE + The value read from d32.flags was never initialized. + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. > d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + +drivers/gpu/drm/drm_ioc32.c:594: error: UNINITIALIZED_VALUE + The value read from d32.request_count was never initialized. + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. > d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + +drivers/gpu/drm/drm_ioc32.c:595: error: UNINITIALIZED_VALUE + The value read from d32.request_indices was never initialized. + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. > d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:596: error: UNINITIALIZED_VALUE + The value read from d32.request_sizes was never initialized. + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. > d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + 598. if (err) + +drivers/gpu/drm/drm_ioc32.c:590: error: UNINITIALIZED_VALUE + The value read from d32.send_count was never initialized. + 588. + 589. d.context = d32.context; + 590. > d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + +drivers/gpu/drm/drm_ioc32.c:591: error: UNINITIALIZED_VALUE + The value read from d32.send_indices was never initialized. + 589. d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. > d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + +drivers/gpu/drm/drm_ioc32.c:592: error: UNINITIALIZED_VALUE + The value read from d32.send_sizes was never initialized. + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. > d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + +drivers/gpu/drm/i915/intel_fbc.c:582: error: DEAD_STORE + The value written to &compressed_llb (type drm_mm_node*) is never used. + 580. struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 581. struct intel_fbc *fbc = &dev_priv->fbc; + 582. > struct drm_mm_node *uninitialized_var(compressed_llb); + 583. int size, fb_cpp, ret; + 584. + +kernel/time/posix-timers.c:587: error: MEMORY_LEAK + `return` is not reachable after line 587, column 3. + 585. if (copy_from_user(&event, timer_event_spec, sizeof (event))) + 586. return -EFAULT; + 587. > return do_timer_create(which_clock, &event, created_timer_id); + 588. } + 589. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:589: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 589, column 9. + 587. return do_timer_create(which_clock, &event, created_timer_id); + 588. } + 589. > return do_timer_create(which_clock, NULL, created_timer_id); + 590. } + 591. + +net/ipv4/tcp_minisocks.c:788: error: UNINITIALIZED_VALUE + The value read from own_req was never initialized. + 786. sock_rps_save_rxhash(child, skb); + 787. tcp_synack_rtt_meas(child, req); + 788. > return inet_csk_complete_hashdance(sk, child, req, own_req); + 789. + 790. listen_overflow: + +drivers/md/md-bitmap.c:588: error: DEAD_STORE + The value written to &err (type int) is never used. + 586. int nodes = 0; + 587. unsigned long sectors_reserved = 0; + 588. > int err = -EINVAL; + 589. struct page *sb_page; + 590. loff_t offset = bitmap->mddev->bitmap_info.offset; + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +sound/core/pcm_native.c:609: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 607. if (trace_hw_interval_param_enabled()) { + 608. if (hw_is_interval(*v)) + 609. > old_interval = *hw_param_interval(params, *v); + 610. } + 611. if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) + +sound/core/pcm_native.c:605: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 603. if (trace_hw_mask_param_enabled()) { + 604. if (hw_is_mask(*v)) + 605. > old_mask = *hw_param_mask(params, *v); + 606. } + 607. if (trace_hw_interval_param_enabled()) { + +drivers/md/dm-region-hash.c:603: error: UNINITIALIZED_VALUE + The value read from region was never initialized. + 601. */ + 602. read_lock(&rh->hash_lock); + 603. > reg = __rh_find(rh, region); + 604. read_unlock(&rh->hash_lock); + 605. + +ipc/mqueue.c:623: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 621. spin_unlock(&info->lock); + 622. out: + 623. > return retval; + 624. } + 625. + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +lib/rhashtable.c:612: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 610. } + 611. + 612. > data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 613. new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 614. if (PTR_ERR(new_tbl) != -EEXIST) + +lib/rhashtable.c:613: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 611. + 612. data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 613. > new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 614. if (PTR_ERR(new_tbl) != -EEXIST) + 615. data = ERR_CAST(new_tbl); + +drivers/hid/usbhid/hiddev.c:748: error: UNINITIALIZED_VALUE + The value read from finfo.report_id was never initialized. + 746. + 747. rinfo.report_type = finfo.report_type; + 748. > rinfo.report_id = finfo.report_id; + 749. + 750. report = hiddev_lookup_report(hid, &rinfo); + +drivers/hid/usbhid/hiddev.c:747: error: UNINITIALIZED_VALUE + The value read from finfo.report_type was never initialized. + 745. } + 746. + 747. > rinfo.report_type = finfo.report_type; + 748. rinfo.report_id = finfo.report_id; + 749. + +net/netfilter/nf_conntrack_proto.c:592: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 589 could be null and is dereferenced at line 592, column 2. + 590. &nf_conntrack_l4proto_generic); + 591. + 592. > pn->users--; + 593. nf_ct_l4proto_unregister_sysctl(net, + 594. pn, + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +include/linux/pagemap.h:609: error: DEAD_STORE + The value written to &c (type char) is never used. + 607. if (((unsigned long)uaddr & PAGE_MASK) == + 608. ((unsigned long)end & PAGE_MASK)) { + 609. > return __get_user(c, end); + 610. } + 611. + +kernel/trace/trace_events.c:596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 594. + 595. /* Nothing to do if we are not tracing */ + 596. > if (this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 597. return; + 598. + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +drivers/usb/host/ohci-q.c:682: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 680. && cnt < urb_priv->length) { + 681. td_fill (ohci, info, 0, 0, urb, cnt); + 682. > cnt++; + 683. } + 684. /* maybe kickstart bulk list */ + +drivers/usb/host/ohci-q.c:706: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 704. ? TD_CC | TD_DP_IN | TD_T_DATA1 + 705. : TD_CC | TD_DP_OUT | TD_T_DATA1; + 706. > td_fill (ohci, info, data, 0, urb, cnt++); + 707. /* maybe kickstart control list */ + 708. wmb (); + +drivers/dma/dmaengine.c:595: error: DEAD_STORE + The value written to &err (type int) is never used. + 593. struct dma_chan *dma_get_slave_channel(struct dma_chan *chan) + 594. { + 595. > int err = -EBUSY; + 596. + 597. /* lock against __dma_request_channel */ + +kernel/time/posix-timers.c:602: error: MEMORY_LEAK + `return` is not reachable after line 602, column 3. + 600. if (get_compat_sigevent(&event, timer_event_spec)) + 601. return -EFAULT; + 602. > return do_timer_create(which_clock, &event, created_timer_id); + 603. } + 604. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:604: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `do_timer_create()` at line 604, column 9. + 602. return do_timer_create(which_clock, &event, created_timer_id); + 603. } + 604. > return do_timer_create(which_clock, NULL, created_timer_id); + 605. } + 606. #endif + +net/sunrpc/rpcb_clnt.c:602: error: UNINITIALIZED_VALUE + The value read from map was never initialized. + 600. .r_owner = RPCB_OWNER_STRING, + 601. }; + 602. > struct rpc_message msg = { + 603. .rpc_argp = &map, + 604. }; + +kernel/sched/cputime.c:624: error: DEAD_STORE + The value written to &utime (type unsigned long long) is never used. + 622. */ + 623. if (stime == 0) { + 624. > utime = rtime; + 625. goto update; + 626. } + +drivers/tty/serial/serial_core.c:604: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 602. port = uart_port_lock(state, flags); + 603. ret = uart_circ_chars_free(&state->xmit); + 604. > uart_port_unlock(port, flags); + 605. return ret; + 606. } + +net/ipv4/ip_sockglue.c:1021: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 1019. memset(&mreq, 0, sizeof(mreq)); + 1020. mreq.imr_multiaddr = psin->sin_addr; + 1021. > mreq.imr_ifindex = greq.gr_interface; + 1022. + 1023. if (optname == MCAST_JOIN_GROUP) + +net/ipv4/ip_sockglue.c:1068: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1066. mreq.imr_multiaddr = psin->sin_addr; + 1067. mreq.imr_address.s_addr = 0; + 1068. > mreq.imr_ifindex = greqs.gsr_interface; + 1069. err = ip_mc_join_group(sk, &mreq); + 1070. if (err && err != -EADDRINUSE) + +net/ipv4/ip_sockglue.c:1079: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1077. add = 0; + 1078. } + 1079. > err = ip_mc_source(add, omode, sk, &mreqs, + 1080. greqs.gsr_interface); + 1081. break; + +net/ipv4/ip_sockglue.c:885: error: UNINITIALIZED_VALUE + The value read from mreq.imr_ifindex was never initialized. + 883. mreq.imr_ifindex = dev->ifindex; + 884. } else + 885. > dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex); + 886. + 887. + +net/ipv4/ip_sockglue.c:990: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_interface was never initialized. + 988. + 989. mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 990. > mreq.imr_address.s_addr = mreqs.imr_interface; + 991. mreq.imr_ifindex = 0; + 992. err = ip_mc_join_group(sk, &mreq); + +net/ipv4/ip_sockglue.c:989: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_multiaddr was never initialized. + 987. struct ip_mreqn mreq; + 988. + 989. > mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 990. mreq.imr_address.s_addr = mreqs.imr_interface; + 991. mreq.imr_ifindex = 0; + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +lib/iov_iter.c:608: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 606. if (iter_is_iovec(i)) + 607. might_fault(); + 608. > iterate_all_kinds(i, bytes, v, ({ + 609. if (copyin((to += v.iov_len) - v.iov_len, + 610. v.iov_base, v.iov_len)) + +drivers/ata/libata-scsi.c:639: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 637. scsi_cmd[0] = ATA_16; + 638. + 639. > scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + +drivers/ata/libata-scsi.c:641: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 639. scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. > scsi_cmd[6] = args[3]; + 642. scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + +drivers/ata/libata-scsi.c:642: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + 642. > scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + 644. scsi_cmd[12] = 0xc2; + +drivers/ata/libata-scsi.c:646: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 644. scsi_cmd[12] = 0xc2; + 645. } else { + 646. > scsi_cmd[6] = args[1]; + 647. } + 648. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:648: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 646. scsi_cmd[6] = args[1]; + 647. } + 648. > scsi_cmd[14] = args[0]; + 649. + 650. /* Good values for timeout and retries? Values below + +drivers/gpu/drm/i915/intel_cdclk.c:628: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 626. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 627. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 628. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 629. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 630. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:628: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 626. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 627. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 628. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 629. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 630. 50)) { + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +drivers/gpu/drm/drm_dp_mst_topology.c:620: error: DEAD_STORE + The value written to &idx (type int) is never used. + 618. msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1; + 619. msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7); + 620. > idx++; + 621. return true; + 622. fail_len: + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +net/ipv4/devinet.c:609: error: DEAD_STORE + The value written to &err (type int) is never used. + 607. struct ifaddrmsg *ifm; + 608. struct in_ifaddr *ifa, **ifap; + 609. > int err = -EINVAL; + 610. + 611. ASSERT_RTNL(); + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +crypto/drbg.c:607: error: DEAD_STORE + The value written to &ret (type int) is never used. + 605. int reseed) + 606. { + 607. > int ret = -EFAULT; + 608. int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + +lib/vsprintf.c:625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 623. for (i = 0; i < depth; i++, d = p) { + 624. p = READ_ONCE(d->d_parent); + 625. > array[i] = READ_ONCE(d->d_name.name); + 626. if (p == d) { + 627. if (i) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +drivers/tty/serial/serial_core.c:617: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 615. port = uart_port_lock(state, flags); + 616. ret = uart_circ_chars_pending(&state->xmit); + 617. > uart_port_unlock(port, flags); + 618. return ret; + 619. } + +kernel/sched/core.c:610: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 608. static inline bool got_nohz_idle_kick(void) + 609. { + 610. > int cpu = smp_processor_id(); + 611. + 612. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +kernel/sched/core.c:610: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 608. static inline bool got_nohz_idle_kick(void) + 609. { + 610. > int cpu = smp_processor_id(); + 611. + 612. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +drivers/pcmcia/ds.c:614: error: DEAD_STORE + The value written to &ret (type int) is never used. + 612. cistpl_longlink_mfc_t mfc; + 613. unsigned int no_funcs, i, no_chains; + 614. > int ret = -EAGAIN; + 615. + 616. mutex_lock(&s->ops_mutex); + +drivers/pcmcia/ds.c:655: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 653. + 654. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) + 655. > no_funcs = mfc.nfn; + 656. else + 657. no_funcs = 1; + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &ret (type int) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +tools/lib/subcmd/parse-options.c:659: error: SHELL_INJECTION + EnvironmentVariable(getenv()) in procedure setup_pager() at line 66, column 22 ~> ShellExec(execvp()) in procedure execv_cmd() at line 180, column 2. + 657. else + 658. astrcatf(&error_buf, "unknown switch `%c'", *ctx.opt); + 659. > usage_with_options(usagestr, options); + 660. } + 661. + +drivers/gpu/drm/i915/i915_pmu.c:635: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 625 could be null and is dereferenced at line 635, column 7. + 633. * bitmask when the last listener on an event goes away. + 634. */ + 635. > if (--engine->pmu.enable_count[sample] == 0) + 636. engine->pmu.enable &= ~BIT(sample); + 637. } + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +net/netfilter/nf_conntrack_core.c:624: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 622. unsigned int sequence; + 623. + 624. > zone = nf_ct_zone(ct); + 625. + 626. local_bh_disable(); + +drivers/tty/pty.c:617: error: DEAD_STORE + The value written to &fd (type int) is never used. + 615. int ptm_open_peer(struct file *master, struct tty_struct *tty, int flags) + 616. { + 617. > int fd = -1; + 618. struct file *filp; + 619. int retval = -EINVAL; + +drivers/tty/pty.c:619: error: DEAD_STORE + The value written to &retval (type int) is never used. + 617. int fd = -1; + 618. struct file *filp; + 619. > int retval = -EINVAL; + 620. struct path path; + 621. + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.act_mask was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_nr was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_size was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.end_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.pid was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.start_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +include/linux/sched/signal.h:622: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 620. unsigned int limit) + 621. { + 622. > return READ_ONCE(tsk->signal->rlim[limit].rlim_cur); + 623. } + 624. + +net/sunrpc/svc_xprt.c:649: error: DEAD_STORE + The value written to &i (type int) is never used. + 647. } + 648. rqstp->rq_page_end = &rqstp->rq_pages[i]; + 649. > rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */ + 650. + 651. /* Make arg->head point to first page and arg->pages point to rest */ + +drivers/tty/serial/serial_core.c:644: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 642. if (port->ops->flush_buffer) + 643. port->ops->flush_buffer(port); + 644. > uart_port_unlock(port, flags); + 645. tty_port_tty_wakeup(&state->port); + 646. } + +net/core/sock.c:624: error: DEAD_STORE + The value written to &ret (type int) is never used. + 622. int __user *optlen, int len) + 623. { + 624. > int ret = -ENOPROTOOPT; + 625. #ifdef CONFIG_NETDEVICES + 626. struct net *net = sock_net(sk); + +net/netlabel/netlabel_kapi.c:624: error: DEAD_STORE + The value written to &iter (type netlbl_lsm_catmap*) is never used. + 622. int netlbl_catmap_walk(struct netlbl_lsm_catmap *catmap, u32 offset) + 623. { + 624. > struct netlbl_lsm_catmap *iter = catmap; + 625. u32 idx; + 626. u32 bit; + +drivers/gpu/drm/i915/intel_guc_submission.c:631: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 629. &data->preempt_ctx_report[engine->guc_id]; + 630. + 631. > WARN_ON(wait_for_atomic(report->report_return_status == + 632. INTEL_GUC_REPORT_STATUS_COMPLETE, + 633. GUC_PREEMPT_POSTPROCESS_DELAY_MS)); + +drivers/gpu/drm/i915/intel_guc_submission.c:631: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 629. &data->preempt_ctx_report[engine->guc_id]; + 630. + 631. > WARN_ON(wait_for_atomic(report->report_return_status == + 632. INTEL_GUC_REPORT_STATUS_COMPLETE, + 633. GUC_PREEMPT_POSTPROCESS_DELAY_MS)); + +net/wireless/util.c:645: error: UNINITIALIZED_VALUE + The value read from eth.h_proto was never initialized. + 643. + 644. skb_copy_bits(skb, offset, ð, sizeof(eth)); + 645. > len = ntohs(eth.h_proto); + 646. subframe_len = sizeof(struct ethhdr) + len; + 647. padding = (4 - subframe_len) & 0x3; + +include/linux/sched/signal.h:628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 626. unsigned int limit) + 627. { + 628. > return READ_ONCE(tsk->signal->rlim[limit].rlim_max); + 629. } + 630. + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +drivers/gpu/drm/drm_dp_mst_topology.c:643: error: DEAD_STORE + The value written to &idx (type int) is never used. + 641. + 642. msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]); + 643. > idx++; + 644. return true; + 645. fail_len: + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +drivers/char/random.c:643: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 641. + 642. retry: + 643. > entropy_count = orig = READ_ONCE(r->entropy_count); + 644. if (nfrac < 0) { + 645. /* Debit */ + +sound/core/info.c:635: error: DEAD_STORE + The value written to &c (type int) is never used. + 633. int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) + 634. { + 635. > int c = -1; + 636. + 637. if (snd_BUG_ON(!buffer || !buffer->buffer)) + +net/ipv4/ipconfig.c:709: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 707. } + 708. + 709. > *e++ = 255; /* End of the list */ + 710. } + 711. + +drivers/usb/core/message.c:658: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 656. break; + 657. } + 658. > return result; + 659. } + 660. EXPORT_SYMBOL_GPL(usb_get_descriptor); + +drivers/gpu/drm/drm_ioc32.c:652: error: UNINITIALIZED_VALUE + The value read from info.agp_version_major was never initialized. + 650. return err; + 651. + 652. > i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + +drivers/gpu/drm/drm_ioc32.c:653: error: UNINITIALIZED_VALUE + The value read from info.agp_version_minor was never initialized. + 651. + 652. i32.agp_version_major = info.agp_version_major; + 653. > i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + +drivers/gpu/drm/drm_ioc32.c:655: error: UNINITIALIZED_VALUE + The value read from info.aperture_base was never initialized. + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. > i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + +drivers/gpu/drm/drm_ioc32.c:656: error: UNINITIALIZED_VALUE + The value read from info.aperture_size was never initialized. + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. > i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + +drivers/gpu/drm/drm_ioc32.c:660: error: UNINITIALIZED_VALUE + The value read from info.id_device was never initialized. + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. > i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + 662. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:659: error: UNINITIALIZED_VALUE + The value read from info.id_vendor was never initialized. + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. > i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + +drivers/gpu/drm/drm_ioc32.c:657: error: UNINITIALIZED_VALUE + The value read from info.memory_allowed was never initialized. + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. > i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + +drivers/gpu/drm/drm_ioc32.c:658: error: UNINITIALIZED_VALUE + The value read from info.memory_used was never initialized. + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. > i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + +drivers/gpu/drm/drm_ioc32.c:654: error: UNINITIALIZED_VALUE + The value read from info.mode was never initialized. + 652. i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. > i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + +include/linux/atomic.h:653: error: UNINITIALIZED_VALUE + The value read from dec was never initialized. + 651. c = old; + 652. } + 653. > return dec; + 654. } + 655. #endif + +net/sunrpc/auth_gss/gss_rpc_xdr.c:683: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 681. + 682. /* ctx->ctx_flags */ + 683. > p = xdr_decode_hyper(p, &ctx->ctx_flags); + 684. + 685. /* ctx->locally_initiated */ + +block/blk-merge.c:651: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 649. int cpu; + 650. + 651. > cpu = part_stat_lock(); + 652. part = req->part; + 653. + +block/blk-merge.c:651: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 649. int cpu; + 650. + 651. > cpu = part_stat_lock(); + 652. part = req->part; + 653. + +kernel/relay.c:685: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 683. } + 684. + 685. > curr_cpu = get_cpu(); + 686. /* + 687. * The CPU hotplug notifier ran before us and created buffers with + +kernel/relay.c:685: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 683. } + 684. + 685. > curr_cpu = get_cpu(); + 686. /* + 687. * The CPU hotplug notifier ran before us and created buffers with + +net/core/dev.c:661: error: UNINITIALIZED_VALUE + The value read from ints.[_] was never initialized. + 659. memset(&map, 0, sizeof(map)); + 660. if (ints[0] > 0) + 661. > map.irq = ints[1]; + 662. if (ints[0] > 1) + 663. map.base_addr = ints[2]; + +net/core/dev.c:663: error: UNINITIALIZED_VALUE + The value read from ints.[_] was never initialized. + 661. map.irq = ints[1]; + 662. if (ints[0] > 1) + 663. > map.base_addr = ints[2]; + 664. if (ints[0] > 2) + 665. map.mem_start = ints[3]; + +net/core/dev.c:665: error: UNINITIALIZED_VALUE + The value read from ints.[_] was never initialized. + 663. map.base_addr = ints[2]; + 664. if (ints[0] > 2) + 665. > map.mem_start = ints[3]; + 666. if (ints[0] > 3) + 667. map.mem_end = ints[4]; + +net/core/dev.c:667: error: UNINITIALIZED_VALUE + The value read from ints.[_] was never initialized. + 665. map.mem_start = ints[3]; + 666. if (ints[0] > 3) + 667. > map.mem_end = ints[4]; + 668. + 669. /* Add new entry to the list */ + +drivers/gpu/drm/i915/intel_guc_submission.c:663: error: DEAD_STORE + The value written to &count (type unsigned int) is never used. + 661. rq = port_unpack(&port[n], &count); + 662. if (rq && count == 0) { + 663. > port_set(&port[n], port_pack(rq, ++count)); + 664. + 665. flush_ggtt_writes(rq->ring->vma); + +net/sunrpc/xprtsock.c:746: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 744. } + 745. + 746. > return status; + 747. } + 748. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/time/tick-sched.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static inline bool local_timer_softirq_pending(void) + 654. { + 655. > return local_softirq_pending() & TIMER_SOFTIRQ; + 656. } + 657. + +block/bio.c:699: error: NULL_DEREFERENCE + pointer `bio->bi_io_vec` last assigned on line 684 could be null and is dereferenced at line 699, column 3. + 697. break; + 698. case REQ_OP_WRITE_SAME: + 699. > bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0]; + 700. break; + 701. default: + +drivers/gpu/drm/i915/intel_ringbuffer.h:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. { + 659. /* Ensure that the compiler doesn't optimize away the load. */ + 660. > return READ_ONCE(engine->status_page.page_addr[reg]); + 661. } + 662. + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +kernel/softirq.c:661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 659. { + 660. local_irq_disable(); + 661. > if (local_softirq_pending()) { + 662. /* + 663. * We can safely run softirq on inline stack, as we are not deep + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/linux/netdevice.h:669: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 667. + 668. /* We only give a hint, preemption can change CPU under us */ + 669. > val |= raw_smp_processor_id(); + 670. + 671. if (table->ents[index] != val) + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +lib/iov_iter.c:673: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 671. if (unlikely(i->count < bytes)) + 672. return false; + 673. > iterate_all_kinds(i, bytes, v, ({ + 674. if (__copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len, + 675. v.iov_base, v.iov_len)) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +drivers/md/dm-stats.c:676: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 674. + 675. local_irq_disable(); + 676. > p = &s->stat_percpu[smp_processor_id()][x]; + 677. dm_stat_round(s, shared, p); + 678. local_irq_enable(); + +ipc/sem.c:717: error: DEAD_STORE + The value written to &result (type int) is never used. + 715. curr = &sma->sems[sop->sem_num]; + 716. sem_op = sop->sem_op; + 717. > result = curr->semval; + 718. + 719. if (sop->sem_flg & SEM_UNDO) { + +kernel/kexec_core.c:759: error: DEAD_STORE + The value written to &addr (type unsigned long) is never used. + 757. continue; + 758. } + 759. > addr = old_addr; + 760. page = old_page; + 761. break; + +drivers/gpu/drm/drm_ioc32.c:685: error: UNINITIALIZED_VALUE + The value read from req32.size was never initialized. + 683. return -EFAULT; + 684. + 685. > request.size = req32.size; + 686. request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:686: error: UNINITIALIZED_VALUE + The value read from req32.type was never initialized. + 684. + 685. request.size = req32.size; + 686. > request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + 688. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +drivers/gpu/drm/drm_ioc32.c:692: error: UNINITIALIZED_VALUE + The value read from request.handle was never initialized. + 690. return err; + 691. + 692. > req32.handle = request.handle; + 693. req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + +drivers/gpu/drm/drm_ioc32.c:693: error: UNINITIALIZED_VALUE + The value read from request.physical was never initialized. + 691. + 692. req32.handle = request.handle; + 693. > req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + 695. drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, + +drivers/thermal/thermal_core.c:708: error: UNINITIALIZED_VALUE + The value read from max_state was never initialized. + 706. /* lower default 0, upper default max_state */ + 707. lower = lower == THERMAL_NO_LIMIT ? 0 : lower; + 708. > upper = upper == THERMAL_NO_LIMIT ? max_state : upper; + 709. + 710. if (lower > upper || upper > max_state) + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +net/ipv4/inet_connection_sock.c:720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 718. } + 719. } + 720. > defer_accept = READ_ONCE(queue->rskq_defer_accept); + 721. if (defer_accept) + 722. max_retries = defer_accept; + +net/ipv6/udp.c:687: error: DEAD_STORE + The value written to &dif (type int) is never used. + 685. unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. > int dif = inet6_iif(skb); + 688. struct hlist_node *node; + 689. struct sk_buff *nskb; + +net/ipv6/udp.c:685: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 683. unsigned short hnum = ntohs(uh->dest); + 684. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 685. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. int dif = inet6_iif(skb); + +net/ipv6/udp.c:697: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 695. start_lookup: + 696. hslot = &udptable->hash2[hash2]; + 697. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 698. } + 699. + +drivers/gpu/drm/i915/intel_runtime_pm.c:683: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 682 could be null and is dereferenced at line 683, column 6. + 681. + 682. power_well = lookup_power_well(dev_priv, BXT_DPIO_CMN_A); + 683. > if (power_well->count > 0) + 684. bxt_ddi_phy_verify_state(dev_priv, power_well->bxt.phy); + 685. + +drivers/thermal/thermal_sysfs.c:689: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 687. if (ret) + 688. return ret; + 689. > return sprintf(buf, "%ld\n", state); + 690. } + 691. + +lib/decompress_bunzip2.c:686: error: DEAD_STORE + The value written to &i (type int) is never used. + 684. { + 685. struct bunzip_data *bd; + 686. > int i = -1; + 687. unsigned char *inbuf; + 688. + +drivers/pcmcia/ds.c:707: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 705. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 706. &mfc)) + 707. > new_funcs = mfc.nfn; + 708. else + 709. new_funcs = 1; + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +drivers/gpu/drm/i915/intel_hdmi.c:692: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 688 could be null and is dereferenced at line 692, column 13. + 690. i915_reg_t reg = TVIDEO_DIP_CTL(intel_crtc->pipe); + 691. u32 val = I915_READ(reg); + 692. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 693. + 694. assert_hdmi_port_disabled(intel_hdmi); + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +drivers/usb/core/message.c:704: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 702. break; + 703. } + 704. > return result; + 705. } + 706. + +kernel/cgroup/cgroup-v1.c:700: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 698 could be null and is dereferenced at line 700, column 7. + 698. for_each_subsys(ss, i) + 699. seq_printf(m, "%s\t%d\t%d\t%d\n", + 700. > ss->legacy_name, ss->root->hierarchy_id, + 701. atomic_read(&ss->root->nr_cgrps), + 702. cgroup_ssid_enabled(i)); + +drivers/iommu/intel-iommu.c:694: error: DEAD_STORE + The value written to &agaw (type int) is never used. + 692. { + 693. unsigned long sagaw; + 694. > int agaw = -1; + 695. + 696. sagaw = cap_sagaw(iommu->cap); + +drivers/thermal/thermal_sysfs.c:703: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 701. if (ret) + 702. return ret; + 703. > return sprintf(buf, "%ld\n", state); + 704. } + 705. + +net/ipv4/ip_fragment.c:712: error: UNINITIALIZED_VALUE + The value read from iph.tot_len was never initialized. + 710. return skb; + 711. + 712. > len = ntohs(iph.tot_len); + 713. if (skb->len < netoff + len || len < (iph.ihl * 4)) + 714. return skb; + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +sound/pci/hda/hda_proc.c:699: error: DEAD_STORE + The value written to &curr (type int) is never used. + 697. struct hda_codec *codec, hda_nid_t nid) + 698. { + 699. > int i, curr = -1; + 700. u8 dev_list[AC_MAX_DEV_LIST_LEN]; + 701. int devlist_len; + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +net/ipv4/ping.c:827: error: UNINITIALIZED_VALUE + The value read from user_icmph.code was never initialized. + 825. + 826. pfh.icmph.type = user_icmph.type; /* already checked */ + 827. > pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + 829. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv4/ping.c:826: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 824. lock_sock(sk); + 825. + 826. > pfh.icmph.type = user_icmph.type; /* already checked */ + 827. pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + +net/ipv4/ping.c:848: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 846. kfree(ipc.opt); + 847. if (!err) { + 848. > icmp_out_count(sock_net(sk), user_icmph.type); + 849. return len; + 850. } + +net/ipv6/ndisc.c:720: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 720, column 3. + 718. __func__, target); + 719. } + 720. > ndisc_send_ns(dev, target, target, saddr, 0); + 721. } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) { + 722. neigh_app_ns(neigh); + +net/ipv6/ndisc.c:725: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 725, column 3. + 723. } else { + 724. addrconf_addr_solict_mult(target, &mcaddr); + 725. > ndisc_send_ns(dev, target, &mcaddr, saddr, 0); + 726. } + 727. } + +net/sunrpc/auth_gss/gss_rpc_xdr.c:711: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 709. if (!p) + 710. return -ENOSPC; + 711. > p = xdr_encode_hyper(p, cb->initiator_addrtype); + 712. + 713. /* cb->initiator_address */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:722: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 720. if (!p) + 721. return -ENOSPC; + 722. > p = xdr_encode_hyper(p, cb->acceptor_addrtype); + 723. + 724. /* cb->acceptor_address */ + +drivers/ata/libata-scsi.c:726: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 724. scsi_cmd[1] = (3 << 1); /* Non-data */ + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. > scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + +drivers/ata/libata-scsi.c:727: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. scsi_cmd[4] = args[1]; + 727. > scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + +drivers/ata/libata-scsi.c:728: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 726. scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. > scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + +drivers/ata/libata-scsi.c:729: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. > scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + +drivers/ata/libata-scsi.c:730: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. > scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:732: error: UNINITIALIZED_VALUE + The value read from args.[_] was never initialized. + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. > scsi_cmd[14] = args[0]; + 733. + 734. /* Good values for timeout and retries? Values below + +net/netlabel/netlabel_cipso_v4.c:706: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 704. static int netlbl_cipsov4_remove(struct sk_buff *skb, struct genl_info *info) + 705. { + 706. > int ret_val = -EINVAL; + 707. struct netlbl_domhsh_walk_arg cb_arg; + 708. struct netlbl_audit audit_info; + +net/sunrpc/svcsock.c:739: error: DEAD_STORE + The value written to &err (type int) is never used. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:739: error: UNINITIALIZED_VALUE + The value read from level was never initialized. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:739: error: UNINITIALIZED_VALUE + The value read from optname was never initialized. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +drivers/char/agp/intel-gtt.c:710: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 708. static void i830_chipset_flush(void) + 709. { + 710. > unsigned long timeout = jiffies + msecs_to_jiffies(1000); + 711. + 712. /* Forcibly evict everything from the CPU write buffers. + +net/wireless/scan.c:719: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 717. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); + 718. struct cfg80211_internal_bss *bss, *res = NULL; + 719. > unsigned long now = jiffies; + 720. int bss_privacy; + 721. + +net/wireless/trace.h:710: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 708. ); + 709. + 710. > DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, + 711. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 712. TP_ARGS(wiphy, netdev, mac), + +net/ipv4/ipconfig.c:742: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 740. *e++ = 150; + 741. + 742. > *e++ = 255; /* End of the list */ + 743. } + 744. + +drivers/gpu/drm/i915/i915_gem_gtt.c:719: error: DEAD_STORE + The value written to &ret (type int) is never used. + 717. { + 718. struct i915_page_directory_pointer *pdp; + 719. > int ret = -ENOMEM; + 720. + 721. WARN_ON(!use_4lvl(vm)); + +arch/x86/events/intel/p4.c:724: error: NULL_DEREFERENCE + pointer `bind` last assigned on line 723 could be null and is dereferenced at line 724, column 9. + 722. config = p4_general_events[hw_event]; + 723. bind = p4_config_get_bind(config); + 724. > esel = P4_OPCODE_ESEL(bind->opcode); + 725. config |= p4_config_pack_cccr(P4_CCCR_ESEL(esel)); + 726. + +drivers/md/dm-stats.c:730: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 728. __dm_stat_init_temporary_percpu_totals(shared, s, x); + 729. local_irq_disable(); + 730. > p = &s->stat_percpu[smp_processor_id()][x]; + 731. p->sectors[READ] -= shared->tmp.sectors[READ]; + 732. p->sectors[WRITE] -= shared->tmp.sectors[WRITE]; + +drivers/md/dm-stats.c:748: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 746. for (i = 0; i < s->n_histogram_entries + 1; i++) { + 747. local_irq_disable(); + 748. > p = &s->stat_percpu[smp_processor_id()][x]; + 749. p->histogram[i] -= shared->tmp.histogram[i]; + 750. local_irq_enable(); + +kernel/rcu/tree.c:725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 723. + 724. lockdep_assert_irqs_disabled(); + 725. > return READ_ONCE(*fp); + 726. } + 727. + +drivers/cpufreq/cpufreq.c:719: error: UNINITIALIZED_VALUE + The value read from new_policy.min was never initialized. + 717. } + 718. + 719. > store_one(scaling_min_freq, min); + 720. store_one(scaling_max_freq, max); + 721. + +drivers/cpufreq/cpufreq.c:720: error: UNINITIALIZED_VALUE + The value read from new_policy.max was never initialized. + 718. + 719. store_one(scaling_min_freq, min); + 720. > store_one(scaling_max_freq, max); + 721. + 722. /** + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +drivers/gpu/drm/drm_ioc32.c:731: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 729. return -EFAULT; + 730. + 731. > request.handle = req32.handle; + 732. request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:732: error: UNINITIALIZED_VALUE + The value read from req32.offset was never initialized. + 730. + 731. request.handle = req32.handle; + 732. > request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + 734. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +net/netfilter/nf_conntrack_core.c:746: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 744. return NF_ACCEPT; + 745. + 746. > zone = nf_ct_zone(ct); + 747. local_bh_disable(); + 748. + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/linux/rhashtable.h:784: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 782. + 783. RCU_INIT_POINTER(list->next, plist); + 784. > head = rht_dereference_bucket(head->next, tbl, hash); + 785. RCU_INIT_POINTER(list->rhead.next, head); + 786. rcu_assign_pointer(*pprev, obj); + +include/linux/rhashtable.h:801: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 799. goto slow_path; + 800. + 801. > head = rht_dereference_bucket(*pprev, tbl, hash); + 802. + 803. RCU_INIT_POINTER(obj->next, head); + +include/linux/rhashtable.h:781: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 779. + 780. list = container_of(obj, struct rhlist_head, rhead); + 781. > plist = container_of(head, struct rhlist_head, rhead); + 782. + 783. RCU_INIT_POINTER(list->next, plist); + +net/wireless/trace.h:727: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 725. ); + 726. + 727. > DECLARE_EVENT_CLASS(station_del, + 728. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 729. struct station_del_parameters *params), + +drivers/usb/host/ohci-hcd.c:791: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 789. + 790. /* find the last TD processed by the controller. */ + 791. > head = hc32_to_cpu(ohci, READ_ONCE(ed->hwHeadP)) & TD_MASK; + 792. td_start = td; + 793. td_next = list_prepare_entry(td, &ed->td_list, td_list); + +arch/x86/events/amd/ibs.c:738: error: DEAD_STORE + The value written to &attr (type attribute**) is never used. + 736. if (ibs_caps & IBS_CAPS_OPCNT) { + 737. perf_ibs_op.config_mask |= IBS_OP_CNT_CTL; + 738. > *attr++ = &format_attr_cnt_ctl.attr; + 739. } + 740. perf_ibs_pmu_init(&perf_ibs_op, "ibs_op"); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +kernel/rcu/tree.c:745: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 743. if (!rcu_segcblist_restempty(&rdp->cblist, RCU_NEXT_READY_TAIL)) + 744. return true; /* Yes, CPU has newly registered callbacks. */ + 745. > if (rcu_segcblist_future_gp_needed(&rdp->cblist, + 746. READ_ONCE(rsp->completed))) + 747. return true; /* Yes, CBs for future grace period. */ + +kernel/smp.c:739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 737. preempt_disable(); + 738. for_each_online_cpu(cpu) { + 739. > if (cpu == smp_processor_id()) + 740. continue; + 741. + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +net/ipv4/tcp_ipv4.c:758: error: UNINITIALIZED_VALUE + The value read from rep was never initialized. + 756. memset(&arg, 0, sizeof(arg)); + 757. + 758. > arg.iov[0].iov_base = (unsigned char *)&rep; + 759. arg.iov[0].iov_len = sizeof(rep.th); + 760. if (tsecr) { + +drivers/pcmcia/ti113x.h:780: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 778. default: + 779. if (operation == HOOK_POWER_PRE) + 780. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + +drivers/pcmcia/ti113x.h:782: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 780. mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + 783. } + 784. + +drivers/pcmcia/ds.c:776: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 774. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 775. &mfc)) + 776. > new_funcs = mfc.nfn; + 777. + 778. if (old_funcs != new_funcs) + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/intel_crt.c:820: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 818. out: + 819. intel_display_power_put(dev_priv, intel_encoder->power_domain); + 820. > return status; + 821. } + 822. + +drivers/video/fbdev/core/fbmem.c:795: error: DEAD_STORE + The value written to &dst (type unsigned char*) is never used. + 793. dst = buffer; + 794. fb_memcpy_fromfb(dst, src, c); + 795. > dst += c; + 796. src += c; + 797. + +sound/core/control.c:759: error: UNINITIALIZED_VALUE + The value read from list.offset was never initialized. + 757. if (copy_from_user(&list, _list, sizeof(list))) + 758. return -EFAULT; + 759. > offset = list.offset; + 760. space = list.space; + 761. + +sound/core/control.c:760: error: UNINITIALIZED_VALUE + The value read from list.space was never initialized. + 758. return -EFAULT; + 759. offset = list.offset; + 760. > space = list.space; + 761. + 762. down_read(&card->controls_rwsem); + +scripts/asn1_compiler.c:769: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 769, column 3. + 767. types = type_list = calloc(nr + 1, sizeof(type_list[0])); + 768. if (!type_list) { + 769. > perror(NULL); + 770. exit(1); + 771. } + +scripts/asn1_compiler.c:774: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 774, column 3. + 772. type_index = calloc(nr, sizeof(type_index[0])); + 773. if (!type_index) { + 774. > perror(NULL); + 775. exit(1); + 776. } + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +lib/rhashtable.c:760: error: DEAD_STORE + The value written to &p (type rhash_head*) is never used. + 758. struct rhlist_head *list = iter->list; + 759. struct rhashtable *ht = iter->ht; + 760. > struct rhash_head *p = iter->p; + 761. bool rhlist = ht->rhlist; + 762. + +drivers/gpu/drm/i915/i915_vma.c:800: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 798. __i915_vma_unpin(vma); + 799. if (ret) + 800. > return ret; + 801. } + 802. GEM_BUG_ON(i915_vma_is_active(vma)); + +drivers/scsi/scsi_transport_spi.c:812: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 810. } + 811. } + 812. > return retval; + 813. } + 814. + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +kernel/printk/printk.c:813: error: DEAD_STORE + The value written to &len (type unsigned long) is never used. + 811. facility = LOG_FACILITY(u); + 812. endp++; + 813. > len -= endp - line; + 814. line = endp; + 815. } + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +arch/x86/events/intel/pt.c:769: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 765 could be null and is dereferenced at line 769, column 9. + 767. + 768. /* offset of the first region in this table from the beginning of buf */ + 769. > base = buf->cur->offset + buf->output_off; + 770. + 771. /* offset of the current output region within this table */ + +arch/x86/events/perf_event.h:767: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 765. u64 enable_mask) + 766. { + 767. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 768. + 769. if (hwc->extra_reg.reg) + +arch/x86/events/perf_event.h:767: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 765. u64 enable_mask) + 766. { + 767. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 768. + 769. if (hwc->extra_reg.reg) + +kernel/rcu/srcutree.c:789: error: DEAD_STORE + The value written to &t (type unsigned long) is never used. + 787. + 788. /* First, see if enough time has passed since the last GP. */ + 789. > t = ktime_get_mono_fast_ns(); + 790. if (exp_holdoff == 0 || + 791. time_in_range_open(t, sp->srcu_last_gp_end, + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +drivers/i2c/busses/i2c-i801.c:813: error: UNINITIALIZED_VALUE + The value read from hostc was never initialized. + 811. && read_write == I2C_SMBUS_WRITE) { + 812. /* restore saved configuration register value */ + 813. > pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc); + 814. } + 815. return result; + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/ipv4/tcp_input.c:793: error: DEAD_STORE + The value written to &rate (type unsigned long long) is never used. + 791. + 792. if (likely(tp->srtt_us)) + 793. > do_div(rate, tp->srtt_us); + 794. + 795. /* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +net/wireless/trace.h:772: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +drivers/usb/core/usb.c:776: error: DEAD_STORE + The value written to &jiffies_expire (type unsigned long) is never used. + 774. const struct usb_interface *iface) + 775. { + 776. > unsigned long jiffies_expire = jiffies + HZ; + 777. + 778. if (udev->state == USB_STATE_NOTATTACHED) + +lib/iov_iter.c:786: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 784. return 0; + 785. } + 786. > iterate_all_kinds(i, bytes, v, + 787. copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len), + 788. memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page, + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +drivers/ata/ahci.c:830: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 828. + 829. DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class); + 830. > return rc; + 831. } + 832. + +kernel/time/timer.c:786: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 784. timer->entry.pprev = NULL; + 785. timer->function = func; + 786. > timer->flags = flags | raw_smp_processor_id(); + 787. lockdep_init_map(&timer->lockdep_map, name, key, 0); + 788. } + +drivers/gpu/drm/i915/intel_lrc.c:836: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 834. + 835. head = execlists->csb_head; + 836. > tail = READ_ONCE(buf[write_idx]); + 837. } + 838. GEM_TRACE("%s cs-irq head=%d [%d], tail=%d [%d]\n", + +drivers/gpu/drm/i915/intel_lrc.c:868: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 866. */ + 867. + 868. > status = READ_ONCE(buf[2 * head]); /* maybe mmio! */ + 869. GEM_TRACE("%s csb[%d]: status=0x%08x:0x%08x, active=0x%x\n", + 870. engine->name, head, + +net/wireless/sme.c:850: error: DEAD_STORE + The value written to &next (type unsigned char*) is never used. + 848. ev->cr.pmkid = next; + 849. memcpy((void *)ev->cr.pmkid, params->pmkid, WLAN_PMKID_LEN); + 850. > next += WLAN_PMKID_LEN; + 851. } + 852. ev->cr.update_erp_next_seq_num = params->update_erp_next_seq_num; + +drivers/ata/libata-scsi.c:789: error: DEAD_STORE + The value written to &rc (type int) is never used. + 787. { + 788. unsigned long val; + 789. > int rc = -EINVAL; + 790. unsigned long flags; + 791. + +drivers/input/serio/i8042.c:787: error: DEAD_STORE + The value written to &retval (type int) is never used. + 785. static int __init i8042_check_aux(void) + 786. { + 787. > int retval = -1; + 788. bool irq_registered = false; + 789. bool aux_loop_broken = false; + +tools/lib/subcmd/parse-options.c:788: error: DEAD_STORE + The value written to &o (type option const *) is never used. + 786. { + 787. int nr_opts = 0, len; + 788. > const struct option *o = opts; + 789. struct option *ordered; + 790. + +drivers/gpu/drm/drm_dp_mst_topology.c:796: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 794. * provided by the wake_up/wait_event pair are enough. + 795. */ + 796. > state = READ_ONCE(txmsg->state); + 797. return (state == DRM_DP_SIDEBAND_TX_RX || + 798. state == DRM_DP_SIDEBAND_TX_TIMEOUT); + +drivers/char/agp/frontend.c:795: error: UNINITIALIZED_VALUE + The value read from mode.agp_mode was never initialized. + 793. return -EFAULT; + 794. + 795. > agp_enable(agp_bridge, mode.agp_mode); + 796. return 0; + 797. } + +net/compat.c:808: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 806. return ret; + 807. + 808. > a0 = a[0]; + 809. a1 = a[1]; + 810. + +net/compat.c:809: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 807. + 808. a0 = a[0]; + 809. > a1 = a[1]; + 810. + 811. switch (call) { + +net/compat.c:813: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 811. switch (call) { + 812. case SYS_SOCKET: + 813. > ret = sys_socket(a0, a1, a[2]); + 814. break; + 815. case SYS_BIND: + +net/compat.c:816: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 814. break; + 815. case SYS_BIND: + 816. > ret = sys_bind(a0, compat_ptr(a1), a[2]); + 817. break; + 818. case SYS_CONNECT: + +net/compat.c:819: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 817. break; + 818. case SYS_CONNECT: + 819. > ret = sys_connect(a0, compat_ptr(a1), a[2]); + 820. break; + 821. case SYS_LISTEN: + +net/compat.c:825: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 823. break; + 824. case SYS_ACCEPT: + 825. > ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), 0); + 826. break; + 827. case SYS_GETSOCKNAME: + +net/compat.c:828: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 826. break; + 827. case SYS_GETSOCKNAME: + 828. > ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2])); + 829. break; + 830. case SYS_GETPEERNAME: + +net/compat.c:831: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 829. break; + 830. case SYS_GETPEERNAME: + 831. > ret = sys_getpeername(a0, compat_ptr(a1), compat_ptr(a[2])); + 832. break; + 833. case SYS_SOCKETPAIR: + +net/compat.c:834: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 832. break; + 833. case SYS_SOCKETPAIR: + 834. > ret = sys_socketpair(a0, a1, a[2], compat_ptr(a[3])); + 835. break; + 836. case SYS_SEND: + +net/compat.c:834: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 832. break; + 833. case SYS_SOCKETPAIR: + 834. > ret = sys_socketpair(a0, a1, a[2], compat_ptr(a[3])); + 835. break; + 836. case SYS_SEND: + +net/compat.c:837: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 835. break; + 836. case SYS_SEND: + 837. > ret = sys_send(a0, compat_ptr(a1), a[2], a[3]); + 838. break; + 839. case SYS_SENDTO: + +net/compat.c:840: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 838. break; + 839. case SYS_SENDTO: + 840. > ret = sys_sendto(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), a[5]); + 841. break; + 842. case SYS_RECV: + +net/compat.c:840: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 838. break; + 839. case SYS_SENDTO: + 840. > ret = sys_sendto(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), a[5]); + 841. break; + 842. case SYS_RECV: + +net/compat.c:843: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 841. break; + 842. case SYS_RECV: + 843. > ret = compat_sys_recv(a0, compat_ptr(a1), a[2], a[3]); + 844. break; + 845. case SYS_RECVFROM: + +net/compat.c:846: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 844. break; + 845. case SYS_RECVFROM: + 846. > ret = compat_sys_recvfrom(a0, compat_ptr(a1), a[2], a[3], + 847. compat_ptr(a[4]), compat_ptr(a[5])); + 848. break; + +net/compat.c:847: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 845. case SYS_RECVFROM: + 846. ret = compat_sys_recvfrom(a0, compat_ptr(a1), a[2], a[3], + 847. > compat_ptr(a[4]), compat_ptr(a[5])); + 848. break; + 849. case SYS_SHUTDOWN: + +net/compat.c:847: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 845. case SYS_RECVFROM: + 846. ret = compat_sys_recvfrom(a0, compat_ptr(a1), a[2], a[3], + 847. > compat_ptr(a[4]), compat_ptr(a[5])); + 848. break; + 849. case SYS_SHUTDOWN: + +net/compat.c:853: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 851. break; + 852. case SYS_SETSOCKOPT: + 853. > ret = compat_sys_setsockopt(a0, a1, a[2], + 854. compat_ptr(a[3]), a[4]); + 855. break; + +net/compat.c:854: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 852. case SYS_SETSOCKOPT: + 853. ret = compat_sys_setsockopt(a0, a1, a[2], + 854. > compat_ptr(a[3]), a[4]); + 855. break; + 856. case SYS_GETSOCKOPT: + +net/compat.c:857: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 855. break; + 856. case SYS_GETSOCKOPT: + 857. > ret = compat_sys_getsockopt(a0, a1, a[2], + 858. compat_ptr(a[3]), compat_ptr(a[4])); + 859. break; + +net/compat.c:858: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 856. case SYS_GETSOCKOPT: + 857. ret = compat_sys_getsockopt(a0, a1, a[2], + 858. > compat_ptr(a[3]), compat_ptr(a[4])); + 859. break; + 860. case SYS_SENDMSG: + +net/compat.c:858: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 856. case SYS_GETSOCKOPT: + 857. ret = compat_sys_getsockopt(a0, a1, a[2], + 858. > compat_ptr(a[3]), compat_ptr(a[4])); + 859. break; + 860. case SYS_SENDMSG: + +net/compat.c:861: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 859. break; + 860. case SYS_SENDMSG: + 861. > ret = compat_sys_sendmsg(a0, compat_ptr(a1), a[2]); + 862. break; + 863. case SYS_SENDMMSG: + +net/compat.c:864: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 862. break; + 863. case SYS_SENDMMSG: + 864. > ret = compat_sys_sendmmsg(a0, compat_ptr(a1), a[2], a[3]); + 865. break; + 866. case SYS_RECVMSG: + +net/compat.c:867: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 865. break; + 866. case SYS_RECVMSG: + 867. > ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]); + 868. break; + 869. case SYS_RECVMMSG: + +net/compat.c:870: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 868. break; + 869. case SYS_RECVMMSG: + 870. > ret = compat_sys_recvmmsg(a0, compat_ptr(a1), a[2], a[3], + 871. compat_ptr(a[4])); + 872. break; + +net/compat.c:871: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 869. case SYS_RECVMMSG: + 870. ret = compat_sys_recvmmsg(a0, compat_ptr(a1), a[2], a[3], + 871. > compat_ptr(a[4])); + 872. break; + 873. case SYS_ACCEPT4: + +net/compat.c:874: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 872. break; + 873. case SYS_ACCEPT4: + 874. > ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), a[3]); + 875. break; + 876. default: + +net/compat.c:874: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 872. break; + 873. case SYS_ACCEPT4: + 874. > ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), a[3]); + 875. break; + 876. default: + +drivers/gpu/drm/i915/intel_runtime_pm.c:814: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 812. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 813. + 814. > if (wait_for(COND, 100)) + 815. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 816. state, + +drivers/gpu/drm/i915/intel_runtime_pm.c:814: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 812. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 813. + 814. > if (wait_for(COND, 100)) + 815. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 816. state, + +sound/pci/hda/hda_controller.c:802: error: DEAD_STORE + The value written to &loopcounter (type unsigned long) is never used. + 800. timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. > for (loopcounter = 0;; loopcounter++) { + 803. spin_lock_irq(&bus->reg_lock); + 804. if (chip->polling_mode || do_poll) + +sound/pci/hda/hda_controller.c:800: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 798. + 799. again: + 800. > timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. for (loopcounter = 0;; loopcounter++) { + +drivers/md/md.c:814: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 810 could be null and is dereferenced at line 814, column 2. + 812. atomic_inc(&rdev->nr_pending); + 813. + 814. > bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev); + 815. bio->bi_iter.bi_sector = sector; + 816. bio_add_page(bio, page, size, 0); + +net/wireless/trace.h:793: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +drivers/char/agp/frontend.c:812: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 810. return -EFAULT; + 811. + 812. > client = agp_find_client_by_pid(reserve.pid); + 813. + 814. if (reserve.seg_count == 0) { + +drivers/char/agp/frontend.c:816: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 814. if (reserve.seg_count == 0) { + 815. /* remove a client */ + 816. > client_priv = agp_find_private(reserve.pid); + 817. + 818. if (client_priv != NULL) { + +drivers/char/agp/frontend.c:826: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 824. return 0; + 825. } + 826. > return agp_remove_client(reserve.pid); + 827. } else { + 828. struct agp_segment *segment; + +drivers/char/agp/frontend.c:848: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 846. if (client == NULL) { + 847. /* Create the client and add the segment */ + 848. > client = agp_create_client(reserve.pid); + 849. + 850. if (client == NULL) { + +drivers/char/agp/frontend.c:854: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 852. return -ENOMEM; + 853. } + 854. > client_priv = agp_find_private(reserve.pid); + 855. + 856. if (client_priv != NULL) { + +drivers/usb/mon/mon_bin.c:849: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 847. } + 848. nbytes -= step_len; + 849. > buf += step_len; + 850. rp->b_read += step_len; + 851. done += step_len; + +drivers/usb/mon/mon_bin.c:848: error: DEAD_STORE + The value written to &nbytes (type unsigned long) is never used. + 846. return -EFAULT; + 847. } + 848. > nbytes -= step_len; + 849. buf += step_len; + 850. rp->b_read += step_len; + +security/keys/key.c:855: error: UNINITIALIZED_VALUE + The value read from prep.description was never initialized. + 853. } + 854. if (!index_key.description) + 855. > index_key.description = prep.description; + 856. key_ref = ERR_PTR(-EINVAL); + 857. if (!index_key.description) + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +drivers/gpu/drm/i915/i915_pmu.c:805: error: DEAD_STORE + The value written to &pmu (type i915_pmu*) is never used. + 803. static int i915_pmu_cpu_online(unsigned int cpu, struct hlist_node *node) + 804. { + 805. > struct i915_pmu *pmu = hlist_entry_safe(node, typeof(*pmu), node); + 806. + 807. GEM_BUG_ON(!pmu->base.event_init); + +net/ipv4/ipmr.c:821: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 819. goto out; + 820. + 821. > now = jiffies; + 822. expires = 10*HZ; + 823. + +drivers/gpu/drm/i915/intel_pipe_crc.c:825: error: UNINITIALIZED_VALUE + The value read from words.[_] was never initialized. + 823. } + 824. + 825. > if (display_crc_ctl_parse_object(words[0], &object) < 0) { + 826. DRM_DEBUG_DRIVER("unknown object %s\n", words[0]); + 827. return -EINVAL; + +drivers/gpu/drm/i915/intel_pipe_crc.c:826: error: UNINITIALIZED_VALUE + The value read from words.[_] was never initialized. + 824. + 825. if (display_crc_ctl_parse_object(words[0], &object) < 0) { + 826. > DRM_DEBUG_DRIVER("unknown object %s\n", words[0]); + 827. return -EINVAL; + 828. } + +drivers/gpu/drm/i915/intel_pipe_crc.c:830: error: UNINITIALIZED_VALUE + The value read from words.[_] was never initialized. + 828. } + 829. + 830. > if (display_crc_ctl_parse_pipe(dev_priv, words[1], &pipe) < 0) { + 831. DRM_DEBUG_DRIVER("unknown pipe %s\n", words[1]); + 832. return -EINVAL; + +drivers/gpu/drm/i915/intel_pipe_crc.c:831: error: UNINITIALIZED_VALUE + The value read from words.[_] was never initialized. + 829. + 830. if (display_crc_ctl_parse_pipe(dev_priv, words[1], &pipe) < 0) { + 831. > DRM_DEBUG_DRIVER("unknown pipe %s\n", words[1]); + 832. return -EINVAL; + 833. } + +drivers/gpu/drm/i915/intel_pipe_crc.c:835: error: UNINITIALIZED_VALUE + The value read from words.[_] was never initialized. + 833. } + 834. + 835. > if (display_crc_ctl_parse_source(words[2], &source) < 0) { + 836. DRM_DEBUG_DRIVER("unknown source %s\n", words[2]); + 837. return -EINVAL; + +drivers/gpu/drm/i915/intel_pipe_crc.c:836: error: UNINITIALIZED_VALUE + The value read from words.[_] was never initialized. + 834. + 835. if (display_crc_ctl_parse_source(words[2], &source) < 0) { + 836. > DRM_DEBUG_DRIVER("unknown source %s\n", words[2]); + 837. return -EINVAL; + 838. } + +kernel/time/posix-cpu-timers.c:832: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 830. tsk_expires->virt_exp = expires; + 831. + 832. > tsk_expires->sched_exp = check_timers_list(++timers, firing, + 833. tsk->se.sum_exec_runtime); + 834. + +arch/x86/events/intel/pt.c:832: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 832, column 32. + 830. */ + 831. if (!pt_cap_get(PT_CAP_topa_multiple_entries) || + 832. > buf->output_off == sizes(TOPA_ENTRY(buf->cur, buf->cur_idx)->size)) { + 833. perf_aux_output_flag(&pt->handle, + 834. PERF_AUX_FLAG_TRUNCATED); + +arch/x86/events/intel/pt.c:843: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 843, column 52. + 841. * before the output reaches its output region's boundary. + 842. */ + 843. > if (!pt_cap_get(PT_CAP_topa_multiple_entries) && !buf->snapshot && + 844. pt_buffer_region_size(buf) - buf->output_off <= TOPA_PMI_MARGIN) { + 845. void *head = pt_buffer_region(buf); + +net/netfilter/nf_conntrack_netlink.c:817: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 815. struct hlist_nulls_node *n; + 816. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 817. > u_int8_t l3proto = nfmsg->nfgen_family; + 818. struct nf_conn *nf_ct_evict[8]; + 819. int res, i; + +net/netfilter/nf_conntrack_netlink.c:812: error: DEAD_STORE + The value written to &net (type net*) is never used. + 810. ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) + 811. { + 812. > struct net *net = sock_net(skb->sk); + 813. struct nf_conn *ct, *last; + 814. struct nf_conntrack_tuple_hash *h; + +net/wireless/trace.h:810: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 808. ); + 809. + 810. > DECLARE_EVENT_CLASS(mpath_evt, + 811. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 812. u8 *next_hop), + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +drivers/video/fbdev/core/fbmem.c:873: error: DEAD_STORE + The value written to &src (type unsigned char*) is never used. + 871. fb_memcpy_tofb(dst, src, c); + 872. dst += c; + 873. > src += c; + 874. *ppos += c; + 875. buf += c; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:891: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 889. + 890. data &= ~I82579_LPI_100_PLL_SHUT; + 891. > ret_val = e1000_write_emi_reg_locked(hw, I82579_LPI_PLL_SHUT, + 892. data); + 893. } + +drivers/gpu/drm/i915/intel_ringbuffer.h:832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 830. * a hint and nothing more. + 831. */ + 832. > return READ_ONCE(engine->timeline->seqno); + 833. } + 834. + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +drivers/md/md.c:846: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 842 could be null and is dereferenced at line 846, column 3. + 844. + 845. if (metadata_op && rdev->meta_bdev) + 846. > bio_set_dev(bio, rdev->meta_bdev); + 847. else + 848. bio_set_dev(bio, rdev->bdev); + +drivers/md/md.c:848: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 842 could be null and is dereferenced at line 848, column 3. + 846. bio_set_dev(bio, rdev->meta_bdev); + 847. else + 848. > bio_set_dev(bio, rdev->bdev); + 849. bio_set_op_attrs(bio, op, op_flags); + 850. if (metadata_op) + +net/netfilter/nf_conntrack_core.c:851: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 849. struct nf_conn *ct; + 850. + 851. > zone = nf_ct_zone(ignored_conntrack); + 852. + 853. rcu_read_lock(); + +scripts/asn1_compiler.c:843: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 843, column 3. + 841. struct element *e = calloc(1, sizeof(*e)); + 842. if (!e) { + 843. > perror(NULL); + 844. exit(1); + 845. } + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/sunrpc/rpcb_clnt.c:858: error: NULL_DEREFERENCE + pointer `p` last assigned on line 858 could be null and is dereferenced at line 858, column 2. + 856. + 857. p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2); + 858. > *p++ = cpu_to_be32(rpcb->r_prog); + 859. *p++ = cpu_to_be32(rpcb->r_vers); + 860. *p++ = cpu_to_be32(rpcb->r_prot); + +drivers/pci/pci-sysfs.c:915: error: DEAD_STORE + The value written to &off (type long long) is never used. + 913. pci_user_read_config_byte(dev, off, &val); + 914. data[off - init_off] = val; + 915. > off++; + 916. --size; + 917. } + +drivers/pci/pci-sysfs.c:916: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 914. data[off - init_off] = val; + 915. off++; + 916. > --size; + 917. } + 918. + +drivers/char/agp/generic.c:867: error: DEAD_STORE + The value written to &size (type int) is never used. + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + 867. > size = page_order = num_entries = 0; + 868. + 869. if (bridge->driver->size_type != FIXED_APER_SIZE) { + +drivers/char/agp/generic.c:873: error: DEAD_STORE + The value written to &size (type int) is never used. + 871. switch (bridge->driver->size_type) { + 872. case U8_APER_SIZE: + 873. > size = A_SIZE_8(temp)->size; + 874. page_order = + 875. A_SIZE_8(temp)->page_order; + +drivers/char/agp/generic.c:880: error: DEAD_STORE + The value written to &size (type int) is never used. + 878. break; + 879. case U16_APER_SIZE: + 880. > size = A_SIZE_16(temp)->size; + 881. page_order = A_SIZE_16(temp)->page_order; + 882. num_entries = A_SIZE_16(temp)->num_entries; + +drivers/char/agp/generic.c:885: error: DEAD_STORE + The value written to &size (type int) is never used. + 883. break; + 884. case U32_APER_SIZE: + 885. > size = A_SIZE_32(temp)->size; + 886. page_order = A_SIZE_32(temp)->page_order; + 887. num_entries = A_SIZE_32(temp)->num_entries; + +drivers/char/agp/generic.c:893: error: DEAD_STORE + The value written to &size (type int) is never used. + 891. case LVL2_APER_SIZE: + 892. default: + 893. > size = page_order = num_entries = 0; + 894. break; + 895. } + +drivers/char/agp/generic.c:923: error: DEAD_STORE + The value written to &size (type int) is never used. + 921. } while (!table && (i < bridge->driver->num_aperture_sizes)); + 922. } else { + 923. > size = ((struct aper_size_info_fixed *) temp)->size; + 924. page_order = ((struct aper_size_info_fixed *) temp)->page_order; + 925. num_entries = ((struct aper_size_info_fixed *) temp)->num_entries; + +net/wireless/trace.h:849: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +block/blk-mq.c:867: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 865. while (true) { + 866. start = read_seqcount_begin(&rq->gstate_seq); + 867. > gstate = READ_ONCE(rq->gstate); + 868. deadline = blk_rq_deadline(rq); + 869. if (!read_seqcount_retry(&rq->gstate_seq, start)) + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +kernel/time/tick-sched.c:884: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 882. return false; + 883. + 884. > if (unlikely(local_softirq_pending() && cpu_online(cpu))) { + 885. static int ratelimit; + 886. + +kernel/time/tick-sched.c:888: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 886. + 887. if (ratelimit < 10 && + 888. > (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +net/ipv4/ip_output.c:1095: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1093. cork->length -= length; + 1094. IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS); + 1095. > return err; + 1096. } + 1097. + +drivers/usb/host/ehci-hub.c:1108: error: DEAD_STORE + The value written to &temp1 (type unsigned int) is never used. + 1106. // status may be from integrated TT + 1107. if (ehci->has_hostpc) { + 1108. > temp1 = ehci_readl(ehci, hostpc_reg); + 1109. status |= ehci_port_speed(ehci, temp1); + 1110. } else + +drivers/usb/class/usblp.c:899: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 897. set_current_state(TASK_RUNNING); + 898. remove_wait_queue(&usblp->wwait, &waita); + 899. > return rc; + 900. } + 901. + +drivers/gpu/drm/drm_ioc32.c:892: error: UNINITIALIZED_VALUE + The value read from req64.fb_id was never initialized. + 890. return err; + 891. + 892. > if (put_user(req64.fb_id, &argp->fb_id)) + 893. return -EFAULT; + 894. + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +net/ipv4/route.c:887: error: DEAD_STORE + The value written to &log_martians (type int) is never used. + 885. return; + 886. } + 887. > log_martians = IN_DEV_LOG_MARTIANS(in_dev); + 888. vif = l3mdev_master_ifindex_rcu(rt->dst.dev); + 889. rcu_read_unlock(); + +kernel/sched/topology.c:903: error: NULL_DEREFERENCE + pointer `last` last assigned on line 876 could be null and is dereferenced at line 903, column 2. + 901. last = sg; + 902. } + 903. > last->next = first; + 904. sd->groups = first; + 905. + +net/wireless/trace.h:873: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +drivers/cpufreq/cpufreq.c:881: error: UNINITIALIZED_VALUE + The value read from limit was never initialized. + 879. ret = cpufreq_driver->bios_limit(policy->cpu, &limit); + 880. if (!ret) + 881. > return sprintf(buf, "%u\n", limit); + 882. } + 883. return sprintf(buf, "%u\n", policy->cpuinfo.max_freq); + +kernel/workqueue.c:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. + 893. /* this can only happen on the local cpu */ + 894. > if (WARN_ON_ONCE(pool->cpu != raw_smp_processor_id())) + 895. return NULL; + 896. + +kernel/sched/sched.h:881: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 879. static inline u64 __rq_clock_broken(struct rq *rq) + 880. { + 881. > return READ_ONCE(rq->clock); + 882. } + 883. + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +kernel/time/timer.c:893: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 891. return; + 892. + 893. > jnow = READ_ONCE(jiffies); + 894. base->must_forward_clk = base->is_idle; + 895. if ((long)(jnow - base->clk) < 2) + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +net/sunrpc/cache.c:894: error: DEAD_STORE + The value written to &ret (type long) is never used. + 892. struct page *page; + 893. char *kaddr; + 894. > ssize_t ret = -ENOMEM; + 895. + 896. if (count >= PAGE_SIZE) + +kernel/cgroup/cgroup-v1.c:897: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 895 could be null and is dereferenced at line 897, column 25. + 895. for_each_subsys(ss, ssid) + 896. if (root->subsys_mask & (1 << ssid)) + 897. > seq_show_option(seq, ss->legacy_name, NULL); + 898. if (root->flags & CGRP_ROOT_NOPREFIX) + 899. seq_puts(seq, ",noprefix"); + +drivers/net/ethernet/intel/e1000e/82571.c:919: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 917. } else { + 918. data &= ~IGP02E1000_PM_D0_LPLU; + 919. > ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data); + 920. /* LPLU and SmartSpeed are mutually exclusive. LPLU is used + 921. * during Dx states where the power conservation is most + +kernel/trace/ring_buffer.c:907: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 905. val &= ~RB_FLAG_MASK; + 906. + 907. > ret = cmpxchg((unsigned long *)&list->next, + 908. val | old_flag, val | new_flag); + 909. + +net/wireless/trace.h:894: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +drivers/input/input.c:919: error: UNINITIALIZED_VALUE + The value read from old_keycode was never initialized. + 917. */ + 918. if (test_bit(EV_KEY, dev->evbit) && + 919. > !is_event_supported(old_keycode, dev->keybit, KEY_MAX) && + 920. __test_and_clear_bit(old_keycode, dev->key)) { + 921. struct input_value vals[] = { + +drivers/input/input.c:920: error: UNINITIALIZED_VALUE + The value read from old_keycode was never initialized. + 918. if (test_bit(EV_KEY, dev->evbit) && + 919. !is_event_supported(old_keycode, dev->keybit, KEY_MAX) && + 920. > __test_and_clear_bit(old_keycode, dev->key)) { + 921. struct input_value vals[] = { + 922. { EV_KEY, old_keycode, 0 }, + +drivers/input/input.c:922: error: UNINITIALIZED_VALUE + The value read from old_keycode was never initialized. + 920. __test_and_clear_bit(old_keycode, dev->key)) { + 921. struct input_value vals[] = { + 922. > { EV_KEY, old_keycode, 0 }, + 923. input_value_sync + 924. }; + +drivers/hid/hid-ntrig.c:956: error: DEAD_STORE + The value written to &ret (type int) is never used. + 954. ntrig_report_version(hdev); + 955. + 956. > ret = sysfs_create_group(&hdev->dev.kobj, + 957. &ntrig_attribute_group); + 958. + +net/ipv4/tcp_output.c:933: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 931. + 932. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 933. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 934. if (nval != oval) + 935. continue; + +net/ipv4/tcp_output.c:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. goto out; + 924. + 925. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 926. struct tsq_tasklet *tsq; + 927. bool empty; + +drivers/gpu/drm/drm_plane.c:915: error: DEAD_STORE + The value written to &ret (type int) is never used. + 913. u32 target_vblank = page_flip->sequence; + 914. struct drm_modeset_acquire_ctx ctx; + 915. > int ret = -EINVAL; + 916. + 917. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +net/core/neighbour.c:917: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 915. state = neigh->nud_state; + 916. now = jiffies; + 917. > next = now + HZ; + 918. + 919. if (!(state & NUD_IN_TIMER)) + +net/core/neighbour.c:926: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 924. neigh->confirmed + neigh->parms->reachable_time)) { + 925. neigh_dbg(2, "neigh %p is still alive\n", neigh); + 926. > next = neigh->confirmed + neigh->parms->reachable_time; + 927. } else if (time_before_eq(now, + 928. neigh->used + + +net/core/neighbour.c:934: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 932. neigh->updated = jiffies; + 933. neigh_suspect(neigh); + 934. > next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); + 935. } else { + 936. neigh_dbg(2, "neigh %p is suspected\n", neigh); + +net/core/neighbour.c:951: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 949. neigh_connect(neigh); + 950. notify = 1; + 951. > next = neigh->confirmed + neigh->parms->reachable_time; + 952. } else { + 953. neigh_dbg(2, "neigh %p is probed\n", neigh); + +net/core/neighbour.c:958: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 956. atomic_set(&neigh->probes, 0); + 957. notify = 1; + 958. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 959. } + 960. } else { + +net/core/neighbour.c:962: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 960. } else { + 961. /* NUD_PROBE|NUD_INCOMPLETE */ + 962. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 963. } + 964. + +net/sunrpc/rpcb_clnt.c:920: error: NULL_DEREFERENCE + pointer `p` last assigned on line 919 could be null and is dereferenced by call to `xdr_encode_opaque()` at line 920, column 2. + 918. len = maxstrlen; + 919. p = xdr_reserve_space(xdr, 4 + len); + 920. > xdr_encode_opaque(p, string, len); + 921. } + 922. + +include/net/sock.h:913: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 911. static inline void sk_incoming_cpu_update(struct sock *sk) + 912. { + 913. > int cpu = raw_smp_processor_id(); + 914. + 915. if (unlikely(sk->sk_incoming_cpu != cpu)) + +include/net/sock.h:913: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 911. static inline void sk_incoming_cpu_update(struct sock *sk) + 912. { + 913. > int cpu = raw_smp_processor_id(); + 914. + 915. if (unlikely(sk->sk_incoming_cpu != cpu)) + +kernel/time/posix-cpu-timers.c:947: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 945. prof_expires = check_timers_list(timers, firing, ptime); + 946. virt_expires = check_timers_list(++timers, firing, utime); + 947. > sched_expires = check_timers_list(++timers, firing, sum_sched_runtime); + 948. + 949. /* + +drivers/usb/early/ehci-dbgp.c:954: error: DEAD_STORE + The value written to &ret (type int) is never used. + 952. } + 953. if (chunk > 0) { + 954. > ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, + 955. dbgp_endpoint_out, buf, chunk); + 956. } + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +net/core/ethtool.c:926: error: UNINITIALIZED_VALUE + The value read from info.sset_mask was never initialized. + 924. + 925. /* store copy of mask, because we zero struct later on */ + 926. > sset_mask = info.sset_mask; + 927. if (!sset_mask) + 928. return 0; + +drivers/char/agp/frontend.c:924: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 922. return -EFAULT; + 923. + 924. > memory = agp_find_mem_by_key(bind_info.key); + 925. + 926. if (memory == NULL) + +drivers/char/agp/frontend.c:929: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 927. return -EINVAL; + 928. + 929. > return agp_bind_memory(memory, bind_info.pg_start); + 930. } + 931. + +kernel/cgroup/cgroup-v1.c:922: error: DEAD_STORE + The value written to &mask (type unsigned short) is never used. + 920. char *token, *o = data; + 921. bool all_ss = false, one_ss = false; + 922. > u16 mask = U16_MAX; + 923. struct cgroup_subsys *ss; + 924. int nr_opts = 0; + +net/wireless/trace.h:918: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +kernel/time/timer.c:934: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 932. * and spin_lock(). + 933. */ + 934. > tf = READ_ONCE(timer->flags); + 935. + 936. if (!(tf & TIMER_MIGRATING)) { + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +net/ipv4/ipconfig.c:982: error: DEAD_STORE + The value written to &h (type iphdr*) is never used. + 980. + 981. b = (struct bootp_pkt *)skb_network_header(skb); + 982. > h = &b->iph; + 983. + 984. /* One reply at a time, please. */ + +net/sunrpc/rpcb_clnt.c:936: error: NULL_DEREFERENCE + pointer `p` last assigned on line 936 could be null and is dereferenced at line 936, column 2. + 934. + 935. p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2); + 936. > *p++ = cpu_to_be32(rpcb->r_prog); + 937. *p = cpu_to_be32(rpcb->r_vers); + 938. + +drivers/pci/pci-sysfs.c:976: error: DEAD_STORE + The value written to &off (type long long) is never used. + 974. if (size) { + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. > off++; + 977. --size; + 978. } + +drivers/pci/pci-sysfs.c:977: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. off++; + 977. > --size; + 978. } + 979. + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +drivers/i2c/i2c-core-base.c:949: error: DEAD_STORE + The value written to &blank (type char*) is never used. + 947. + 948. /* Parse remaining parameters, reject extra parameters */ + 949. > res = sscanf(++blank, "%hi%c", &info.addr, &end); + 950. if (res < 1) { + 951. dev_err(dev, "%s: Can't parse I2C address\n", "new_device"); + +drivers/i2c/i2c-core-base.c:949: error: UNINITIALIZED_VALUE + The value read from info.addr was never initialized. + 947. + 948. /* Parse remaining parameters, reject extra parameters */ + 949. > res = sscanf(++blank, "%hi%c", &info.addr, &end); + 950. if (res < 1) { + 951. dev_err(dev, "%s: Can't parse I2C address\n", "new_device"); + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/usb/class/usblp.c:951: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 949. set_current_state(TASK_RUNNING); + 950. remove_wait_queue(&usblp->rwait, &waita); + 951. > return rc; + 952. } + 953. + +drivers/char/agp/frontend.c:941: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 939. return -EFAULT; + 940. + 941. > memory = agp_find_mem_by_key(unbind.key); + 942. + 943. if (memory == NULL) + +drivers/md/dm-ioctl.c:966: error: UNINITIALIZED_VALUE + The value read from indata.[_] was never initialized. + 964. } + 965. + 966. > geometry.cylinders = indata[0]; + 967. geometry.heads = indata[1]; + 968. geometry.sectors = indata[2]; + +drivers/md/dm-ioctl.c:967: error: UNINITIALIZED_VALUE + The value read from indata.[_] was never initialized. + 965. + 966. geometry.cylinders = indata[0]; + 967. > geometry.heads = indata[1]; + 968. geometry.sectors = indata[2]; + 969. geometry.start = indata[3]; + +drivers/md/dm-ioctl.c:968: error: UNINITIALIZED_VALUE + The value read from indata.[_] was never initialized. + 966. geometry.cylinders = indata[0]; + 967. geometry.heads = indata[1]; + 968. > geometry.sectors = indata[2]; + 969. geometry.start = indata[3]; + 970. + +drivers/md/dm-ioctl.c:969: error: UNINITIALIZED_VALUE + The value read from indata.[_] was never initialized. + 967. geometry.heads = indata[1]; + 968. geometry.sectors = indata[2]; + 969. > geometry.start = indata[3]; + 970. + 971. r = dm_set_geometry(md, &geometry); + +drivers/gpu/drm/i915/intel_dpio_phy.c:943: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 940 could be null and is dereferenced at line 943, column 6. + 941. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 942. + 943. > if (dport->release_cl2_override) { + 944. chv_phy_powergate_ch(dev_priv, DPIO_PHY0, DPIO_CH1, false); + 945. dport->release_cl2_override = false; + +drivers/net/ethernet/broadcom/tg3.c:955: error: DEAD_STORE + The value written to &apedata (type unsigned int) is never used. + 953. APE_HOST_SEG_LEN_MAGIC); + 954. apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT); + 955. > tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata); + 956. tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID, + 957. APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM)); + +net/ipv4/devinet.c:958: error: DEAD_STORE + The value written to &ret (type int) is never used. + 956. struct net_device *dev; + 957. char *colon; + 958. > int ret = -EFAULT; + 959. int tryaddrmatch = 0; + 960. + +drivers/usb/core/hub.c:959: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 958 could be null and is dereferenced at line 959, column 9. + 957. return -EINVAL; + 958. hub = usb_hub_to_struct_hub(udev->parent); + 959. > intf = to_usb_interface(hub->intfdev); + 960. + 961. usb_autopm_get_interface(intf); + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +net/ipv4/tcp_output.c:968: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 966. + 967. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 968. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 969. if (nval != oval) + 970. continue; + +net/ipv4/tcp_output.c:960: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 958. unsigned long nval, oval; + 959. + 960. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 961. struct tsq_tasklet *tsq; + 962. bool empty; + +net/wireless/trace.h:956: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/ipv4/netfilter/ip_tables.c:984: error: DEAD_STORE + The value written to &ret (type int) is never used. + 982. + 983. if (compat) { + 984. > ret = compat_table_info(private, &tmp); + 985. xt_compat_flush_offsets(AF_INET); + 986. private = &tmp; + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/input/mouse/synaptics.c:988: error: UNINITIALIZED_VALUE + The value read from slot.[_] was never initialized. + 986. + 987. for (i = 0; i < nsemi; i++) { + 988. > input_mt_slot(dev, slot[i]); + 989. input_mt_report_slot_state(dev, MT_TOOL_FINGER, true); + 990. input_report_abs(dev, ABS_MT_POSITION_X, pos[i].x); + +drivers/input/serio/i8042.c:997: error: UNINITIALIZED_VALUE + The value read from ctr.[_] was never initialized. + 995. } while (n < 2 || ctr[0] != ctr[1]); + 996. + 997. > i8042_initial_ctr = i8042_ctr = ctr[0]; + 998. + 999. /* + +net/core/skbuff.c:1000: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 998. uarg->len++; + 999. uarg->bytelen = bytelen; + 1000. > atomic_set(&sk->sk_zckey, ++next); + 1001. sock_zerocopy_get(uarg); + 1002. return uarg; + +net/wireless/trace.h:973: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +net/ipv6/netfilter/ip6_tables.c:1001: error: DEAD_STORE + The value written to &ret (type int) is never used. + 999. + 1000. if (compat) { + 1001. > ret = compat_table_info(private, &tmp); + 1002. xt_compat_flush_offsets(AF_INET6); + 1003. private = &tmp; + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +drivers/gpu/drm/i915/intel_dpio_phy.c:990: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 989 could be null and is dereferenced by call to `vlv_dport_to_channel()` at line 990, column 27. + 988. struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc); + 989. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 990. > enum dpio_channel port = vlv_dport_to_channel(dport); + 991. enum pipe pipe = intel_crtc->pipe; + 992. + +drivers/usb/mon/mon_bin.c:1067: error: UNINITIALIZED_VALUE + The value read from getb.alloc was never initialized. + 1065. if (getb.alloc > 0x10000000) /* Want to cast to u32 */ + 1066. return -EINVAL; + 1067. > ret = mon_bin_get_event(file, rp, getb.hdr, + 1068. (cmd == MON_IOCX_GET)? PKT_SZ_API0: PKT_SZ_API1, + 1069. getb.data, (unsigned int)getb.alloc); + +drivers/usb/mon/mon_bin.c:1090: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch was never initialized. + 1088. return -EFAULT; + 1089. } + 1090. > ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch); + 1091. if (ret < 0) + 1092. return ret; + +drivers/usb/mon/mon_bin.c:1084: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush was never initialized. + 1082. + 1083. if (mfetch.nflush) { + 1084. > ret = mon_bin_flush(rp, mfetch.nflush); + 1085. if (ret < 0) + 1086. return ret; + +drivers/md/dm.c:996: error: DEAD_STORE + The value written to &offset (type unsigned long) is never used. + 994. offset = dm_target_offset(ti, sector); + 995. if (unlikely(ti->max_io_len & (ti->max_io_len - 1))) + 996. > max_len = sector_div(offset, ti->max_io_len); + 997. else + 998. max_len = offset & (ti->max_io_len - 1); + +drivers/cdrom/cdrom.c:1025: error: UNINITIALIZED_VALUE + The value read from entry.cdte_ctrl was never initialized. + 1023. tracks->audio++; + 1024. } + 1025. > cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n", + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + +drivers/cdrom/cdrom.c:1009: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk0 was never initialized. + 1007. /* check what type of tracks are on this disc */ + 1008. entry.cdte_format = CDROM_MSF; + 1009. > for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) { + 1010. entry.cdte_track = i; + 1011. if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) { + +drivers/cdrom/cdrom.c:1028: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk1 was never initialized. + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + 1028. > cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n", + 1029. header.cdth_trk1, tracks->audio, tracks->data, + 1030. tracks->cdi, tracks->xa); + +kernel/trace/ring_buffer.c:1000: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 998. val |= RB_PAGE_HEAD; + 999. + 1000. > ret = cmpxchg(ptr, val, (unsigned long)&new->list); + 1001. + 1002. return ret == val; + +kernel/relay.c:996: error: DEAD_STORE + The value written to &consumed (type unsigned long) is never used. + 994. size_t n_subbufs = buf->chan->n_subbufs; + 995. size_t produced = buf->subbufs_produced; + 996. > size_t consumed = buf->subbufs_consumed; + 997. + 998. relay_file_read_consume(buf, read_pos, 0); + +net/ipv4/tcp_output.c:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. static bool tcp_needs_internal_pacing(const struct sock *sk) + 992. { + 993. > return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED; + 994. } + 995. + +net/netfilter/nf_conntrack_core.c:1005: error: DEAD_STORE + The value written to &nf_conntrack_max95 (type unsigned int) is never used. + 1003. i = gc_work->last_bucket; + 1004. if (gc_work->early_drop) + 1005. > nf_conntrack_max95 = nf_conntrack_max / 100u * 95u; + 1006. + 1007. do { + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +net/wireless/trace.h:993: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +security/selinux/ss/policydb.c:1006: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1004. + 1005. rc = -EINVAL; + 1006. > items = le32_to_cpu(buf[0]); + 1007. if (items > ARRAY_SIZE(buf)) { + 1008. printk(KERN_ERR "SELinux: mls: range overflow\n"); + +net/ipv6/ipv6_sockglue.c:1289: error: UNINITIALIZED_VALUE + The value read from freq.flr_flags was never initialized. + 1287. + 1288. len = sizeof(freq); + 1289. > flags = freq.flr_flags; + 1290. + 1291. memset(&freq, 0, sizeof(freq)); + +security/selinux/avc.c:1022: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1020. node = avc_lookup(ssid, tsid, tclass); + 1021. if (unlikely(!node)) { + 1022. > node = avc_compute_av(ssid, tsid, tclass, &avd, xp_node); + 1023. } else { + 1024. memcpy(&avd, &node->ae.avd, sizeof(avd)); + +security/selinux/avc.c:1049: error: UNINITIALIZED_VALUE + The value read from avd.seqno was never initialized. + 1047. &local_xpd); + 1048. rcu_read_lock(); + 1049. > avc_update_node(AVC_CALLBACK_ADD_XPERMS, requested, driver, xperm, + 1050. ssid, tsid, tclass, avd.seqno, &local_xpd, 0); + 1051. } else { + +drivers/video/fbdev/core/fbmon.c:1074: error: UNINITIALIZED_VALUE + The value read from svd.[_] was never initialized. + 1072. + 1073. for (i = specs->modedb_len + num; i < specs->modedb_len + num + svd_n; i++) { + 1074. > int idx = svd[i - specs->modedb_len - num]; + 1075. if (!idx || idx >= ARRAY_SIZE(cea_modes)) { + 1076. pr_warn("Reserved SVD code %d\n", idx); + +drivers/pci/pci.c:1028: error: DEAD_STORE + The value written to &i (type int) is never used. + 1026. pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]); + 1027. pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]); + 1028. > pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]); + 1029. + 1030. return 0; + +arch/x86/events/core.c:1013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1011. + 1012. hwc->idx = cpuc->assign[i]; + 1013. > hwc->last_cpu = smp_processor_id(); + 1014. hwc->last_tag = ++cpuc->tags[i]; + 1015. + +net/wireless/trace.h:1012: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +drivers/gpu/drm/i915/i915_gem_gtt.c:1066: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1064. kunmap_atomic(vaddr); + 1065. + 1066. > return ret; + 1067. } + 1068. + +drivers/gpu/drm/i915/intel_display.c:1022: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 1020. static void wait_for_pipe_scanline_moving(struct intel_crtc *crtc, bool state) + 1021. { + 1022. > struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 1023. enum pipe pipe = crtc->pipe; + 1024. + +drivers/gpu/drm/i915/intel_display.c:1026: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1024. + 1025. /* Wait for the display line to settle/start moving */ + 1026. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1027. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1028. pipe_name(pipe), onoff(state)); + +drivers/gpu/drm/i915/intel_display.c:1026: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1024. + 1025. /* Wait for the display line to settle/start moving */ + 1026. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1027. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1028. pipe_name(pipe), onoff(state)); + +net/ipv4/ping.c:1027: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1025. struct sock *sk; + 1026. struct ping_iter_state *state = seq->private; + 1027. > struct net *net = seq_file_net(seq); + 1028. + 1029. for (state->bucket = start; state->bucket < PING_HTABLE_SIZE; + +drivers/gpu/drm/i915/intel_dp.c:1130: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1128. + 1129. if ((status & DP_AUX_CH_CTL_DONE) == 0) { + 1130. > DRM_ERROR("dp_aux_ch not done status 0x%08x\n", status); + 1131. ret = -EBUSY; + 1132. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1140: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1138. */ + 1139. if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) { + 1140. > DRM_ERROR("dp_aux_ch receive error status 0x%08x\n", status); + 1141. ret = -EIO; + 1142. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1148: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1146. * "normal" -- don't fill the kernel log with these */ + 1147. if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) { + 1148. > DRM_DEBUG_KMS("dp_aux_ch timeout status 0x%08x\n", status); + 1149. ret = -ETIMEDOUT; + 1150. goto out; + +drivers/nvmem/core.c:1045: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1043. + 1044. /* setup the first byte with lsb bits from nvmem */ + 1045. > rc = nvmem_reg_read(nvmem, cell->offset, &v, 1); + 1046. *b++ |= GENMASK(bit_offset - 1, 0) & v; + 1047. + +drivers/nvmem/core.c:1062: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1060. if ((nbits + bit_offset) % BITS_PER_BYTE) { + 1061. /* setup the last byte with msb bits from nvmem */ + 1062. > rc = nvmem_reg_read(nvmem, + 1063. cell->offset + cell->bytes - 1, &v, 1); + 1064. *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v; + +lib/vsprintf.c:1059: error: UNINITIALIZED_VALUE + The value read from zerolength.[_] was never initialized. + 1057. for (i = 0; i < range; i++) { + 1058. if (zerolength[i] > longest) { + 1059. > longest = zerolength[i]; + 1060. colonpos = i; + 1061. } + +include/linux/rhashtable.h:1065: error: DEAD_STORE + The value written to &list (type rhlist_head*) is never used. + 1063. continue; + 1064. + 1065. > list = rht_dereference_bucket(list->next, tbl, hash); + 1066. RCU_INIT_POINTER(*lpprev, list); + 1067. err = 0; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1067: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1065. if ((hw->mac_type == e1000_82545_rev_3) || + 1066. (hw->mac_type == e1000_82546_rev_3)) { + 1067. > ret_val = + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1070: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + 1070. > ret_val = + 1071. e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); + 1072. } + +arch/x86/events/core.c:1035: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1033. { + 1034. return hwc->idx == cpuc->assign[i] && + 1035. > hwc->last_cpu == smp_processor_id() && + 1036. hwc->last_tag == cpuc->tags[i]; + 1037. } + +drivers/pci/pci.c:1050: error: DEAD_STORE + The value written to &i (type int) is never used. + 1048. pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]); + 1049. pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]); + 1050. > pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]); + 1051. } + 1052. + +drivers/gpu/drm/i915/intel_dpio_phy.c:1050: error: DEAD_STORE + The value written to &val (type unsigned int) is never used. + 1048. + 1049. /* Enable clock channels for this port */ + 1050. > val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(port)); + 1051. val = 0; + 1052. if (pipe) + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1040 could be null and is dereferenced at line 1043, column 17. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 1039 could be null and is dereferenced at line 1043, column 2. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +net/ipv6/tcp_ipv6.c:1072: error: DEAD_STORE + The value written to &newinet (type inet_sock*) is never used. + 1070. inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; + 1071. + 1072. > newinet = inet_sk(newsk); + 1073. newnp = inet6_sk(newsk); + 1074. newtp = tcp_sk(newsk); + +net/wireless/trace.h:1042: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/ipv6/route.c:1061: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1060 could be null and is dereferenced by call to `dev_net()` at line 1061, column 23. + 1059. rcu_read_lock(); + 1060. dev = ip6_rt_get_dev_rcu(ort); + 1061. > rt = __ip6_dst_alloc(dev_net(dev), dev, 0); + 1062. rcu_read_unlock(); + 1063. if (!rt) + +drivers/gpu/drm/i915/i915_gem_request.c:1067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1065. * stop busywaiting, see busywait_stop(). + 1066. */ + 1067. > *cpu = get_cpu(); + 1068. t = local_clock() >> 10; + 1069. put_cpu(); + +kernel/time/tick-sched.c:1071: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1069. + 1070. if (ts->idle_active) + 1071. > tick_nohz_stop_idle(ts, now); + 1072. + 1073. if (ts->tick_stopped) { + +kernel/time/tick-sched.c:1074: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1072. + 1073. if (ts->tick_stopped) { + 1074. > tick_nohz_restart_sched_tick(ts, now); + 1075. tick_nohz_account_idle_ticks(ts); + 1076. } + +drivers/gpu/drm/i915/i915_gem.c:1113: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1111. * page_length = bytes to copy for this page + 1112. */ + 1113. > u32 page_base = node.start; + 1114. unsigned page_offset = offset_in_page(offset); + 1115. unsigned page_length = PAGE_SIZE - page_offset; + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/input/evdev.c:1141: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1139. + 1140. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. > return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + 1143. compat_mode); + +drivers/input/evdev.c:1153: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1151. + 1152. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. > return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + 1155. compat_mode); + +drivers/input/evdev.c:1141: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1139. + 1140. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. > return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + 1143. compat_mode); + +drivers/input/evdev.c:1153: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1151. + 1152. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. > return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + 1155. compat_mode); + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.data was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1094: error: UNINITIALIZED_VALUE + The value read from ctrl.timeout was never initialized. + 1092. goto done; + 1093. } + 1094. > tmo = ctrl.timeout; + 1095. snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1082: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1080. if (ret) + 1081. return ret; + 1082. > wLength = ctrl.wLength; /* To suppress 64k PAGE_SIZE warning */ + 1083. if (wLength > PAGE_SIZE) + 1084. return -EINVAL; + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1107: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1105. } + 1106. pipe = usb_rcvctrlpipe(dev, 0); + 1107. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, NULL, 0); + 1108. + 1109. usb_unlock_device(dev); + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1124: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1122. } else { + 1123. if (ctrl.wLength) { + 1124. > if (copy_from_user(tbuf, ctrl.data, ctrl.wLength)) { + 1125. ret = -EFAULT; + 1126. goto done; + +drivers/usb/core/devio.c:1130: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1128. } + 1129. pipe = usb_sndctrlpipe(dev, 0); + 1130. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, + 1131. tbuf, ctrl.wLength); + 1132. + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +net/ipv4/tcp_ipv4.c:1099: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 1097. return -EINVAL; + 1098. + 1099. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr, + 1100. AF_INET, prefixlen, cmd.tcpm_key, cmd.tcpm_keylen, + 1101. GFP_KERNEL); + +net/ipv4/tcp_ipv4.c:1087: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 1085. if (optname == TCP_MD5SIG_EXT && + 1086. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 1087. > prefixlen = cmd.tcpm_prefixlen; + 1088. if (prefixlen > 32) + 1089. return -EINVAL; + +net/wireless/trace.h:1069: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +drivers/gpu/drm/drm_dp_mst_topology.c:1079: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1077. case DP_PEER_DEVICE_SST_SINK: + 1078. /* add i2c over sideband */ + 1079. > ret = drm_dp_mst_register_i2c_bus(&port->aux); + 1080. break; + 1081. case DP_PEER_DEVICE_MST_BRANCHING: + +drivers/md/dm-raid1.c:1142: error: DEAD_STORE + The value written to &argv (type char**) is never used. + 1140. goto err_destroy_wq; + 1141. + 1142. > argv += args_used; + 1143. argc -= args_used; + 1144. + +net/ipv4/cipso_ipv4.c:1105: error: UNINITIALIZED_VALUE + The value read from array.[_] was never initialized. + 1103. + 1104. for (iter = 0; array_cnt > 0;) { + 1105. > *((__be16 *)&net_cat[iter]) = htons(array[--array_cnt]); + 1106. iter += 2; + 1107. array_cnt--; + +net/ipv4/cipso_ipv4.c:1109: error: UNINITIALIZED_VALUE + The value read from array.[_] was never initialized. + 1107. array_cnt--; + 1108. if (array[array_cnt] != 0) { + 1109. > *((__be16 *)&net_cat[iter]) = htons(array[array_cnt]); + 1110. iter += 2; + 1111. } + +net/sunrpc/svc.c:1083: error: DEAD_STORE + The value written to &error (type int) is never used. + 1081. */ + 1082. if (error == -EPROTONOSUPPORT) + 1083. > error = rpcb_register(net, program, version, 0, 0); + 1084. + 1085. dprintk("svc: %s(%sv%u), error %d\n", + +drivers/tty/vt/vt_ioctl.c:1092: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1090. op->height = cfdarg.charheight; + 1091. op->charcount = cfdarg.charcount; + 1092. > op->data = compat_ptr(cfdarg.chardata); + 1093. return con_font_op(vc_cons[fg_console].d, op); + 1094. case GIO_FONTX: + +drivers/tty/vt/vt_ioctl.c:1100: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1098. op->height = cfdarg.charheight; + 1099. op->charcount = cfdarg.charcount; + 1100. > op->data = compat_ptr(cfdarg.chardata); + 1101. i = con_font_op(vc_cons[fg_console].d, op); + 1102. if (i) + +drivers/iommu/intel-iommu.c:1078: error: DEAD_STORE + The value written to &large_page (type unsigned int) is never used. + 1076. unsigned long last_pfn) + 1077. { + 1078. > unsigned int large_page = 1; + 1079. struct dma_pte *first_pte, *pte; + 1080. + +drivers/pci/pci.c:1087: error: DEAD_STORE + The value written to &i (type int) is never used. + 1085. cap = (u16 *)&save_state->cap.data[0]; + 1086. + 1087. > pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]); + 1088. } + 1089. + +drivers/gpu/drm/i915/intel_dsi.c:1152: error: DEAD_STORE + The value written to &vbp (type unsigned short) is never used. + 1150. vfp = I915_READ(MIPI_VFP_COUNT(port)); + 1151. vsync = I915_READ(MIPI_VSYNC_PADDING_COUNT(port)); + 1152. > vbp = I915_READ(MIPI_VBP_COUNT(port)); + 1153. + 1154. adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp; + +block/elevator.c:1091: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `elevator_switch()` at line 1091, column 10. + 1089. */ + 1090. if (q->mq_ops && !strncmp(name, "none", 4)) + 1091. > return elevator_switch(q, NULL); + 1092. + 1093. strlcpy(elevator_name, name, sizeof(elevator_name)); + +kernel/irq/irqdomain.c:1090: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1089 could be null and is dereferenced at line 1090, column 9. + 1088. for (i = 0; i < nr_irqs; i++) { + 1089. irq_data = irq_get_irq_data(virq + i); + 1090. > tmp = irq_data->parent_data; + 1091. irq_data->parent_data = NULL; + 1092. irq_data->domain = NULL; + +net/netfilter/nf_conntrack_sip.c:1099: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1094 could be null and is dereferenced at line 1099, column 11. + 1097. (code >= 200 && code <= 299)) + 1098. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1099. > else if (ct_sip_info->invite_cseq == cseq) + 1100. flush_expectations(ct, true); + 1101. return NF_ACCEPT; + +net/wireless/trace.h:1087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/ipv6/route.c:1095: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1094 could be null and is dereferenced by call to `dev_net()` at line 1095, column 28. + 1093. rcu_read_lock(); + 1094. dev = ip6_rt_get_dev_rcu(rt); + 1095. > pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags); + 1096. rcu_read_unlock(); + 1097. if (!pcpu_rt) + +drivers/video/fbdev/core/fbmem.c:1188: error: UNINITIALIZED_VALUE + The value read from con2fb.framebuffer was never initialized. + 1186. return -EINVAL; + 1187. if (!registered_fb[con2fb.framebuffer]) + 1188. > request_module("fb%d", con2fb.framebuffer); + 1189. if (!registered_fb[con2fb.framebuffer]) { + 1190. ret = -EINVAL; + +drivers/gpu/drm/drm_dp_mst_topology.c:1102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1100. if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) { + 1101. if (mstb->port_parent) { + 1102. > ret = drm_dp_send_dpcd_write( + 1103. mstb->mgr, + 1104. mstb->port_parent, + +drivers/gpu/drm/drm_dp_mst_topology.c:1110: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1108. } else { + 1109. + 1110. > ret = drm_dp_dpcd_write( + 1111. mstb->mgr->aux, + 1112. DP_GUID, + +kernel/rcu/srcutree.c:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. * by the prior grace period. + 1109. */ + 1110. > idx = rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq)); /* ^^^ */ + 1111. if (idx == SRCU_STATE_IDLE) { + 1112. spin_lock_irq_rcu_node(sp); + +kernel/rcu/srcutree.c:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. return; + 1118. } + 1119. > idx = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 1120. if (idx == SRCU_STATE_IDLE) + 1121. srcu_gp_start(sp); + +kernel/rcu/srcutree.c:1129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1127. } + 1128. + 1129. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN1) { + 1130. idx = 1 ^ (sp->srcu_idx & 1); + 1131. if (!try_check_zero(sp, idx, 1)) { + +kernel/rcu/srcutree.c:1139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1137. } + 1138. + 1139. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN2) { + 1140. + 1141. /* + +net/ipv4/ipmr.c:1107: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1107, column 5. + 1105. + 1106. if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) { + 1107. > nlh->nlmsg_len = skb_tail_pointer(skb) - + 1108. (u8 *)nlh; + 1109. } else { + +net/ipv4/ipmr.c:1110: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1110, column 5. + 1108. (u8 *)nlh; + 1109. } else { + 1110. > nlh->nlmsg_type = NLMSG_ERROR; + 1111. nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr)); + 1112. skb_trim(skb, nlh->nlmsg_len); + +security/selinux/avc.c:1110: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1108. node = avc_lookup(ssid, tsid, tclass); + 1109. if (unlikely(!node)) + 1110. > node = avc_compute_av(ssid, tsid, tclass, avd, &xp_node); + 1111. else + 1112. memcpy(avd, &node->ae.avd, sizeof(*avd)); + +drivers/input/mouse/alps.c:1113: error: DEAD_STORE + The value written to &z (type int) is never used. + 1111. y = (packet[3] & 0x07) | (packet[4] & 0xb8) | + 1112. ((packet[3] & 0x20) << 1); + 1113. > z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1); + 1114. + 1115. left = (packet[1] & 0x01); + +drivers/gpu/drm/i915/intel_ddi.c:1102: error: DEAD_STORE + The value written to &refclk (type int) is never used. + 1100. i915_reg_t reg) + 1101. { + 1102. > int refclk = LC_FREQ; + 1103. int n, p, r; + 1104. u32 wrpll; + +net/core/sock.c:1376: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1374. #ifdef CONFIG_NET_RX_BUSY_POLL + 1375. case SO_INCOMING_NAPI_ID: + 1376. > v.val = READ_ONCE(sk->sk_napi_id); + 1377. + 1378. /* aggregate non-NAPI IDs down to 0 */ + +kernel/irq/irqdomain.c:1112: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1111 could be null and is dereferenced at line 1112, column 3. + 1110. for (i = 0; i < nr_irqs; i++) { + 1111. irq_data = irq_get_irq_data(virq + i); + 1112. > irq_data->domain = domain; + 1113. + 1114. for (parent = domain->parent; parent; parent = parent->parent) { + +kernel/time/timekeeping.c:1138: error: UNINITIALIZED_VALUE + The value read from system_counterval.cycles was never initialized. + 1136. if (tk->tkr_mono.clock != system_counterval.cs) + 1137. return -ENODEV; + 1138. > cycles = system_counterval.cycles; + 1139. + 1140. /* + +kernel/time/timekeeping.c:1159: error: UNINITIALIZED_VALUE + The value read from system_counterval.cycles was never initialized. + 1157. base_raw = tk->tkr_raw.base; + 1158. + 1159. > nsec_real = timekeeping_cycles_to_ns(&tk->tkr_mono, + 1160. system_counterval.cycles); + 1161. nsec_raw = timekeeping_cycles_to_ns(&tk->tkr_raw, + +kernel/time/timekeeping.c:1161: error: UNINITIALIZED_VALUE + The value read from system_counterval.cycles was never initialized. + 1159. nsec_real = timekeeping_cycles_to_ns(&tk->tkr_mono, + 1160. system_counterval.cycles); + 1161. > nsec_raw = timekeeping_cycles_to_ns(&tk->tkr_raw, + 1162. system_counterval.cycles); + 1163. } while (read_seqcount_retry(&tk_core.seq, seq)); + +kernel/time/timekeeping.c:1182: error: UNINITIALIZED_VALUE + The value read from system_counterval.cycles was never initialized. + 1180. */ + 1181. if (!history_begin || + 1182. > !cycle_between(history_begin->cycles, + 1183. system_counterval.cycles, cycles) || + 1184. history_begin->cs_was_changed_seq != cs_was_changed_seq) + +drivers/char/random.c:1113: error: DEAD_STORE + The value written to &idx (type unsigned int) is never used. + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + 1113. > ptr += idx++; + 1114. WRITE_ONCE(f->reg_idx, idx); + 1115. return *ptr; + +drivers/char/random.c:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. if (regs == NULL) + 1109. return 0; + 1110. > idx = READ_ONCE(f->reg_idx); + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + +net/wireless/trace.h:1103: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +scripts/kconfig/confdata.c:1114: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1109 could be null and is dereferenced at line 1114, column 2. + 1112. * Set all non-assinged choice values to no + 1113. */ + 1114. > expr_list_for_each_sym(prop->expr, e, sym) { + 1115. if (!sym_has_value(sym)) + 1116. sym->def[S_DEF_USER].tri = no; + +net/netfilter/nf_conntrack_sip.c:1116: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1111 could be null and is dereferenced at line 1116, column 11. + 1114. (code >= 200 && code <= 299)) + 1115. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1116. > else if (ct_sip_info->invite_cseq == cseq) + 1117. flush_expectations(ct, true); + 1118. return NF_ACCEPT; + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +net/ipv4/netfilter/ip_tables.c:1135: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1133. tmp.name[sizeof(tmp.name)-1] = 0; + 1134. + 1135. > newinfo = xt_alloc_table_info(tmp.size); + 1136. if (!newinfo) + 1137. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1140: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1138. + 1139. loc_cpu_entry = newinfo->entries; + 1140. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1141. tmp.size) != 0) { + 1142. ret = -EFAULT; + +security/selinux/ss/policydb.c:1133: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1131. goto bad; + 1132. + 1133. > len = le32_to_cpu(buf[0]); + 1134. perdatum->value = le32_to_cpu(buf[1]); + 1135. + +arch/x86/events/core.c:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. left = x86_pmu.limit_period(event, left); + 1156. + 1157. > per_cpu(pmc_prev_left[idx], smp_processor_id()) = left; + 1158. + 1159. if (!(hwc->flags & PERF_X86_EVENT_AUTO_RELOAD) || + +security/keys/keyctl.c:1138: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `keyctl_instantiate_key_common()` at line 1138, column 9. + 1136. } + 1137. + 1138. > return keyctl_instantiate_key_common(id, NULL, ringid); + 1139. } + 1140. + +net/netfilter/nf_conntrack_sip.c:1133: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1128 could be null and is dereferenced at line 1133, column 11. + 1131. (code >= 200 && code <= 299)) + 1132. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1133. > else if (ct_sip_info->invite_cseq == cseq) + 1134. flush_expectations(ct, true); + 1135. return NF_ACCEPT; + +drivers/pci/msi.c:1129: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1129, column 9. + 1127. int minvec, int maxvec) + 1128. { + 1129. > return __pci_enable_msix_range(dev, entries, minvec, maxvec, NULL); + 1130. } + 1131. EXPORT_SYMBOL(pci_enable_msix_range); + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.alloc32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1146: error: UNINITIALIZED_VALUE + The value read from getb.data32 was never initialized. + 1144. ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. > compat_ptr(getb.data32), getb.alloc32); + 1147. if (ret < 0) + 1148. return ret; + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.hdr32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +drivers/usb/mon/mon_bin.c:1163: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush32 was never initialized. + 1161. + 1162. if (mfetch.nflush32) { + 1163. > ret = mon_bin_flush(rp, mfetch.nflush32); + 1164. if (ret < 0) + 1165. return ret; + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.offvec32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +net/wireless/trace.h:1127: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/ipv6/ip6_fib.c:1135: error: DEAD_STORE + The value written to &err (type int) is never used. + 1133. struct fib6_table *table = rt->rt6i_table; + 1134. struct fib6_node *fn, *pn = NULL; + 1135. > int err = -ENOMEM; + 1136. int allow_create = 1; + 1137. int replace_required = 0; + +net/ipv6/ip6_fib.c:1164: error: DEAD_STORE + The value written to &pn (type fib6_node*) is never used. + 1162. } + 1163. + 1164. > pn = fn; + 1165. + 1166. #ifdef CONFIG_IPV6_SUBTREES + +net/ipv6/netfilter/ip6_tables.c:1153: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1151. tmp.name[sizeof(tmp.name)-1] = 0; + 1152. + 1153. > newinfo = xt_alloc_table_info(tmp.size); + 1154. if (!newinfo) + 1155. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1158: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1156. + 1157. loc_cpu_entry = newinfo->entries; + 1158. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1159. tmp.size) != 0) { + 1160. ret = -EFAULT; + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_tv.c:1194: error: DEAD_STORE + The value written to &type (type int) is never used. + 1192. intel_wait_for_vblank(dev_priv, intel_crtc->pipe); + 1193. + 1194. > type = -1; + 1195. tv_dac = I915_READ(TV_DAC); + 1196. DRM_DEBUG_KMS("TV detected: %x, %x\n", tv_ctl, tv_dac); + +kernel/audit.c:1404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1402. unsigned int t; + 1403. + 1404. > t = READ_ONCE(current->signal->audit_tty); + 1405. s.enabled = t & AUDIT_TTY_ENABLE; + 1406. s.log_passwd = !!(t & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1423. + 1424. if (err) + 1425. > t = READ_ONCE(current->signal->audit_tty); + 1426. else { + 1427. t = s.enabled | (-s.log_passwd & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1255: error: UNINITIALIZED_VALUE + The value read from s.backlog_limit was never initialized. + 1253. } + 1254. if (s.mask & AUDIT_STATUS_BACKLOG_LIMIT) { + 1255. > err = audit_set_backlog_limit(s.backlog_limit); + 1256. if (err < 0) + 1257. return err; + +kernel/audit.c:1264: error: UNINITIALIZED_VALUE + The value read from s.backlog_wait_time was never initialized. + 1262. if (s.backlog_wait_time > 10*AUDIT_BACKLOG_WAIT_TIME) + 1263. return -EINVAL; + 1264. > err = audit_set_backlog_wait_time(s.backlog_wait_time); + 1265. if (err < 0) + 1266. return err; + +kernel/audit.c:1180: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1178. memcpy(&s, data, min_t(size_t, sizeof(s), nlmsg_len(nlh))); + 1179. if (s.mask & AUDIT_STATUS_ENABLED) { + 1180. > err = audit_set_enabled(s.enabled); + 1181. if (err < 0) + 1182. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1185: error: UNINITIALIZED_VALUE + The value read from s.failure was never initialized. + 1183. } + 1184. if (s.mask & AUDIT_STATUS_FAILURE) { + 1185. > err = audit_set_failure(s.failure); + 1186. if (err < 0) + 1187. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.log_passwd was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1196: error: UNINITIALIZED_VALUE + The value read from s.pid was never initialized. + 1194. * run auditd from the initial pid namespace, but + 1195. * something to keep in mind if this changes */ + 1196. > pid_t new_pid = s.pid; + 1197. pid_t auditd_pid; + 1198. struct pid *req_pid = task_tgid(current); + +kernel/audit.c:1250: error: UNINITIALIZED_VALUE + The value read from s.rate_limit was never initialized. + 1248. } + 1249. if (s.mask & AUDIT_STATUS_RATE_LIMIT) { + 1250. > err = audit_set_rate_limit(s.rate_limit); + 1251. if (err < 0) + 1252. return err; + +kernel/audit.c:1351: error: UNINITIALIZED_VALUE + The value read from sizes.[_] was never initialized. + 1349. bufp += 2 * sizeof(u32); + 1350. msglen -= 2 * sizeof(u32); + 1351. > old = audit_unpack_string(&bufp, &msglen, sizes[0]); + 1352. if (IS_ERR(old)) { + 1353. err = PTR_ERR(old); + +kernel/audit.c:1356: error: UNINITIALIZED_VALUE + The value read from sizes.[_] was never initialized. + 1354. break; + 1355. } + 1356. > new = audit_unpack_string(&bufp, &msglen, sizes[1]); + 1357. if (IS_ERR(new)) { + 1358. err = PTR_ERR(new); + +net/netfilter/nf_conntrack_sip.c:1151: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1145 could be null and is dereferenced at line 1151, column 3. + 1149. ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1150. if (ret == NF_ACCEPT) + 1151. > ct_sip_info->invite_cseq = cseq; + 1152. return ret; + 1153. } + +drivers/tty/vt/vt_ioctl.c:1155: error: UNINITIALIZED_VALUE + The value read from tmp.entries was never initialized. + 1153. if (copy_from_user(&tmp, user_ud, sizeof tmp)) + 1154. return -EFAULT; + 1155. > tmp_entries = compat_ptr(tmp.entries); + 1156. switch (cmd) { + 1157. case PIO_UNIMAP: + +drivers/tty/vt/vt_ioctl.c:1160: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1158. if (!perm) + 1159. return -EPERM; + 1160. > return con_set_unimap(vc, tmp.entry_ct, tmp_entries); + 1161. case GIO_UNIMAP: + 1162. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:1164: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1162. if (!perm && fg_console != vc->vc_num) + 1163. return -EPERM; + 1164. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries); + 1165. } + 1166. return 0; + +kernel/cgroup/cpuset.c:1165: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 1156 could be null and is dereferenced at line 1165, column 16. + 1163. */ + 1164. if (is_in_v2_mode() && nodes_empty(*new_mems)) + 1165. > *new_mems = parent->effective_mems; + 1166. + 1167. /* Skip the whole subtree if the nodemask remains the same. */ + +kernel/rcu/tree.c:1151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1149. static int rcu_is_cpu_rrupt_from_idle(void) + 1150. { + 1151. > return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 0 && + 1152. __this_cpu_read(rcu_dynticks.dynticks_nmi_nesting) <= 1; + 1153. } + +kernel/rcu/tree.c:1152: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1150. { + 1151. return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 0 && + 1152. > __this_cpu_read(rcu_dynticks.dynticks_nmi_nesting) <= 1; + 1153. } + 1154. + +net/sunrpc/svc.c:1163: error: DEAD_STORE + The value written to &rpc_stat (type unsigned int) is never used. + 1161. __be32 *reply_statp; + 1162. + 1163. > rpc_stat = rpc_success; + 1164. + 1165. if (argv->iov_len < 6*4) + +security/selinux/ss/policydb.c:1166: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1164. goto bad; + 1165. + 1166. > len = le32_to_cpu(buf[0]); + 1167. comdatum->value = le32_to_cpu(buf[1]); + 1168. + +security/selinux/ss/policydb.c:1173: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1171. goto bad; + 1172. comdatum->permissions.nprim = le32_to_cpu(buf[2]); + 1173. > nel = le32_to_cpu(buf[3]); + 1174. + 1175. rc = str_read(&key, GFP_KERNEL, fp, len); + +crypto/drbg.c:1153: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1151. static inline int drbg_alloc_state(struct drbg_state *drbg) + 1152. { + 1153. > int ret = -ENOMEM; + 1154. unsigned int sb_size = 0; + 1155. + +drivers/pci/msi.c:1167: error: NULL_DEREFERENCE + pointer `affd` last assigned on line 1163 could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1167, column 10. + 1165. + 1166. if (flags & PCI_IRQ_MSIX) { + 1167. > vecs = __pci_enable_msix_range(dev, NULL, min_vecs, max_vecs, + 1168. affd); + 1169. if (vecs > 0) + +drivers/usb/core/devio.c:1190: error: UNINITIALIZED_VALUE + The value read from bulk.data was never initialized. + 1188. tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. > if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + 1191. ret = -EINVAL; + 1192. goto done; + +drivers/usb/core/devio.c:1165: error: UNINITIALIZED_VALUE + The value read from bulk.ep was never initialized. + 1163. if (copy_from_user(&bulk, arg, sizeof(bulk))) + 1164. return -EFAULT; + 1165. > ret = findintfep(ps->dev, bulk.ep); + 1166. if (ret < 0) + 1167. return ret; + +drivers/usb/core/devio.c:1177: error: UNINITIALIZED_VALUE + The value read from bulk.len was never initialized. + 1175. if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN))) + 1176. return -EINVAL; + 1177. > len1 = bulk.len; + 1178. if (len1 >= (INT_MAX - sizeof(struct urb))) + 1179. return -EINVAL; + +drivers/usb/core/devio.c:1188: error: UNINITIALIZED_VALUE + The value read from bulk.timeout was never initialized. + 1186. goto done; + 1187. } + 1188. > tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + +net/wireless/trace.h:1157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/sunrpc/auth_gss/svcauth_gss.c:1167: error: DEAD_STORE + The value written to &status (type int) is never used. + 1165. struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. > int status = -EINVAL; + 1168. + 1169. memset(&rsci, 0, sizeof(rsci)); + +net/sunrpc/auth_gss/svcauth_gss.c:1205: error: DEAD_STORE + The value written to &status (type int) is never used. + 1203. rsci.cred.cr_gss_mech = gm; + 1204. + 1205. > status = -EINVAL; + 1206. /* mech-specific data: */ + 1207. status = gss_import_sec_context(ud->out_handle.data, + +net/core/rtnetlink.c:1215: error: UNINITIALIZED_VALUE + The value read from ivi.max_tx_rate was never initialized. + 1213. vf_vlan_info.qos = ivi.qos; + 1214. vf_vlan_info.vlan_proto = ivi.vlan_proto; + 1215. > vf_tx_rate.rate = ivi.max_tx_rate; + 1216. vf_rate.min_tx_rate = ivi.min_tx_rate; + 1217. vf_rate.max_tx_rate = ivi.max_tx_rate; + +net/core/rtnetlink.c:1217: error: UNINITIALIZED_VALUE + The value read from ivi.max_tx_rate was never initialized. + 1215. vf_tx_rate.rate = ivi.max_tx_rate; + 1216. vf_rate.min_tx_rate = ivi.min_tx_rate; + 1217. > vf_rate.max_tx_rate = ivi.max_tx_rate; + 1218. vf_spoofchk.setting = ivi.spoofchk; + 1219. vf_linkstate.link_state = ivi.linkstate; + +net/core/rtnetlink.c:1216: error: UNINITIALIZED_VALUE + The value read from ivi.min_tx_rate was never initialized. + 1214. vf_vlan_info.vlan_proto = ivi.vlan_proto; + 1215. vf_tx_rate.rate = ivi.max_tx_rate; + 1216. > vf_rate.min_tx_rate = ivi.min_tx_rate; + 1217. vf_rate.max_tx_rate = ivi.max_tx_rate; + 1218. vf_spoofchk.setting = ivi.spoofchk; + +net/core/rtnetlink.c:1211: error: UNINITIALIZED_VALUE + The value read from ivi.qos was never initialized. + 1209. memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac)); + 1210. vf_vlan.vlan = ivi.vlan; + 1211. > vf_vlan.qos = ivi.qos; + 1212. vf_vlan_info.vlan = ivi.vlan; + 1213. vf_vlan_info.qos = ivi.qos; + +net/core/rtnetlink.c:1213: error: UNINITIALIZED_VALUE + The value read from ivi.qos was never initialized. + 1211. vf_vlan.qos = ivi.qos; + 1212. vf_vlan_info.vlan = ivi.vlan; + 1213. > vf_vlan_info.qos = ivi.qos; + 1214. vf_vlan_info.vlan_proto = ivi.vlan_proto; + 1215. vf_tx_rate.rate = ivi.max_tx_rate; + +net/core/rtnetlink.c:1207: error: UNINITIALIZED_VALUE + The value read from ivi.vf was never initialized. + 1205. vf_linkstate.vf = + 1206. vf_rss_query_en.vf = + 1207. > vf_trust.vf = ivi.vf; + 1208. + 1209. memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac)); + +net/core/rtnetlink.c:1210: error: UNINITIALIZED_VALUE + The value read from ivi.vlan was never initialized. + 1208. + 1209. memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac)); + 1210. > vf_vlan.vlan = ivi.vlan; + 1211. vf_vlan.qos = ivi.qos; + 1212. vf_vlan_info.vlan = ivi.vlan; + +net/core/rtnetlink.c:1212: error: UNINITIALIZED_VALUE + The value read from ivi.vlan was never initialized. + 1210. vf_vlan.vlan = ivi.vlan; + 1211. vf_vlan.qos = ivi.qos; + 1212. > vf_vlan_info.vlan = ivi.vlan; + 1213. vf_vlan_info.qos = ivi.qos; + 1214. vf_vlan_info.vlan_proto = ivi.vlan_proto; + +net/core/rtnetlink.c:1265: error: UNINITIALIZED_VALUE + The value read from vf_stats.broadcast was never initialized. + 1263. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1264. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1265. > nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1266. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1267. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + +net/core/rtnetlink.c:1267: error: UNINITIALIZED_VALUE + The value read from vf_stats.multicast was never initialized. + 1265. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1266. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1267. > nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + 1268. vf_stats.multicast, IFLA_VF_STATS_PAD) || + 1269. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + +net/core/rtnetlink.c:1261: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_bytes was never initialized. + 1259. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1260. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1261. > nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1262. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1263. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + +net/core/rtnetlink.c:1269: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_dropped was never initialized. + 1267. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + 1268. vf_stats.multicast, IFLA_VF_STATS_PAD) || + 1269. > nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + 1270. vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || + 1271. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, + +net/core/rtnetlink.c:1257: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_packets was never initialized. + 1255. if (!vfstats) + 1256. goto nla_put_vf_failure; + 1257. > if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1258. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1259. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + +net/core/rtnetlink.c:1263: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_bytes was never initialized. + 1261. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1262. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1263. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1264. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1265. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + +net/core/rtnetlink.c:1271: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_dropped was never initialized. + 1269. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + 1270. vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || + 1271. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, + 1272. vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) { + 1273. nla_nest_cancel(skb, vfstats); + +net/core/rtnetlink.c:1259: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_packets was never initialized. + 1257. if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1258. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1259. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1260. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1261. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + +net/sched/act_api.c:1168: error: DEAD_STORE + The value written to &t (type tcamsg*) is never used. + 1166. struct tc_action_ops *a_o; + 1167. int ret = 0; + 1168. > struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1169. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1170. struct nlattr *count_attr = NULL; + +net/core/ethtool.c:1200: error: UNINITIALIZED_VALUE + The value read from rx_rings.data was never initialized. + 1198. if (user_size == 0) { + 1199. for (i = 0; i < dev_size; i++) + 1200. > indir[i] = ethtool_rxfh_indir_default(i, rx_rings.data); + 1201. } else { + 1202. ret = ethtool_copy_validate_indir(indir, + +net/ipv6/ip6_output.c:1217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1215. v6_cork->tclass = ipc6->tclass; + 1216. if (rt->dst.flags & DST_XFRM_TUNNEL) + 1217. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1218. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1219. else + +net/ipv6/ip6_output.c:1220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1218. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1219. else + 1220. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1221. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(xfrm_dst_path(&rt->dst)); + 1222. if (np->frag_size < mtu) { + +drivers/usb/host/uhci-q.c:1182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1180. int len; + 1181. + 1182. > ctrlstat = td_status(uhci, td); + 1183. status = uhci_status_bits(ctrlstat); + 1184. if (status & TD_CTRL_ACTIVE) + +net/netfilter/nf_conntrack_sip.c:1265: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1178 could be null and is dereferenced at line 1265, column 3. + 1263. store_cseq: + 1264. if (ret == NF_ACCEPT) + 1265. > ct_sip_info->register_cseq = cseq; + 1266. return ret; + 1267. } + +drivers/tty/serial/serial_core.c:1224: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1222. uart_port_deref(uport); + 1223. + 1224. > return ret; + 1225. } + 1226. + +net/wireless/trace.h:1178: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +drivers/net/ethernet/broadcom/tg3.c:1213: error: DEAD_STORE + The value written to &frame_val (type unsigned int) is never used. + 1211. if ((frame_val & MI_COM_BUSY) == 0) { + 1212. udelay(5); + 1213. > frame_val = tr32(MAC_MI_COM); + 1214. break; + 1215. } + +net/ipv4/tcp.c:1426: error: UNINITIALIZED_VALUE + The value read from size_goal was never initialized. + 1424. if (copied) { + 1425. tcp_tx_timestamp(sk, sockc.tsflags); + 1426. > tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1427. } + 1428. out_nopush: + +net/ipv4/tcp.c:1425: error: UNINITIALIZED_VALUE + The value read from sockc.tsflags was never initialized. + 1423. out: + 1424. if (copied) { + 1425. > tcp_tx_timestamp(sk, sockc.tsflags); + 1426. tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1427. } + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1226: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1224. *batch++ = lower_32_bits(addr); + 1225. *batch++ = upper_32_bits(addr); + 1226. > *batch++ = upper_32_bits(target_offset); + 1227. } else { + 1228. *batch++ = (MI_STORE_DWORD_IMM_GEN4 | (1 << 21)) + 1; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1232: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1230. *batch++ = upper_32_bits(addr); + 1231. *batch++ = lower_32_bits(target_offset); + 1232. > *batch++ = upper_32_bits(target_offset); + 1233. } + 1234. } else if (gen >= 6) { + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1238: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1236. *batch++ = 0; + 1237. *batch++ = addr; + 1238. > *batch++ = target_offset; + 1239. } else if (gen >= 4) { + 1240. *batch++ = MI_STORE_DWORD_IMM_GEN4 | MI_USE_GGTT; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1243: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1241. *batch++ = 0; + 1242. *batch++ = addr; + 1243. > *batch++ = target_offset; + 1244. } else { + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1247: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + 1246. *batch++ = addr; + 1247. > *batch++ = target_offset; + 1248. } + 1249. + +arch/x86/events/core.c:1187: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1185. void x86_pmu_enable_event(struct perf_event *event) + 1186. { + 1187. > if (__this_cpu_read(cpu_hw_events.enabled)) + 1188. __x86_pmu_enable_event(&event->hw, + 1189. ARCH_PERFMON_EVENTSEL_ENABLE); + +arch/x86/pci/irq.c:1197: error: DEAD_STORE + The value written to &msg (type char*) is never used. + 1195. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin); + 1196. if (pin && !pcibios_lookup_irq(dev, 1)) { + 1197. > char *msg = ""; + 1198. + 1199. if (!io_apic_assign_pci_irqs && dev->irq) + +kernel/relay.c:1203: error: DEAD_STORE + The value written to &pos (type unsigned long long) is never used. + 1201. uint64_t pos = (uint64_t) *ppos; + 1202. uint32_t alloc_size = (uint32_t) rbuf->chan->alloc_size; + 1203. > size_t read_start = (size_t) do_div(pos, alloc_size); + 1204. size_t read_subbuf = read_start / subbuf_size; + 1205. size_t padding = rbuf->padding[read_subbuf]; + +drivers/gpu/drm/i915/intel_lrc.c:1197: error: DEAD_STORE + The value written to &ce (type intel_context*) is never used. + 1195. { + 1196. struct intel_engine_cs *engine = request->engine; + 1197. > struct intel_context *ce = &request->ctx->engine[engine->id]; + 1198. int ret; + 1199. + +net/netfilter/nf_conntrack_netlink.c:1251: error: DEAD_STORE + The value written to &err (type int) is never used. + 1249. ct = nf_ct_tuplehash_to_ctrack(h); + 1250. + 1251. > err = -ENOMEM; + 1252. skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); + 1253. if (skb2 == NULL) { + +drivers/gpu/drm/i915/intel_dp.c:1233: error: UNINITIALIZED_VALUE + The value read from rxbuf.[_] was never initialized. + 1231. if (ret > 1) { + 1232. /* Number of bytes written in a short write. */ + 1233. > ret = clamp_t(int, rxbuf[1], 0, msg->size); + 1234. } else { + 1235. /* Return payload size. */ + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +net/rfkill/core.c:1230: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1228. if (rfkill->type == ev.type || + 1229. ev.type == RFKILL_TYPE_ALL) + 1230. > rfkill_set_block(rfkill, ev.soft); + 1231. ret = 0; + 1232. break; + +net/rfkill/core.c:1238: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1236. (rfkill->type == ev.type || + 1237. ev.type == RFKILL_TYPE_ALL)) + 1238. > rfkill_set_block(rfkill, ev.soft); + 1239. ret = 0; + 1240. break; + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.type was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +drivers/iommu/intel-iommu.c:1244: error: DEAD_STORE + The value written to &last_pte (type dma_pte*) is never used. + 1242. if (first_pte) + 1243. domain_flush_cache(domain, first_pte, + 1244. > (void *)++last_pte - (void *)first_pte); + 1245. + 1246. return freelist; + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +net/wireless/trace.h:1206: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/ipv6/calipso.c:1216: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1212 could be null and is dereferenced at line 1216, column 6. + 1214. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1215. + 1216. > if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt) + 1217. old = req_inet->ipv6_opt->hopopt; + 1218. else + +net/ipv6/addrconf.c:1260: error: UNINITIALIZED_VALUE + The value read from expires was never initialized. + 1258. + 1259. if (action != CLEANUP_PREFIX_RT_NOP) { + 1260. > cleanup_prefix_route(ifp, expires, + 1261. action == CLEANUP_PREFIX_RT_DEL); + 1262. } + +kernel/trace/trace_uprobe.c:1234: error: UNINITIALIZED_VALUE + The value read from udd was never initialized. + 1232. udd.bp_addr = instruction_pointer(regs); + 1233. + 1234. > current->utask->vaddr = (unsigned long) &udd; + 1235. + 1236. if (WARN_ON_ONCE(!uprobe_cpu_buffer)) + +security/selinux/ss/policydb.c:1244: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1242. return rc; + 1243. c->permissions = le32_to_cpu(buf[0]); + 1244. > nexpr = le32_to_cpu(buf[1]); + 1245. le = NULL; + 1246. depth = -1; + +kernel/time/tick-sched.c:1238: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1236. u64 offset = ktime_to_ns(tick_period) >> 1; + 1237. do_div(offset, num_possible_cpus()); + 1238. > offset *= smp_processor_id(); + 1239. hrtimer_add_expires_ns(&ts->sched_timer, offset); + 1240. } + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1241: error: DEAD_STORE + The value written to &ctrl_reg (type unsigned int) is never used. + 1239. } + 1240. + 1241. > ctrl_reg = er32(CTRL); + 1242. + 1243. /* force 1000, set loopback */ + +net/wireless/trace.h:1224: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/core/ethtool.c:1250: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1248. if (copy_from_user(&rxfh, useraddr, sizeof(rxfh))) + 1249. return -EFAULT; + 1250. > user_indir_size = rxfh.indir_size; + 1251. user_key_size = rxfh.key_size; + 1252. + +net/core/ethtool.c:1251: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1249. return -EFAULT; + 1250. user_indir_size = rxfh.indir_size; + 1251. > user_key_size = rxfh.key_size; + 1252. + 1253. /* Check that reserved fields are 0 for now */ + +drivers/net/ethernet/intel/e1000e/netdev.c:1230: error: DEAD_STORE + The value written to &hw (type e1000_hw*) is never used. + 1228. struct e1000_adapter *adapter = tx_ring->adapter; + 1229. struct net_device *netdev = adapter->netdev; + 1230. > struct e1000_hw *hw = &adapter->hw; + 1231. struct e1000_tx_desc *tx_desc, *eop_desc; + 1232. struct e1000_buffer *buffer_info; + +drivers/scsi/scsi_transport_spi.c:1235: error: DEAD_STORE + The value written to &msg (type unsigned char*) is never used. + 1233. if (cmd->flags & SCMD_TAGGED) { + 1234. *msg++ = SIMPLE_QUEUE_TAG; + 1235. > *msg++ = cmd->request->tag; + 1236. return 2; + 1237. } + +drivers/gpu/drm/i915/i915_debugfs.c:1307: error: UNINITIALIZED_VALUE + The value read from acthd.[_] was never initialized. + 1305. spin_unlock_irq(&b->rb_lock); + 1306. + 1307. > seq_printf(m, "\tACTHD = 0x%08llx [current 0x%08llx]\n", + 1308. (long long)engine->hangcheck.acthd, + 1309. (long long)acthd[id]); + +drivers/gpu/drm/i915/i915_debugfs.c:1288: error: UNINITIALIZED_VALUE + The value read from seqno.[_] was never initialized. + 1286. + 1287. seq_printf(m, "%s:\n", engine->name); + 1288. > seq_printf(m, "\tseqno = %x [current %x, last %x], inflight %d\n", + 1289. engine->hangcheck.seqno, seqno[id], + 1290. intel_engine_last_submit(engine), + +net/ipv6/ip6_output.c:1541: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1539. cork->length -= length; + 1540. IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS); + 1541. > return err; + 1542. } + 1543. + +drivers/ata/libahci.c:1258: error: DEAD_STORE + The value written to &tmp (type unsigned int) is never used. + 1256. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1257. writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL); + 1258. > tmp = readl(mmio + HOST_CTL); + 1259. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1260. } + +drivers/gpu/drm/i915/i915_gem.c:1316: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1314. * page_length = bytes to copy for this page + 1315. */ + 1316. > u32 page_base = node.start; + 1317. unsigned int page_offset = offset_in_page(offset); + 1318. unsigned int page_length = PAGE_SIZE - page_offset; + +net/wireless/trace.h:1245: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/ipv6/calipso.c:1257: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1252 could be null and is dereferenced at line 1257, column 7. + 1255. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1256. + 1257. > if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt) + 1258. return; + 1259. + +include/linux/sched.h:1253: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1251. static inline unsigned int task_state_index(struct task_struct *tsk) + 1252. { + 1253. > unsigned int tsk_state = READ_ONCE(tsk->state); + 1254. unsigned int state = (tsk_state | tsk->exit_state) & TASK_REPORT; + 1255. + +kernel/trace/trace_uprobe.c:1269: error: UNINITIALIZED_VALUE + The value read from udd was never initialized. + 1267. udd.bp_addr = func; + 1268. + 1269. > current->utask->vaddr = (unsigned long) &udd; + 1270. + 1271. if (WARN_ON_ONCE(!uprobe_cpu_buffer)) + +drivers/char/random.c:1267: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1265. /* Can we pull enough? */ + 1266. retry: + 1267. > entropy_count = orig = READ_ONCE(r->entropy_count); + 1268. ibytes = nbytes; + 1269. /* never pull more than available */ + +scripts/kconfig/symbol.c:1273: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1272 could be null and is dereferenced at line 1273, column 2. + 1271. + 1272. prop = sym_get_choice_prop(choice); + 1273. > expr_list_for_each_sym(prop->expr, e, sym) + 1274. sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); + 1275. + +net/ipv4/tcp_ipv4.c:1273: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1271. { + 1272. struct inet_request_sock *ireq = inet_rsk(req); + 1273. > struct net *net = sock_net(sk_listener); + 1274. + 1275. sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr); + +net/netfilter/nf_conntrack_sip.c:1293: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1276 could be null and is dereferenced at line 1293, column 6. + 1291. * request and compare it here. + 1292. */ + 1293. > if (ct_sip_info->register_cseq != cseq) + 1294. return NF_ACCEPT; + 1295. + +net/ipv6/addrconf.c:1327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1325. * idev->desync_factor if it's larger + 1326. */ + 1327. > cnf_temp_preferred_lft = READ_ONCE(idev->cnf.temp_prefered_lft); + 1328. max_desync_factor = min_t(__u32, + 1329. idev->cnf.max_desync_factor, + +net/ipv4/route.c:1289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1287. return mtu; + 1288. + 1289. > mtu = READ_ONCE(dst->dev->mtu); + 1290. + 1291. if (unlikely(ip_mtu_locked(dst))) { + +net/wireless/trace.h:1280: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +block/bio.c:1312: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1310. + 1311. if (unlikely(offs & queue_dma_alignment(q))) { + 1312. > ret = -EINVAL; + 1313. j = 0; + 1314. } else { + +drivers/usb/core/devio.c:1291: error: UNINITIALIZED_VALUE + The value read from gd.interface was never initialized. + 1289. if (copy_from_user(&gd, arg, sizeof(gd))) + 1290. return -EFAULT; + 1291. > intf = usb_ifnum_to_if(ps->dev, gd.interface); + 1292. if (!intf || !intf->dev.driver) + 1293. ret = -ENODATA; + +drivers/dma/dmaengine.c:1287: error: DEAD_STORE + The value written to &dma_sync_wait_timeout (type unsigned long) is never used. + 1285. dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx) + 1286. { + 1287. > unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000); + 1288. + 1289. if (!tx) + +net/netfilter/nf_conntrack_netlink.c:1293: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 1291. struct hlist_nulls_node *n; + 1292. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 1293. > u_int8_t l3proto = nfmsg->nfgen_family; + 1294. int res; + 1295. int cpu; + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +net/sunrpc/auth_gss/svcauth_gss.c:1298: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1296. + 1297. WARN_ON_ONCE(type != 0 && type != 1); + 1298. > ret = cmpxchg(&sn->use_gss_proxy, -1, type); + 1299. if (ret != -1 && ret != type) + 1300. return -EBUSY; + +drivers/net/ethernet/marvell/sky2.c:1312: error: UNINITIALIZED_VALUE + The value read from rss_key.[_] was never initialized. + 1310. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 1311. for (i = 0; i < nkeys; i++) + 1312. > sky2_write32(hw, SK_REG(sky2->port, RSS_KEY + i * 4), + 1313. rss_key[i]); + 1314. + +kernel/cgroup/cgroup-v1.c:1311: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 1310 could be null and is dereferenced at line 1311, column 22. + 1309. + 1310. for_each_subsys(ss, i) { + 1311. > if (strcmp(token, ss->name) && + 1312. strcmp(token, ss->legacy_name)) + 1313. continue; + +net/core/ethtool.c:1364: error: UNINITIALIZED_VALUE + The value read from rx_rings.data was never initialized. + 1362. indir = (u32 *)rss_config; + 1363. for (i = 0; i < dev_indir_size; i++) + 1364. > indir[i] = ethtool_rxfh_indir_default(i, rx_rings.data); + 1365. } + 1366. + +net/core/ethtool.c:1355: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1353. rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE) { + 1354. indir = (u32 *)rss_config; + 1355. > ret = ethtool_copy_validate_indir(indir, + 1356. useraddr + rss_cfg_offset, + 1357. &rx_rings, + +net/core/ethtool.c:1369: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1367. if (rxfh.key_size) { + 1368. hkey = rss_config + indir_bytes; + 1369. > if (copy_from_user(hkey, + 1370. useraddr + rss_cfg_offset + indir_bytes, + 1371. rxfh.key_size)) { + +net/wireless/trace.h:1298: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +scripts/kconfig/symbol.c:1318: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1317 could be null and is dereferenced by call to `prop_get_symbol()` at line 1318, column 25. + 1316. dep_stack_insert(&stack, sym); + 1317. prop = sym_get_choice_prop(sym); + 1318. > sym2 = sym_check_deps(prop_get_symbol(prop)); + 1319. dep_stack_remove(); + 1320. } else if (sym_is_choice(sym)) { + +block/blk-mq.c:1326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1324. * handle dispatched requests to this hctx + 1325. */ + 1326. > if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + +block/blk-mq.c:1329: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + 1329. > raw_smp_processor_id(), + 1330. cpumask_empty(hctx->cpumask) ? "inactive": "active"); + 1331. dump_stack(); + +block/blk-mq.c:1326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1324. * handle dispatched requests to this hctx + 1325. */ + 1326. > if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + +block/blk-mq.c:1328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1326. if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. > printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + 1329. raw_smp_processor_id(), + 1330. cpumask_empty(hctx->cpumask) ? "inactive": "active"); + +lib/vsprintf.c:1316: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 1314. bool uc = false; + 1315. + 1316. > switch (*(++fmt)) { + 1317. case 'L': + 1318. uc = true; /* fall-through */ + +drivers/usb/host/ehci-hub.c:1313: error: DEAD_STORE + The value written to &portnum (type int) is never used. + 1311. if (ehci_is_TDI(ehci)) + 1312. return; + 1313. > set_owner(ehci, --portnum, PORT_OWNER); + 1314. } + 1315. + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +block/genhd.c:1336: error: UNINITIALIZED_VALUE + The value read from inflight.[_] was never initialized. + 1334. part_stat_unlock(); + 1335. part_in_flight(gp->queue, hd, inflight); + 1336. > seq_printf(seqf, "%4d %7d %s %lu %lu %lu " + 1337. "%u %lu %lu %lu %u %u %u %u\n", + 1338. MAJOR(part_devt(hd)), MINOR(part_devt(hd)), + +block/genhd.c:1332: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1330. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1331. while ((hd = disk_part_iter_next(&piter))) { + 1332. > cpu = part_stat_lock(); + 1333. part_round_stats(gp->queue, cpu, hd); + 1334. part_stat_unlock(); + +block/genhd.c:1332: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1330. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1331. while ((hd = disk_part_iter_next(&piter))) { + 1332. > cpu = part_stat_lock(); + 1333. part_round_stats(gp->queue, cpu, hd); + 1334. part_stat_unlock(); + +security/selinux/ss/policydb.c:1331: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1329. goto bad; + 1330. + 1331. > len = le32_to_cpu(buf[0]); + 1332. len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1332: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1330. + 1331. len = le32_to_cpu(buf[0]); + 1332. > len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + 1334. + +security/selinux/ss/policydb.c:1339: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1337. goto bad; + 1338. cladatum->permissions.nprim = le32_to_cpu(buf[3]); + 1339. > nel = le32_to_cpu(buf[4]); + 1340. + 1341. ncons = le32_to_cpu(buf[5]); + +security/selinux/ss/policydb.c:1341: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1339. nel = le32_to_cpu(buf[4]); + 1340. + 1341. > ncons = le32_to_cpu(buf[5]); + 1342. + 1343. rc = str_read(&key, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:1374: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1372. if (rc) + 1373. goto bad; + 1374. > ncons = le32_to_cpu(buf[0]); + 1375. rc = read_cons_helper(p, &cladatum->validatetrans, + 1376. ncons, 1, fp); + +net/wireless/trace.h:1321: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +ipc/sem.c:1361: error: DEAD_STORE + The value written to &err (type int) is never used. + 1359. goto out_rcu_wakeup; + 1360. + 1361. > err = -EACCES; + 1362. switch (cmd) { + 1363. case GETALL: + +kernel/exit.c:1342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1340. * can't confuse the checks below. + 1341. */ + 1342. > int exit_state = READ_ONCE(p->exit_state); + 1343. int ret; + 1344. + +kernel/sched/core.c:1425: error: UNINITIALIZED_VALUE + The value read from ncsw was never initialized. + 1423. } + 1424. + 1425. > return ncsw; + 1426. } + 1427. + +kernel/rcu/tree.c:1343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1341. + 1342. j = jiffies; + 1343. > gpa = READ_ONCE(rsp->gp_activity); + 1344. if (j - gpa > 2 * HZ) { + 1345. pr_err("%s kthread starved for %ld jiffies! g%lu c%lu f%#x %s(%d) ->state=%#lx ->cpu=%d\n", + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +arch/x86/events/intel/p4.c:1347: error: DEAD_STORE + The value written to &high (type unsigned int) is never used. + 1345. BUILD_BUG_ON(ARCH_P4_MAX_CCCR > INTEL_PMC_MAX_GENERIC); + 1346. + 1347. > rdmsr(MSR_IA32_MISC_ENABLE, low, high); + 1348. if (!(low & (1 << 7))) { + 1349. pr_cont("unsupported Netburst CPU model %d ", + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.altsetting was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +drivers/usb/core/devio.c:1349: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1347. if (copy_from_user(&setintf, arg, sizeof(setintf))) + 1348. return -EFAULT; + 1349. > ret = checkintf(ps, setintf.interface); + 1350. if (ret) + 1351. return ret; + +drivers/usb/core/devio.c:1353: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1351. return ret; + 1352. + 1353. > destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. return usb_set_interface(ps->dev, setintf.interface, + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +net/wireless/trace.h:1343: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +kernel/sys.c:1356: error: UNINITIALIZED_VALUE + The value read from r32.rlim_cur was never initialized. + 1354. r.rlim_cur = RLIM_INFINITY; + 1355. else + 1356. > r.rlim_cur = r32.rlim_cur; + 1357. if (r32.rlim_max == COMPAT_RLIM_INFINITY) + 1358. r.rlim_max = RLIM_INFINITY; + +kernel/sys.c:1360: error: UNINITIALIZED_VALUE + The value read from r32.rlim_max was never initialized. + 1358. r.rlim_max = RLIM_INFINITY; + 1359. else + 1360. > r.rlim_max = r32.rlim_max; + 1361. return do_prlimit(current, resource, &r, NULL); + 1362. } + +net/ipv4/tcp_input.c:1473: error: DEAD_STORE + The value written to &pcount (type int) is never used. + 1471. len = skb->len; + 1472. if (skb_shift(prev, skb, len)) { + 1473. > pcount += tcp_skb_pcount(skb); + 1474. tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb), + 1475. len, mss, 0); + +net/packet/af_packet.c:1355: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1353. unsigned int num) + 1354. { + 1355. > return smp_processor_id() % num; + 1356. } + 1357. + +drivers/cpufreq/intel_pstate.c:1361: error: DEAD_STORE + The value written to &pstate (type int) is never used. + 1359. + 1360. update_turbo_state(); + 1361. > pstate = intel_pstate_get_base_pstate(cpu); + 1362. pstate = max(cpu->pstate.min_pstate, cpu->max_perf_ratio); + 1363. intel_pstate_set_pstate(cpu, pstate); + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +net/netfilter/nf_conntrack_core.c:1420: error: UNINITIALIZED_VALUE + The value read from dataoff was never initialized. + 1418. } + 1419. repeat: + 1420. > ret = resolve_normal_ct(net, tmpl, skb, dataoff, pf, protonum, + 1421. l3proto, l4proto); + 1422. if (ret < 0) { + +net/netfilter/nf_conntrack_core.c:1402: error: UNINITIALIZED_VALUE + The value read from protonum was never initialized. + 1400. } + 1401. + 1402. > l4proto = __nf_ct_l4proto_find(pf, protonum); + 1403. + 1404. /* It may be an special packet, error, unclean... + +net/netfilter/nf_conntrack_core.c:1420: error: UNINITIALIZED_VALUE + The value read from protonum was never initialized. + 1418. } + 1419. repeat: + 1420. > ret = resolve_normal_ct(net, tmpl, skb, dataoff, pf, protonum, + 1421. l3proto, l4proto); + 1422. if (ret < 0) { + +net/wireless/trace.h:1366: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +drivers/usb/host/uhci-q.c:1385: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1383. uhci_remove_tds_from_frame(uhci, qh->iso_frame); + 1384. + 1385. > ctrlstat = td_status(uhci, td); + 1386. if (ctrlstat & TD_CTRL_ACTIVE) { + 1387. status = -EXDEV; /* TD was added too late? */ + +net/core/net-sysfs.c:1405: error: DEAD_STORE + The value written to &txq (type int) is never used. + 1403. if (error) + 1404. goto error; + 1405. > txq = real_tx; + 1406. + 1407. return 0; + +net/wireless/trace.h:1384: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +kernel/rcu/tree.c:1391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1389. if (!rcu_kick_kthreads) + 1390. return; + 1391. > j = READ_ONCE(rsp->jiffies_kick_kthreads); + 1392. if (time_after(jiffies, j) && rsp->gp_kthread && + 1393. (rcu_gp_in_progress(rsp) || READ_ONCE(rsp->gp_flags))) { + +arch/x86/events/intel/ds.c:1485: error: UNINITIALIZED_VALUE + The value read from counts.[_] was never initialized. + 1483. + 1484. if (counts[bit]) { + 1485. > __intel_pmu_pebs_event(event, iregs, base, + 1486. top, bit, counts[bit]); + 1487. } + +arch/x86/events/intel/ds.c:1478: error: UNINITIALIZED_VALUE + The value read from error.[_] was never initialized. + 1476. /* log dropped samples number */ + 1477. if (error[bit]) { + 1478. > perf_log_lost_samples(event, error[bit]); + 1479. + 1480. if (perf_event_account_interrupt(event)) + +drivers/gpu/drm/i915/intel_overlay.c:1429: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1427. if (IS_ERR(vma)) { + 1428. DRM_ERROR("failed to pin overlay register bo\n"); + 1429. > ret = PTR_ERR(vma); + 1430. goto out_free_bo; + 1431. } + +drivers/md/dm.c:1399: error: NULL_DEREFERENCE + pointer `tio` last assigned on line 1398 could be null and is dereferenced at line 1399, column 2. + 1397. + 1398. tio = alloc_tio(ci, ti, 0, GFP_NOIO); + 1399. > tio->len_ptr = len; + 1400. r = clone_bio(tio, bio, sector, *len); + 1401. if (r < 0) { + +net/core/ethtool.c:1422: error: UNINITIALIZED_VALUE + The value read from regs.len was never initialized. + 1420. goto out; + 1421. useraddr += offsetof(struct ethtool_regs, data); + 1422. > if (regbuf && copy_to_user(useraddr, regbuf, regs.len)) + 1423. goto out; + 1424. ret = 0; + +scripts/kconfig/symbol.c:1403: error: NULL_DEREFERENCE + pointer `sym2` last assigned on line 1402 could be null and is dereferenced at line 1403, column 14. + 1401. for_all_properties(sym, prop, P_ENV) { + 1402. sym2 = prop_get_symbol(prop); + 1403. > if (strcmp(sym2->name, env)) + 1404. menu_warn(current_entry, "redefining environment symbol from %s", + 1405. sym2->name); + +block/blk-mq.c:1409: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1407. + 1408. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1409. > int cpu = get_cpu(); + 1410. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1411. __blk_mq_run_hw_queue(hctx); + +block/blk-mq.c:1409: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1407. + 1408. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1409. > int cpu = get_cpu(); + 1410. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1411. __blk_mq_run_hw_queue(hctx); + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1449: error: DEAD_STORE + The value written to &l (type int) is never used. + 1447. if (!ret_val) + 1448. good_cnt++; + 1449. > if (unlikely(++l == rxdr->count)) + 1450. l = 0; + 1451. /* time + 20 msecs (200 msecs on 2.4) is more than + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1435: error: DEAD_STORE + The value written to &time (type unsigned long) is never used. + 1433. E1000_WRITE_FLUSH(); + 1434. msleep(200); + 1435. > time = jiffies; /* set the start time for the receive */ + 1436. good_cnt = 0; + 1437. do { /* receive the sent packets */ + +net/netfilter/nf_conntrack_sip.c:1423: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1405 could be null and is dereferenced at line 1423, column 3. + 1421. port != ct->tuplehash[dir].tuple.src.u.udp.port && + 1422. nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3)) + 1423. > ct_sip_info->forced_dport = port; + 1424. + 1425. for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) { + +drivers/md/dm-raid1.c:1422: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1420. (unsigned long long)ms->nr_regions, buffer); + 1421. + 1422. > sz += log->type->status(log, type, result+sz, maxlen-sz); + 1423. + 1424. break; + +drivers/md/dm-raid1.c:1441: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1439. DMEMIT(" handle_errors"); + 1440. if (keep_log(ms)) + 1441. > DMEMIT(" keep_log"); + 1442. } + 1443. + +drivers/gpu/drm/i915/intel_runtime_pm.c:1425: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1423. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1424. + 1425. > if (wait_for(COND, 100)) + 1426. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1427. state, + +drivers/gpu/drm/i915/intel_runtime_pm.c:1425: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1423. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1424. + 1425. > if (wait_for(COND, 100)) + 1426. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1427. state, + +drivers/gpu/drm/i915/i915_debugfs.c:1415: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1413. + 1414. for_each_fw_domain(fw_domain, i915, tmp) + 1415. > seq_printf(m, "%s.wake_count = %u\n", + 1416. intel_uncore_forcewake_domain_to_str(fw_domain->id), + 1417. READ_ONCE(fw_domain->wake_count)); + +net/wireless/trace.h:1405: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +kernel/fork.c:1411: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1409. unsigned long cpu_limit; + 1410. + 1411. > cpu_limit = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); + 1412. if (cpu_limit != RLIM_INFINITY) { + 1413. sig->cputime_expires.prof_exp = cpu_limit * NSEC_PER_SEC; + +kernel/rcu/tree.c:1474: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1472. } else { + 1473. j = jiffies; + 1474. > gpa = READ_ONCE(rsp->gp_activity); + 1475. pr_err("All QSes seen, last %s kthread activity %ld (%ld-%ld), jiffies_till_next_fqs=%ld, root ->qsmask %#lx\n", + 1476. rsp->name, j - gpa, j, gpa, + +kernel/rcu/tree.c:1460: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1458. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1459. cpu)->cblist); + 1460. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1461. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1462. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +kernel/rcu/tree.c:1460: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1458. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1459. cpu)->cblist); + 1460. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1461. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1462. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +security/selinux/ss/policydb.c:1427: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1425. goto bad; + 1426. + 1427. > len = le32_to_cpu(buf[0]); + 1428. role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +drivers/net/ethernet/broadcom/tg3.c:1421: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 1420 could be null and is dereferenced at line 1421, column 10. + 1419. + 1420. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 1421. > switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) { + 1422. case PHY_ID_BCM50610: + 1423. case PHY_ID_BCM50610M: + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1431: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1429. return -EFAULT; + 1430. + 1431. > if (tmp.oldlenp && get_user(oldlen, tmp.oldlenp)) + 1432. return -EFAULT; + 1433. + +kernel/sysctl_binary.c:1442: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1440. } + 1441. + 1442. > if (tmp.oldlenp && put_user(oldlen, tmp.oldlenp)) + 1443. return -EFAULT; + 1444. + +drivers/gpu/drm/i915/intel_tv.c:1432: error: NULL_DEREFERENCE + pointer `old_state` last assigned on line 1429 could be null and is dereferenced at line 1432, column 6. + 1430. new_crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc); + 1431. + 1432. > if (old_state->tv.mode != new_state->tv.mode || + 1433. old_state->tv.margins.left != new_state->tv.margins.left || + 1434. old_state->tv.margins.right != new_state->tv.margins.right || + +net/wireless/trace.h:1421: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/sunrpc/auth_gss/auth_gss.c:1430: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 1428. struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base); + 1429. struct gss_cl_ctx *ctx; + 1430. > unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ); + 1431. int ret = 0; + 1432. + +net/packet/af_packet.c:1436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1434. { + 1435. struct packet_fanout *f = pt->af_packet_priv; + 1436. > unsigned int num = READ_ONCE(f->num_members); + 1437. struct net *net = read_pnet(&f->net); + 1438. struct packet_sock *po; + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +kernel/sched/core.c:1447: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1445. preempt_disable(); + 1446. cpu = task_cpu(p); + 1447. > if ((cpu != smp_processor_id()) && task_curr(p)) + 1448. smp_send_reschedule(cpu); + 1449. preempt_enable(); + +net/wireless/trace.h:1441: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/ipv4/ipmr.c:1542: error: UNINITIALIZED_VALUE + The value read from mfc.mfcc_parent was never initialized. + 1540. } + 1541. if (parent == 0) + 1542. > parent = mfc.mfcc_parent; + 1543. if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY) + 1544. ret = ipmr_mfc_delete(mrt, &mfc, parent); + +net/ipv4/ipmr.c:1521: error: UNINITIALIZED_VALUE + The value read from vif.vifc_vifi was never initialized. + 1519. sk == rtnl_dereference(mrt->mroute_sk)); + 1520. } else { + 1521. > ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL); + 1522. } + 1523. break; + +net/ipv4/devinet.c:1466: error: DEAD_STORE + The value written to &in_dev (type in_device*) is never used. + 1464. /* Re-enabling IP */ + 1465. if (inetdev_valid_mtu(dev->mtu)) + 1466. > in_dev = inetdev_init(dev); + 1467. } + 1468. goto out; + +drivers/gpu/drm/drm_vblank.c:1550: error: DEAD_STORE + The value written to &end (type unsigned long) is never used. + 1548. DRM_DEBUG("waiting on vblank count %llu, crtc %u\n", + 1549. req_seq, pipe); + 1550. > DRM_WAIT_ON(ret, vblank->queue, 3 * HZ, + 1551. vblank_passed(drm_vblank_count(dev, pipe), + 1552. req_seq) || + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +drivers/gpu/drm/i915/i915_debugfs.c:1463: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1461. int count = 0; + 1462. + 1463. > forcewake_count = READ_ONCE(dev_priv->uncore.fw_domain[FW_DOMAIN_ID_RENDER].wake_count); + 1464. if (forcewake_count) { + 1465. seq_puts(m, "RC information inaccurate because somebody " + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.name was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1480: error: UNINITIALIZED_VALUE + The value read from tmp.newval was never initialized. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. > compat_ptr(tmp.newval), tmp.newlen); + 1481. + 1482. if (result >= 0) { + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1474: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1472. return -EFAULT; + 1473. + 1474. > compat_oldlenp = compat_ptr(tmp.oldlenp); + 1475. if (compat_oldlenp && get_user(oldlen, compat_oldlenp)) + 1476. return -EFAULT; + +kernel/sysctl_binary.c:1479: error: UNINITIALIZED_VALUE + The value read from tmp.oldval was never initialized. + 1477. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. > compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + 1481. + +net/wireless/trace.h:1461: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +drivers/net/ethernet/intel/e100.c:1472: error: DEAD_STORE + The value written to &stat (type unsigned short) is never used. + 1470. nic->mii.phy_id = (addr == 0) ? 1 : (addr == 1) ? 0 : addr; + 1471. bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR); + 1472. > stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1473. stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1474. if (!((bmcr == 0xFFFF) || ((stat == 0) && (bmcr == 0)))) + +security/selinux/ss/policydb.c:1483: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1481. goto bad; + 1482. + 1483. > len = le32_to_cpu(buf[0]); + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + +security/selinux/ss/policydb.c:1486: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + 1486. > u32 prop = le32_to_cpu(buf[2]); + 1487. + 1488. if (prop & TYPEDATUM_PROPERTY_PRIMARY) + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1496: error: DEAD_STORE + The value written to &c (type char) is never used. + 1494. end = addr + size; + 1495. for (; addr < end; addr += PAGE_SIZE) { + 1496. > int err = __get_user(c, addr); + 1497. if (err) + 1498. return err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1500: error: DEAD_STORE + The value written to &c (type char) is never used. + 1498. return err; + 1499. } + 1500. > return __get_user(c, end - 1); + 1501. } + 1502. + +drivers/cpufreq/intel_pstate.c:1485: error: DEAD_STORE + The value written to &max_pstate (type int) is never used. + 1483. static int intel_pstate_prepare_request(struct cpudata *cpu, int pstate) + 1484. { + 1485. > int max_pstate = intel_pstate_get_base_pstate(cpu); + 1486. int min_pstate; + 1487. + +sound/core/control.c:1511: error: UNINITIALIZED_VALUE + The value read from header.length was never initialized. + 1509. if (header.length < sizeof(unsigned int) * 2) + 1510. return -EINVAL; + 1511. > container_size = header.length; + 1512. container = buf->tlv; + 1513. + +sound/core/control.c:1514: error: UNINITIALIZED_VALUE + The value read from header.numid was never initialized. + 1512. container = buf->tlv; + 1513. + 1514. > kctl = snd_ctl_find_numid(file->card, header.numid); + 1515. if (kctl == NULL) + 1516. return -ENOENT; + +kernel/rcu/tree.c:1512: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1510. print_cpu_stall_info_begin(); + 1511. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1512. > print_cpu_stall_info(rsp, smp_processor_id()); + 1513. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1514. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1541: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1539. * switches for an entirely unreasonable amount of time. + 1540. */ + 1541. > resched_cpu(smp_processor_id()); + 1542. } + 1543. + +kernel/rcu/tree.c:1512: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1510. print_cpu_stall_info_begin(); + 1511. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1512. > print_cpu_stall_info(rsp, smp_processor_id()); + 1513. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1514. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1541: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1539. * switches for an entirely unreasonable amount of time. + 1540. */ + 1541. > resched_cpu(smp_processor_id()); + 1542. } + 1543. + +net/ipv4/netfilter/ip_tables.c:1516: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1514. tmp.name[sizeof(tmp.name)-1] = 0; + 1515. + 1516. > newinfo = xt_alloc_table_info(tmp.size); + 1517. if (!newinfo) + 1518. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1521: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1519. + 1520. loc_cpu_entry = newinfo->entries; + 1521. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1522. tmp.size) != 0) { + 1523. ret = -EFAULT; + +kernel/cgroup/cpuset.c:1503: error: DEAD_STORE + The value written to &cs (type cpuset*) is never used. + 1501. + 1502. cgroup_taskset_first(tset, &css); + 1503. > cs = css_cs(css); + 1504. + 1505. mutex_lock(&cpuset_mutex); + +net/ipv6/netfilter/ip6_tables.c:1526: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1524. tmp.name[sizeof(tmp.name)-1] = 0; + 1525. + 1526. > newinfo = xt_alloc_table_info(tmp.size); + 1527. if (!newinfo) + 1528. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1531: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1529. + 1530. loc_cpu_entry = newinfo->entries; + 1531. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1532. tmp.size) != 0) { + 1533. ret = -EFAULT; + +net/wireless/trace.h:1506: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +drivers/hid/hid-sony.c:1645: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1643. err_stop: + 1644. kfree(buf); + 1645. > return ret; + 1646. } + 1647. + +net/ipv4/ip_output.c:1518: error: DEAD_STORE + The value written to &rt (type rtable*) is never used. + 1516. struct ipcm_cookie ipc; + 1517. struct flowi4 fl4; + 1518. > struct rtable *rt = skb_rtable(skb); + 1519. struct net *net = sock_net(sk); + 1520. struct sk_buff *nskb; + +kernel/time/timer.c:1521: error: DEAD_STORE + The value written to &base (type timer_base*) is never used. + 1519. u64 get_next_timer_interrupt(unsigned long basej, u64 basem) + 1520. { + 1521. > struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]); + 1522. u64 expires = KTIME_MAX; + 1523. unsigned long nextevt; + +kernel/time/timer.c:1530: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1528. * Possible pending timers will be migrated later to an active cpu. + 1529. */ + 1530. > if (cpu_is_offline(smp_processor_id())) + 1531. return expires; + 1532. + +kernel/time/timer.c:1530: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1528. * Possible pending timers will be migrated later to an active cpu. + 1529. */ + 1530. > if (cpu_is_offline(smp_processor_id())) + 1531. return expires; + 1532. + +net/socket.c:1581: error: UNINITIALIZED_VALUE + The value read from len was never initialized. + 1579. goto out_fd; + 1580. } + 1581. > err = move_addr_to_user(&address, + 1582. len, upeer_sockaddr, upeer_addrlen); + 1583. if (err < 0) + +net/wireless/trace.h:1524: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +drivers/pci/setup-bus.c:1532: error: DEAD_STORE + The value written to &idx (type int) is never used. + 1530. unsigned old_flags = 0; + 1531. struct resource *b_res; + 1532. > int idx = 1; + 1533. + 1534. b_res = &dev->resource[PCI_BRIDGE_RESOURCES]; + +drivers/cpufreq/intel_pstate.c:1534: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1532. + 1533. /* Don't allow remote callbacks */ + 1534. > if (smp_processor_id() != cpu->cpu) + 1535. return; + 1536. + +net/core/ethtool.c:1560: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1558. return -ENOMEM; + 1559. + 1560. > bytes_remaining = eeprom.len; + 1561. while (bytes_remaining > 0) { + 1562. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +security/selinux/ss/policydb.c:1557: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1555. goto bad; + 1556. + 1557. > len = le32_to_cpu(buf[0]); + 1558. usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +kernel/rcu/tree.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. * and rsp->gp_start suffice to forestall false positives. + 1575. */ + 1576. > gpnum = READ_ONCE(rsp->gpnum); + 1577. smp_rmb(); /* Pick up ->gpnum first... */ + 1578. js = READ_ONCE(rsp->jiffies_stall); + +kernel/rcu/tree.c:1578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1576. gpnum = READ_ONCE(rsp->gpnum); + 1577. smp_rmb(); /* Pick up ->gpnum first... */ + 1578. > js = READ_ONCE(rsp->jiffies_stall); + 1579. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1580. gps = READ_ONCE(rsp->gp_start); + +kernel/rcu/tree.c:1580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1578. js = READ_ONCE(rsp->jiffies_stall); + 1579. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1580. > gps = READ_ONCE(rsp->gp_start); + 1581. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1582. completed = READ_ONCE(rsp->completed); + +kernel/rcu/tree.c:1582: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1580. gps = READ_ONCE(rsp->gp_start); + 1581. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1582. > completed = READ_ONCE(rsp->completed); + 1583. if (ULONG_CMP_GE(completed, gpnum) || + 1584. ULONG_CMP_LT(j, js) || + +net/wireless/trace.h:1545: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/xfrm/xfrm_policy.c:1638: error: NULL_DEREFERENCE + pointer `xdst_prev` last assigned on line 1559 could be null and is dereferenced by call to `xfrm_dst_set_child()` at line 1638, column 2. + 1636. } + 1637. + 1638. > xfrm_dst_set_child(xdst_prev, dst); + 1639. xdst0->path = dst; + 1640. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +net/wireless/trace.h:1564: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +include/linux/blkdev.h:1571: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1569. { + 1570. unsigned int granularity = max(lim->physical_block_size, lim->io_min); + 1571. > unsigned int alignment = sector_div(sector, granularity >> 9) << 9; + 1572. + 1573. return (granularity + lim->alignment_offset - alignment) % granularity; + +net/core/net-sysfs.c:1596: error: DEAD_STORE + The value written to &groups (type attribute_group const **) is never used. + 1594. #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211) + 1595. if (ndev->ieee80211_ptr) + 1596. > *groups++ = &wireless_group; + 1597. #if IS_ENABLED(CONFIG_WIRELESS_EXT) + 1598. else if (ndev->wireless_handlers) + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +drivers/gpu/drm/i915/intel_engine_cs.c:1601: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1599. * are truly idle. + 1600. */ + 1601. > if (wait_for(intel_engine_is_idle(engine), 10)) { + 1602. struct drm_printer p = drm_debug_printer(__func__); + 1603. + +drivers/gpu/drm/i915/intel_engine_cs.c:1601: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1599. * are truly idle. + 1600. */ + 1601. > if (wait_for(intel_engine_is_idle(engine), 10)) { + 1602. struct drm_printer p = drm_debug_printer(__func__); + 1603. + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +net/wireless/trace.h:1587: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1585. ); + 1586. + 1587. > DECLARE_EVENT_CLASS(tx_rx_evt, + 1588. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1589. TP_ARGS(wiphy, rx, tx), + +security/selinux/ss/policydb.c:1604: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1602. goto bad; + 1603. + 1604. > len = le32_to_cpu(buf[0]); + 1605. levdatum->isalias = le32_to_cpu(buf[1]); + 1606. + +drivers/gpu/drm/drm_dp_mst_topology.c:1605: error: DEAD_STORE + The value written to &len (type int) is never used. + 1603. + 1604. txmsg->dst = mstb; + 1605. > len = build_link_address(txmsg); + 1606. + 1607. mstb->link_address_sent = true; + +net/sunrpc/auth_gss/svcauth_gss.c:1616: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1614. BUG_ON(integ_len % 4); + 1615. *p++ = htonl(integ_len); + 1616. > *p++ = htonl(gc->gc_seq); + 1617. if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset, integ_len)) { + 1618. WARN_ON_ONCE(1); + +include/linux/blkdev.h:1611: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1609. + 1610. /* Offset of the partition start in 'granularity' sectors */ + 1611. > offset = sector_div(sector, granularity); + 1612. + 1613. /* And why do we do this modulus *again* in blkdev_issue_discard()? */ + +net/core/ethtool.c:1625: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1623. return -ENOMEM; + 1624. + 1625. > bytes_remaining = eeprom.len; + 1626. while (bytes_remaining > 0) { + 1627. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +kernel/printk/printk.c:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. + 1603. raw_spin_lock(&console_owner_lock); + 1604. > waiter = READ_ONCE(console_waiter); + 1605. console_owner = NULL; + 1606. raw_spin_unlock(&console_owner_lock); + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +drivers/scsi/scsi_transport_spi.c:1625: error: DEAD_STORE + The value written to &error (type int) is never used. + 1623. if (error) + 1624. return error; + 1625. > error = anon_transport_class_register(&spi_device_class); + 1626. return transport_class_register(&spi_host_class); + 1627. } + +drivers/scsi/sd.c:1636: error: UNINITIALIZED_VALUE + The value read from res was never initialized. + 1634. + 1635. if (res) { + 1636. > sd_print_result(sdkp, "Synchronize Cache(10) failed", res); + 1637. + 1638. if (driver_byte(res) & DRIVER_SENSE) + +kernel/cgroup/cpuset.c:1614: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1609 could be null and is dereferenced by call to `is_cpuset_online()` at line 1614, column 7. + 1612. + 1613. mutex_lock(&cpuset_mutex); + 1614. > if (!is_cpuset_online(cs)) { + 1615. retval = -ENODEV; + 1616. goto out_unlock; + +net/wireless/trace.h:1609: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1607. ); + 1608. + 1609. > DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, + 1610. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1611. TP_ARGS(wiphy, netdev, id), + +block/blk-core.c:1632: error: UNINITIALIZED_VALUE + The value read from inflight.[_] was never initialized. + 1630. + 1631. if (stats & 2) + 1632. > part_round_stats_single(q, cpu, part2, now, inflight[1]); + 1633. if (stats & 1) + 1634. part_round_stats_single(q, cpu, part, now, inflight[0]); + +block/blk-core.c:1634: error: UNINITIALIZED_VALUE + The value read from inflight.[_] was never initialized. + 1632. part_round_stats_single(q, cpu, part2, now, inflight[1]); + 1633. if (stats & 1) + 1634. > part_round_stats_single(q, cpu, part, now, inflight[0]); + 1635. } + 1636. EXPORT_SYMBOL_GPL(part_round_stats); + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from fault_reason was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from guest_addr was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from source_id was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/clk/clk.c:1635: error: DEAD_STORE + The value written to &best_parent_rate (type unsigned long) is never used. + 1633. parent = old_parent = core->parent; + 1634. if (parent) + 1635. > best_parent_rate = parent->rate; + 1636. + 1637. clk_core_get_boundaries(core, &min_rate, &max_rate); + +drivers/gpu/drm/i915/intel_cdclk.c:1628: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1626. + 1627. /* Timeout 200us */ + 1628. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1629. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1630. + +drivers/gpu/drm/i915/intel_cdclk.c:1628: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1626. + 1627. /* Timeout 200us */ + 1628. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1629. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1630. + +kernel/sched/rt.c:1628: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1626. struct sched_domain *sd; + 1627. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1628. > int this_cpu = smp_processor_id(); + 1629. int cpu = task_cpu(task); + 1630. + +kernel/sched/rt.c:1628: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1626. struct sched_domain *sd; + 1627. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1628. > int this_cpu = smp_processor_id(); + 1629. int cpu = task_cpu(task); + 1630. + +net/unix/af_unix.c:1707: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 1705. goto out_free; + 1706. + 1707. > other = unix_find_other(net, sunaddr, namelen, sk->sk_type, + 1708. hash, &err); + 1709. if (other == NULL) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +drivers/scsi/scsi_lib.c:1631: error: DEAD_STORE + The value written to &wait_for (type unsigned long) is never used. + 1629. { + 1630. struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); + 1631. > unsigned long wait_for = (cmd->allowed + 1) * rq->timeout; + 1632. int disposition; + 1633. + +security/selinux/ss/policydb.c:1645: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1643. goto bad; + 1644. + 1645. > len = le32_to_cpu(buf[0]); + 1646. catdatum->value = le32_to_cpu(buf[1]); + 1647. catdatum->isalias = le32_to_cpu(buf[2]); + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +drivers/gpu/drm/i915/intel_cdclk.c:1646: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1644. + 1645. /* Timeout 200us */ + 1646. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1647. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1648. + +drivers/gpu/drm/i915/intel_cdclk.c:1646: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1644. + 1645. /* Timeout 200us */ + 1646. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1647. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1648. + +kernel/printk/printk.c:1650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1648. raw_spin_lock(&console_owner_lock); + 1649. owner = READ_ONCE(console_owner); + 1650. > waiter = READ_ONCE(console_waiter); + 1651. if (!waiter && owner && owner != current) { + 1652. WRITE_ONCE(console_waiter, true); + +net/wireless/trace.h:1636: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +drivers/hid/usbhid/hid-core.c:1641: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1639. static int __init hid_init(void) + 1640. { + 1641. > int retval = -ENOMEM; + 1642. + 1643. retval = hid_quirks_init(quirks_param, BUS_USB, MAX_USBHID_BOOT_QUIRKS); + +drivers/hid/hid-core.c:1698: error: DEAD_STORE + The value written to &len (type int) is never used. + 1696. ((struct hiddev *)hdev->hiddev)->minor); + 1697. if (hdev->claimed & HID_CLAIMED_HIDRAW) + 1698. > len += sprintf(buf + len, "%shidraw%d", len ? "," : "", + 1699. ((struct hidraw *)hdev->hidraw)->minor); + 1700. + +drivers/net/ethernet/intel/e1000e/ethtool.c:1690: error: DEAD_STORE + The value written to &time (type unsigned long) is never used. + 1688. e1e_flush(); + 1689. msleep(200); + 1690. > time = jiffies; /* set the start time for the receive */ + 1691. good_cnt = 0; + 1692. /* receive the sent packets */ + +net/sunrpc/auth_gss/svcauth_gss.c:1661: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1659. len = p++; + 1660. offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base; + 1661. > *p++ = htonl(gc->gc_seq); + 1662. inpages = resbuf->pages; + 1663. /* XXX: Would be better to write some xdr helper functions for + +drivers/gpu/drm/drm_dp_mst_topology.c:1659: error: DEAD_STORE + The value written to &len (type int) is never used. + 1657. + 1658. txmsg->dst = mstb; + 1659. > len = build_enum_path_resources(txmsg, port->port_num); + 1660. + 1661. drm_dp_queue_down_tx(mgr, txmsg); + +net/core/sock.c:1722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1720. newsk->sk_err_soft = 0; + 1721. newsk->sk_priority = 0; + 1722. > newsk->sk_incoming_cpu = raw_smp_processor_id(); + 1723. atomic64_set(&newsk->sk_cookie, 0); + 1724. if (likely(newsk->sk_net_refcnt)) + +net/socket.c:1670: error: UNINITIALIZED_VALUE + The value read from len was never initialized. + 1668. if (err) + 1669. goto out_put; + 1670. > err = move_addr_to_user(&address, len, usockaddr, usockaddr_len); + 1671. + 1672. out_put: + +kernel/cgroup/cpuset.c:1661: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1656 could be null and is dereferenced by call to `is_cpuset_online()` at line 1661, column 7. + 1659. + 1660. mutex_lock(&cpuset_mutex); + 1661. > if (!is_cpuset_online(cs)) + 1662. goto out_unlock; + 1663. + +drivers/tty/n_tty.c:1688: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1686. * read_tail (so this producer will not overwrite unread data) + 1687. */ + 1688. > size_t tail = smp_load_acquire(&ldata->read_tail); + 1689. + 1690. room = N_TTY_BUF_SIZE - (ldata->read_head - tail); + +drivers/net/ethernet/broadcom/tg3.c:1699: error: DEAD_STORE + The value written to &data (type unsigned int*) is never used. + 1697. else + 1698. val = 0; + 1699. > *data++ = val; + 1700. } + 1701. + +drivers/usb/host/uhci-q.c:1693: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1691. urbp = list_entry(qh->queue.next, struct urb_priv, node); + 1692. td = list_entry(urbp->td_list.next, struct uhci_td, list); + 1693. > status = td_status(uhci, td); + 1694. if (!(status & TD_CTRL_ACTIVE)) { + 1695. + +block/bio.c:1674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1672. unsigned long sectors, struct hd_struct *part) + 1673. { + 1674. > int cpu = part_stat_lock(); + 1675. + 1676. part_round_stats(q, cpu, part); + +block/bio.c:1674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1672. unsigned long sectors, struct hd_struct *part) + 1673. { + 1674. > int cpu = part_stat_lock(); + 1675. + 1676. part_round_stats(q, cpu, part); + +net/wireless/trace.h:1675: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +drivers/gpu/drm/i915/intel_hdmi.c:1688: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1683 could be null and is dereferenced at line 1688, column 2. + 1686. intel_hdmi_prepare(encoder, pipe_config); + 1687. + 1688. > intel_dig_port->set_infoframes(&encoder->base, + 1689. pipe_config->has_infoframe, + 1690. pipe_config, conn_state); + +drivers/md/dm-ioctl.c:1689: error: UNINITIALIZED_VALUE + The value read from version.[_] was never initialized. + 1687. if ((DM_VERSION_MAJOR != version[0]) || + 1688. (DM_VERSION_MINOR < version[1])) { + 1689. > DMWARN("ioctl interface mismatch: " + 1690. "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)", + 1691. DM_VERSION_MAJOR, DM_VERSION_MINOR, + +net/socket.c:1702: error: UNINITIALIZED_VALUE + The value read from len was never initialized. + 1700. 1); + 1701. if (!err) + 1702. > err = move_addr_to_user(&address, len, usockaddr, + 1703. usockaddr_len); + 1704. fput_light(sock->file, fput_needed); + +block/bio.c:1689: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1687. { + 1688. unsigned long duration = jiffies - start_time; + 1689. > int cpu = part_stat_lock(); + 1690. + 1691. part_stat_add(cpu, part, ticks[rw], duration); + +block/bio.c:1689: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1687. { + 1688. unsigned long duration = jiffies - start_time; + 1689. > int cpu = part_stat_lock(); + 1690. + 1691. part_stat_add(cpu, part, ticks[rw], duration); + +net/wireless/trace.h:1692: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +drivers/gpu/drm/i915/intel_hdmi.c:1706: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1697 could be null and is dereferenced at line 1706, column 2. + 1704. 0x2b247878); + 1705. + 1706. > dport->set_infoframes(&encoder->base, + 1707. pipe_config->has_infoframe, + 1708. pipe_config, conn_state); + +net/ipv4/netfilter/ip_tables.c:1731: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1729. target = 0; + 1730. + 1731. > try_then_request_module(xt_find_revision(AF_INET, rev.name, + 1732. rev.revision, + 1733. target, &ret), + +kernel/printk/printk.c:1712: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1710. if (!con->write) + 1711. continue; + 1712. > if (!cpu_online(smp_processor_id()) && + 1713. !(con->flags & CON_ANYTIME)) + 1714. continue; + +kernel/printk/printk.c:1712: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1710. if (!con->write) + 1711. continue; + 1712. > if (!cpu_online(smp_processor_id()) && + 1713. !(con->flags & CON_ANYTIME)) + 1714. continue; + +drivers/gpu/drm/drm_atomic_helper.c:1705: error: DEAD_STORE + The value written to &completed (type _Bool) is never used. + 1703. { + 1704. struct drm_crtc_commit *commit, *stall_commit = NULL; + 1705. > bool completed = true; + 1706. int i; + 1707. long ret = 0; + +drivers/net/ethernet/broadcom/tg3.c:1716: error: UNINITIALIZED_VALUE + The value read from data.[_] was never initialized. + 1714. tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_LINK_UPDATE); + 1715. tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 14); + 1716. > tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x0, data[0]); + 1717. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x4, data[1]); + 1718. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x8, data[2]); + +drivers/net/ethernet/broadcom/tg3.c:1717: error: UNINITIALIZED_VALUE + The value read from data.[_] was never initialized. + 1715. tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 14); + 1716. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x0, data[0]); + 1717. > tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x4, data[1]); + 1718. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x8, data[2]); + 1719. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0xc, data[3]); + +drivers/net/ethernet/broadcom/tg3.c:1718: error: UNINITIALIZED_VALUE + The value read from data.[_] was never initialized. + 1716. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x0, data[0]); + 1717. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x4, data[1]); + 1718. > tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x8, data[2]); + 1719. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0xc, data[3]); + 1720. + +drivers/net/ethernet/broadcom/tg3.c:1719: error: UNINITIALIZED_VALUE + The value read from data.[_] was never initialized. + 1717. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x4, data[1]); + 1718. tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0x8, data[2]); + 1719. > tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 0xc, data[3]); + 1720. + 1721. tg3_generate_fw_event(tp); + +net/core/filter.c:1707: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1705. int ret; + 1706. + 1707. > if (unlikely(__this_cpu_read(xmit_recursion) > XMIT_RECURSION_LIMIT)) { + 1708. net_crit_ratelimited("bpf: recursion limit reached on datapath, buggy bpf program?\n"); + 1709. kfree_skb(skb); + +net/ipv6/netfilter/ip6_tables.c:1741: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1739. target = 0; + 1740. + 1741. > try_then_request_module(xt_find_revision(AF_INET6, rev.name, + 1742. rev.revision, + 1743. target, &ret), + +net/ipv6/mcast.c:1720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1718. return skb; + 1719. + 1720. > mtu = READ_ONCE(dev->mtu); + 1721. if (mtu < IPV6_MIN_MTU) + 1722. return skb; + +net/sunrpc/auth_gss/svcauth_gss.c:1716: error: DEAD_STORE + The value written to &stat (type int) is never used. + 1714. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1715. struct xdr_buf *resbuf = &rqstp->rq_res; + 1716. > int stat = -EINVAL; + 1717. struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id); + 1718. + +drivers/gpu/drm/drm_dp_mst_topology.c:1747: error: DEAD_STORE + The value written to &len (type int) is never used. + 1745. + 1746. txmsg->dst = mstb; + 1747. > len = build_allocate_payload(txmsg, port_num, + 1748. id, + 1749. pbn, port->num_sdp_streams, sinks); + +kernel/rcu/tree_plugin.h:1715: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1713. { + 1714. rdp->ticks_this_gp = 0; + 1715. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1716. } + 1717. + +kernel/rcu/tree_plugin.h:1715: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1713. { + 1714. rdp->ticks_this_gp = 0; + 1715. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1716. } + 1717. + +net/wireless/trace.h:1732: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +drivers/input/mouse/alps.c:1756: error: UNINITIALIZED_VALUE + The value read from param.[_] was never initialized. + 1754. return -1; + 1755. + 1756. > return param[2]; + 1757. } + 1758. + +net/xfrm/xfrm_policy.c:1756: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1754. old = per_cpu(xfrm_last_dst, cpu); + 1755. if (old && !xfrm_bundle_ok(old)) { + 1756. > if (smp_processor_id() == cpu) { + 1757. __xfrm_pcpu_work_fn(); + 1758. continue; + +sound/core/timer.c:1812: error: UNINITIALIZED_VALUE + The value read from params.queue_size was never initialized. + 1810. if (params.queue_size > 0 && + 1811. (unsigned int)tu->queue_size != params.queue_size) { + 1812. > err = realloc_user_queue(tu, params.queue_size); + 1813. if (err < 0) + 1814. goto _end; + +net/wireless/trace.h:1752: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1750. ); + 1751. + 1752. > DECLARE_EVENT_CLASS(rdev_pmksa, + 1753. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1754. struct cfg80211_pmksa *pmksa), + +drivers/gpu/drm/i915/intel_ddi.c:1760: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 1756 could be null and is dereferenced at line 1760, column 10. + 1758. + 1759. if (intel_ddi_get_hw_state(encoder, &pipe)) + 1760. > return BIT_ULL(dig_port->ddi_io_power_domain); + 1761. + 1762. return 0; + +kernel/workqueue.c:1758: error: DEAD_STORE + The value written to &id (type int) is never used. + 1756. { + 1757. struct worker *worker = NULL; + 1758. > int id = -1; + 1759. char id_buf[16]; + 1760. + +drivers/block/loop.c:1783: error: DEAD_STORE + The value written to &err (type int) is never used. + 1781. i = err; + 1782. + 1783. > err = -ENOMEM; + 1784. lo->tag_set.ops = &loop_mq_ops; + 1785. lo->tag_set.nr_hw_queues = 1; + +drivers/gpu/drm/i915/intel_hdmi.c:1777: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1767 could be null and is dereferenced at line 1777, column 2. + 1775. chv_set_phy_signal_level(encoder, 128, 102, false); + 1776. + 1777. > dport->set_infoframes(&encoder->base, + 1778. pipe_config->has_infoframe, + 1779. pipe_config, conn_state); + +drivers/gpu/drm/drm_dp_mst_topology.c:1784: error: DEAD_STORE + The value written to &len (type int) is never used. + 1782. + 1783. txmsg->dst = port->parent; + 1784. > len = build_power_updown_phy(txmsg, port->port_num, power_up); + 1785. drm_dp_queue_down_tx(mgr, txmsg); + 1786. + +net/wireless/trace.h:1770: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +drivers/gpu/drm/drm_fb_helper.c:1862: error: UNINITIALIZED_VALUE + The value read from sizes.surface_height was never initialized. + 1860. + 1861. sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1862. > sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1863. + 1864. for (j = 0; j < mode_set->num_connectors; j++) { + +drivers/gpu/drm/drm_fb_helper.c:1861: error: UNINITIALIZED_VALUE + The value read from sizes.surface_width was never initialized. + 1859. gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size; + 1860. + 1861. > sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1862. sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1863. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +kernel/events/core.c:1802: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1800. event_filter_match(struct perf_event *event) + 1801. { + 1802. > return (event->cpu == -1 || event->cpu == smp_processor_id()) && + 1803. perf_cgroup_match(event) && pmu_filter_match(event); + 1804. } + +net/wireless/trace.h:1800: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +kernel/cgroup/cpuset.c:1817: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1813 could be null and is dereferenced at line 1817, column 10. + 1815. switch (type) { + 1816. case FILE_SCHED_RELAX_DOMAIN_LEVEL: + 1817. > return cs->relax_domain_level; + 1818. default: + 1819. BUG(); + +drivers/usb/core/hub.c:1831: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1817 could be null and is dereferenced at line 1831, column 9. + 1829. info->nports = hdev->maxchild; + 1830. for (i = 0; i < info->nports; i++) { + 1831. > if (hub->ports[i]->child == NULL) + 1832. info->port[i] = 0; + 1833. else + +net/core/ethtool.c:1830: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1828. return -EFAULT; + 1829. + 1830. > ret = __ethtool_get_sset_count(dev, gstrings.string_set); + 1831. if (ret < 0) + 1832. return ret; + +net/core/ethtool.c:1842: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1840. return -ENOMEM; + 1841. + 1842. > __ethtool_get_strings(dev, gstrings.string_set, data); + 1843. + 1844. ret = -EFAULT; + +net/wireless/trace.h:1821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.keycode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +drivers/tty/vt/keyboard.c:1834: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1832. switch (cmd) { + 1833. case KDGETKEYCODE: + 1834. > kc = getkeycode(tmp.scancode); + 1835. if (kc >= 0) + 1836. kc = put_user(kc, &user_kbkc->keycode); + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +net/ipv4/cipso_ipv4.c:1830: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1828. const struct netlbl_lsm_secattr *secattr) + 1829. { + 1830. > int ret_val = -EPERM; + 1831. unsigned char *buf = NULL; + 1832. u32 buf_len; + +drivers/usb/host/ehci-sched.c:1888: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 1886. + 1887. /* give urb back to the driver; completion often (re)submits */ + 1888. > dev = urb->dev; + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + +kernel/sys.c:1835: error: DEAD_STORE + The value written to &mm (type mm_struct*) is never used. + 1833. { + 1834. unsigned long mmap_max_addr = TASK_SIZE; + 1835. > struct mm_struct *mm = current->mm; + 1836. int error = -EINVAL, i; + 1837. + +drivers/i2c/i2c-core-base.c:1855: error: DEAD_STORE + The value written to &orig_jiffies (type unsigned long) is never used. + 1853. + 1854. /* Retry automatically on arbitration loss */ + 1855. > orig_jiffies = jiffies; + 1856. for (ret = 0, try = 0; try <= adap->retries; try++) { + 1857. ret = adap->algo->master_xfer(adap, msgs, num); + +drivers/iommu/dmar.c:1836: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1834. dmar_res_handler_t handler, void *arg) + 1835. { + 1836. > int ret = -ENODEV; + 1837. union acpi_object *obj; + 1838. struct acpi_dmar_header *start; + +net/wireless/trace.h:1838: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +security/selinux/ss/policydb.c:1853: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1851. return rc; + 1852. + 1853. > nel = le32_to_cpu(buf[0]); + 1854. for (i = 0; i < nel; i++) { + 1855. rc = -ENOMEM; + +net/sunrpc/xprtsock.c:1850: error: DEAD_STORE + The value written to &port (type unsigned short) is never used. + 1848. if (port <= xprt_min_resvport || port > xprt_max_resvport) + 1849. return xprt_max_resvport; + 1850. > return --port; + 1851. } + 1852. static int xs_bind(struct sock_xprt *transport, struct socket *sock) + +drivers/iommu/intel-iommu.c:1850: error: DEAD_STORE + The value written to &count (type int) is never used. + 1848. struct intel_iommu *iommu) + 1849. { + 1850. > int num, count = INT_MAX; + 1851. + 1852. assert_spin_locked(&device_domain_lock); + +net/ipv4/af_inet.c:1854: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1852. struct inet_protosw *q; + 1853. struct list_head *r; + 1854. > int rc = -EINVAL; + 1855. + 1856. sock_skb_cb_check_size(sizeof(struct inet_skb_parm)); + +kernel/sched/core.c:1857: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1855. + 1856. #if defined(CONFIG_SMP) + 1857. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1858. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1859. ttwu_queue_remote(p, cpu, wake_flags); + +kernel/sched/core.c:1857: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1855. + 1856. #if defined(CONFIG_SMP) + 1857. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1858. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1859. ttwu_queue_remote(p, cpu, wake_flags); + +kernel/time/hrtimer.c:1853: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1851. void __init hrtimers_init(void) + 1852. { + 1853. > hrtimers_prepare_cpu(smp_processor_id()); + 1854. open_softirq(HRTIMER_SOFTIRQ, hrtimer_run_softirq); + 1855. } + +kernel/time/hrtimer.c:1853: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1851. void __init hrtimers_init(void) + 1852. { + 1853. > hrtimers_prepare_cpu(smp_processor_id()); + 1854. open_softirq(HRTIMER_SOFTIRQ, hrtimer_run_softirq); + 1855. } + +drivers/ata/libata-sff.c:1865: error: UNINITIALIZED_VALUE + The value read from tf.feature was never initialized. + 1863. + 1864. ap->ops->sff_tf_read(ap, &tf); + 1865. > err = tf.feature; + 1866. if (r_err) + 1867. *r_err = err; + +drivers/usb/core/hub.c:1865: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1855 could be null and is dereferenced at line 1865, column 15. + 1863. * will always have maxchild equal to 0. + 1864. */ + 1865. > *ppowner = &(hub->ports[port1 - 1]->port_owner); + 1866. return 0; + 1867. } + +kernel/sched/deadline.c:1856: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1854. struct sched_domain *sd; + 1855. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1856. > int this_cpu = smp_processor_id(); + 1857. int cpu = task_cpu(task); + 1858. + +kernel/sched/deadline.c:1856: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1854. struct sched_domain *sd; + 1855. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1856. > int this_cpu = smp_processor_id(); + 1857. int cpu = task_cpu(task); + 1858. + +net/wireless/trace.h:1855: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +security/selinux/ss/services.c:1914: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1912. + 1913. /* Convert the user. */ + 1914. > rc = -EINVAL; + 1915. usrdatum = hashtab_search(args->newp->p_users.table, + 1916. sym_name(args->oldp, SYM_USERS, c->user - 1)); + +security/selinux/ss/services.c:1922: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1920. + 1921. /* Convert the role. */ + 1922. > rc = -EINVAL; + 1923. role = hashtab_search(args->newp->p_roles.table, + 1924. sym_name(args->oldp, SYM_ROLES, c->role - 1)); + +security/selinux/ss/services.c:1930: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1928. + 1929. /* Convert the type. */ + 1930. > rc = -EINVAL; + 1931. typdatum = hashtab_search(args->newp->p_types.table, + 1932. sym_name(args->oldp, SYM_TYPES, c->type - 1)); + +security/selinux/ss/services.c:1960: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1958. while (oc && oc->sid[0] != SECINITSID_UNLABELED) + 1959. oc = oc->next; + 1960. > rc = -EINVAL; + 1961. if (!oc) { + 1962. printk(KERN_ERR "SELinux: unable to look up" + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/rcu/tree.c:1903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1901. need_gp = !!(rnp->qsmask & rdp->grpmask); + 1902. rdp->cpu_no_qs.b.norm = need_gp; + 1903. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 1904. rdp->core_needs_qs = need_gp; + 1905. zero_cpu_stall_ticks(rdp); + +ipc/sem.c:1874: error: DEAD_STORE + The value written to &error (type int) is never used. + 1872. unsigned nsops, const struct timespec64 *timeout) + 1873. { + 1874. > int error = -EINVAL; + 1875. struct sem_array *sma; + 1876. struct sembuf fast_sops[SEMOPM_FAST]; + +ipc/sem.c:2078: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2076. * window between wake_q_add() and wake_up_q(). + 2077. */ + 2078. > error = READ_ONCE(queue.status); + 2079. if (error != -EINTR) { + 2080. /* + +ipc/sem.c:2096: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2094. goto out_unlock_free; + 2095. + 2096. > error = READ_ONCE(queue.status); + 2097. + 2098. /* + +drivers/gpu/drm/i915/intel_uncore.c:1921: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1919. intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL); + 1920. + 1921. > return ret; + 1922. } + 1923. + +net/wireless/trace.h:1885: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +crypto/drbg.c:1904: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1902. struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. > int rc = -EFAULT; + 1905. bool pr = false; + 1906. int coreref = 0; + +crypto/drbg.c:1903: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1901. unsigned char buf[OUTBUFLEN]; + 1902. struct drbg_state *drbg = NULL; + 1903. > int ret = -EFAULT; + 1904. int rc = -EFAULT; + 1905. bool pr = false; + +block/blk-core.c:1992: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1990. + 1991. if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) + 1992. > req->cpu = raw_smp_processor_id(); + 1993. + 1994. plug = current->plug; + +drivers/cpufreq/cpufreq.c:1906: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1904. unsigned int intermediate_freq = 0; + 1905. unsigned int newfreq = policy->freq_table[index].frequency; + 1906. > int retval = -EINVAL; + 1907. bool notify; + 1908. + +drivers/usb/core/hub.c:1908: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1904 could be null and is dereferenced at line 1908, column 7. + 1906. + 1907. for (n = 0; n < hdev->maxchild; n++) { + 1908. > if (hub->ports[n]->port_owner == owner) + 1909. hub->ports[n]->port_owner = NULL; + 1910. } + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +security/selinux/ss/policydb.c:1925: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1923. if (rc) + 1924. return rc; + 1925. > nel = le32_to_cpu(buf[0]); + 1926. + 1927. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:1945: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 1943. if (rc) + 1944. goto out; + 1945. > len = le32_to_cpu(buf[0]); + 1946. + 1947. /* path component string */ + +net/ipv4/cipso_ipv4.c:1915: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1913. const struct netlbl_lsm_secattr *secattr) + 1914. { + 1915. > int ret_val = -EPERM; + 1916. unsigned char *buf = NULL; + 1917. u32 buf_len; + +kernel/sched/rt.c:1948: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1946. * Matches WMB in rt_set_overload(). + 1947. */ + 1948. > next = atomic_read_acquire(&rd->rto_loop_next); + 1949. + 1950. if (rd->rto_loop == next) + +drivers/usb/core/hub.c:1922: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1921 could be null and is dereferenced at line 1922, column 11. + 1920. return false; + 1921. hub = usb_hub_to_struct_hub(udev->parent); + 1922. > return !!hub->ports[udev->portnum - 1]->port_owner; + 1923. } + 1924. + +arch/x86/events/core.c:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. * transaction. See x86_pmu_add() and x86_pmu_*_txn(). + 1933. */ + 1934. > __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + +arch/x86/events/core.c:1935: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1933. */ + 1934. __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. > __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + 1937. } + +net/socket.c:1965: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 1963. kmsg->msg_iocb = NULL; + 1964. + 1965. > return import_iovec(save_addr ? READ : WRITE, + 1966. msg.msg_iov, msg.msg_iovlen, + 1967. UIO_FASTIOV, iov, &kmsg->msg_iter); + +drivers/usb/core/hub.c:1931: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1927 could be null and is dereferenced at line 1931, column 7. + 1929. + 1930. for (i = 0; i < udev->maxchild; ++i) { + 1931. > if (hub->ports[i]->child) + 1932. recursively_mark_NOTATTACHED(hub->ports[i]->child); + 1933. } + +net/ipv4/tcp_output.c:1966: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1964. goto send_now; + 1965. + 1966. > win_divisor = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_tso_win_divisor); + 1967. if (win_divisor) { + 1968. u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache); + +drivers/video/fbdev/core/fbmem.c:1934: error: DEAD_STORE + The value written to &err (type int) is never used. + 1932. struct fb_modelist *modelist; + 1933. struct fb_videomode *m, mode; + 1934. > int err = 1; + 1935. + 1936. list_for_each_safe(pos, n, &info->modelist) { + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +drivers/tty/n_tty.c:1947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1945. size_t n; + 1946. bool is_eof; + 1947. > size_t head = smp_load_acquire(&ldata->commit_head); + 1948. size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + 1949. + +net/wireless/trace.h:1939: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +drivers/input/mouse/alps.c:1948: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1946. { + 1947. u16 reg_val = 0x181; + 1948. > int ret = -1; + 1949. + 1950. /* enter monitor mode, to write the register */ + +net/ipv4/udp.c:1956: error: DEAD_STORE + The value written to &dif (type int) is never used. + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. > int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + +net/ipv4/udp.c:1955: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1953. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + +net/ipv4/udp.c:1967: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1965. start_lookup: + 1966. hslot = &udptable->hash2[hash2]; + 1967. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 1968. } + 1969. + +net/ipv4/udp.c:1957: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. > int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + 1959. struct sk_buff *nskb; + +net/sunrpc/auth_gss/auth_gss.c:1965: error: DEAD_STORE + The value written to &status (type int) is never used. + 1963. struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; + 1964. int savedlen = head->iov_len; + 1965. > int status = -EIO; + 1966. + 1967. if (ctx->gc_proc != RPC_GSS_PROC_DATA) + +drivers/input/input.c:1967: error: UNINITIALIZED_VALUE + The value read from mt_slots was never initialized. + 1965. mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum - + 1966. dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1, + 1967. > mt_slots = clamp(mt_slots, 2, 32); + 1968. } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) { + 1969. mt_slots = 2; + +net/wireless/trace.h:1961: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +drivers/usb/core/devio.c:1969: error: UNINITIALIZED_VALUE + The value read from ds.context was never initialized. + 1967. return -EFAULT; + 1968. ps->discsignr = ds.signr; + 1969. > ps->disccontext = compat_ptr(ds.context); + 1970. return 0; + 1971. } + +kernel/cgroup/cpuset.c:1974: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1973 could be null and is dereferenced by call to `parent_cs()` at line 1974, column 26. + 1972. { + 1973. struct cpuset *cs = css_cs(css); + 1974. > struct cpuset *parent = parent_cs(cs); + 1975. struct cpuset *tmp_cs; + 1976. struct cgroup_subsys_state *pos_css; + +drivers/usb/core/devio.c:1983: error: UNINITIALIZED_VALUE + The value read from urb32.buffer was never initialized. + 1981. kurb->status = urb32.status; + 1982. kurb->flags = urb32.flags; + 1983. > kurb->buffer = compat_ptr(urb32.buffer); + 1984. kurb->buffer_length = urb32.buffer_length; + 1985. kurb->actual_length = urb32.actual_length; + +drivers/usb/core/devio.c:1990: error: UNINITIALIZED_VALUE + The value read from urb32.usercontext was never initialized. + 1988. kurb->error_count = urb32.error_count; + 1989. kurb->signr = urb32.signr; + 1990. > kurb->usercontext = compat_ptr(urb32.usercontext); + 1991. return 0; + 1992. } + +kernel/sched/core.c:2054: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2052. * their previous state and preserve Program Order. + 2053. */ + 2054. > smp_cond_load_acquire(&p->on_cpu, !VAL); + 2055. + 2056. p->sched_contributes_to_load = !!task_contributes_to_load(p); + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +lib/vsprintf.c:2056: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2054. /* it's the next argument */ + 2055. spec->type = FORMAT_TYPE_WIDTH; + 2056. > return ++fmt - start; + 2057. } + 2058. + +lib/vsprintf.c:2071: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2069. /* it's the next argument */ + 2070. spec->type = FORMAT_TYPE_PRECISION; + 2071. > return ++fmt - start; + 2072. } + 2073. } + +lib/vsprintf.c:2097: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2095. case 'c': + 2096. spec->type = FORMAT_TYPE_CHAR; + 2097. > return ++fmt - start; + 2098. + 2099. case 's': + +lib/vsprintf.c:2101: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2099. case 's': + 2100. spec->type = FORMAT_TYPE_STR; + 2101. > return ++fmt - start; + 2102. + 2103. case 'p': + +lib/vsprintf.c:2105: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2103. case 'p': + 2104. spec->type = FORMAT_TYPE_PTR; + 2105. > return ++fmt - start; + 2106. + 2107. case '%': + +lib/vsprintf.c:2109: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2107. case '%': + 2108. spec->type = FORMAT_TYPE_PERCENT_CHAR; + 2109. > return ++fmt - start; + 2110. + 2111. /* integer number formats - set up the flags and "break" */ + +lib/vsprintf.c:2163: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2161. } + 2162. + 2163. > return ++fmt - start; + 2164. } + 2165. + +net/wireless/trace.h:1990: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +security/selinux/ss/policydb.c:2005: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2003. if (rc) + 2004. return rc; + 2005. > nel = le32_to_cpu(buf[0]); + 2006. + 2007. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2011: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2009. if (rc) + 2010. goto out; + 2011. > len = le32_to_cpu(buf[0]); + 2012. + 2013. rc = -ENOMEM; + +security/selinux/ss/policydb.c:2045: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2043. goto out; + 2044. + 2045. > nel2 = le32_to_cpu(buf[0]); + 2046. for (j = 0; j < nel2; j++) { + 2047. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:2050: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2048. if (rc) + 2049. goto out; + 2050. > len = le32_to_cpu(buf[0]); + 2051. + 2052. rc = -ENOMEM; + +drivers/tty/n_tty.c:2007: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2005. return 0; + 2006. + 2007. > n = min(*nr + 1, smp_load_acquire(&ldata->canon_head) - ldata->read_tail); + 2008. + 2009. tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + +drivers/cpufreq/cpufreq.c:2002: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2000. unsigned int relation) + 2001. { + 2002. > int ret = -EINVAL; + 2003. + 2004. down_write(&policy->rwsem); + +drivers/gpu/drm/drm_dp_mst_topology.c:2019: error: DEAD_STORE + The value written to &len (type int) is never used. + 2017. } + 2018. + 2019. > len = build_dpcd_write(txmsg, port->port_num, offset, size, bytes); + 2020. txmsg->dst = mstb; + 2021. + +net/ipv4/tcp_ipv4.c:2005: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2003. { + 2004. struct tcp_iter_state *st = seq->private; + 2005. > struct net *net = seq_file_net(seq); + 2006. void *rc = NULL; + 2007. + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +drivers/net/ethernet/broadcom/tg3.c:2023: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2014 could be null and is dereferenced at line 2023, column 6. + 2021. oldflowctrl = tp->link_config.active_flowctrl; + 2022. + 2023. > if (phydev->link) { + 2024. lcl_adv = 0; + 2025. rmt_adv = 0; + +kernel/cgroup/cgroup.c:2022: error: NULL_DEREFERENCE + pointer `ns` last assigned on line 2015 could be null and is dereferenced at line 2022, column 18. + 2020. + 2021. /* Check if the caller has permission to mount. */ + 2022. > if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN)) { + 2023. put_cgroup_ns(ns); + 2024. return ERR_PTR(-EPERM); + +net/wireless/trace.h:2011: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +kernel/workqueue.c:2034: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2032. #endif + 2033. /* ensure we're on the correct CPU */ + 2034. > WARN_ON_ONCE(!(pool->flags & POOL_DISASSOCIATED) && + 2035. raw_smp_processor_id() != pool->cpu); + 2036. + +kernel/trace/trace.c:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. if (atomic_read(&trace_record_taskinfo_disabled) || !tracing_is_on()) + 2028. return true; + 2029. > if (!__this_cpu_read(trace_taskinfo_save)) + 2030. return true; + 2031. return false; + +kernel/cpu.c:2027: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2025. void __init boot_cpu_state_init(void) + 2026. { + 2027. > per_cpu_ptr(&cpuhp_state, smp_processor_id())->state = CPUHP_ONLINE; + 2028. } + +net/wireless/trace.h:2029: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/ipv4/tcp_output.c:2036: error: NULL_DEREFERENCE + pointer `skb` last assigned on line 2035 could be null and is dereferenced at line 2036, column 2. + 2034. + 2035. skb = tcp_send_head(sk); + 2036. > tcp_for_write_queue_from_safe(skb, next, sk) { + 2037. if (len <= skb->len) + 2038. break; + +net/ipv4/tcp_ipv4.c:2038: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2036. struct hlist_nulls_node *node; + 2037. struct tcp_iter_state *st = seq->private; + 2038. > struct net *net = seq_file_net(seq); + 2039. + 2040. ++st->num; + +net/sunrpc/xprtsock.c:2042: error: DEAD_STORE + The value written to &status (type int) is never used. + 2040. struct rpc_xprt *xprt = &transport->xprt; + 2041. struct socket *sock; + 2042. > int status = -EIO; + 2043. + 2044. status = __sock_create(xprt->xprt_net, AF_LOCAL, + +net/wireless/trace.h:2047: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +drivers/scsi/sd.c:2139: error: DEAD_STORE + The value written to &spintime_expire (type unsigned long) is never used. + 2137. SD_TIMEOUT, SD_MAX_RETRIES, + 2138. NULL); + 2139. > spintime_expire = jiffies + 100 * HZ; + 2140. spintime = 1; + 2141. } + +drivers/scsi/sd.c:2155: error: DEAD_STORE + The value written to &spintime_expire (type unsigned long) is never used. + 2153. sshdr.asc == 0x28) { + 2154. if (!spintime) { + 2155. > spintime_expire = jiffies + 5 * HZ; + 2156. spintime = 1; + 2157. } + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2115: error: UNINITIALIZED_VALUE + The value read from fence.flags was never initialized. + 2113. ~__I915_EXEC_FENCE_UNKNOWN_FLAGS); + 2114. + 2115. > fences[n] = ptr_pack_bits(syncobj, fence.flags, 2); + 2116. } + 2117. + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2105: error: UNINITIALIZED_VALUE + The value read from fence.handle was never initialized. + 2103. } + 2104. + 2105. > syncobj = drm_syncobj_find(file, fence.handle); + 2106. if (!syncobj) { + 2107. DRM_DEBUG("Invalid syncobj handle provided\n"); + +net/wireless/trace.h:2067: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/xfrm/xfrm_user.c:2084: error: DEAD_STORE + The value written to &err (type int) is never used. + 2082. struct xfrm_userpolicy_info *p = &up->pol; + 2083. u8 type = XFRM_POLICY_TYPE_MAIN; + 2084. > int err = -ENOENT; + 2085. struct xfrm_mark m; + 2086. u32 mark = xfrm_mark_get(attrs, &m); + +drivers/hid/hid-sony.c:2126: error: DEAD_STORE + The value written to &offset (type int) is never used. + 2124. /* If both delay values are zero the DualShock 4 disables blinking. */ + 2125. buf[offset++] = sc->led_delay_on[3]; + 2126. > buf[offset++] = sc->led_delay_off[3]; + 2127. + 2128. if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2088: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 2087 could be null and is dereferenced at line 2088, column 8. + 2086. + 2087. power_well = lookup_power_well(dev_priv, power_well_id); + 2088. > ret = power_well->ops->is_enabled(dev_priv, power_well); + 2089. + 2090. return ret; + +drivers/usb/core/hub.c:2088: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2083 could be null and is dereferenced at line 2088, column 7. + 2086. /* Free up all the children before we remove this device */ + 2087. for (i = 0; i < udev->maxchild; i++) { + 2088. > if (hub->ports[i]->child) + 2089. usb_disconnect(&hub->ports[i]->child); + 2090. } + +net/wireless/trace.h:2087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +drivers/net/ethernet/broadcom/tg3.c:2106: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2103 could be null and is dereferenced by call to `phydev_name()` at line 2106, column 32. + 2104. + 2105. /* Attach the MAC to the PHY. */ + 2106. > phydev = phy_connect(tp->dev, phydev_name(phydev), + 2107. tg3_adjust_link, phydev->interface); + 2108. if (IS_ERR(phydev)) { + +arch/x86/events/intel/core.c:2100: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2098. + 2099. if (unlikely(hwc->idx == INTEL_PMC_IDX_FIXED_BTS)) { + 2100. > if (!__this_cpu_read(cpu_hw_events.enabled)) + 2101. return; + 2102. + +kernel/sched/core.c:2133: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2131. + 2132. ttwu_do_wakeup(rq, p, 0, rf); + 2133. > ttwu_stat(p, smp_processor_id(), 0); + 2134. out: + 2135. raw_spin_unlock(&p->pi_lock); + +kernel/sched/core.c:2133: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2131. + 2132. ttwu_do_wakeup(rq, p, 0, rf); + 2133. > ttwu_stat(p, smp_processor_id(), 0); + 2134. out: + 2135. raw_spin_unlock(&p->pi_lock); + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +security/selinux/ss/policydb.c:2118: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2116. if (rc) + 2117. goto out; + 2118. > nel = le32_to_cpu(buf[0]); + 2119. + 2120. l = NULL; + +security/selinux/ss/policydb.c:2148: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2146. if (rc) + 2147. goto out; + 2148. > len = le32_to_cpu(buf[0]); + 2149. + 2150. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:2195: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2193. goto out; + 2194. + 2195. > len = le32_to_cpu(buf[1]); + 2196. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + 2197. if (rc) + +security/selinux/ss/policydb.c:2245: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2243. if (rc) + 2244. goto out; + 2245. > len = le32_to_cpu(buf[0]); + 2246. + 2247. rc = str_read(&c->u.ibendport.dev_name, GFP_KERNEL, fp, len); + +kernel/rcu/tree.c:2170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2168. if (needgp || cpu_needs_another_gp(rsp, rdp)) { + 2169. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2170. > trace_rcu_grace_period(rsp->name, + 2171. READ_ONCE(rsp->gpnum), + 2172. TPS("newreq")); + +drivers/tty/n_tty.c:2168: error: DEAD_STORE + The value written to &nr (type unsigned long) is never used. + 2166. } + 2167. b++; + 2168. > nr--; + 2169. break; + 2170. } + +sound/core/pcm_lib.c:2208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2206. } + 2207. frames = size > avail ? avail : size; + 2208. > appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 2209. appl_ofs = appl_ptr % runtime->buffer_size; + 2210. cont = runtime->buffer_size - appl_ofs; + +net/core/ethtool.c:2135: error: UNINITIALIZED_VALUE + The value read from dump.len was never initialized. + 2133. return ret; + 2134. + 2135. > len = min(tmp.len, dump.len); + 2136. if (!len) + 2137. return -EFAULT; + +net/core/ethtool.c:2135: error: UNINITIALIZED_VALUE + The value read from tmp.len was never initialized. + 2133. return ret; + 2134. + 2135. > len = min(tmp.len, dump.len); + 2136. if (!len) + 2137. return -EFAULT; + +net/core/ethtool.c:2148: error: UNINITIALIZED_VALUE + The value read from tmp.len was never initialized. + 2146. * dumping. + 2147. */ + 2148. > data = vzalloc(tmp.len); + 2149. if (!data) + 2150. return -ENOMEM; + +net/ipv4/route.c:2154: error: NULL_DEREFERENCE + pointer `in_dev` last assigned on line 2132 could be null and is dereferenced at line 2154, column 8. + 2152. || + 2153. (!ipv4_is_local_multicast(daddr) && + 2154. > IN_DEV_MFORWARD(in_dev)) + 2155. #endif + 2156. ) { + +kernel/irq/manage.c:2154: error: MEMORY_LEAK + `chip` is not reachable after line 2154, column 3. + 2152. + 2153. if (data) + 2154. > err = chip->irq_get_irqchip_state(data, which, state); + 2155. + 2156. irq_put_desc_busunlock(desc, flags); + +drivers/md/md.c:2148: error: DEAD_STORE + The value written to &bi_rdev (type blk_integrity*) is never used. + 2146. return 0; + 2147. + 2148. > bi_rdev = bdev_get_integrity(rdev->bdev); + 2149. bi_mddev = blk_get_integrity(mddev->gendisk); + 2150. + +net/wireless/trace.h:2139: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +drivers/net/ethernet/broadcom/tg3.c:2154: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced at line 2154, column 3. + 2152. if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) { + 2153. tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER; + 2154. > phydev->speed = tp->link_config.speed; + 2155. phydev->duplex = tp->link_config.duplex; + 2156. phydev->autoneg = tp->link_config.autoneg; + +drivers/net/ethernet/broadcom/tg3.c:2160: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced by call to `phy_start()` at line 2160, column 2. + 2158. } + 2159. + 2160. > phy_start(phydev); + 2161. + 2162. phy_start_aneg(phydev); + +drivers/tty/serial/serial_core.c:2155: error: NULL_DEREFERENCE + pointer `tty_dev` last assigned on line 2154 could be null and is dereferenced by call to `device_may_wakeup()` at line 2155, column 27. + 2153. + 2154. tty_dev = device_find_child(uport->dev, &match, serial_match_port); + 2155. > if (!uport->suspended && device_may_wakeup(tty_dev)) { + 2156. if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) + 2157. disable_irq_wake(uport->irq); + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +net/wireless/trace.h:2157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +block/blk-mq.c:2172: error: NULL_DEREFERENCE + pointer `hctx` last assigned on line 2171 could be null and is dereferenced at line 2172, column 25. + 2170. + 2171. hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead); + 2172. > ctx = __blk_mq_get_ctx(hctx->queue, cpu); + 2173. + 2174. spin_lock(&ctx->lock); + +kernel/trace/trace.c:2189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2187. + 2188. preempt_disable(); + 2189. > if (cpu == smp_processor_id() && + 2190. this_cpu_read(trace_buffered_event) != + 2191. per_cpu(trace_buffered_event, cpu)) + +net/xfrm/xfrm_user.c:2214: error: DEAD_STORE + The value written to &err (type int) is never used. + 2212. t->ealgos = ua->ealgos; + 2213. t->calgos = ua->calgos; + 2214. > err = km_query(x, t, xp); + 2215. + 2216. } + +kernel/irq/manage.c:2200: error: MEMORY_LEAK + `chip` is not reachable after line 2200, column 3. + 2198. + 2199. if (data) + 2200. > err = chip->irq_set_irqchip_state(data, which, val); + 2201. + 2202. irq_put_desc_busunlock(desc, flags); + +net/wireless/trace.h:2175: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +kernel/rcu/tree.c:2230: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2228. TPS("fqswait")); + 2229. rsp->gp_state = RCU_GP_WAIT_FQS; + 2230. > ret = swait_event_idle_timeout(rsp->gp_wq, + 2231. rcu_gp_fqs_check_wake(rsp, &gf), j); + 2232. rsp->gp_state = RCU_GP_DOING_FQS; + +kernel/rcu/tree.c:2194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2192. /* Handle grace-period start. */ + 2193. for (;;) { + 2194. > trace_rcu_grace_period(rsp->name, + 2195. READ_ONCE(rsp->gpnum), + 2196. TPS("reqwait")); + +kernel/rcu/tree.c:2207: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2205. WRITE_ONCE(rsp->gp_activity, jiffies); + 2206. WARN_ON(signal_pending(current)); + 2207. > trace_rcu_grace_period(rsp->name, + 2208. READ_ONCE(rsp->gpnum), + 2209. TPS("reqwaitsig")); + +kernel/rcu/tree.c:2226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2224. jiffies + 3 * j); + 2225. } + 2226. > trace_rcu_grace_period(rsp->name, + 2227. READ_ONCE(rsp->gpnum), + 2228. TPS("fqswait")); + +kernel/rcu/tree.c:2241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2239. if (ULONG_CMP_GE(jiffies, rsp->jiffies_force_qs) || + 2240. (gf & RCU_GP_FLAG_FQS)) { + 2241. > trace_rcu_grace_period(rsp->name, + 2242. READ_ONCE(rsp->gpnum), + 2243. TPS("fqsstart")); + +kernel/rcu/tree.c:2246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2244. rcu_gp_fqs(rsp, first_gp_fqs); + 2245. first_gp_fqs = false; + 2246. > trace_rcu_grace_period(rsp->name, + 2247. READ_ONCE(rsp->gpnum), + 2248. TPS("fqsend")); + +kernel/rcu/tree.c:2265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2263. WRITE_ONCE(rsp->gp_activity, jiffies); + 2264. WARN_ON(signal_pending(current)); + 2265. > trace_rcu_grace_period(rsp->name, + 2266. READ_ONCE(rsp->gpnum), + 2267. TPS("fqswaitsig")); + +net/core/dev.c:2231: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2229. for (i = tc, tci = cpu * num_tc; dev_maps && i--; tci++) { + 2230. /* fill in the new device map from the old device map */ + 2231. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2232. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2233. } + +net/core/dev.c:2258: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2256. } else if (dev_maps) { + 2257. /* fill in the new device map from the old device map */ + 2258. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2259. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2260. } + +net/core/dev.c:2265: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2263. for (i = num_tc - tc, tci++; dev_maps && --i; tci++) { + 2264. /* fill in the new device map from the old device map */ + 2265. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2266. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2267. } + +kernel/sysctl.c:2247: error: UNINITIALIZED_VALUE + The value read from lval was never initialized. + 2245. if (err) + 2246. break; + 2247. > err = proc_put_long(&buffer, &left, lval, neg); + 2248. if (err) + 2249. break; + +kernel/sysctl.c:2247: error: UNINITIALIZED_VALUE + The value read from neg was never initialized. + 2245. if (err) + 2246. break; + 2247. > err = proc_put_long(&buffer, &left, lval, neg); + 2248. if (err) + 2249. break; + +drivers/net/ethernet/intel/e1000/e1000_main.c:2206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2204. struct e1000_rx_ring *ring = &adapter->rx_ring[0]; + 2205. e1000_configure_rx(adapter); + 2206. > adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); + 2207. } + 2208. } + +block/cfq-iosched.c:2213: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced at line 2213, column 12. + 2211. if (cfq_class_idle(cfqq)) { + 2212. rb_key = CFQ_IDLE_DELAY; + 2213. > parent = st->rb_rightmost; + 2214. if (parent && parent != &cfqq->rb_node) { + 2215. __cfqq = rb_entry(parent, struct cfq_queue, rb_node); + +block/cfq-iosched.c:2231: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced by call to `cfq_rb_first()` at line 2231, column 12. + 2229. } else { + 2230. rb_key = -NSEC_PER_SEC; + 2231. > __cfqq = cfq_rb_first(st); + 2232. rb_key += __cfqq ? __cfqq->rb_key : now; + 2233. } + +net/wireless/trace.h:2200: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +drivers/usb/core/devio.c:2210: error: UNINITIALIZED_VALUE + The value read from ioc32.data was never initialized. + 2208. ctrl.ifno = ioc32.ifno; + 2209. ctrl.ioctl_code = ioc32.ioctl_code; + 2210. > ctrl.data = compat_ptr(ioc32.data); + 2211. return proc_ioctl(ps, &ctrl); + 2212. } + +drivers/usb/core/devio.c:2208: error: UNINITIALIZED_VALUE + The value read from ioc32.ifno was never initialized. + 2206. if (copy_from_user(&ioc32, compat_ptr(arg), sizeof(ioc32))) + 2207. return -EFAULT; + 2208. > ctrl.ifno = ioc32.ifno; + 2209. ctrl.ioctl_code = ioc32.ioctl_code; + 2210. ctrl.data = compat_ptr(ioc32.data); + +drivers/usb/core/devio.c:2209: error: UNINITIALIZED_VALUE + The value read from ioc32.ioctl_code was never initialized. + 2207. return -EFAULT; + 2208. ctrl.ifno = ioc32.ifno; + 2209. > ctrl.ioctl_code = ioc32.ioctl_code; + 2210. ctrl.data = compat_ptr(ioc32.data); + 2211. return proc_ioctl(ps, &ctrl); + +kernel/trace/trace_events.c:2237: error: UNINITIALIZED_VALUE + The value read from last_i was never initialized. + 2235. * system. + 2236. */ + 2237. > for (i = last_i; i < len; i++) { + 2238. if (call->class->system == map[i]->system) { + 2239. /* Save the first system if need be */ + +net/wireless/trace.h:2220: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +drivers/usb/host/ehci-sched.c:2270: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 2268. + 2269. /* give urb back to the driver; completion often (re)submits */ + 2270. > dev = urb->dev; + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + +drivers/iommu/intel-iommu.c:2293: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2291. * touches the iova range + 2292. */ + 2293. > tmp = cmpxchg64_local(&pte->val, 0ULL, pteval); + 2294. if (tmp) { + 2295. static int dumps = 5; + +net/wireless/trace.h:2244: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/unix/af_unix.c:2365: error: DEAD_STORE + The value written to &sunaddr (type sockaddr_un*) is never used. + 2363. /* Copy address just once */ + 2364. if (state->msg && state->msg->msg_name) { + 2365. > DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + +drivers/gpu/drm/drm_dp_mst_topology.c:2276: error: DEAD_STORE + The value written to &origlen (type int) is never used. + 2274. replylen = msg->curchunk_len + msg->curchunk_hdrlen; + 2275. + 2276. > origlen = replylen; + 2277. replylen -= len; + 2278. curreply = len; + +drivers/gpu/drm/drm_dp_mst_topology.c:2271: error: UNINITIALIZED_VALUE + The value read from replyblock.[_] was never initialized. + 2269. ret = drm_dp_sideband_msg_build(msg, replyblock, len, true); + 2270. if (!ret) { + 2271. > DRM_DEBUG_KMS("sideband msg build failed %d\n", replyblock[0]); + 2272. return false; + 2273. } + +drivers/usb/core/devio.c:2264: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2262. return -EFAULT; + 2263. + 2264. > intf = usb_ifnum_to_if(ps->dev, dc.interface); + 2265. if (!intf) + 2266. return -EINVAL; + +drivers/usb/core/devio.c:2288: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2286. } + 2287. + 2288. > return claimintf(ps, dc.interface); + 2289. } + 2290. + +kernel/trace/trace.c:2276: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2274. (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. > val = this_cpu_inc_return(trace_buffered_event_cnt); + 2277. if (val == 1) { + 2278. trace_event_setup(entry, type, flags, pc); + +net/wireless/trace.h:2262: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +kernel/printk/printk.c:2271: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2269. static inline int can_use_console(void) + 2270. { + 2271. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2272. } + 2273. + +kernel/printk/printk.c:2271: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2269. static inline int can_use_console(void) + 2270. { + 2271. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2272. } + 2273. + +security/selinux/ss/policydb.c:2447: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2445. goto bad; + 2446. + 2447. > rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + +security/selinux/ss/policydb.c:2298: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2296. rc = -EINVAL; + 2297. if (le32_to_cpu(buf[0]) != POLICYDB_MAGIC) { + 2298. > printk(KERN_ERR "SELinux: policydb magic number 0x%x does " + 2299. "not match expected magic number 0x%x\n", + 2300. le32_to_cpu(buf[0]), POLICYDB_MAGIC); + +security/selinux/ss/policydb.c:2305: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2303. + 2304. rc = -EINVAL; + 2305. > len = le32_to_cpu(buf[1]); + 2306. if (len != strlen(POLICYDB_STRING)) { + 2307. printk(KERN_ERR "SELinux: policydb string length %d does not " + +security/selinux/ss/policydb.c:2349: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2347. if (p->policyvers < POLICYDB_VERSION_MIN || + 2348. p->policyvers > POLICYDB_VERSION_MAX) { + 2349. > printk(KERN_ERR "SELinux: policydb version %d does not match " + 2350. "my version range %d-%d\n", + 2351. le32_to_cpu(buf[0]), POLICYDB_VERSION_MIN, POLICYDB_VERSION_MAX); + +security/selinux/ss/policydb.c:2392: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2390. if (le32_to_cpu(buf[2]) != info->sym_num || + 2391. le32_to_cpu(buf[3]) != info->ocon_num) { + 2392. > printk(KERN_ERR "SELinux: policydb table sizes (%d,%d) do " + 2393. "not match mine (%d,%d)\n", le32_to_cpu(buf[2]), + 2394. le32_to_cpu(buf[3]), + +security/selinux/ss/policydb.c:2403: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2401. if (rc) + 2402. goto bad; + 2403. > nprim = le32_to_cpu(buf[0]); + 2404. nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + +security/selinux/ss/policydb.c:2404: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2402. goto bad; + 2403. nprim = le32_to_cpu(buf[0]); + 2404. > nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + 2406. rc = read_f[i](p, p->symtab[i].table, fp); + +security/selinux/ss/policydb.c:2432: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2430. if (rc) + 2431. goto bad; + 2432. > nel = le32_to_cpu(buf[0]); + 2433. ltr = NULL; + 2434. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2471: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 2469. if (rc) + 2470. goto bad; + 2471. > nel = le32_to_cpu(buf[0]); + 2472. lra = NULL; + 2473. for (i = 0; i < nel; i++) { + +kernel/sysctl.c:2325: error: DEAD_STORE + The value written to &left (type unsigned long) is never used. + 2323. + 2324. if (!err && left) + 2325. > left -= proc_skip_spaces(&p); + 2326. + 2327. out_free: + +drivers/cdrom/cdrom.c:2302: error: UNINITIALIZED_VALUE + The value read from ms_info.addr_format was never initialized. + 2300. return -EFAULT; + 2301. + 2302. > requested_format = ms_info.addr_format; + 2303. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2304. return -EINVAL; + +kernel/printk/printk.c:2428: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 2426. retry = console_seq != log_next_seq; + 2427. raw_spin_unlock(&logbuf_lock); + 2428. > printk_safe_exit_irqrestore(flags); + 2429. + 2430. if (retry && console_trylock()) + +include/linux/pci.h:2314: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2312. + 2313. if (idx > 0) { + 2314. > envp[idx++] = NULL; + 2315. kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp); + 2316. } + +drivers/gpu/drm/i915/intel_ddi.c:2303: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2298 could be null and is dereferenced at line 2303, column 2. + 2301. intel_disable_ddi_buf(encoder); + 2302. + 2303. > dig_port->set_infoframes(&encoder->base, false, + 2304. old_crtc_state, old_conn_state); + 2305. + +kernel/rcu/tree.c:2310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2308. } + 2309. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2310. > trace_rcu_grace_period(rsp->name, READ_ONCE(rsp->gpnum), + 2311. TPS("newreq")); + 2312. + +drivers/gpu/drm/drm_dp_mst_topology.c:2314: error: DEAD_STORE + The value written to &slot (type int) is never used. + 2312. struct drm_dp_sideband_msg_tx *txmsg; + 2313. struct drm_dp_mst_branch *mstb; + 2314. > int slot = -1; + 2315. mstb = drm_dp_get_mst_branch_device(mgr, + 2316. mgr->down_rep_recv.initial_hdr.lct, + +net/wireless/trace.h:2301: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/ipv4/ipmr.c:2343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2341. nla_nest_end(skb, mp_attr); + 2342. + 2343. > lastuse = READ_ONCE(c->mfc_un.res.lastuse); + 2344. lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0; + 2345. + +kernel/trace/ring_buffer.c:2338: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2336. old_index += write_mask; + 2337. new_index += write_mask; + 2338. > index = local_cmpxchg(&bpage->write, old_index, new_index); + 2339. if (index == old_index) { + 2340. /* update counters */ + +net/sunrpc/clnt.c:2375: error: DEAD_STORE + The value written to &len (type int) is never used. + 2373. goto out_err; + 2374. } + 2375. > if (--len < 0) + 2376. goto out_overflow; + 2377. switch ((n = ntohl(*p++))) { + +net/sunrpc/clnt.c:2377: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 2375. if (--len < 0) + 2376. goto out_overflow; + 2377. > switch ((n = ntohl(*p++))) { + 2378. case RPC_AUTH_REJECTEDCRED: + 2379. case RPC_AUTH_REJECTEDVERF: + +net/wireless/trace.h:2326: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/ipv4/route.c:2337: error: DEAD_STORE + The value written to &err (type int) is never used. + 2335. unsigned int flags = 0; + 2336. struct rtable *rth; + 2337. > int err = -ENETUNREACH; + 2338. + 2339. if (fl4->saddr) { + +net/xfrm/xfrm_policy.c:2349: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2347. for (; idx < sp->len; idx++) { + 2348. if (xfrm_state_ok(tmpl, sp->xvec[idx], family)) + 2349. > return ++idx; + 2350. if (sp->xvec[idx]->props.mode != XFRM_MODE_TRANSPORT) { + 2351. if (start == -1) + +net/wireless/trace.h:2338: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2336. ); + 2337. + 2338. > DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, + 2339. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2340. TP_ARGS(netdev, macaddr), + +kernel/sysctl.c:2358: error: UNINITIALIZED_VALUE + The value read from lval was never initialized. + 2356. } + 2357. + 2358. > err = proc_put_long(&buffer, &left, lval, false); + 2359. if (err || !left) + 2360. goto out; + +kernel/sched/core.c:2344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2342. { + 2343. unsigned long flags; + 2344. > int cpu = get_cpu(); + 2345. + 2346. __sched_fork(clone_flags, p); + +kernel/sched/core.c:2344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2342. { + 2343. unsigned long flags; + 2344. > int cpu = get_cpu(); + 2345. + 2346. __sched_fork(clone_flags, p); + +drivers/usb/core/hub.c:2360: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2354 could be null and is dereferenced at line 2360, column 10. + 2358. * use that to determine whether it's removable. + 2359. */ + 2360. > switch (hub->ports[udev->portnum - 1]->connect_type) { + 2361. case USB_PORT_CONNECT_TYPE_HOT_PLUG: + 2362. udev->removable = USB_DEVICE_REMOVABLE; + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2358: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2356. ); + 2357. + 2358. > DECLARE_EVENT_CLASS(netdev_evt_only, + 2359. TP_PROTO(struct net_device *netdev), + 2360. TP_ARGS(netdev), + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2375: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +drivers/gpu/drm/i915/i915_drv.c:2388: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/i915_drv.c:2388: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/i915_drv.c:2388: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/intel_ddi.c:2408: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2396 could be null and is dereferenced at line 2408, column 2. + 2406. * enabling the port. + 2407. */ + 2408. > I915_WRITE(DDI_BUF_CTL(port), + 2409. dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE); + 2410. + +net/wireless/trace.h:2392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2390. ); + 2391. + 2392. > DECLARE_EVENT_CLASS(netdev_frame_event, + 2393. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2394. TP_ARGS(netdev, buf, len), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2407: error: DEAD_STORE + The value written to &ctrl (type unsigned int) is never used. + 2405. u16 phy_data; + 2406. + 2407. > ctrl = er32(CTRL); + 2408. status = er32(STATUS); + 2409. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2468: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 2466. hw->forced_speed_duplex == e1000_10_half)) { + 2467. ew32(IMC, 0xffffffff); + 2468. > ret_val = + 2469. e1000_polarity_reversal_workaround(hw); + 2470. icr = er32(ICR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2416: error: DEAD_STORE + The value written to &rxcw (type unsigned int) is never used. + 2414. if ((hw->media_type == e1000_media_type_fiber) || + 2415. (hw->media_type == e1000_media_type_internal_serdes)) { + 2416. > rxcw = er32(RXCW); + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2419: error: DEAD_STORE + The value written to &signal (type unsigned int) is never used. + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + 2419. > signal = + 2420. (hw->mac_type > + 2421. e1000_82544) ? E1000_CTRL_SWDPIN1 : 0; + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/sunrpc/xprtsock.c:2419: error: DEAD_STORE + The value written to &status (type int) is never used. + 2417. struct socket *sock = transport->sock; + 2418. struct rpc_xprt *xprt = &transport->xprt; + 2419. > int status = -EIO; + 2420. + 2421. if (!sock) { + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2418: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/socket.c:2445: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2443. return err; + 2444. + 2445. > a0 = a[0]; + 2446. a1 = a[1]; + 2447. + +net/socket.c:2446: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2444. + 2445. a0 = a[0]; + 2446. > a1 = a[1]; + 2447. + 2448. switch (call) { + +net/socket.c:2450: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2448. switch (call) { + 2449. case SYS_SOCKET: + 2450. > err = sys_socket(a0, a1, a[2]); + 2451. break; + 2452. case SYS_BIND: + +net/socket.c:2453: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2451. break; + 2452. case SYS_BIND: + 2453. > err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); + 2454. break; + 2455. case SYS_CONNECT: + +net/socket.c:2456: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2454. break; + 2455. case SYS_CONNECT: + 2456. > err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); + 2457. break; + 2458. case SYS_LISTEN: + +net/socket.c:2462: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2460. break; + 2461. case SYS_ACCEPT: + 2462. > err = sys_accept4(a0, (struct sockaddr __user *)a1, + 2463. (int __user *)a[2], 0); + 2464. break; + +net/socket.c:2467: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2465. case SYS_GETSOCKNAME: + 2466. err = + 2467. > sys_getsockname(a0, (struct sockaddr __user *)a1, + 2468. (int __user *)a[2]); + 2469. break; + +net/socket.c:2472: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2470. case SYS_GETPEERNAME: + 2471. err = + 2472. > sys_getpeername(a0, (struct sockaddr __user *)a1, + 2473. (int __user *)a[2]); + 2474. break; + +net/socket.c:2476: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2474. break; + 2475. case SYS_SOCKETPAIR: + 2476. > err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); + 2477. break; + 2478. case SYS_SEND: + +net/socket.c:2479: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2477. break; + 2478. case SYS_SEND: + 2479. > err = sys_send(a0, (void __user *)a1, a[2], a[3]); + 2480. break; + 2481. case SYS_SENDTO: + +net/socket.c:2482: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2480. break; + 2481. case SYS_SENDTO: + 2482. > err = sys_sendto(a0, (void __user *)a1, a[2], a[3], + 2483. (struct sockaddr __user *)a[4], a[5]); + 2484. break; + +net/socket.c:2486: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2484. break; + 2485. case SYS_RECV: + 2486. > err = sys_recv(a0, (void __user *)a1, a[2], a[3]); + 2487. break; + 2488. case SYS_RECVFROM: + +net/socket.c:2489: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2487. break; + 2488. case SYS_RECVFROM: + 2489. > err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], + 2490. (struct sockaddr __user *)a[4], + 2491. (int __user *)a[5]); + +net/socket.c:2497: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2495. break; + 2496. case SYS_SETSOCKOPT: + 2497. > err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); + 2498. break; + 2499. case SYS_GETSOCKOPT: + +net/socket.c:2501: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2499. case SYS_GETSOCKOPT: + 2500. err = + 2501. > sys_getsockopt(a0, a1, a[2], (char __user *)a[3], + 2502. (int __user *)a[4]); + 2503. break; + +net/socket.c:2505: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2503. break; + 2504. case SYS_SENDMSG: + 2505. > err = sys_sendmsg(a0, (struct user_msghdr __user *)a1, a[2]); + 2506. break; + 2507. case SYS_SENDMMSG: + +net/socket.c:2508: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2506. break; + 2507. case SYS_SENDMMSG: + 2508. > err = sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3]); + 2509. break; + 2510. case SYS_RECVMSG: + +net/socket.c:2511: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2509. break; + 2510. case SYS_RECVMSG: + 2511. > err = sys_recvmsg(a0, (struct user_msghdr __user *)a1, a[2]); + 2512. break; + 2513. case SYS_RECVMMSG: + +net/socket.c:2514: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2512. break; + 2513. case SYS_RECVMMSG: + 2514. > err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3], + 2515. (struct timespec __user *)a[4]); + 2516. break; + +net/socket.c:2518: error: UNINITIALIZED_VALUE + The value read from a.[_] was never initialized. + 2516. break; + 2517. case SYS_ACCEPT4: + 2518. > err = sys_accept4(a0, (struct sockaddr __user *)a1, + 2519. (int __user *)a[2], a[3]); + 2520. break; + +drivers/md/md.c:2453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2451. if (ret == 0) + 2452. md_cluster_ops->metadata_update_cancel(mddev); + 2453. > bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2454. BIT(MD_SB_CHANGE_DEVS) | + 2455. BIT(MD_SB_CHANGE_CLEAN)); + +drivers/md/md.c:2602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2600. + 2601. if (mddev->in_sync != sync_req || + 2602. > !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2603. BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN))) + 2604. /* have to write it out again */ + +net/wireless/trace.h:2434: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2432. ); + 2433. + 2434. > DECLARE_EVENT_CLASS(netdev_mac_evt, + 2435. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2436. TP_ARGS(netdev, mac), + +drivers/net/ethernet/intel/e1000/e1000_main.c:2461: error: DEAD_STORE + The value written to &txb2b (type _Bool) is never used. + 2459. if (!netif_carrier_ok(netdev)) { + 2460. u32 ctrl; + 2461. > bool txb2b = true; + 2462. /* update snapshot of PHY registers on LSC */ + 2463. e1000_get_speed_and_duplex(hw, + +drivers/net/ethernet/intel/e1000/e1000_main.c:2535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2533. + 2534. if (!netif_carrier_ok(netdev)) { + 2535. > if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { + 2536. /* We've lost link, so the controller stops DMA, + 2537. * but we've got queued Tx work that's never going + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2459: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +drivers/net/ethernet/intel/e100.c:2464: error: DEAD_STORE + The value written to &nic (type nic*) is never used. + 2462. static int e100_get_regs_len(struct net_device *netdev) + 2463. { + 2464. > struct nic *nic = netdev_priv(netdev); + 2465. return 1 + E100_PHY_REGS + sizeof(nic->mem->dump_buf); + 2466. } + +net/ipv4/tcp.c:2497: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wup was never initialized. + 2495. return -EINVAL; + 2496. + 2497. > if (after(opt.rcv_wup, tp->rcv_nxt)) + 2498. return -EINVAL; + 2499. + +net/ipv4/tcp.c:2494: error: UNINITIALIZED_VALUE + The value read from opt.snd_wl1 was never initialized. + 2492. return -EINVAL; + 2493. + 2494. > if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd)) + 2495. return -EINVAL; + 2496. + +kernel/rcu/tree.c:2499: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2497. */ + 2498. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */ + 2499. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 2500. raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + 2501. return; + +net/wireless/trace.h:2483: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +include/linux/netdevice.h:2487: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2485. static inline int dev_recursion_level(void) + 2486. { + 2487. > return this_cpu_read(xmit_recursion); + 2488. } + 2489. + +include/linux/netdevice.h:2487: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2485. static inline int dev_recursion_level(void) + 2486. { + 2487. > return this_cpu_read(xmit_recursion); + 2488. } + 2489. + +net/wireless/trace.h:2505: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2523: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +drivers/base/regmap/regmap.c:2574: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2572. map->unlock(map->lock_arg); + 2573. + 2574. > return ret; + 2575. } + 2576. EXPORT_SYMBOL_GPL(regmap_raw_read); + +drivers/iommu/intel-iommu.c:2542: error: DEAD_STORE + The value written to &req_id (type unsigned short) is never used. + 2540. return NULL; + 2541. + 2542. > req_id = ((u16)bus << 8) | devfn; + 2543. + 2544. if (dev_is_pci(dev)) { + +kernel/events/core.c:2549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2547. * so we need to check again lest we try to stop another CPU's event. + 2548. */ + 2549. > if (READ_ONCE(event->oncpu) != smp_processor_id()) + 2550. return -EAGAIN; + 2551. + +drivers/gpu/drm/i915/intel_ddi.c:2585: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 2583 could be null and is dereferenced at line 2585, column 7. + 2583. intel_dig_port = enc_to_dig_port(&encoder->base); + 2584. + 2585. > if (intel_dig_port->infoframe_enabled(&encoder->base, pipe_config)) + 2586. pipe_config->has_infoframe = true; + 2587. + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/core/neighbour.c:2550: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2548. struct neigh_hash_table *nht = state->nht; + 2549. struct neighbour *n = NULL; + 2550. > int bucket = state->bucket; + 2551. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + +net/wireless/trace.h:2546: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +drivers/net/ethernet/broadcom/tg3.c:2613: error: UNINITIALIZED_VALUE + The value read from phy9_orig was never initialized. + 2611. tg3_phy_toggle_auxctl_smdsp(tp, false); + 2612. + 2613. > tg3_writephy(tp, MII_CTRL1000, phy9_orig); + 2614. + 2615. err = tg3_readphy(tp, MII_TG3_EXT_CTRL, ®32); + +net/wireless/trace.h:2563: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +kernel/events/core.c:2589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2587. * fall through with ret==-ENXIO. + 2588. */ + 2589. > ret = cpu_function_call(READ_ONCE(event->oncpu), + 2590. __perf_event_stop, &sd); + 2591. } while (ret == -EAGAIN); + +kernel/trace/trace.c:2603: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2601. preempt_disable_notrace(); + 2602. + 2603. > use_stack = __this_cpu_inc_return(ftrace_stack_reserve); + 2604. /* + 2605. * We don't need any atomic variables, just a barrier. + +drivers/iommu/amd_iommu.c:2581: error: DEAD_STORE + The value written to &npages (type int) is never used. + 2579. struct dma_ops_domain *dma_dom; + 2580. unsigned long startaddr; + 2581. > int npages = 2; + 2582. + 2583. domain = get_domain(dev); + +net/ipv4/ipmr.c:2592: error: DEAD_STORE + The value written to &rtm (type rtmsg*) is never used. + 2590. goto errout; + 2591. + 2592. > rtm = nlmsg_data(nlh); + 2593. + 2594. src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0; + +net/wireless/trace.h:2580: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +drivers/iommu/amd_iommu.c:2601: error: DEAD_STORE + The value written to &dma_mask (type unsigned long long) is never used. + 2599. unsigned long attrs) + 2600. { + 2601. > u64 dma_mask = dev->coherent_dma_mask; + 2602. struct protection_domain *domain; + 2603. struct dma_ops_domain *dma_dom; + +drivers/gpu/drm/i915/i915_debugfs.c:2656: error: UNINITIALIZED_VALUE + The value read from crc.[_] was never initialized. + 2654. goto err; + 2655. + 2656. > seq_printf(m, "%02x%02x%02x%02x%02x%02x\n", + 2657. crc[0], crc[1], crc[2], + 2658. crc[3], crc[4], crc[5]); + +net/wireless/trace.h:2599: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +block/blk-core.c:2613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2611. int cpu; + 2612. + 2613. > cpu = part_stat_lock(); + 2614. part = req->part; + 2615. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +block/blk-core.c:2613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2611. int cpu; + 2612. + 2613. > cpu = part_stat_lock(); + 2614. part = req->part; + 2615. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +drivers/cdrom/cdrom.c:2618: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 2616. return -EFAULT; + 2617. + 2618. > requested = q.cdsc_format; + 2619. if (requested != CDROM_MSF && requested != CDROM_LBA) + 2620. return -EINVAL; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +net/sunrpc/clnt.c:2657: error: NULL_DEREFERENCE + pointer `xprt` last assigned on line 2627 could be null and is dereferenced at line 2657, column 2. + 2655. xprt_put(xprt); + 2656. xprt_switch_put(xps); + 2657. > pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n", + 2658. status, xprt->address_strings[RPC_DISPLAY_ADDR]); + 2659. return status; + +drivers/net/ethernet/intel/e100.c:2631: error: DEAD_STORE + The value written to &err (type int) is never used. + 2629. + 2630. /* save speed, duplex & autoneg settings */ + 2631. > err = mii_ethtool_gset(&nic->mii, &cmd); + 2632. + 2633. if (netif_running(netdev)) + +drivers/net/ethernet/intel/e100.c:2640: error: DEAD_STORE + The value written to &err (type int) is never used. + 2638. + 2639. /* restore speed, duplex & autoneg settings */ + 2640. > err = mii_ethtool_sset(&nic->mii, &cmd); + 2641. + 2642. if (netif_running(netdev)) + +block/blk-core.c:2633: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2631. int cpu; + 2632. + 2633. > cpu = part_stat_lock(); + 2634. part = req->part; + 2635. + +block/blk-core.c:2633: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2631. int cpu; + 2632. + 2633. > cpu = part_stat_lock(); + 2634. part = req->part; + 2635. + +net/wireless/trace.h:2620: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2635: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +kernel/rcu/tree.c:2663: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2661. */ + 2662. local_irq_save(flags); + 2663. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2664. bl = rdp->blimit; + 2665. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +kernel/rcu/tree.c:2663: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2661. */ + 2662. local_irq_save(flags); + 2663. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2664. bl = rdp->blimit; + 2665. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +drivers/gpu/drm/i915/intel_sdvo.c:2695: error: UNINITIALIZED_VALUE + The value read from bytes.[_] was never initialized. + 2693. intel_sdvo->controlled_output = 0; + 2694. memcpy(bytes, &intel_sdvo->caps.output_flags, 2); + 2695. > DRM_DEBUG_KMS("%s: Unknown SDVO output type (0x%02x%02x)\n", + 2696. SDVO_NAME(intel_sdvo), + 2697. bytes[0], bytes[1]); + +net/core/neighbour.c:2652: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2650. struct neigh_table *tbl = state->tbl; + 2651. struct pneigh_entry *pn = NULL; + 2652. > int bucket = state->bucket; + 2653. + 2654. state->flags |= NEIGH_SEQ_IS_PNEIGH; + +net/wireless/trace.h:2651: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/socket.c:2664: error: UNINITIALIZED_VALUE + The value read from ktv was never initialized. + 2662. + 2663. set_fs(KERNEL_DS); + 2664. > err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv); + 2665. set_fs(old_fs); + 2666. if (!err) + +drivers/cdrom/cdrom.c:2670: error: UNINITIALIZED_VALUE + The value read from entry.cdte_format was never initialized. + 2668. return -EFAULT; + 2669. + 2670. > requested_format = entry.cdte_format; + 2671. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2672. return -EINVAL; + +drivers/tty/tty_io.c:2669: error: DEAD_STORE + The value written to &retval (type int) is never used. + 2667. struct tty_struct *tty = file_tty(file); + 2668. struct tty_ldisc *ld; + 2669. > int retval = -ENOIOCTLCMD; + 2670. + 2671. if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl")) + +net/wireless/trace.h:2667: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +block/blk-core.c:2679: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2677. return; + 2678. + 2679. > cpu = part_stat_lock(); + 2680. + 2681. if (!new_io) { + +block/blk-core.c:2679: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2677. return; + 2678. + 2679. > cpu = part_stat_lock(); + 2680. + 2681. if (!new_io) { + +drivers/usb/core/hub.c:2721: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 2719. return -EBUSY; + 2720. + 2721. > if (hub_port_warm_reset_required(hub, port1, portstatus)) + 2722. return -ENOTCONN; + 2723. + +net/socket.c:2680: error: UNINITIALIZED_VALUE + The value read from kts was never initialized. + 2678. + 2679. set_fs(KERNEL_DS); + 2680. > err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts); + 2681. set_fs(old_fs); + 2682. if (!err) + +kernel/cgroup/cgroup.c:2685: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2684 could be null and is dereferenced at line 2685, column 7. + 2683. percpu_up_write(&cgroup_threadgroup_rwsem); + 2684. for_each_subsys(ss, ssid) + 2685. > if (ss->post_attach) + 2686. ss->post_attach(); + 2687. } + +drivers/ata/libata-eh.c:2839: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2837. rc = ata_do_reset(link, reset, classes, deadline, true); + 2838. if (rc && rc != -EAGAIN) { + 2839. > failed_link = link; + 2840. goto fail; + 2841. } + +drivers/ata/libata-eh.c:2859: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2857. break; + 2858. default: + 2859. > failed_link = slave; + 2860. rc = tmp; + 2861. goto fail; + +drivers/ata/libata-eh.c:2873: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2871. ata_link_err(link, + 2872. "follow-up softreset required but no softreset available\n"); + 2873. > failed_link = link; + 2874. rc = -EINVAL; + 2875. goto fail; + +drivers/ata/libata-eh.c:2881: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2879. rc = ata_do_reset(link, reset, classes, deadline, true); + 2880. if (rc) { + 2881. > failed_link = link; + 2882. goto fail; + 2883. } + +drivers/ata/libata-eh.c:2988: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2986. "link online but %d devices misclassified, retrying\n", + 2987. nr_unknown); + 2988. > failed_link = link; + 2989. rc = -EAGAIN; + 2990. goto fail; + +drivers/md/md.c:2687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2685. char *sep = ","; + 2686. size_t len = 0; + 2687. > unsigned long flags = READ_ONCE(rdev->flags); + 2688. + 2689. if (test_bit(Faulty, &flags) || + +net/wireless/trace.h:2682: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/socket.c:2697: error: UNINITIALIZED_VALUE + The value read from ifc32.ifc_len was never initialized. + 2695. return -EFAULT; + 2696. + 2697. > ifc.ifc_len = ifc32.ifc_len; + 2698. ifc.ifc_req = compat_ptr(ifc32.ifcbuf); + 2699. + +net/socket.c:2698: error: UNINITIALIZED_VALUE + The value read from ifc32.ifcbuf was never initialized. + 2696. + 2697. ifc.ifc_len = ifc32.ifc_len; + 2698. > ifc.ifc_req = compat_ptr(ifc32.ifcbuf); + 2699. + 2700. rtnl_lock(); + +net/wireless/trace.h:2697: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2695. ); + 2696. + 2697. > DECLARE_EVENT_CLASS(cfg80211_rx_evt, + 2698. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2699. TP_ARGS(netdev, addr), + +block/blk-core.c:2709: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 2709, column 31. + 2707. { + 2708. struct request *rq; + 2709. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 2710. + 2711. WARN_ON_ONCE(q->mq_ops); + +sound/pci/hda/hda_codec.c:2712: error: DEAD_STORE + The value written to &end_time (type unsigned long) is never used. + 2710. unsigned int power_state) + 2711. { + 2712. > unsigned long end_time = jiffies + msecs_to_jiffies(500); + 2713. unsigned int state, actual_state; + 2714. + +sound/pci/hda/hda_codec.c:2728: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2726. msleep(1); + 2727. } + 2728. > return state; + 2729. } + 2730. + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +drivers/net/ethernet/intel/e100.c:2732: error: DEAD_STORE + The value written to &i (type int) is never used. + 2730. data[i++] = nic->rx_tco_frames; + 2731. data[i++] = nic->rx_short_frame_errors; + 2732. > data[i++] = nic->rx_over_length_errors; + 2733. } + 2734. + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +kernel/trace/trace.c:2743: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2741. */ + 2742. preempt_disable(); + 2743. > if (__this_cpu_read(user_stack_count)) + 2744. goto out; + 2745. + +net/wireless/trace.h:2721: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/ipv6/addrconf.c:2731: error: DEAD_STORE + The value written to &err (type int) is never used. + 2729. struct in6_ifreq ireq; + 2730. struct net_device *dev; + 2731. > int err = -EINVAL; + 2732. + 2733. rtnl_lock(); + +net/ipv6/addrconf.c:2739: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2737. goto err_exit; + 2738. + 2739. > dev = __dev_get_by_index(net, ireq.ifr6_ifindex); + 2740. + 2741. err = -ENODEV; + +net/ipv4/tcp_output.c:2737: error: NULL_DEREFERENCE + pointer `next_skb` last assigned on line 2733 could be null and is dereferenced at line 2737, column 18. + 2735. + 2736. skb_size = skb->len; + 2737. > next_skb_size = next_skb->len; + 2738. + 2739. BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1); + +net/wireless/trace.h:2739: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +kernel/sched/fair.c:2753: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2751. cfs_rq->runnable_weight -= se->runnable_weight; + 2752. + 2753. > sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + +kernel/sched/fair.c:2754: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2752. + 2753. sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. > sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + 2756. } + +drivers/scsi/scsi_lib.c:2793: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2791. } + 2792. + 2793. > envp[idx++] = NULL; + 2794. + 2795. kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); + +net/wireless/trace.h:2760: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +sound/pci/hda/hda_codec.c:2798: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2796. } + 2797. + 2798. > return state; + 2799. } + 2800. + +drivers/usb/core/hub.c:2882: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 2880. up_read(&ehci_cf_port_reset_rwsem); + 2881. + 2882. > return status; + 2883. } + 2884. + +kernel/sched/fair.c:2768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2766. dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) + 2767. { + 2768. > sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + +kernel/sched/fair.c:2769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2767. { + 2768. sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. > sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + 2771. #else + +sound/core/pcm_native.c:2782: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2780. return -EFAULT; + 2781. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2782. > result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + +sound/core/pcm_native.c:2784: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2782. result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. > result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + 2785. __put_user(result, &_xferi->result); + 2786. return result < 0 ? result : 0; + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2782: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +drivers/gpu/drm/i915/intel_sdvo.c:2811: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2809. intel_sdvo_connector->max_hscan = data_value[0]; + 2810. intel_sdvo_connector->left = + 2811. > drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]); + 2812. if (!intel_sdvo_connector->left) + 2813. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2819: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2817. + 2818. intel_sdvo_connector->right = + 2819. > drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]); + 2820. if (!intel_sdvo_connector->right) + 2821. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2825: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2823. drm_object_attach_property(&connector->base, + 2824. intel_sdvo_connector->right, 0); + 2825. > DRM_DEBUG_KMS("h_overscan: max %d, " + 2826. "default %d, current %d\n", + 2827. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2845: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2843. intel_sdvo_connector->max_vscan = data_value[0]; + 2844. intel_sdvo_connector->top = + 2845. > drm_property_create_range(dev, 0, + 2846. "top_margin", 0, data_value[0]); + 2847. if (!intel_sdvo_connector->top) + +drivers/gpu/drm/i915/intel_sdvo.c:2854: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2852. + 2853. intel_sdvo_connector->bottom = + 2854. > drm_property_create_range(dev, 0, + 2855. "bottom_margin", 0, data_value[0]); + 2856. if (!intel_sdvo_connector->bottom) + +drivers/gpu/drm/i915/intel_sdvo.c:2861: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2859. drm_object_attach_property(&connector->base, + 2860. intel_sdvo_connector->bottom, 0); + 2861. > DRM_DEBUG_KMS("v_overscan: max %d, " + 2862. "default %d, current %d\n", + 2863. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2866: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2864. } + 2865. + 2866. > ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + +drivers/gpu/drm/i915/intel_sdvo.c:2867: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2865. + 2866. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. > ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + +drivers/gpu/drm/i915/intel_sdvo.c:2868: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2866. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. > ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + +drivers/gpu/drm/i915/intel_sdvo.c:2869: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. > ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2870: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. > ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2871: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. > ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2872: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. > ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + +drivers/gpu/drm/i915/intel_sdvo.c:2873: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. > ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + +drivers/gpu/drm/i915/intel_sdvo.c:2874: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2875: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2876: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. > _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2878. + +drivers/gpu/drm/i915/intel_sdvo.c:2877: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. > _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2878. + 2879. if (enhancements.dot_crawl) { + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +sound/core/pcm_native.c:2810: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2808. return PTR_ERR(bufs); + 2809. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2810. > result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + +sound/core/pcm_native.c:2812: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2810. result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. > result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + 2813. kfree(bufs); + 2814. __put_user(result, &_xfern->result); + +net/wireless/trace.h:2803: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +drivers/cdrom/cdrom.c:2838: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2836. track_information ti; + 2837. __u32 last_track; + 2838. > int ret = -1, ti_size; + 2839. + 2840. if (!CDROM_CAN(CDC_GENERIC_PACKET)) + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +drivers/input/mouse/alps.c:2895: error: DEAD_STORE + The value written to &protocol (type alps_protocol_info const *) is never used. + 2893. protocol = &alps_v8_protocol_data; + 2894. } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0xc8) { + 2895. > protocol = &alps_v9_protocol_data; + 2896. psmouse_warn(psmouse, + 2897. "Unsupported ALPS V9 touchpad: E7=%3ph, EC=%3ph\n", + +drivers/gpu/drm/i915/i915_gem_gtt.c:2885: error: UNINITIALIZED_VALUE + The value read from hole_end was never initialized. + 2883. /* Clear any non-preallocated blocks */ + 2884. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2885. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2886. hole_start, hole_end); + 2887. ggtt->base.clear_range(&ggtt->base, hole_start, + +drivers/gpu/drm/i915/i915_gem_gtt.c:2885: error: UNINITIALIZED_VALUE + The value read from hole_start was never initialized. + 2883. /* Clear any non-preallocated blocks */ + 2884. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2885. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2886. hole_start, hole_end); + 2887. ggtt->base.clear_range(&ggtt->base, hole_start, + +kernel/printk/printk.c:2860: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2858. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2859. { + 2860. > int pending = __this_cpu_xchg(printk_pending, 0); + 2861. + 2862. if (pending & PRINTK_PENDING_OUTPUT) { + +kernel/printk/printk.c:2860: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 2858. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2859. { + 2860. > int pending = __this_cpu_xchg(printk_pending, 0); + 2861. + 2862. if (pending & PRINTK_PENDING_OUTPUT) { + +drivers/gpu/drm/i915/i915_debugfs.c:2879: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 2877 could be null and is dereferenced at line 2879, column 36. + 2877. struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base); + 2878. + 2879. > seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]); + 2880. seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio)); + 2881. if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) + +drivers/md/dm.c:2913: error: UNINITIALIZED_VALUE + The value read from front_pad was never initialized. + 2911. } + 2912. + 2913. > pools->bs = bioset_create(pool_size, front_pad, 0); + 2914. if (!pools->bs) + 2915. goto out; + +net/wireless/trace.h:2884: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2882. ); + 2883. + 2884. > DECLARE_EVENT_CLASS(wiphy_id_evt, + 2885. TP_PROTO(struct wiphy *wiphy, u64 id), + 2886. TP_ARGS(wiphy, id), + +drivers/tty/serial/8250/8250_port.c:2899: error: DEAD_STORE + The value written to &i (type int) is never used. + 2897. if (bytes < conf_type->rxtrig_bytes[i]) + 2898. /* Use the nearest lower value */ + 2899. > return (--i) << UART_FCR_R_TRIG_SHIFT; + 2900. } + 2901. + +lib/vsprintf.c:2911: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2909. */ + 2910. if (isspace(*fmt)) { + 2911. > fmt = skip_spaces(++fmt); + 2912. str = skip_spaces(str); + 2913. } + +lib/vsprintf.c:3116: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3114. while (next - str > field_width) { + 3115. if (is_sign) + 3116. > val.s = div_s64(val.s, base); + 3117. else + 3118. val.u = div_u64(val.u, base); + +lib/vsprintf.c:3126: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3124. case 'H': /* that's 'hh' in format */ + 3125. if (is_sign) + 3126. > *va_arg(args, signed char *) = val.s; + 3127. else + 3128. *va_arg(args, unsigned char *) = val.u; + +lib/vsprintf.c:3132: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3130. case 'h': + 3131. if (is_sign) + 3132. > *va_arg(args, short *) = val.s; + 3133. else + 3134. *va_arg(args, unsigned short *) = val.u; + +lib/vsprintf.c:3138: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3136. case 'l': + 3137. if (is_sign) + 3138. > *va_arg(args, long *) = val.s; + 3139. else + 3140. *va_arg(args, unsigned long *) = val.u; + +lib/vsprintf.c:3144: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3142. case 'L': + 3143. if (is_sign) + 3144. > *va_arg(args, long long *) = val.s; + 3145. else + 3146. *va_arg(args, unsigned long long *) = val.u; + +lib/vsprintf.c:3153: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3151. default: + 3152. if (is_sign) + 3153. > *va_arg(args, int *) = val.s; + 3154. else + 3155. *va_arg(args, unsigned int *) = val.u; + +lib/vsprintf.c:3118: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3116. val.s = div_s64(val.s, base); + 3117. else + 3118. > val.u = div_u64(val.u, base); + 3119. --next; + 3120. } + +lib/vsprintf.c:3128: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3126. *va_arg(args, signed char *) = val.s; + 3127. else + 3128. > *va_arg(args, unsigned char *) = val.u; + 3129. break; + 3130. case 'h': + +lib/vsprintf.c:3134: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3132. *va_arg(args, short *) = val.s; + 3133. else + 3134. > *va_arg(args, unsigned short *) = val.u; + 3135. break; + 3136. case 'l': + +lib/vsprintf.c:3140: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3138. *va_arg(args, long *) = val.s; + 3139. else + 3140. > *va_arg(args, unsigned long *) = val.u; + 3141. break; + 3142. case 'L': + +lib/vsprintf.c:3146: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3144. *va_arg(args, long long *) = val.s; + 3145. else + 3146. > *va_arg(args, unsigned long long *) = val.u; + 3147. break; + 3148. case 'z': + +lib/vsprintf.c:3149: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3147. break; + 3148. case 'z': + 3149. > *va_arg(args, size_t *) = val.u; + 3150. break; + 3151. default: + +lib/vsprintf.c:3155: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3153. *va_arg(args, int *) = val.s; + 3154. else + 3155. > *va_arg(args, unsigned int *) = val.u; + 3156. break; + 3157. } + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +drivers/gpu/drm/i915/intel_sdvo.c:2906: error: UNINITIALIZED_VALUE + The value read from data_value.[_] was never initialized. + 2904. uint16_t response, data_value[2]; + 2905. + 2906. > ENHANCEMENT(&connector->state->tv, brightness, BRIGHTNESS); + 2907. + 2908. return true; + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +kernel/cgroup/cgroup.c:2912: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2907 could be null and is dereferenced at line 2912, column 39. + 2910. WARN_ON_ONCE(css && percpu_ref_is_dying(&css->refcnt)); + 2911. + 2912. > if (!(cgroup_ss_mask(dsct) & (1 << ss->id))) + 2913. continue; + 2914. + +kernel/sched/fair.c:2905: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2903. struct task_group *tg = cfs_rq->tg; + 2904. + 2905. > tg_shares = READ_ONCE(tg->shares); + 2906. + 2907. load = max(scale_load_down(cfs_rq->load.weight), cfs_rq->avg.load_avg); + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +kernel/rcu/tree.c:2913: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2911. struct rcu_state *rsp; + 2912. + 2913. > if (cpu_is_offline(smp_processor_id())) + 2914. return; + 2915. trace_rcu_utilization(TPS("Start RCU core")); + +kernel/rcu/tree.c:2913: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2911. struct rcu_state *rsp; + 2912. + 2913. > if (cpu_is_offline(smp_processor_id())) + 2914. return; + 2915. trace_rcu_utilization(TPS("Start RCU core")); + +net/core/neighbour.c:2926: error: UNINITIALIZED_VALUE + The value read from size was never initialized. + 2924. tmp.extra1 = &zero; + 2925. tmp.extra2 = &unres_qlen_max; + 2926. > tmp.data = &size; + 2927. + 2928. size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN); + +net/unix/af_unix.c:2920: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2918. static int __init af_unix_init(void) + 2919. { + 2920. > int rc = -1; + 2921. + 2922. BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb)); + +net/netfilter/nf_conntrack_netlink.c:2931: error: NULL_DEREFERENCE + pointer `m_help` last assigned on line 2929 could be null and is dereferenced at line 2931, column 16. + 2929. m_help = nfct_help(exp->master); + 2930. + 2931. > return strcmp(m_help->helper->name, name) == 0; + 2932. } + 2933. + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +kernel/rcu/tree.c:2941: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2939. static void invoke_rcu_core(void) + 2940. { + 2941. > if (cpu_online(smp_processor_id())) + 2942. raise_softirq(RCU_SOFTIRQ); + 2943. } + +kernel/rcu/tree.c:2941: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2939. static void invoke_rcu_core(void) + 2940. { + 2941. > if (cpu_online(smp_processor_id())) + 2942. raise_softirq(RCU_SOFTIRQ); + 2943. } + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +net/ipv4/tcp.c:2959: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2957. + 2958. /* Report meaningful fields for all TCP states, including listeners */ + 2959. > rate = READ_ONCE(sk->sk_pacing_rate); + 2960. rate64 = rate != ~0U ? rate : ~0ULL; + 2961. info->tcpi_pacing_rate = rate64; + +net/ipv4/tcp.c:2963: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2961. info->tcpi_pacing_rate = rate64; + 2962. + 2963. > rate = READ_ONCE(sk->sk_max_pacing_rate); + 2964. rate64 = rate != ~0U ? rate : ~0ULL; + 2965. info->tcpi_max_pacing_rate = rate64; + +net/ipv6/addrconf.c:2955: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2953. + 2954. rtnl_lock(); + 2955. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2956. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2957. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +net/ipv6/addrconf.c:2955: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2953. + 2954. rtnl_lock(); + 2955. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2956. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2957. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +kernel/cgroup/cgroup.c:2966: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2953 could be null and is dereferenced at line 2966, column 9. + 2964. } else if (!css_visible(css)) { + 2965. css_clear_dir(css); + 2966. > if (ss->css_reset) + 2967. ss->css_reset(css); + 2968. } + +kernel/rcu/tree.c:2961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2959. + 2960. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 2961. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 2962. return; + 2963. + +kernel/rcu/tree.c:2961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2959. + 2960. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 2961. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 2962. return; + 2963. + +drivers/gpu/drm/i915/intel_runtime_pm.c:2963: error: NULL_DEREFERENCE + pointer `cmn` last assigned on line 2957 could be null and is dereferenced at line 2963, column 6. + 2961. + 2962. /* If the display might be already active skip this */ + 2963. > if (cmn->ops->is_enabled(dev_priv, cmn) && + 2964. disp2d->ops->is_enabled(dev_priv, disp2d) && + 2965. I915_READ(DPIO_CTL) & DPIO_CMNRST) + +net/ipv6/addrconf.c:2974: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2972. + 2973. rtnl_lock(); + 2974. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2975. ireq.ifr6_prefixlen); + 2976. rtnl_unlock(); + +net/ipv6/addrconf.c:2974: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2972. + 2973. rtnl_lock(); + 2974. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2975. ireq.ifr6_prefixlen); + 2976. rtnl_unlock(); + +drivers/gpu/drm/drm_dp_mst_topology.c:3016: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3014. int ret; + 3015. + 3016. > ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + +drivers/gpu/drm/drm_dp_mst_topology.c:3018: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3016. ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. > ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + +drivers/gpu/drm/drm_dp_mst_topology.c:3020: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. > ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + 3021. seq_printf(m, "mst ctrl: %*ph\n", 1, buf); + 3022. + +drivers/gpu/drm/drm_dp_mst_topology.c:3024: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3022. + 3023. /* dump the standard OUI branch header */ + 3024. > ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE); + 3025. seq_printf(m, "branch oui: %*phN devid: ", 3, buf); + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + +drivers/gpu/drm/drm_dp_mst_topology.c:3027: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 3025. seq_printf(m, "branch oui: %*phN devid: ", 3, buf); + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + 3027. > seq_printf(m, "%c", buf[i]); + 3028. seq_printf(m, " revision: hw: %x.%x sw: %x.%x\n", + 3029. buf[0x9] >> 4, buf[0x9] & 0xf, buf[0xa], buf[0xb]); + +drivers/gpu/drm/drm_dp_mst_topology.c:3028: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + 3027. seq_printf(m, "%c", buf[i]); + 3028. > seq_printf(m, " revision: hw: %x.%x sw: %x.%x\n", + 3029. buf[0x9] >> 4, buf[0x9] & 0xf, buf[0xa], buf[0xb]); + 3030. if (dump_dp_payload_table(mgr, buf)) + +net/wireless/trace.h:2970: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2968. ); + 2969. + 2970. > DECLARE_EVENT_CLASS(cfg80211_bss_evt, + 2971. TP_PROTO(struct cfg80211_bss *pub), + 2972. TP_ARGS(pub), + +kernel/events/core.c:2981: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2979. int ctxn; + 2980. + 2981. > if (__this_cpu_read(perf_sched_cb_usages)) + 2982. perf_pmu_sched_task(task, next, false); + 2983. + +kernel/sched/core.c:2988: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2986. raw_spin_lock_irqsave(&p->pi_lock, flags); + 2987. dest_cpu = p->sched_class->select_task_rq(p, task_cpu(p), SD_BALANCE_EXEC, 0); + 2988. > if (dest_cpu == smp_processor_id()) + 2989. goto unlock; + 2990. + +drivers/gpu/drm/drm_atomic_helper.c:3001: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2999. + 3000. if (ret) + 3001. > DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret); + 3002. + 3003. drm_modeset_drop_locks(&ctx); + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2989: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +drivers/cdrom/cdrom.c:3026: error: UNINITIALIZED_VALUE + The value read from ra.nframes was never initialized. + 3024. return -EINVAL; + 3025. + 3026. > return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes); + 3027. } + 3028. + +net/wireless/trace.h:3013: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/ipv4/tcp_input.c:3126: error: UNINITIALIZED_VALUE + The value read from last_ackt was never initialized. + 3124. if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) { + 3125. seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt); + 3126. > ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt); + 3127. + 3128. if (pkts_acked == 1 && last_in_flight < tp->mss_cache && + +drivers/cdrom/cdrom.c:3037: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 3035. if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q))) + 3036. return -EFAULT; + 3037. > requested = q.cdsc_format; + 3038. if (!((requested == CDROM_MSF) || + 3039. (requested == CDROM_LBA))) + +kernel/signal.c:3045: error: UNINITIALIZED_VALUE + The value read from from.si_code was never initialized. + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. > switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + 3047. to->si_pid = from.si_pid; + +kernel/signal.c:3045: error: UNINITIALIZED_VALUE + The value read from from.si_signo was never initialized. + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. > switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + 3047. to->si_pid = from.si_pid; + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/ipv4/tcp.c:3078: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3076. tp->total_retrans, TCP_NLA_PAD); + 3077. + 3078. > rate = READ_ONCE(sk->sk_pacing_rate); + 3079. rate64 = rate != ~0U ? rate : ~0ULL; + 3080. nla_put_u64_64bit(stats, TCP_NLA_PACING_RATE, rate64, TCP_NLA_PAD); + +kernel/sched/core.c:3077: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3075. void scheduler_tick(void) + 3076. { + 3077. > int cpu = smp_processor_id(); + 3078. struct rq *rq = cpu_rq(cpu); + 3079. struct task_struct *curr = rq->curr; + +kernel/sched/core.c:3077: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3075. void scheduler_tick(void) + 3076. { + 3077. > int cpu = smp_processor_id(); + 3078. struct rq *rq = cpu_rq(cpu); + 3079. struct task_struct *curr = rq->curr; + +net/wireless/trace.h:3077: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +drivers/net/ethernet/intel/e1000/e1000_main.c:3107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3105. * made room available. + 3106. */ + 3107. > if (likely(E1000_DESC_UNUSED(tx_ring) < size)) + 3108. return -EBUSY; + 3109. + +net/wireless/trace.h:3092: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +drivers/cdrom/cdrom.c:3142: error: UNINITIALIZED_VALUE + The value read from buffer.[_] was never initialized. + 3140. a CDROMVOLREAD, return these values */ + 3141. if (cmd == CDROMVOLREAD) { + 3142. > volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + +drivers/cdrom/cdrom.c:3143: error: UNINITIALIZED_VALUE + The value read from buffer.[_] was never initialized. + 3141. if (cmd == CDROMVOLREAD) { + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. > volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + +drivers/cdrom/cdrom.c:3144: error: UNINITIALIZED_VALUE + The value read from buffer.[_] was never initialized. + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. > volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + +drivers/cdrom/cdrom.c:3145: error: UNINITIALIZED_VALUE + The value read from buffer.[_] was never initialized. + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. > volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + 3147. sizeof(volctrl))) + +net/wireless/trace.h:3115: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +drivers/net/ethernet/intel/e1000/e1000_main.c:3119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3117. struct e1000_tx_ring *tx_ring, int size) + 3118. { + 3119. > if (likely(E1000_DESC_UNUSED(tx_ring) >= size)) + 3120. return 0; + 3121. return __e1000_maybe_stop_tx(netdev, size); + +drivers/gpu/drm/drm_atomic_helper.c:3163: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 3161. drm_modeset_acquire_fini(&ctx); + 3162. + 3163. > return err; + 3164. } + 3165. EXPORT_SYMBOL(drm_atomic_helper_resume); + +net/wireless/trace.h:3138: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +drivers/net/ethernet/nvidia/forcedeth.c:3193: error: UNINITIALIZED_VALUE + The value read from mask.[_] was never initialized. + 3191. writel(addr[0], base + NvRegMulticastAddrA); + 3192. writel(addr[1], base + NvRegMulticastAddrB); + 3193. > writel(mask[0], base + NvRegMulticastMaskA); + 3194. writel(mask[1], base + NvRegMulticastMaskB); + 3195. writel(pff, base + NvRegPacketFilterFlags); + +drivers/net/ethernet/nvidia/forcedeth.c:3194: error: UNINITIALIZED_VALUE + The value read from mask.[_] was never initialized. + 3192. writel(addr[1], base + NvRegMulticastAddrB); + 3193. writel(mask[0], base + NvRegMulticastMaskA); + 3194. > writel(mask[1], base + NvRegMulticastMaskB); + 3195. writel(pff, base + NvRegPacketFilterFlags); + 3196. nv_start_rx(dev); + +net/socket.c:3159: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced at line 3159, column 2. + 3157. } + 3158. + 3159. > (*newsock)->ops = sock->ops; + 3160. __module_get((*newsock)->ops->owner); + 3161. + +net/socket.c:3154: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced by call to `sock_release()` at line 3154, column 3. + 3152. err = sock->ops->accept(sock, *newsock, flags, true); + 3153. if (err < 0) { + 3154. > sock_release(*newsock); + 3155. *newsock = NULL; + 3156. goto done; + +drivers/usb/core/hub.c:3146: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3145 could be null and is dereferenced at line 3146, column 30. + 3144. { + 3145. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3146. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3147. int port1 = udev->portnum; + 3148. int status; + +security/selinux/hooks.c:3149: error: MEMORY_LEAK + `return` is not reachable after line 3149, column 3. + 3147. + 3148. if (cap_capable(cred, &init_user_ns, CAP_MAC_ADMIN, cap_audit)) + 3149. > return false; + 3150. if (cred_has_capability(cred, CAP_MAC_ADMIN, cap_audit, true)) + 3151. return false; + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +kernel/events/core.c:3182: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3180. perf_event_switch(task, prev, true); + 3181. + 3182. > if (__this_cpu_read(perf_sched_cb_usages)) + 3183. perf_pmu_sched_task(prev, task, true); + 3184. } + +net/wireless/trace.h:3158: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +block/blk-mq.c:3196: error: NULL_DEREFERENCE + pointer `rq` last assigned on line 3183 could be null and is dereferenced by call to `__blk_mq_poll()` at line 3196, column 9. + 3194. } + 3195. + 3196. > return __blk_mq_poll(hctx, rq); + 3197. } + 3198. + +kernel/cgroup/cgroup.c:3177: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 3176 could be null and is dereferenced at line 3177, column 28. + 3175. { + 3176. struct cgroup *parent = cgroup_parent(cgrp); + 3177. > struct cgroup *dom_cgrp = parent->dom_cgrp; + 3178. int ret; + 3179. + +drivers/tty/serial/8250/8250_port.c:3230: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 3228. + 3229. if (locked) + 3230. > spin_unlock_irqrestore(&port->lock, flags); + 3231. serial8250_rpm_put(up); + 3232. } + +kernel/rcu/tree.c:3263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3261. * and cond_synchronize_rcu(). + 3262. */ + 3263. > return smp_load_acquire(&rcu_state_p->gpnum); + 3264. } + 3265. EXPORT_SYMBOL_GPL(get_state_synchronize_rcu); + +kernel/cgroup/cgroup.c:3258: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3256. { + 3257. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3258. > int descendants = READ_ONCE(cgrp->max_descendants); + 3259. + 3260. if (descendants == INT_MAX) + +kernel/rcu/tree.c:3289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3287. * actions the caller might carry out after we return. + 3288. */ + 3289. > newstate = smp_load_acquire(&rcu_state_p->completed); + 3290. if (ULONG_CMP_GE(oldstate, newstate)) + 3291. synchronize_rcu(); + +kernel/printk/printk.c:3292: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3290. { + 3291. printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3292. > log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3293. print_tainted(), init_utsname()->release, + 3294. (int)strcspn(init_utsname()->version, " "), + +kernel/printk/printk.c:3291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3289. void dump_stack_print_info(const char *log_lvl) + 3290. { + 3291. > printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3292. log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3293. print_tainted(), init_utsname()->release, + +kernel/cgroup/cgroup.c:3301: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3299. { + 3300. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3301. > int depth = READ_ONCE(cgrp->max_depth); + 3302. + 3303. if (depth == INT_MAX) + +kernel/rcu/tree.c:3315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3313. * and cond_synchronize_sched(). + 3314. */ + 3315. > return smp_load_acquire(&rcu_sched_state.gpnum); + 3316. } + 3317. EXPORT_SYMBOL_GPL(get_state_synchronize_sched); + +drivers/net/ethernet/nvidia/forcedeth.c:3321: error: DEAD_STORE + The value written to &newdup (type int) is never used. + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. int newls = np->linkspeed; + 3321. > int newdup = np->duplex; + 3322. int mii_status; + 3323. u32 bmcr; + +drivers/net/ethernet/nvidia/forcedeth.c:3320: error: DEAD_STORE + The value written to &newls (type int) is never used. + 3318. int lpa = 0; + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. > int newls = np->linkspeed; + 3321. int newdup = np->duplex; + 3322. int mii_status; + +kernel/rcu/tree.c:3341: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3339. * actions the caller might carry out after we return. + 3340. */ + 3341. > newstate = smp_load_acquire(&rcu_sched_state.completed); + 3342. if (ULONG_CMP_GE(oldstate, newstate)) + 3343. synchronize_sched(); + +drivers/gpu/drm/i915/i915_drv.h:3338: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3336. static inline u32 i915_reset_count(struct i915_gpu_error *error) + 3337. { + 3338. > return READ_ONCE(error->reset_count); + 3339. } + 3340. + +drivers/gpu/drm/i915/i915_drv.h:3344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3342. struct intel_engine_cs *engine) + 3343. { + 3344. > return READ_ONCE(error->reset_engine_count[engine->id]); + 3345. } + 3346. + +kernel/sched/core.c:3358: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3356. int cpu; + 3357. + 3358. > cpu = smp_processor_id(); + 3359. rq = cpu_rq(cpu); + 3360. prev = rq->curr; + +kernel/sched/core.c:3358: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3356. int cpu; + 3357. + 3358. > cpu = smp_processor_id(); + 3359. rq = cpu_rq(cpu); + 3360. prev = rq->curr; + +kernel/rcu/tree.c:3370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3368. if (rcu_scheduler_fully_active && + 3369. rdp->core_needs_qs && rdp->cpu_no_qs.b.norm && + 3370. > rdp->rcu_qs_ctr_snap == __this_cpu_read(rcu_dynticks.rcu_qs_ctr)) { + 3371. rdp->n_rp_core_needs_qs++; + 3372. } else if (rdp->core_needs_qs && !rdp->cpu_no_qs.b.norm) { + +kernel/trace/trace.c:3393: error: DEAD_STORE + The value written to &name (type char const *) is never used. + 3391. unsigned long entries; + 3392. unsigned long total; + 3393. > const char *name = "preemption"; + 3394. + 3395. name = type->name; + +net/ipv4/tcp_input.c:3407: error: DEAD_STORE + The value written to &half (type unsigned int) is never used. + 3405. if (now != challenge_timestamp) { + 3406. u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit; + 3407. > u32 half = (ack_limit + 1) >> 1; + 3408. + 3409. challenge_timestamp = now; + +net/ipv4/tcp_input.c:3412: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3410. WRITE_ONCE(challenge_count, half + prandom_u32_max(ack_limit)); + 3411. } + 3412. > count = READ_ONCE(challenge_count); + 3413. if (count > 0) { + 3414. WRITE_ONCE(challenge_count, count - 1); + +drivers/usb/core/hub.c:3415: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3414 could be null and is dereferenced at line 3415, column 30. + 3413. { + 3414. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3415. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3416. int port1 = udev->portnum; + 3417. int status; + +kernel/events/core.c:3425: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + 3427. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3424: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 3422. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + +kernel/events/core.c:3425: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + 3427. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3424: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 3422. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + +net/core/rtnetlink.c:3461: error: NULL_DEREFERENCE + pointer `br_dev` last assigned on line 3460 could be null and is dereferenced at line 3461, column 38. + 3459. (dev->priv_flags & IFF_BRIDGE_PORT)) { + 3460. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + 3461. > const struct net_device_ops *ops = br_dev->netdev_ops; + 3462. + 3463. err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, + +drivers/gpu/drm/i915/i915_debugfs.c:3442: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 3441 could be null and is dereferenced at line 3442, column 8. + 3440. + 3441. intel_dig_port = enc_to_dig_port(&intel_encoder->base); + 3442. > if (!intel_dig_port->dp.can_mst) + 3443. continue; + 3444. + +net/core/dev.c:3436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3434. + 3435. if (sender_cpu >= (u32)NR_CPUS) + 3436. > skb->sender_cpu = raw_smp_processor_id() + 1; + 3437. #endif + 3438. + +drivers/gpu/drm/i915/i915_debugfs.c:3499: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3499, column 5. + 3497. */ + 3498. if (val == 1) + 3499. > intel_dp->compliance.test_active = 1; + 3500. else + 3501. intel_dp->compliance.test_active = 0; + +drivers/gpu/drm/i915/i915_debugfs.c:3501: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3501, column 5. + 3499. intel_dp->compliance.test_active = 1; + 3500. else + 3501. > intel_dp->compliance.test_active = 0; + 3502. } + 3503. } + +drivers/net/ethernet/intel/e1000e/netdev.c:3474: error: UNINITIALIZED_VALUE + The value read from rss_key.[_] was never initialized. + 3472. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 3473. for (i = 0; i < 10; i++) + 3474. > ew32(RSSRK(i), rss_key[i]); + 3475. + 3476. /* Direct all traffic to queue 0 */ + +kernel/sched/fair.c:3492: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3490. + 3491. /* Update parent cfs_rq utilization */ + 3492. > add_positive(&cfs_rq->avg.util_avg, delta); + 3493. cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX; + 3494. } + +net/core/dev.c:3542: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3540. */ + 3541. if (dev->flags & IFF_UP) { + 3542. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + +net/core/dev.c:3545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + 3545. > if (unlikely(__this_cpu_read(xmit_recursion) > + 3546. XMIT_RECURSION_LIMIT)) + 3547. goto recursion_alert; + +net/core/dev.c:3542: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3540. */ + 3541. if (dev->flags & IFF_UP) { + 3542. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + +kernel/events/core.c:3501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3499. + 3500. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3501. > int local_cpu = smp_processor_id(); + 3502. + 3503. event_pkg = topology_physical_package_id(event_cpu); + +kernel/events/core.c:3501: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3499. + 3500. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3501. > int local_cpu = smp_processor_id(); + 3502. + 3503. event_pkg = topology_physical_package_id(event_cpu); + +kernel/sched/fair.c:3547: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3545. se->avg.load_sum = runnable_sum; + 3546. se->avg.load_avg = load_avg; + 3547. > add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + +kernel/sched/fair.c:3548: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3546. se->avg.load_avg = load_avg; + 3547. add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. > add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + 3550. runnable_load_sum = (s64)se_runnable(se) * runnable_sum; + +kernel/sched/fair.c:3559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3557. + 3558. if (se->on_rq) { + 3559. > add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + +kernel/sched/fair.c:3560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3558. if (se->on_rq) { + 3559. add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. > add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + 3562. } + +drivers/gpu/drm/i915/i915_debugfs.c:3534: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3533 could be null and is dereferenced at line 3534, column 8. + 3532. if (encoder && connector->status == connector_status_connected) { + 3533. intel_dp = enc_to_intel_dp(&encoder->base); + 3534. > if (intel_dp->compliance.test_active) + 3535. seq_puts(m, "1"); + 3536. else + +net/core/rtnetlink.c:3525: error: DEAD_STORE + The value written to &err (type int) is never used. + 3523. struct nlattr *tb[NDA_MAX+1]; + 3524. struct net_device *dev; + 3525. > int err = -EINVAL; + 3526. __u8 *addr; + 3527. u16 vid; + +drivers/clk/clk.c:3549: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3547. { + 3548. struct clk_notifier *cn = NULL; + 3549. > int ret = -EINVAL; + 3550. + 3551. if (!clk || !nb) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3569: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3567. u32 flash_linear_addr; + 3568. u32 flash_data = 0; + 3569. > s32 ret_val = -E1000_ERR_NVM; + 3570. u8 count = 0; + 3571. + +drivers/gpu/drm/i915/i915_debugfs.c:3585: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3584 could be null and is dereferenced at line 3585, column 8. + 3583. if (encoder && connector->status == connector_status_connected) { + 3584. intel_dp = enc_to_intel_dp(&encoder->base); + 3585. > if (intel_dp->compliance.test_type == + 3586. DP_TEST_LINK_EDID_READ) + 3587. seq_printf(m, "%lx", + +drivers/gpu/drm/i915/i915_gem.c:3571: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 3569. static int wait_for_engines(struct drm_i915_private *i915) + 3570. { + 3571. > if (wait_for(intel_engines_are_idle(i915), I915_IDLE_ENGINES_TIMEOUT)) { + 3572. dev_err(i915->drm.dev, + 3573. "Failed to idle engines, declaring wedged!\n"); + +drivers/gpu/drm/i915/i915_gem.c:3571: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 3569. static int wait_for_engines(struct drm_i915_private *i915) + 3570. { + 3571. > if (wait_for(intel_engines_are_idle(i915), I915_IDLE_ENGINES_TIMEOUT)) { + 3572. dev_err(i915->drm.dev, + 3573. "Failed to idle engines, declaring wedged!\n"); + +drivers/usb/core/hub.c:3611: error: DEAD_STORE + The value written to &status (type int) is never used. + 3609. /* Enable hub to send remote wakeup for all ports. */ + 3610. for (port1 = 1; port1 <= hdev->maxchild; port1++) { + 3611. > status = set_port_feature(hdev, + 3612. port1 | + 3613. USB_PORT_FEAT_REMOTE_WAKE_CONNECT | + +drivers/video/fbdev/core/fbcon.c:3597: error: DEAD_STORE + The value written to &pending (type int) is never used. + 3595. + 3596. if (info->queue.func) + 3597. > pending = cancel_work_sync(&info->queue); + 3598. DPRINTK("fbcon: %s pending work\n", (pending ? "canceled" : + 3599. "no")); + +kernel/signal.c:3588: error: UNINITIALIZED_VALUE + The value read from uss32.ss_flags was never initialized. + 3586. return -EFAULT; + 3587. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. > uss.ss_flags = uss32.ss_flags; + 3589. uss.ss_size = uss32.ss_size; + 3590. } + +kernel/signal.c:3589: error: UNINITIALIZED_VALUE + The value read from uss32.ss_size was never initialized. + 3587. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. uss.ss_flags = uss32.ss_flags; + 3589. > uss.ss_size = uss32.ss_size; + 3590. } + 3591. ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, + +kernel/signal.c:3587: error: UNINITIALIZED_VALUE + The value read from uss32.ss_sp was never initialized. + 3585. if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t))) + 3586. return -EFAULT; + 3587. > uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. uss.ss_flags = uss32.ss_flags; + 3589. uss.ss_size = uss32.ss_size; + +include/linux/netdevice.h:3586: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3584. bool ok = spin_trylock(&txq->_xmit_lock); + 3585. if (likely(ok)) + 3586. > txq->xmit_lock_owner = smp_processor_id(); + 3587. return ok; + 3588. } + +kernel/events/core.c:3616: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3614. /* If this is a per-CPU event, it must be for this CPU */ + 3615. if (!(event->attach_state & PERF_ATTACH_TASK) && + 3616. > event->cpu != smp_processor_id()) { + 3617. ret = -EINVAL; + 3618. goto out; + +kernel/events/core.c:3626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3624. * oncpu == -1). + 3625. */ + 3626. > if (event->oncpu == smp_processor_id()) + 3627. event->pmu->read(event); + 3628. + +drivers/gpu/drm/i915/i915_debugfs.c:3643: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3642 could be null and is dereferenced at line 3643, column 27. + 3641. if (encoder && connector->status == connector_status_connected) { + 3642. intel_dp = enc_to_intel_dp(&encoder->base); + 3643. > seq_printf(m, "%02lx", intel_dp->compliance.test_type); + 3644. } else + 3645. seq_puts(m, "0"); + +include/linux/netdevice.h:3629: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3627. + 3628. spin_lock(&dev->tx_global_lock); + 3629. > cpu = smp_processor_id(); + 3630. for (i = 0; i < dev->num_tx_queues; i++) { + 3631. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3629: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3627. + 3628. spin_lock(&dev->tx_global_lock); + 3629. > cpu = smp_processor_id(); + 3630. for (i = 0; i < dev->num_tx_queues; i++) { + 3631. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3644: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3642. union ich8_hws_flash_ctrl hsflctl; + 3643. u32 flash_linear_addr; + 3644. > s32 ret_val = -E1000_ERR_NVM; + 3645. u8 count = 0; + 3646. + +kernel/events/core.c:3648: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3646. static int perf_event_read(struct perf_event *event, bool group) + 3647. { + 3648. > enum perf_event_state state = READ_ONCE(event->state); + 3649. int event_cpu, ret = 0; + 3650. + +kernel/events/core.c:3667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3665. smp_rmb(); + 3666. + 3667. > event_cpu = READ_ONCE(event->oncpu); + 3668. if ((unsigned)event_cpu >= nr_cpu_ids) + 3669. return 0; + +kernel/sched/fair.c:3672: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3670. + 3671. r = removed_load; + 3672. > sub_positive(&sa->load_avg, r); + 3673. sub_positive(&sa->load_sum, r * divider); + 3674. + +kernel/sched/fair.c:3673: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3671. r = removed_load; + 3672. sub_positive(&sa->load_avg, r); + 3673. > sub_positive(&sa->load_sum, r * divider); + 3674. + 3675. r = removed_util; + +kernel/sched/fair.c:3676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3674. + 3675. r = removed_util; + 3676. > sub_positive(&sa->util_avg, r); + 3677. sub_positive(&sa->util_sum, r * divider); + 3678. + +kernel/sched/fair.c:3677: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3675. r = removed_util; + 3676. sub_positive(&sa->util_avg, r); + 3677. > sub_positive(&sa->util_sum, r * divider); + 3678. + 3679. add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum); + +drivers/gpu/drm/i915/intel_dp.c:3745: error: UNINITIALIZED_VALUE + The value read from sink_rates.[_] was never initialized. + 3743. + 3744. for (i = 0; i < ARRAY_SIZE(sink_rates); i++) { + 3745. > int val = le16_to_cpu(sink_rates[i]); + 3746. + 3747. if (val == 0) + +drivers/ata/libata-scsi.c:3697: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3695. struct scsi_cmnd *scmd = qc->scsicmd; + 3696. const u8 *cdb = scmd->cmnd; + 3697. > u16 sect, fp = (u16)-1; + 3698. u8 sa, options, bp = 0xff; + 3699. u64 block; + +drivers/gpu/drm/drm_edid.c:3734: error: UNINITIALIZED_VALUE + The value read from hdmi_len was never initialized. + 3732. */ + 3733. if (hdmi) + 3734. > modes += do_hdmi_vsdb_modes(connector, hdmi, hdmi_len, video, + 3735. video_len); + 3736. + +include/linux/netdevice.h:3701: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3699. + 3700. local_bh_disable(); + 3701. > cpu = smp_processor_id(); + 3702. for (i = 0; i < dev->num_tx_queues; i++) { + 3703. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3701: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3699. + 3700. local_bh_disable(); + 3701. > cpu = smp_processor_id(); + 3702. for (i = 0; i < dev->num_tx_queues; i++) { + 3703. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +drivers/ata/libata-core.c:3726: error: DEAD_STORE + The value written to &nodev_deadline (type unsigned long) is never used. + 3724. + 3725. if (time_after(nodev_deadline, deadline)) + 3726. > nodev_deadline = deadline; + 3727. + 3728. while (1) { + +drivers/ata/libata-core.c:3729: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 3727. + 3728. while (1) { + 3729. > unsigned long now = jiffies; + 3730. int ready, tmp; + 3731. + +drivers/ata/libata-core.c:3766: error: DEAD_STORE + The value written to &warned (type int) is never used. + 3764. "link is slow to respond, please be patient " + 3765. "(ready=%d)\n", tmp); + 3766. > warned = 1; + 3767. } + 3768. + +drivers/pci/quirks.c:3743: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 3741. iowrite32(val, mmio_base + PCH_PP_CONTROL); + 3742. + 3743. > timeout = jiffies + msecs_to_jiffies(IGD_OPERATION_TIMEOUT); + 3744. do { + 3745. val = ioread32(mmio_base + PCH_PP_STATUS); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3821: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3819. + 3820. /* Convert offset to bytes. */ + 3821. > act_offset = (i + new_bank_offset) << 1; + 3822. + 3823. usleep_range(100, 200); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3867: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3865. * to 1's. We can write 1's to 0's without an erase + 3866. */ + 3867. > act_offset = (old_bank_offset + E1000_ICH_NVM_SIG_WORD) * 2 + 1; + 3868. + 3869. /* offset in words but we read dword */ + +kernel/sched/fair.c:3755: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3753. { + 3754. dequeue_load_avg(cfs_rq, se); + 3755. > sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + +kernel/sched/fair.c:3756: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3754. dequeue_load_avg(cfs_rq, se); + 3755. sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. > sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + 3758. add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum); + +drivers/ata/libata-scsi.c:3784: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3782. u64 block; + 3783. u32 n_block; + 3784. > u16 fp = (u16)-1; + 3785. + 3786. if (unlikely(scmd->cmd_len < 16)) { + +net/core/dev.c:3809: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3807. if (flow_table && flow_id <= flow_table->mask) { + 3808. rflow = &flow_table->flows[flow_id]; + 3809. > cpu = READ_ONCE(rflow->cpu); + 3810. if (rflow->filter == filter_id && cpu < nr_cpu_ids && + 3811. ((int)(per_cpu(softnet_data, cpu).input_queue_head - + +kernel/rcu/tree.c:3834: error: DEAD_STORE + The value written to &nbits (type int) is never used. + 3832. rnp->expmaskinitnext |= mask; + 3833. oldmask ^= rnp->expmaskinitnext; + 3834. > nbits = bitmap_weight(&oldmask, BITS_PER_LONG); + 3835. /* Allow lockless access for expedited grace periods. */ + 3836. smp_store_release(&rsp->ncpus, rsp->ncpus + nbits); /* ^^^ */ + +drivers/ata/libata-core.c:3828: error: DEAD_STORE + The value written to &deadline (type unsigned long) is never used. + 3826. t = ata_deadline(jiffies, params[2]); + 3827. if (time_before(t, deadline)) + 3828. > deadline = t; + 3829. + 3830. if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) + +drivers/ata/libata-core.c:3834: error: DEAD_STORE + The value written to &last (type unsigned int) is never used. + 3832. cur &= 0xf; + 3833. + 3834. > last = cur; + 3835. last_jiffies = jiffies; + 3836. + +drivers/ata/libata-core.c:3835: error: DEAD_STORE + The value written to &last_jiffies (type unsigned long) is never used. + 3833. + 3834. last = cur; + 3835. > last_jiffies = jiffies; + 3836. + 3837. while (1) { + +net/packet/af_packet.c:3875: error: DEAD_STORE + The value written to &val (type int) is never used. + 3873. break; + 3874. case PACKET_AUXDATA: + 3875. > val = po->auxdata; + 3876. break; + 3877. case PACKET_ORIGDEV: + +net/packet/af_packet.c:3878: error: DEAD_STORE + The value written to &val (type int) is never used. + 3876. break; + 3877. case PACKET_ORIGDEV: + 3878. > val = po->origdev; + 3879. break; + 3880. case PACKET_VNET_HDR: + +net/packet/af_packet.c:3881: error: DEAD_STORE + The value written to &val (type int) is never used. + 3879. break; + 3880. case PACKET_VNET_HDR: + 3881. > val = po->has_vnet_hdr; + 3882. break; + 3883. case PACKET_VERSION: + +net/packet/af_packet.c:3884: error: DEAD_STORE + The value written to &val (type int) is never used. + 3882. break; + 3883. case PACKET_VERSION: + 3884. > val = po->tp_version; + 3885. break; + 3886. case PACKET_HDRLEN: + +net/packet/af_packet.c:3895: error: DEAD_STORE + The value written to &val (type int) is never used. + 3893. switch (val) { + 3894. case TPACKET_V1: + 3895. > val = sizeof(struct tpacket_hdr); + 3896. break; + 3897. case TPACKET_V2: + +net/packet/af_packet.c:3898: error: DEAD_STORE + The value written to &val (type int) is never used. + 3896. break; + 3897. case TPACKET_V2: + 3898. > val = sizeof(struct tpacket2_hdr); + 3899. break; + 3900. case TPACKET_V3: + +net/packet/af_packet.c:3901: error: DEAD_STORE + The value written to &val (type int) is never used. + 3899. break; + 3900. case TPACKET_V3: + 3901. > val = sizeof(struct tpacket3_hdr); + 3902. break; + 3903. default: + +net/packet/af_packet.c:3908: error: DEAD_STORE + The value written to &val (type int) is never used. + 3906. break; + 3907. case PACKET_RESERVE: + 3908. > val = po->tp_reserve; + 3909. break; + 3910. case PACKET_LOSS: + +net/packet/af_packet.c:3911: error: DEAD_STORE + The value written to &val (type int) is never used. + 3909. break; + 3910. case PACKET_LOSS: + 3911. > val = po->tp_loss; + 3912. break; + 3913. case PACKET_TIMESTAMP: + +net/packet/af_packet.c:3914: error: DEAD_STORE + The value written to &val (type int) is never used. + 3912. break; + 3913. case PACKET_TIMESTAMP: + 3914. > val = po->tp_tstamp; + 3915. break; + 3916. case PACKET_FANOUT: + +net/packet/af_packet.c:3917: error: DEAD_STORE + The value written to &val (type int) is never used. + 3915. break; + 3916. case PACKET_FANOUT: + 3917. > val = (po->fanout ? + 3918. ((u32)po->fanout->id | + 3919. ((u32)po->fanout->type << 16) | + +net/packet/af_packet.c:3933: error: DEAD_STORE + The value written to &val (type int) is never used. + 3931. break; + 3932. case PACKET_TX_HAS_OFF: + 3933. > val = po->tp_tx_has_off; + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + +net/packet/af_packet.c:3936: error: DEAD_STORE + The value written to &val (type int) is never used. + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + 3936. > val = packet_use_direct_xmit(po); + 3937. break; + 3938. default: + +drivers/net/ethernet/intel/e1000/e1000_main.c:3856: error: DEAD_STORE + The value written to &hw (type e1000_hw*) is never used. + 3854. struct e1000_tx_ring *tx_ring) + 3855. { + 3856. > struct e1000_hw *hw = &adapter->hw; + 3857. struct net_device *netdev = adapter->netdev; + 3858. struct e1000_tx_desc *tx_desc, *eop_desc; + +drivers/net/ethernet/intel/e1000/e1000_main.c:3906: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3904. + 3905. #define TX_WAKE_THRESHOLD 32 + 3906. > if (unlikely(count && netif_carrier_ok(netdev) && + 3907. E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) { + 3908. /* Make sure that anybody stopping the queue after this + +drivers/pci/pci.c:3963: error: UNINITIALIZED_VALUE + The value read from cmd_status_dword was never initialized. + 3961. } + 3962. + 3963. > origcmd = cmd_status_dword; + 3964. newcmd = origcmd & ~PCI_COMMAND_INTX_DISABLE; + 3965. if (mask) + +net/core/rtnetlink.c:3947: error: DEAD_STORE + The value written to &err (type int) is never used. + 3945. struct net *net = dev_net(dev); + 3946. struct sk_buff *skb; + 3947. > int err = -EOPNOTSUPP; + 3948. + 3949. if (!dev->netdev_ops->ndo_bridge_getlink) + +drivers/tty/vt/vt.c:3993: error: UNINITIALIZED_VALUE + The value read from colormap.[_] was never initialized. + 3991. console_lock(); + 3992. for (i = k = 0; i < 16; i++) { + 3993. > default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + +drivers/tty/vt/vt.c:3994: error: UNINITIALIZED_VALUE + The value read from colormap.[_] was never initialized. + 3992. for (i = k = 0; i < 16; i++) { + 3993. default_red[i] = colormap[k++]; + 3994. > default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + 3996. } + +drivers/tty/vt/vt.c:3995: error: UNINITIALIZED_VALUE + The value read from colormap.[_] was never initialized. + 3993. default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. > default_blu[i] = colormap[k++]; + 3996. } + 3997. for (i = 0; i < MAX_NR_CONSOLES; i++) { + +net/core/dev.c:4063: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4061. + 4062. txq = netdev_pick_tx(dev, skb, NULL); + 4063. > cpu = smp_processor_id(); + 4064. HARD_TX_LOCK(dev, txq, cpu); + 4065. if (!netif_xmit_stopped(txq)) { + +net/core/dev.c:4063: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4061. + 4062. txq = netdev_pick_tx(dev, skb, NULL); + 4063. > cpu = smp_processor_id(); + 4064. HARD_TX_LOCK(dev, txq, cpu); + 4065. if (!netif_xmit_stopped(txq)) { + +drivers/tty/vt/vt.c:4060: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4058. { + 4059. struct console_font font; + 4060. > int rc = -EINVAL; + 4061. int c; + 4062. + +drivers/gpu/drm/i915/intel_pm.c:4131: error: DEAD_STORE + The value written to &src_h (type unsigned int) is never used. + 4129. if (fb->format->format == DRM_FORMAT_NV12 && !y) { + 4130. src_w /= 2; + 4131. > src_h /= 2; + 4132. } + 4133. + +net/core/dev.c:4143: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4141. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4142. if (cpu < 0) + 4143. > cpu = smp_processor_id(); + 4144. + 4145. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4154: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4152. unsigned int qtail; + 4153. + 4154. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4155. put_cpu(); + 4156. } + +net/core/dev.c:4143: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4141. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4142. if (cpu < 0) + 4143. > cpu = smp_processor_id(); + 4144. + 4145. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4154: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4152. unsigned int qtail; + 4153. + 4154. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4155. put_cpu(); + 4156. } + +drivers/tty/vt/vt.c:4114: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4112. { + 4113. struct console_font font; + 4114. > int rc = -EINVAL; + 4115. int size; + 4116. + +drivers/net/ethernet/intel/e1000/e1000_main.c:4331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4329. rx_ring->next_to_clean = i; + 4330. + 4331. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4332. if (cleaned_count) + 4333. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +drivers/gpu/drm/i915/i915_gem.c:4158: error: DEAD_STORE + The value written to &recent_enough (type unsigned long) is never used. + 4156. struct drm_i915_private *dev_priv = to_i915(dev); + 4157. struct drm_i915_file_private *file_priv = file->driver_priv; + 4158. > unsigned long recent_enough = jiffies - DRM_I915_THROTTLE_JIFFIES; + 4159. struct drm_i915_gem_request *request, *target = NULL; + 4160. long ret; + +kernel/sched/fair.c:4184: error: NULL_DEREFERENCE + pointer `se` last assigned on line 4183 could be null and is dereferenced at line 4184, column 27. + 4182. + 4183. se = __pick_first_entity(cfs_rq); + 4184. > delta = curr->vruntime - se->vruntime; + 4185. + 4186. if (delta < 0) + +net/core/dev.c:4191: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4189. preempt_disable(); + 4190. err = netif_rx_internal(skb); + 4191. > if (local_softirq_pending()) + 4192. do_softirq(); + 4193. preempt_enable(); + +drivers/gpu/drm/i915/intel_pm.c:4274: error: UNINITIALIZED_VALUE + The value read from minimum.[_] was never initialized. + 4272. * result is < available as data_rate / total_data_rate < 1 + 4273. */ + 4274. > plane_blocks = minimum[plane_id]; + 4275. plane_blocks += div_u64((uint64_t)alloc_size * data_rate, + 4276. total_data_rate); + +drivers/gpu/drm/i915/intel_pm.c:4267: error: UNINITIALIZED_VALUE + The value read from plane_data_rate.[_] was never initialized. + 4265. continue; + 4266. + 4267. > data_rate = plane_data_rate[plane_id]; + 4268. + 4269. /* + +drivers/gpu/drm/i915/intel_pm.c:4289: error: UNINITIALIZED_VALUE + The value read from plane_y_data_rate.[_] was never initialized. + 4287. * allocation for y_plane part of planar format: + 4288. */ + 4289. > y_data_rate = plane_y_data_rate[plane_id]; + 4290. + 4291. y_plane_blocks = y_minimum[plane_id]; + +drivers/gpu/drm/i915/intel_pm.c:4291: error: UNINITIALIZED_VALUE + The value read from y_minimum.[_] was never initialized. + 4289. y_data_rate = plane_y_data_rate[plane_id]; + 4290. + 4291. > y_plane_blocks = y_minimum[plane_id]; + 4292. y_plane_blocks += div_u64((uint64_t)alloc_size * y_data_rate, + 4293. total_data_rate); + +net/packet/af_packet.c:4209: error: DEAD_STORE + The value written to &err (type int) is never used. + 4207. struct sk_buff_head *rb_queue; + 4208. __be16 num; + 4209. > int err = -EINVAL; + 4210. /* Added to avoid minimal code churn */ + 4211. struct tpacket_req *req = &req_u->req; + +net/ipv6/route.c:4211: error: DEAD_STORE + The value written to &err (type int) is never used. + 4209. int remaining; + 4210. int attrlen; + 4211. > int err = 1, last_err = 0; + 4212. + 4213. remaining = cfg->fc_mp_len; + +drivers/usb/core/hub.c:4212: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 4210 could be null and is dereferenced by call to `hub_port_disable()` at line 4212, column 9. + 4210. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 4211. + 4212. > return hub_port_disable(hub, udev->portnum, 0); + 4213. } + 4214. + +kernel/workqueue.c:4231: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4229. + 4230. if (cpu == WORK_CPU_UNBOUND) + 4231. > cpu = smp_processor_id(); + 4232. + 4233. if (!(wq->flags & WQ_UNBOUND)) + +kernel/workqueue.c:4231: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4229. + 4230. if (cpu == WORK_CPU_UNBOUND) + 4231. > cpu = smp_processor_id(); + 4232. + 4233. if (!(wq->flags & WQ_UNBOUND)) + +drivers/usb/core/hub.c:4265: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4263. } + 4264. + 4265. > dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n", + 4266. total_time, stable_time, portstatus); + 4267. + +drivers/usb/core/hub.c:4270: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4268. if (stable_time < HUB_DEBOUNCE_STABLE) + 4269. return -ETIMEDOUT; + 4270. > return portstatus; + 4271. } + 4272. + +drivers/net/ethernet/marvell/sky2.c:4282: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 4280. static int sky2_vpd_wait(const struct sky2_hw *hw, int cap, u16 busy) + 4281. { + 4282. > unsigned long start = jiffies; + 4283. + 4284. while ( (sky2_pci_read16(hw, cap + PCI_VPD_ADDR) & PCI_VPD_ADDR_F) == busy) { + +drivers/gpu/drm/i915/intel_display.c:4338: error: UNINITIALIZED_VALUE + The value read from divsel was never initialized. + 4336. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4337. + 4338. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4339. clock, + 4340. auxdiv, + +drivers/gpu/drm/i915/intel_display.c:4338: error: UNINITIALIZED_VALUE + The value read from phaseinc was never initialized. + 4336. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4337. + 4338. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4339. clock, + 4340. auxdiv, + +net/ipv4/tcp_input.c:4346: error: UNINITIALIZED_VALUE + The value read from fragstolen was never initialized. + 4344. __skb_queue_tail(&sk->sk_receive_queue, skb); + 4345. else + 4346. > kfree_skb_partial(skb, fragstolen); + 4347. + 4348. if (unlikely(fin)) { + +kernel/cgroup/cgroup.c:4330: error: NULL_DEREFERENCE + pointer `com_cgrp` last assigned on line 4331 could be null and is dereferenced by call to `cgroup_is_descendant()` at line 4330, column 10. + 4328. + 4329. /* find the common ancestor */ + 4330. > while (!cgroup_is_descendant(dst_cgrp, com_cgrp)) + 4331. com_cgrp = cgroup_parent(com_cgrp); + 4332. + +drivers/net/ethernet/intel/e1000e/netdev.c:4365: error: DEAD_STORE + The value written to &temp (type unsigned long long) is never used. + 4363. temp = time_delta; + 4364. /* VMWare users have seen incvalue of zero, don't div / 0 */ + 4365. > rem = incvalue ? do_div(temp, incvalue) : (time_delta != 0); + 4366. + 4367. systim = systim_next; + +net/core/filter.c:4375: error: DEAD_STORE + The value written to &insn (type bpf_insn*) is never used. + 4373. struct bpf_prog *prog, u32 *target_size) + 4374. { + 4375. > struct bpf_insn *insn = insn_buf; + 4376. + 4377. switch (si->off) { + +net/core/filter.c:4379: error: NULL_DEREFERENCE + pointer `insn` last assigned on line 4379 could be null and is dereferenced at line 4379, column 13. + 4377. switch (si->off) { + 4378. case offsetof(struct __sk_buff, ifindex): + 4379. > *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, dev), + 4380. si->dst_reg, si->src_reg, + 4381. offsetof(struct sk_buff, dev)); + +drivers/net/ethernet/intel/e1000/e1000_main.c:4504: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4502. rx_ring->next_to_clean = i; + 4503. + 4504. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4505. if (cleaned_count) + 4506. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +drivers/md/md.c:4482: error: DEAD_STORE + The value written to &namelen (type unsigned long) is never used. + 4480. mddev->metadata_type[namelen] = 0; + 4481. if (namelen && mddev->metadata_type[namelen-1] == '\n') + 4482. > mddev->metadata_type[--namelen] = 0; + 4483. mddev->persistent = 0; + 4484. mddev->external = 1; + +drivers/gpu/drm/i915/i915_gem.c:4562: error: NULL_DEREFERENCE + pointer `obj->base.filp` last assigned on line 4551 could be null and is dereferenced at line 4562, column 12. + 4560. } + 4561. + 4562. > mapping = obj->base.filp->f_mapping; + 4563. mapping_set_gfp_mask(mapping, mask); + 4564. GEM_BUG_ON(!(mapping_gfp_mask(mapping) & __GFP_RECLAIM)); + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &preferred_lft (type unsigned int) is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &valid_lft (type unsigned int) is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +kernel/workqueue.c:4656: error: DEAD_STORE + The value written to &worker_flags (type unsigned int) is never used. + 4654. WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND)); + 4655. worker_flags |= WORKER_REBOUND; + 4656. > worker_flags &= ~WORKER_UNBOUND; + 4657. WRITE_ONCE(worker->flags, worker_flags); + 4658. } + +drivers/gpu/drm/i915/intel_display.c:4618: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4616. u32 temp; + 4617. + 4618. > temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + +drivers/gpu/drm/i915/intel_display.c:4620: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 4618. temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4621: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4623. } + +drivers/gpu/drm/i915/intel_display.c:4620: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 4618. temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4621: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4623. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4705: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4703. volatile u32 temp; + 4704. + 4705. > temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4706: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4704. + 4705. temp = er32(CRCERRS); + 4706. > temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4707: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4705. temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. > temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4708: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. > temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4709: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. > temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4710: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. > temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4711: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. > temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4712: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. > temp = er32(COLC); + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4713: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. > temp = er32(DC); + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4714: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + 4714. > temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4715: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + 4715. > temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4716: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. > temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4717: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. > temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4718: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. > temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4719: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. > temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + 4721. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4720: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. > temp = er32(FCRUC); + 4721. + 4722. temp = er32(PRC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4722: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4720. temp = er32(FCRUC); + 4721. + 4722. > temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4723: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4721. + 4722. temp = er32(PRC64); + 4723. > temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4724: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4722. temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. > temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4725: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. > temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4726: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. > temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + 4728. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4727: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. > temp = er32(PRC1522); + 4728. + 4729. temp = er32(GPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4729: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4727. temp = er32(PRC1522); + 4728. + 4729. > temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4730: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4728. + 4729. temp = er32(GPRC); + 4730. > temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4731: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4729. temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. > temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4732: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. > temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4733: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. > temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4734: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. > temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4735: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. > temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4736: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. > temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4737: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. > temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4738: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. > temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4739: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. > temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4740: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. > temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4741: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. > temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4742: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. > temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4743: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. > temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4744: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. > temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4745: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. > temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. temp = er32(TPT); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4746: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. > temp = er32(TPR); + 4747. temp = er32(TPT); + 4748. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4747: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. > temp = er32(TPT); + 4748. + 4749. temp = er32(PTC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4749: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4747. temp = er32(TPT); + 4748. + 4749. > temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4750: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4748. + 4749. temp = er32(PTC64); + 4750. > temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4751: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4749. temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. > temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4752: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. > temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4753: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. > temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + 4755. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4754: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. > temp = er32(PTC1522); + 4755. + 4756. temp = er32(MPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4756: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4754. temp = er32(PTC1522); + 4755. + 4756. > temp = er32(MPTC); + 4757. temp = er32(BPTC); + 4758. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4757: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4755. + 4756. temp = er32(MPTC); + 4757. > temp = er32(BPTC); + 4758. + 4759. if (hw->mac_type < e1000_82543) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4762: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4760. return; + 4761. + 4762. > temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4763: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4761. + 4762. temp = er32(ALGNERRC); + 4763. > temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4764: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4762. temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. > temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4765: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. > temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4766: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. > temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + 4768. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4767: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. > temp = er32(TSCTFC); + 4768. + 4769. if (hw->mac_type <= e1000_82544) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4772: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4770. return; + 4771. + 4772. > temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4773: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4771. + 4772. temp = er32(MGTPRC); + 4773. > temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + 4775. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4774: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4772. temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. > temp = er32(MGTPTC); + 4775. } + 4776. + +drivers/pci/quirks.c:4792: error: DEAD_STORE + The value written to &i (type int) is never used. + 4790. pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &cap[i++]); + 4791. pcie_capability_read_word(pdev, PCI_EXP_LNKCTL2, &cap[i++]); + 4792. > pcie_capability_read_word(pdev, PCI_EXP_SLTCTL2, &cap[i++]); + 4793. hlist_add_head(&state->next, &pdev->saved_cap_space); + 4794. } + +kernel/workqueue.c:4736: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4734. + 4735. /* unbinding per-cpu workers should happen on the local CPU */ + 4736. > if (WARN_ON(cpu != smp_processor_id())) + 4737. return -1; + 4738. + +drivers/gpu/drm/i915/i915_gem.c:4780: error: DEAD_STORE + The value written to &kernel_context (type i915_gem_context*) is never used. + 4778. static void assert_kernel_context_is_current(struct drm_i915_private *i915) + 4779. { + 4780. > struct i915_gem_context *kernel_context = i915->kernel_context; + 4781. struct intel_engine_cs *engine; + 4782. enum intel_engine_id id; + +drivers/gpu/drm/i915/intel_dp.c:4944: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 4941 could be null and is dereferenced by call to `intel_dp_mst_encoder_cleanup()` at line 4944, column 2. + 4942. struct intel_dp *intel_dp = &intel_dig_port->dp; + 4943. + 4944. > intel_dp_mst_encoder_cleanup(intel_dig_port); + 4945. if (intel_dp_is_edp(intel_dp)) { + 4946. cancel_delayed_work_sync(&intel_dp->panel_vdd_work); + +drivers/gpu/drm/i915/intel_dp.c:5025: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5025, column 18. + 5023. + 5024. if (!HAS_DDI(dev_priv)) + 5025. > intel_dp->DP = I915_READ(intel_dp->output_reg); + 5026. + 5027. if (lspcon->active) + +drivers/gpu/drm/i915/intel_dp.c:5030: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5030, column 2. + 5028. lspcon_resume(lspcon); + 5029. + 5030. > intel_dp->reset_link_params = true; + 5031. + 5032. pps_lock(intel_dp); + +drivers/iommu/intel-iommu.c:5095: error: DEAD_STORE + The value written to &iommu (type intel_iommu*) is never used. + 5093. + 5094. for_each_domain_iommu(iommu_id, dmar_domain) { + 5095. > iommu = g_iommus[iommu_id]; + 5096. + 5097. iommu_flush_iotlb_psi(g_iommus[iommu_id], dmar_domain, + +drivers/ata/libata-core.c:5126: error: NULL_DEREFERENCE + pointer `qc` last assigned on line 5125 could be null and is dereferenced at line 5126, column 2. + 5124. + 5125. qc = __ata_qc_from_tag(ap, tag); + 5126. > qc->tag = tag; + 5127. qc->scsicmd = NULL; + 5128. qc->ap = ap; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:5141: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 5139. * stability + 5140. */ + 5141. > ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); + 5142. if (!link) + 5143. return 0; + +kernel/events/core.c:5253: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5251. goto aux_unlock; + 5252. + 5253. > aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5254. aux_size = READ_ONCE(rb->user_page->aux_size); + 5255. + +kernel/events/core.c:5254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5252. + 5253. aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5254. > aux_size = READ_ONCE(rb->user_page->aux_size); + 5255. + 5256. if (aux_offset < perf_data_size(rb) + PAGE_SIZE) + +kernel/cgroup/cgroup.c:5219: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5218 could be null and is dereferenced at line 5219, column 3. + 5217. + 5218. for_each_subsys(ss, i) { + 5219. > WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id, + 5220. "invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p id:name=%d:%s\n", + 5221. i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free, + +kernel/trace/trace.c:5245: error: DEAD_STORE + The value written to &ret (type int) is never used. + 5243. unsigned long size, int cpu_id) + 5244. { + 5245. > int ret = size; + 5246. + 5247. mutex_lock(&trace_types_lock); + +net/core/dev.c:5370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5368. + 5369. do { + 5370. > val = READ_ONCE(n->state); + 5371. if (unlikely(val & NAPIF_STATE_DISABLE)) + 5372. return false; + +drivers/md/md.c:5402: error: UNINITIALIZED_VALUE + The value read from buf.[_] was never initialized. + 5400. return md_alloc(0, buf); + 5401. if (strncmp(buf, "md", 2) == 0 && + 5402. > isdigit(buf[2]) && + 5403. kstrtoul(buf+2, 10, &devnum) == 0 && + 5404. devnum <= MINORMASK) + +net/core/dev.c:5435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5433. + 5434. do { + 5435. > val = READ_ONCE(n->state); + 5436. + 5437. WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED)); + +kernel/cgroup/cgroup.c:5495: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5492 could be null and is dereferenced at line 5495, column 7. + 5493. if (j >= i) + 5494. break; + 5495. > if (ss->cancel_fork) + 5496. ss->cancel_fork(child); + 5497. } + +drivers/gpu/drm/i915/intel_dp.c:5500: error: DEAD_STORE + The value written to &encoder (type intel_encoder*) is never used. + 5498. + 5499. dig_port = dp_to_dig_port(intel_dp); + 5500. > encoder = &dig_port->base; + 5501. + 5502. if (!intel_crtc) { + +kernel/sched/core.c:5505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5503. struct mm_struct *mm = current->active_mm; + 5504. + 5505. > BUG_ON(cpu_online(smp_processor_id())); + 5506. + 5507. if (mm != &init_mm) { + +kernel/sched/core.c:5505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5503. struct mm_struct *mm = current->active_mm; + 5504. + 5505. > BUG_ON(cpu_online(smp_processor_id())); + 5506. + 5507. if (mm != &init_mm) { + +net/core/dev.c:5528: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5526. local_bh_disable(); + 5527. if (!napi_poll) { + 5528. > unsigned long val = READ_ONCE(napi->state); + 5529. + 5530. /* If multiple threads are competing for this napi, + +kernel/sched/fair.c:5513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5511. return; + 5512. + 5513. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), 0); + 5514. } + 5515. + +kernel/cgroup/cgroup.c:5515: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5514 could be null and is dereferenced at line 5515, column 7. + 5513. + 5514. for_each_subsys(ss, i) + 5515. > if (ss->cancel_fork) + 5516. ss->cancel_fork(child); + 5517. } + +kernel/sched/fair.c:5539: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5537. void cpu_load_update_nohz_stop(void) + 5538. { + 5539. > unsigned long curr_jiffies = READ_ONCE(jiffies); + 5540. struct rq *this_rq = this_rq(); + 5541. unsigned long load; + +kernel/sched/fair.c:5576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5574. + 5575. if (tick_nohz_tick_stopped()) + 5576. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), load); + 5577. else + 5578. cpu_load_update_periodic(this_rq, load); + +kernel/sched/fair.c:5627: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5625. { + 5626. struct rq *rq = cpu_rq(cpu); + 5627. > unsigned long nr_running = READ_ONCE(rq->cfs.h_nr_running); + 5628. unsigned long load_avg = weighted_cpuload(rq); + 5629. + +drivers/gpu/drm/i915/intel_pm.c:5657: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 5655. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5656. + 5657. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5658. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5659. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +drivers/gpu/drm/i915/intel_pm.c:5657: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 5655. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5656. + 5657. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5658. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5659. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +kernel/events/core.c:5661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5659. + 5660. if (sample_type & PERF_SAMPLE_CPU) { + 5661. > data->cpu_entry.cpu = raw_smp_processor_id(); + 5662. data->cpu_entry.reserved = 0; + 5663. } + +kernel/cgroup/cgroup.c:5648: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5647 could be null and is dereferenced at line 5648, column 22. + 5646. + 5647. for_each_subsys(ss, i) { + 5648. > if (strcmp(token, ss->name) && + 5649. strcmp(token, ss->legacy_name)) + 5650. continue; + +drivers/usb/core/hub.c:5674: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5659 could be null and is dereferenced at line 5674, column 13. + 5672. } + 5673. + 5674. > port_dev = hub->ports[udev->portnum - 1]; + 5675. + 5676. /* + +kernel/workqueue.c:5678: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5676. + 5677. list_for_each_entry(wq, &workqueues, list) { + 5678. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5679. WARN(init_rescuer(wq), + 5680. "workqueue: failed to create early rescuer for %s", + +kernel/workqueue.c:5678: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5676. + 5677. list_for_each_entry(wq, &workqueues, list) { + 5678. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5679. WARN(init_rescuer(wq), + 5680. "workqueue: failed to create early rescuer for %s", + +kernel/sched/fair.c:5674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5672. unsigned int master = current->wakee_flips; + 5673. unsigned int slave = p->wakee_flips; + 5674. > int factor = this_cpu_read(sd_llc_size); + 5675. + 5676. if (master < slave) + +kernel/sched/fair.c:5674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5672. unsigned int master = current->wakee_flips; + 5673. unsigned int slave = p->wakee_flips; + 5674. > int factor = this_cpu_read(sd_llc_size); + 5675. + 5676. if (master < slave) + +net/core/dev.c:5751: error: DEAD_STORE + The value written to &time_limit (type unsigned long) is never used. + 5749. { + 5750. struct softnet_data *sd = this_cpu_ptr(&softnet_data); + 5751. > unsigned long time_limit = jiffies + + 5752. usecs_to_jiffies(netdev_budget_usecs); + 5753. int budget = netdev_budget; + +net/wireless/nl80211.c:5803: error: UNINITIALIZED_VALUE + The value read from cur_params.auto_open_plinks was never initialized. + 5801. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5802. cur_params.element_ttl) || + 5803. > nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5804. cur_params.auto_open_plinks) || + 5805. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + +net/wireless/nl80211.c:5841: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshAwakeWindowDuration was never initialized. + 5839. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5840. cur_params.power_mode) || + 5841. > nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5842. cur_params.dot11MeshAwakeWindowDuration) || + 5843. nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + +net/wireless/nl80211.c:5791: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshConfirmTimeout was never initialized. + 5789. nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5790. cur_params.dot11MeshRetryTimeout) || + 5791. > nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5792. cur_params.dot11MeshConfirmTimeout) || + 5793. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + +net/wireless/nl80211.c:5827: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshForwarding was never initialized. + 5825. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5826. cur_params.dot11MeshGateAnnouncementProtocol) || + 5827. > nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5828. cur_params.dot11MeshForwarding) || + 5829. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + +net/wireless/nl80211.c:5825: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshGateAnnouncementProtocol was never initialized. + 5823. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5824. cur_params.dot11MeshHWMPRannInterval) || + 5825. > nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5826. cur_params.dot11MeshGateAnnouncementProtocol) || + 5827. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + +net/wireless/nl80211.c:5823: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRannInterval was never initialized. + 5821. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5822. cur_params.dot11MeshHWMPRootMode) || + 5823. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5824. cur_params.dot11MeshHWMPRannInterval) || + 5825. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + +net/wireless/nl80211.c:5821: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRootMode was never initialized. + 5819. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5820. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5821. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5822. cur_params.dot11MeshHWMPRootMode) || + 5823. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + +net/wireless/nl80211.c:5813: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathTimeout was never initialized. + 5811. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5812. cur_params.min_discovery_timeout) || + 5813. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5814. cur_params.dot11MeshHWMPactivePathTimeout) || + 5815. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + +net/wireless/nl80211.c:5833: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathToRootTimeout was never initialized. + 5831. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5832. cur_params.ht_opmode) || + 5833. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5834. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5835. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + +net/wireless/nl80211.c:5837: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPconfirmationInterval was never initialized. + 5835. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5836. cur_params.dot11MeshHWMProotInterval) || + 5837. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5838. cur_params.dot11MeshHWMPconfirmationInterval) || + 5839. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + +net/wireless/nl80211.c:5807: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPmaxPREQretries was never initialized. + 5805. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5806. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5807. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5808. cur_params.dot11MeshHWMPmaxPREQretries) || + 5809. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + +net/wireless/nl80211.c:5819: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPnetDiameterTraversalTime was never initialized. + 5817. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5818. cur_params.dot11MeshHWMPperrMinInterval) || + 5819. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5820. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5821. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + +net/wireless/nl80211.c:5817: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPperrMinInterval was never initialized. + 5815. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5816. cur_params.dot11MeshHWMPpreqMinInterval) || + 5817. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5818. cur_params.dot11MeshHWMPperrMinInterval) || + 5819. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + +net/wireless/nl80211.c:5815: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPpreqMinInterval was never initialized. + 5813. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5814. cur_params.dot11MeshHWMPactivePathTimeout) || + 5815. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5816. cur_params.dot11MeshHWMPpreqMinInterval) || + 5817. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + +net/wireless/nl80211.c:5835: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMProotInterval was never initialized. + 5833. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5834. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5835. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5836. cur_params.dot11MeshHWMProotInterval) || + 5837. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + +net/wireless/nl80211.c:5793: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHoldingTimeout was never initialized. + 5791. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5792. cur_params.dot11MeshConfirmTimeout) || + 5793. > nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5794. cur_params.dot11MeshHoldingTimeout) || + 5795. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + +net/wireless/nl80211.c:5795: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxPeerLinks was never initialized. + 5793. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5794. cur_params.dot11MeshHoldingTimeout) || + 5795. > nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5796. cur_params.dot11MeshMaxPeerLinks) || + 5797. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + +net/wireless/nl80211.c:5797: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxRetries was never initialized. + 5795. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5796. cur_params.dot11MeshMaxPeerLinks) || + 5797. > nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5798. cur_params.dot11MeshMaxRetries) || + 5799. nla_put_u8(msg, NL80211_MESHCONF_TTL, + +net/wireless/nl80211.c:5805: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshNbrOffsetMaxNeighbor was never initialized. + 5803. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5804. cur_params.auto_open_plinks) || + 5805. > nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5806. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5807. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + +net/wireless/nl80211.c:5789: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshRetryTimeout was never initialized. + 5787. goto nla_put_failure; + 5788. if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || + 5789. > nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5790. cur_params.dot11MeshRetryTimeout) || + 5791. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + +net/wireless/nl80211.c:5799: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshTTL was never initialized. + 5797. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5798. cur_params.dot11MeshMaxRetries) || + 5799. > nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5800. cur_params.dot11MeshTTL) || + 5801. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + +net/wireless/nl80211.c:5801: error: UNINITIALIZED_VALUE + The value read from cur_params.element_ttl was never initialized. + 5799. nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5800. cur_params.dot11MeshTTL) || + 5801. > nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5802. cur_params.element_ttl) || + 5803. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + +net/wireless/nl80211.c:5831: error: UNINITIALIZED_VALUE + The value read from cur_params.ht_opmode was never initialized. + 5829. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5830. cur_params.rssi_threshold) || + 5831. > nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5832. cur_params.ht_opmode) || + 5833. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + +net/wireless/nl80211.c:5811: error: UNINITIALIZED_VALUE + The value read from cur_params.min_discovery_timeout was never initialized. + 5809. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5810. cur_params.path_refresh_time) || + 5811. > nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5812. cur_params.min_discovery_timeout) || + 5813. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + +net/wireless/nl80211.c:5809: error: UNINITIALIZED_VALUE + The value read from cur_params.path_refresh_time was never initialized. + 5807. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5808. cur_params.dot11MeshHWMPmaxPREQretries) || + 5809. > nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5810. cur_params.path_refresh_time) || + 5811. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + +net/wireless/nl80211.c:5843: error: UNINITIALIZED_VALUE + The value read from cur_params.plink_timeout was never initialized. + 5841. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5842. cur_params.dot11MeshAwakeWindowDuration) || + 5843. > nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + 5844. cur_params.plink_timeout)) + 5845. goto nla_put_failure; + +net/wireless/nl80211.c:5839: error: UNINITIALIZED_VALUE + The value read from cur_params.power_mode was never initialized. + 5837. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5838. cur_params.dot11MeshHWMPconfirmationInterval) || + 5839. > nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5840. cur_params.power_mode) || + 5841. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + +net/wireless/nl80211.c:5829: error: UNINITIALIZED_VALUE + The value read from cur_params.rssi_threshold was never initialized. + 5827. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5828. cur_params.dot11MeshForwarding) || + 5829. > nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5830. cur_params.rssi_threshold) || + 5831. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + +kernel/sched/fair.c:5756: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5754. int prev_cpu, int sync) + 5755. { + 5756. > int this_cpu = smp_processor_id(); + 5757. int target = nr_cpumask_bits; + 5758. + +kernel/sched/fair.c:5756: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5754. int prev_cpu, int sync) + 5755. { + 5756. > int this_cpu = smp_processor_id(); + 5757. int target = nr_cpumask_bits; + 5758. + +drivers/usb/core/hub.c:5795: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5791 could be null and is dereferenced at line 5795, column 9. + 5793. if (port1 < 1 || port1 > hdev->maxchild) + 5794. return NULL; + 5795. > return hub->ports[port1 - 1]->child; + 5796. } + 5797. EXPORT_SYMBOL_GPL(usb_hub_find_child); + +drivers/net/ethernet/broadcom/tg3.c:5990: error: UNINITIALIZED_VALUE + The value read from local_adv was never initialized. + 5988. fiber_setup_done: + 5989. if (current_link_up && current_duplex == DUPLEX_FULL) + 5990. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5991. + 5992. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +drivers/net/ethernet/broadcom/tg3.c:5990: error: UNINITIALIZED_VALUE + The value read from remote_adv was never initialized. + 5988. fiber_setup_done: + 5989. if (current_link_up && current_duplex == DUPLEX_FULL) + 5990. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5991. + 5992. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +kernel/sched/core.c:5862: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5860. static int __init migration_init(void) + 5861. { + 5862. > sched_rq_cpu_starting(smp_processor_id()); + 5863. return 0; + 5864. } + +kernel/sched/core.c:5862: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5860. static int __init migration_init(void) + 5861. { + 5862. > sched_rq_cpu_starting(smp_processor_id()); + 5863. return 0; + 5864. } + +kernel/sched/core.c:5918: error: DEAD_STORE + The value written to &ptr (type unsigned long) is never used. + 5916. + 5917. root_task_group.cfs_rq = (struct cfs_rq **)ptr; + 5918. > ptr += nr_cpu_ids * sizeof(void **); + 5919. + 5920. #endif /* CONFIG_FAIR_GROUP_SCHED */ + +kernel/sched/core.c:6049: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6047. * when this runqueue becomes "idle". + 6048. */ + 6049. > init_idle(current, smp_processor_id()); + 6050. + 6051. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:6055: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6053. #ifdef CONFIG_SMP + 6054. idle_thread_set_boot_cpu(); + 6055. > set_cpu_rq_start_time(smp_processor_id()); + 6056. #endif + 6057. init_sched_fair_class(); + +kernel/sched/core.c:6049: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6047. * when this runqueue becomes "idle". + 6048. */ + 6049. > init_idle(current, smp_processor_id()); + 6050. + 6051. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:6055: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6053. #ifdef CONFIG_SMP + 6054. idle_thread_set_boot_cpu(); + 6055. > set_cpu_rq_start_time(smp_processor_id()); + 6056. #endif + 6057. init_sched_fair_class(); + +kernel/cgroup/cgroup.c:5913: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5912 could be null and is dereferenced at line 5913, column 33. + 5911. + 5912. for_each_subsys(ss, ssid) + 5913. > ret += show_delegatable_files(ss->dfl_cftypes, buf + ret, + 5914. PAGE_SIZE - ret, + 5915. cgroup_subsys_name[ssid]); + +drivers/gpu/drm/i915/intel_pm.c:5976: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5974. I915_WRITE(MEMMODECTL, rgvmodectl); + 5975. + 5976. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5977. DRM_ERROR("stuck trying to change perf mode\n"); + 5978. mdelay(1); + +drivers/gpu/drm/i915/intel_pm.c:5976: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5974. I915_WRITE(MEMMODECTL, rgvmodectl); + 5975. + 5976. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5977. DRM_ERROR("stuck trying to change perf mode\n"); + 5978. mdelay(1); + +security/selinux/hooks.c:6040: error: DEAD_STORE + The value written to &error (type int) is never used. + 6038. + 6039. /* Only allow single threaded processes to change context */ + 6040. > error = -EPERM; + 6041. if (!current_is_single_threaded()) { + 6042. error = security_bounded_transition(tsec->sid, sid); + +kernel/sched/fair.c:6033: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6031. sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6032. if (sds) + 6033. > return READ_ONCE(sds->has_idle_cores); + 6034. + 6035. return def; + +drivers/md/md.c:6284: error: UNINITIALIZED_VALUE + The value read from info.number was never initialized. + 6282. + 6283. rcu_read_lock(); + 6284. > rdev = md_find_rdev_nr_rcu(mddev, info.number); + 6285. if (rdev) { + 6286. info.major = MAJOR(rdev->bdev->bd_dev); + +drivers/net/ethernet/intel/e1000e/netdev.c:6420: error: DEAD_STORE + The value written to &retval (type int) is never used. + 6418. lpi_ctrl |= I82579_LPI_CTRL_1000_ENABLE; + 6419. + 6420. > retval = e1e_wphy_locked(hw, I82579_LPI_CTRL, + 6421. lpi_ctrl); + 6422. } + +kernel/sched/fair.c:6342: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6340. { + 6341. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6342. > int cpu = smp_processor_id(); + 6343. int new_cpu = prev_cpu; + 6344. int want_affine = 0; + +kernel/sched/fair.c:6342: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6340. { + 6341. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6342. > int cpu = smp_processor_id(); + 6343. int new_cpu = prev_cpu; + 6344. int want_affine = 0; + +kernel/sched/core.c:6399: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6397 could be null and is dereferenced by call to `sched_offline_group()` at line 6399, column 2. + 6397. struct task_group *tg = css_tg(css); + 6398. + 6399. > sched_offline_group(tg); + 6400. } + 6401. + +kernel/events/core.c:6434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6432. cpu = iter->cpu; + 6433. if (cpu == -1) + 6434. > cpu = READ_ONCE(iter->oncpu); + 6435. + 6436. if (cpu == -1) + +kernel/sched/core.c:6485: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6483 could be null and is dereferenced at line 6485, column 15. + 6483. struct task_group *tg = css_tg(css); + 6484. + 6485. > return (u64) scale_load_down(tg->shares); + 6486. } + 6487. + +drivers/net/ethernet/broadcom/tg3.c:6619: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6617. if (unlikely(netif_tx_queue_stopped(txq) && + 6618. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6619. > __netif_tx_lock(txq, smp_processor_id()); + 6620. if (netif_tx_queue_stopped(txq) && + 6621. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +drivers/net/ethernet/broadcom/tg3.c:6619: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6617. if (unlikely(netif_tx_queue_stopped(txq) && + 6618. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6619. > __netif_tx_lock(txq, smp_processor_id()); + 6620. if (netif_tx_queue_stopped(txq) && + 6621. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +kernel/sched/core.c:6831: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6830 could be null and is dereferenced at line 6831, column 15. + 6829. { + 6830. struct task_group *tg = css_tg(css); + 6831. > u64 weight = scale_load_down(tg->shares); + 6832. + 6833. return DIV_ROUND_CLOSEST_ULL(weight * CGROUP_WEIGHT_DFL, 1024); + +drivers/ata/libata-core.c:7104: error: DEAD_STORE + The value written to &deadline (type unsigned long) is never used. + 7102. * eat away the timeout. + 7103. */ + 7104. > deadline = ata_deadline(jiffies, timeout); + 7105. + 7106. while ((tmp & mask) == val && time_before(jiffies, deadline)) { + +drivers/ata/libata-core.c:7128: error: DEAD_STORE + The value written to &lpm_timeout (type unsigned long) is never used. + 7126. bool sata_lpm_ignore_phy_events(struct ata_link *link) + 7127. { + 7128. > unsigned long lpm_timeout = link->last_lpm_change + + 7129. msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY); + 7130. + +kernel/events/core.c:7343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7341. u64 seq; + 7342. + 7343. > seq = __this_cpu_read(perf_throttled_seq); + 7344. if (seq != hwc->interrupts_seq) { + 7345. hwc->interrupts_seq = seq; + +kernel/events/core.c:7352: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7350. && hwc->interrupts >= max_samples_per_tick)) { + 7351. __this_cpu_inc(perf_throttled_count); + 7352. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7353. hwc->interrupts = MAX_INTERRUPTS; + 7354. perf_log_throttle(event, 0); + +kernel/events/core.c:7343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7341. u64 seq; + 7342. + 7343. > seq = __this_cpu_read(perf_throttled_seq); + 7344. if (seq != hwc->interrupts_seq) { + 7345. hwc->interrupts_seq = seq; + +kernel/events/core.c:7352: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7350. && hwc->interrupts >= max_samples_per_tick)) { + 7351. __this_cpu_inc(perf_throttled_count); + 7352. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7353. hwc->interrupts = MAX_INTERRUPTS; + 7354. perf_log_throttle(event, 0); + +drivers/gpu/drm/i915/intel_display.c:7480: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7478. + 7479. if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) { + 7480. > offset = I915_READ(DSPOFFSET(i9xx_plane)); + 7481. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + +drivers/gpu/drm/i915/intel_display.c:7484: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + 7483. if (plane_config->tiling) + 7484. > offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. offset = I915_READ(DSPLINOFF(i9xx_plane)); + +drivers/gpu/drm/i915/intel_display.c:7486: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7484. offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. > offset = I915_READ(DSPLINOFF(i9xx_plane)); + 7487. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7488. } else { + +net/wireless/nl80211.c:7487: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced at line 7487, column 11. + 7485. */ + 7486. if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) { + 7487. > while (!sched_scan_req->reqid) + 7488. sched_scan_req->reqid = rdev->wiphy.cookie_counter++; + 7489. } + +net/wireless/nl80211.c:7491: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced by call to `rdev_sched_scan_start()` at line 7491, column 8. + 7489. } + 7490. + 7491. > err = rdev_sched_scan_start(rdev, dev, sched_scan_req); + 7492. if (err) + 7493. goto out_free; + +kernel/sched/fair.c:7577: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7575. * we read them once before doing sanity checks on them. + 7576. */ + 7577. > age_stamp = READ_ONCE(rq->age_stamp); + 7578. avg = READ_ONCE(rq->rt_avg); + 7579. delta = __rq_clock_broken(rq) - age_stamp; + +kernel/sched/fair.c:7578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7576. */ + 7577. age_stamp = READ_ONCE(rq->age_stamp); + 7578. > avg = READ_ONCE(rq->rt_avg); + 7579. delta = __rq_clock_broken(rq) - age_stamp; + 7580. + +drivers/md/md.c:7750: error: DEAD_STORE + The value written to &l (type long long) is never used. + 7748. } + 7749. spin_unlock(&all_mddevs_lock); + 7750. > if (!l--) + 7751. return (void*)2;/* tail */ + 7752. return NULL; + +drivers/gpu/drm/i915/intel_display.c:7835: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/net/ethernet/broadcom/tg3.c:8153: error: DEAD_STORE + The value written to &i (type int) is never used. + 8151. + 8152. dma_error: + 8153. > tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, --i); + 8154. tnapi->tx_buffers[tnapi->tx_prod].skb = NULL; + 8155. drop: + +net/core/dev.c:8049: error: DEAD_STORE + The value written to &rebroadcast_time (type unsigned long) is never used. + 8047. linkwatch_forget_dev(dev); + 8048. + 8049. > rebroadcast_time = warning_time = jiffies; + 8050. refcnt = netdev_refcnt_read(dev); + 8051. + +net/core/dev.c:8087: error: DEAD_STORE + The value written to &warning_time (type unsigned long) is never used. + 8085. pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n", + 8086. dev->name, refcnt); + 8087. > warning_time = jiffies; + 8088. } + 8089. } + +kernel/trace/trace.c:8197: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8195. break; + 8196. case DUMP_ORIG: + 8197. > iter.cpu_file = raw_smp_processor_id(); + 8198. break; + 8199. case DUMP_NONE: + +kernel/trace/trace.c:8197: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8195. break; + 8196. case DUMP_ORIG: + 8197. > iter.cpu_file = raw_smp_processor_id(); + 8198. break; + 8199. case DUMP_NONE: + +drivers/gpu/drm/i915/intel_display.c:8540: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 8538. plane_config->base = base; + 8539. + 8540. > offset = I915_READ(PLANE_OFFSET(pipe, plane_id)); + 8541. + 8542. val = I915_READ(PLANE_SIZE(pipe, plane_id)); + +net/core/dev.c:8562: error: DEAD_STORE + The value written to &err (type int) is never used. + 8560. + 8561. /* And unlink it from device chain */ + 8562. > err = -ENODEV; + 8563. unlist_netdevice(dev); + 8564. + +net/core/dev.c:8640: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8638. + 8639. local_irq_disable(); + 8640. > cpu = smp_processor_id(); + 8641. sd = &per_cpu(softnet_data, cpu); + 8642. oldsd = &per_cpu(softnet_data, oldcpu); + +net/core/dev.c:8640: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8638. + 8639. local_irq_disable(); + 8640. > cpu = smp_processor_id(); + 8641. sd = &per_cpu(softnet_data, cpu); + 8642. oldsd = &per_cpu(softnet_data, oldcpu); + +drivers/gpu/drm/i915/intel_display.c:8765: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8784: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8782. ndelay(100); + 8783. + 8784. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8785. 1)) + 8786. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8784: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 8782. ndelay(100); + 8783. + 8784. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8785. 1)) + 8786. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +kernel/sched/fair.c:8781: error: DEAD_STORE + The value written to &next_balance (type unsigned long) is never used. + 8779. static int idle_balance(struct rq *this_rq, struct rq_flags *rf) + 8780. { + 8781. > unsigned long next_balance = jiffies + HZ; + 8782. int this_cpu = this_rq->cpu; + 8783. struct sched_domain *sd; + +drivers/gpu/drm/i915/intel_display.c:8841: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +kernel/events/core.c:8886: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8884. static int perf_pmu_commit_txn(struct pmu *pmu) + 8885. { + 8886. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8887. + 8888. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8886: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8884. static int perf_pmu_commit_txn(struct pmu *pmu) + 8885. { + 8886. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8887. + 8888. __this_cpu_write(nop_txn_flags, 0); + +kernel/sched/fair.c:8915: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8913. + 8914. /* make sure the requested cpu hasn't gone down in the meantime */ + 8915. > if (unlikely(busiest_cpu != smp_processor_id() || + 8916. !busiest_rq->active_balance)) + 8917. goto out_unlock; + +kernel/events/core.c:8899: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8897. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8898. { + 8899. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8900. + 8901. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8899: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8897. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8898. { + 8899. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8900. + 8901. __this_cpu_write(nop_txn_flags, 0); + +drivers/md/md.c:9014: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9012. "unacknowledged_bad_blocks"); + 9013. sysfs_notify_dirent_safe(rdev->sysfs_state); + 9014. > set_mask_bits(&mddev->sb_flags, 0, + 9015. BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING)); + 9016. md_wakeup_thread(rdev->mddev->thread); + +kernel/sched/fair.c:9053: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9051. { + 9052. struct sched_domain *sd; + 9053. > int cpu = smp_processor_id(); + 9054. + 9055. rcu_read_lock(); + +kernel/sched/fair.c:9053: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9051. { + 9052. struct sched_domain *sd; + 9053. > int cpu = smp_processor_id(); + 9054. + 9055. rcu_read_lock(); + +kernel/sched/fair.c:9070: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9068. { + 9069. struct sched_domain *sd; + 9070. > int cpu = smp_processor_id(); + 9071. + 9072. rcu_read_lock(); + +kernel/sched/fair.c:9070: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9068. { + 9069. struct sched_domain *sd; + 9070. > int cpu = smp_processor_id(); + 9071. + 9072. rcu_read_lock(); + +drivers/md/md.c:9161: error: DEAD_STORE + The value written to &ret (type int) is never used. + 9159. if (rdev2->raid_disk == -1 && role != 0xffff) { + 9160. rdev2->saved_raid_disk = role; + 9161. > ret = remove_and_add_spares(mddev, rdev2); + 9162. pr_info("Activated spare: %s\n", + 9163. bdevname(rdev2->bdev,b)); + +kernel/sched/fair.c:9134: error: DEAD_STORE + The value written to &continue_balancing (type int) is never used. + 9132. static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle) + 9133. { + 9134. > int continue_balancing = 1; + 9135. int cpu = rq->cpu; + 9136. unsigned long interval; + +drivers/gpu/drm/i915/intel_pm.c:9249: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/gpu/drm/i915/intel_pm.c:9249: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9249: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/gpu/drm/i915/intel_display.c:9260: error: NULL_DEREFERENCE + pointer `obj` last assigned on line 9256 could be null and is dereferenced at line 9260, column 10. + 9258. + 9259. if (INTEL_INFO(dev_priv)->cursor_needs_physical) + 9260. > base = obj->phys_handle->busaddr; + 9261. else + 9262. base = intel_plane_ggtt_offset(plane_state); + +kernel/sched/fair.c:9312: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 9310. static inline bool nohz_kick_needed(struct rq *rq) + 9311. { + 9312. > unsigned long now = jiffies; + 9313. struct sched_domain_shared *sds; + 9314. struct sched_domain *sd; + +drivers/gpu/drm/i915/intel_pm.c:9381: error: DEAD_STORE + The value written to &loop (type int) is never used. + 9379. _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH)); + 9380. upper = I915_READ_FW(reg); + 9381. > } while (upper != tmp && --loop); + 9382. + 9383. /* Everywhere else we always use VLV_COUNTER_CONTROL with the + +drivers/gpu/drm/i915/intel_display.c:10082: error: UNINITIALIZED_VALUE + The value read from pipe was never initialized. + 10080. return NULL; + 10081. + 10082. > crtc = intel_get_crtc_for_pipe(dev_priv, pipe); + 10083. + 10084. mode = kzalloc(sizeof(*mode), GFP_KERNEL); + +drivers/net/ethernet/broadcom/tg3.c:10778: error: DEAD_STORE + The value written to &off (type unsigned int) is never used. + 10776. + 10777. tg3_ape_scratchpad_read(tp, (u32 *) ocir, off, len); + 10778. > off += len; + 10779. + 10780. if (ocir->signature != TG3_OCIR_SIG_MAGIC || + +kernel/events/core.c:11198: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11196. perf_pmu_register(&perf_task_clock, NULL, -1); + 11197. perf_tp_register(); + 11198. > perf_event_init_cpu(smp_processor_id()); + 11199. register_reboot_notifier(&perf_reboot_notifier); + 11200. + +kernel/events/core.c:11198: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11196. perf_pmu_register(&perf_task_clock, NULL, -1); + 11197. perf_tp_register(); + 11198. > perf_event_init_cpu(smp_processor_id()); + 11199. register_reboot_notifier(&perf_reboot_notifier); + 11200. + +drivers/net/ethernet/broadcom/tg3.c:12197: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 12196 could be null and is dereferenced by call to `phy_ethtool_ksettings_set()` at line 12197, column 10. + 12195. return -EAGAIN; + 12196. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 12197. > return phy_ethtool_ksettings_set(phydev, cmd); + 12198. } + 12199. + +drivers/gpu/drm/i915/intel_display.c:12320: error: UNINITIALIZED_VALUE + The value read from put_domains.[_] was never initialized. + 12318. + 12319. if (put_domains[i]) + 12320. > modeset_put_power_domains(dev_priv, put_domains[i]); + 12321. + 12322. intel_modeset_verify_crtc(crtc, state, old_crtc_state, new_crtc_state); + +drivers/net/ethernet/broadcom/tg3.c:12980: error: UNINITIALIZED_VALUE + The value read from data.[_] was never initialized. + 12978. err = -EIO; + 12979. for (i = 0; i < NVRAM_SELFBOOT_DATA_SIZE; i++) { + 12980. > u8 hw8 = hweight8(data[i]); + 12981. + 12982. if ((hw8 & 0x1) && parity[i]) + +net/wireless/nl80211.c:14334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 14332. struct sk_buff *msg; + 14333. void *hdr; + 14334. > u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid); + 14335. + 14336. if (!nlportid) + +drivers/gpu/drm/i915/intel_display.c:15182: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 15180. + 15181. if (ret) + 15182. > DRM_ERROR("Restoring old state failed with %i\n", ret); + 15183. if (state) + 15184. drm_atomic_state_put(state); + +Summary of the reports + + UNINITIALIZED_VALUE: 2778 + DEAD_STORE: 886 + NULL_DEREFERENCE: 209 + MEMORY_LEAK: 11 + RESOURCE_LEAK: 9 + SHELL_INJECTION: 8 \ No newline at end of file diff --git a/infer/results/v416/infer0140/defconfig/inferdefconfig b/infer/results/v416/infer0140/defconfig/inferdefconfig new file mode 100644 index 0000000..a4c81c6 --- /dev/null +++ b/infer/results/v416/infer0140/defconfig/inferdefconfig @@ -0,0 +1,13 @@ +{"skip-analysis-in-path": [ +"linux/arch/x86/entry/vdso", +"linux/arch/x86/boot", +"linux/arch/x86/kernel", +"linux/arch/x86/mm", +"linux/arch/x86/boot/compressed", +"linux/drivers/acpi", +"linux/kernel/bpf", +"linux/mm", +"linux/fs", +"linux/net/mac80211" +] +} diff --git a/infer/results/v416/infer0150/defconfig/bugs.txt b/infer/results/v416/infer0150/defconfig/bugs.txt new file mode 100644 index 0000000..09a60db --- /dev/null +++ b/infer/results/v416/infer0150/defconfig/bugs.txt @@ -0,0 +1,46368 @@ +Found 5795 issues + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +net/netfilter/utils.c:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. break; + 18. case AF_INET6: + 19. > v6ops = rcu_dereference(nf_ipv6_ops); + 20. if (v6ops) + 21. csum = v6ops->checksum(skb, hook, dataoff, protocol); + +include/linux/netfilter_ingress.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. return false; + 14. #endif + 15. > return rcu_access_pointer(skb->dev->nf_hooks_ingress); + 16. } + 17. + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +arch/x86/include/asm/current.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. static __always_inline struct task_struct *get_current(void) + 14. { + 15. > return this_cpu_read_stable(current_task); + 16. } + 17. + +block/blk-lib.c:19: error: NULL_DEREFERENCE + pointer `new` last assigned on line 16 could be null and is dereferenced by call to `bio_chain()` at line 19, column 3. + 17. + 18. if (bio) { + 19. > bio_chain(bio, new); + 20. submit_bio(bio); + 21. } + +block/ioctl.c:146: error: UNINITIALIZED_VALUE + The value read from p.length was never initialized. + 144. disk_part_iter_exit(&piter); + 145. part_nr_sects_write(part, (sector_t)length); + 146. > i_size_write(bdevp->bd_inode, p.length); + 147. mutex_unlock(&bdevp->bd_mutex); + 148. mutex_unlock(&bdev->bd_mutex); + +block/ioctl.c:33: error: UNINITIALIZED_VALUE + The value read from p.pno was never initialized. + 31. if (bdev != bdev->bd_contains) + 32. return -EINVAL; + 33. > partno = p.pno; + 34. if (partno <= 0) + 35. return -EINVAL; + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +net/ipv4/tcp_fastopen.c:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. + 18. rcu_read_lock(); + 19. > ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx); + 20. if (ctxt) { + 21. rcu_read_unlock(); + +tools/include/asm-generic/bitops/fls.h:36: error: DEAD_STORE + The value written to &x (type int) is never used. + 34. } + 35. if (!(x & 0x80000000u)) { + 36. > x <<= 1; + 37. r -= 1; + 38. } + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +block/blk-merge.c:50: error: DEAD_STORE + The value written to &tmp (type unsigned long) is never used. + 48. + 49. tmp = bio->bi_iter.bi_sector + split_sectors - alignment; + 50. > tmp = sector_div(tmp, granularity); + 51. + 52. if (split_sectors > tmp) + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +kernel/sched/stats.c:46: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 44. /* domain-specific stats */ + 45. rcu_read_lock(); + 46. > for_each_domain(cpu, sd) { + 47. enum cpu_idle_type itype; + 48. + +net/core/net-procfs.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. + 23. h = &net->dev_name_head[get_bucket(*pos)]; + 24. > hlist_for_each_entry_rcu(dev, h, name_hlist) { + 25. if (++count == offset) + 26. return dev; + +tools/lib/subcmd/help.c:20: error: NULL_DEREFERENCE + pointer `ent` last assigned on line 18 could be null and is dereferenced at line 20, column 2. + 18. struct cmdname *ent = malloc(sizeof(*ent) + len + 1); + 19. + 20. > ent->len = len; + 21. memcpy(ent->name, name, len); + 22. ent->name[len] = 0; + +arch/x86/include/asm/irq_regs.h:19: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 17. static inline struct pt_regs *get_irq_regs(void) + 18. { + 19. > return this_cpu_read(irq_regs); + 20. } + 21. + +arch/x86/include/asm/irq_regs.h:19: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 17. static inline struct pt_regs *get_irq_regs(void) + 18. { + 19. > return this_cpu_read(irq_regs); + 20. } + 21. + +drivers/input/input-compat.c:30: error: UNINITIALIZED_VALUE + The value read from compat_event.code was never initialized. + 28. event->input_event_usec = compat_event.usec; + 29. event->type = compat_event.type; + 30. > event->code = compat_event.code; + 31. event->value = compat_event.value; + 32. + +drivers/input/input-compat.c:27: error: UNINITIALIZED_VALUE + The value read from compat_event.sec was never initialized. + 25. return -EFAULT; + 26. + 27. > event->input_event_sec = compat_event.sec; + 28. event->input_event_usec = compat_event.usec; + 29. event->type = compat_event.type; + +drivers/input/input-compat.c:29: error: UNINITIALIZED_VALUE + The value read from compat_event.type was never initialized. + 27. event->input_event_sec = compat_event.sec; + 28. event->input_event_usec = compat_event.usec; + 29. > event->type = compat_event.type; + 30. event->code = compat_event.code; + 31. event->value = compat_event.value; + +drivers/input/input-compat.c:28: error: UNINITIALIZED_VALUE + The value read from compat_event.usec was never initialized. + 26. + 27. event->input_event_sec = compat_event.sec; + 28. > event->input_event_usec = compat_event.usec; + 29. event->type = compat_event.type; + 30. event->code = compat_event.code; + +drivers/input/input-compat.c:31: error: UNINITIALIZED_VALUE + The value read from compat_event.value was never initialized. + 29. event->type = compat_event.type; + 30. event->code = compat_event.code; + 31. > event->value = compat_event.value; + 32. + 33. } else { + +lib/list_sort.c:27: error: MEMORY_LEAK + `tail->next` is not reachable after line 27, column 4. + 25. /* if equal, take 'a' -- important for sort stability */ + 26. if ((*cmp)(priv, a, b) <= 0) { + 27. > tail->next = a; + 28. a = a->next; + 29. } else { + +lib/list_sort.c:30: error: MEMORY_LEAK + `tail->next` is not reachable after line 30, column 4. + 28. a = a->next; + 29. } else { + 30. > tail->next = b; + 31. b = b->next; + 32. } + +lib/list_sort.c:35: error: MEMORY_LEAK + `tail->next` is not reachable after line 35, column 2. + 33. tail = tail->next; + 34. } + 35. > tail->next = a?:b; + 36. return head.next; + 37. } + +lib/list_sort.c:36: error: UNINITIALIZED_VALUE + The value read from head.next was never initialized. + 34. } + 35. tail->next = a?:b; + 36. > return head.next; + 37. } + 38. + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +lib/dynamic_queue_limits.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. bool all_prev_completed; + 23. + 24. > num_queued = READ_ONCE(dql->num_queued); + 25. + 26. /* Can't complete more than what's in queue */ + +include/linux/netfilter_ingress.h:21: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 19. static inline int nf_hook_ingress(struct sk_buff *skb) + 20. { + 21. > struct nf_hook_entries *e = rcu_dereference(skb->dev->nf_hooks_ingress); + 22. struct nf_hook_state state; + 23. int ret; + +lib/is_single_threaded.c:34: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 32. ret = false; + 33. rcu_read_lock(); + 34. > for_each_process(p) { + 35. if (unlikely(p->flags & PF_KTHREAD)) + 36. continue; + +lib/is_single_threaded.c:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. continue; + 39. + 40. > for_each_thread(p, t) { + 41. if (unlikely(t->mm == mm)) + 42. goto found; + +sound/hda/trace.h:19: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +arch/x86/include/asm/atomic64_64.h:22: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 20. static inline long atomic64_read(const atomic64_t *v) + 21. { + 22. > return READ_ONCE((v)->counter); + 23. } + 24. + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +net/ipv4/tcp_ulp.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. struct tcp_ulp_ops *e; + 23. + 24. > list_for_each_entry_rcu(e, &tcp_ulp_list, list) { + 25. if (strcmp(e->name, name) == 0) + 26. return e; + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +block/noop-iosched.c:26: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 24. struct request *rq; + 25. + 26. > rq = list_first_entry_or_null(&nd->queue, struct request, queuelist); + 27. if (rq) { + 28. list_del_init(&rq->queuelist); + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +drivers/tty/tty_port.c:30: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 28. struct tty_ldisc *disc; + 29. + 30. > tty = READ_ONCE(port->itty); + 31. if (!tty) + 32. return 0; + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +lib/assoc_array.c:101: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr const *) is never used. + 99. if (assoc_array_ptr_is_shortcut(parent)) { + 100. shortcut = assoc_array_ptr_to_shortcut(parent); + 101. > cursor = parent; + 102. parent = READ_ONCE(shortcut->back_pointer); /* Address dependency. */ + 103. slot = shortcut->parent_slot; + +lib/assoc_array.c:41: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 39. /* Descend through a shortcut */ + 40. shortcut = assoc_array_ptr_to_shortcut(cursor); + 41. > cursor = READ_ONCE(shortcut->next_node); /* Address dependency. */ + 42. } + 43. + +lib/assoc_array.c:56: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 54. has_meta = 0; + 55. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 56. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 57. has_meta |= (unsigned long)ptr; + 58. if (ptr && assoc_array_ptr_is_leaf(ptr)) { + +lib/assoc_array.c:85: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 83. node = assoc_array_ptr_to_node(cursor); + 84. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 85. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 86. if (assoc_array_ptr_is_meta(ptr)) { + 87. cursor = ptr; + +lib/assoc_array.c:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. finished_node: + 93. /* Move up to the parent (may need to skip back over a shortcut) */ + 94. > parent = READ_ONCE(node->back_pointer); /* Address dependency. */ + 95. slot = node->parent_slot; + 96. if (parent == stop) + +lib/assoc_array.c:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. shortcut = assoc_array_ptr_to_shortcut(parent); + 101. cursor = parent; + 102. > parent = READ_ONCE(shortcut->back_pointer); /* Address dependency. */ + 103. slot = shortcut->parent_slot; + 104. if (parent == stop) + +net/ipv4/tcp_cong.c:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. struct tcp_congestion_ops *e; + 26. + 27. > list_for_each_entry_rcu(e, &tcp_cong_list, list) { + 28. if (strcmp(e->name, name) == 0) + 29. return e; + +net/ipv6/ip6_offload.c:32: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 30. + 31. if (proto != NEXTHDR_HOP) { + 32. > ops = rcu_dereference(inet6_offloads[proto]); + 33. + 34. if (unlikely(!ops)) + +net/netfilter/nf_conntrack_extend.c:30: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 28. for (i = 0; i < NF_CT_EXT_NUM; i++) { + 29. rcu_read_lock(); + 30. > t = rcu_dereference(nf_ct_ext_types[i]); + 31. + 32. /* Here the nf_ct_ext_type might have been unregisterd. + +tools/include/tools/be_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val >> 8; + 26. > *p++ = val; + 27. } + 28. + +tools/include/tools/le_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val; + 26. > *p++ = val >> 8; + 27. } + 28. + +drivers/dma-buf/seqno-fence.c:28: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 26 could be null and is dereferenced at line 28, column 9. + 26. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 27. + 28. > return seqno_fence->ops->get_driver_name(fence); + 29. } + 30. + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +arch/x86/include/asm/atomic.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. static __always_inline int atomic_read(const atomic_t *v) + 26. { + 27. > return READ_ONCE((v)->counter); + 28. } + 29. + +arch/x86/include/asm/preempt.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. + 30. do { + 31. > old = raw_cpu_read_4(__preempt_count); + 32. new = (old & PREEMPT_NEED_RESCHED) | + 33. (pc & ~PREEMPT_NEED_RESCHED); + +security/selinux/ss/conditional.c:80: error: UNINITIALIZED_VALUE + The value read from s[_] was never initialized. + 78. } + 79. } + 80. > return s[0]; + 81. } + 82. + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/pci/proc.c:100: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 98. pci_user_read_config_byte(dev, pos, &val); + 99. __put_user(val, buf); + 100. > buf++; + 101. pos++; + 102. cnt--; + +drivers/pci/proc.c:102: error: DEAD_STORE + The value written to &cnt (type unsigned int) is never used. + 100. buf++; + 101. pos++; + 102. > cnt--; + 103. } + 104. + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +kernel/task_work.c:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. + 32. do { + 33. > head = READ_ONCE(task->task_works); + 34. if (unlikely(head == &work_exited)) + 35. return -ESRCH; + +kernel/time/tick-oneshot.c:29: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 27. int tick_program_event(ktime_t expires, int force) + 28. { + 29. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 30. + 31. if (unlikely(expires == KTIME_MAX)) { + +kernel/time/tick-oneshot.c:29: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 27. int tick_program_event(ktime_t expires, int force) + 28. { + 29. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 30. + 31. if (unlikely(expires == KTIME_MAX)) { + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +include/net/netfilter/nf_conntrack_timeout.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. struct ctnl_timeout *timeout; + 32. + 33. > timeout = rcu_dereference(t->timeout); + 34. if (timeout == NULL) + 35. return NULL; + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +lib/ratelimit.c:42: error: DEAD_STORE + The value written to &flags (type unsigned long) is never used. + 40. * the entity that is holding the lock already: + 41. */ + 42. > if (!raw_spin_trylock_irqsave(&rs->lock, flags)) + 43. return 0; + 44. + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +block/partitions/amiga.c:36: error: DEAD_STORE + The value written to &blksize (type int) is never used. + 34. struct PartitionBlock *pb; + 35. int start_sect, nr_sects, blk, part, res = 0; + 36. > int blksize = 1; /* Multiplier for disk block size */ + 37. int slot = 1; + 38. char b[BDEVNAME_SIZE]; + +block/partitions/amiga.c:123: error: UNINITIALIZED_VALUE + The value read from dostype[_] was never initialized. + 121. *dt = pb->pb_Environment[16]; + 122. if (dostype[3] < ' ') + 123. > snprintf(tmp, sizeof(tmp), " (%c%c%c^%c)", + 124. dostype[0], dostype[1], + 125. dostype[2], dostype[3] + '@' ); + +block/partitions/amiga.c:127: error: UNINITIALIZED_VALUE + The value read from dostype[_] was never initialized. + 125. dostype[2], dostype[3] + '@' ); + 126. else + 127. > snprintf(tmp, sizeof(tmp), " (%c%c%c%c)", + 128. dostype[0], dostype[1], + 129. dostype[2], dostype[3]); + +drivers/pci/setup-res.c:121: error: UNINITIALIZED_VALUE + The value read from cmd was never initialized. + 119. + 120. if (disable) + 121. > pci_write_config_word(dev, PCI_COMMAND, cmd); + 122. } + 123. + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +kernel/irq_work.c:40: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 38. for (;;) { + 39. nflags = flags | IRQ_WORK_CLAIMED; + 40. > oflags = cmpxchg(&work->flags, flags, nflags); + 41. if (oflags == flags) + 42. break; + +net/core/fib_notifier.c:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. for_each_net(net) { + 37. rcu_read_lock(); + 38. > list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) { + 39. if (!try_module_get(ops->owner)) + 40. continue; + +net/netfilter/utils.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. break; + 41. case AF_INET6: + 42. > v6ops = rcu_dereference(nf_ipv6_ops); + 43. if (v6ops) + 44. csum = v6ops->checksum_partial(skb, hook, dataoff, len, + +tools/lib/subcmd/run-command.c:96: error: UNINITIALIZED_VALUE + The value read from fderr[_] was never initialized. + 94. dup_devnull(2); + 95. else if (need_err) { + 96. > dup2(fderr[1], 2); + 97. close_pair(fderr); + 98. } + +tools/lib/subcmd/run-command.c:161: error: UNINITIALIZED_VALUE + The value read from fderr[_] was never initialized. + 159. + 160. if (need_err) + 161. > close(fderr[1]); + 162. + 163. return 0; + +tools/lib/subcmd/run-command.c:86: error: UNINITIALIZED_VALUE + The value read from fdin[_] was never initialized. + 84. dup_devnull(0); + 85. else if (need_in) { + 86. > dup2(fdin[0], 0); + 87. close_pair(fdin); + 88. } else if (cmd->in) { + +tools/lib/subcmd/run-command.c:151: error: UNINITIALIZED_VALUE + The value read from fdin[_] was never initialized. + 149. + 150. if (need_in) + 151. > close(fdin[0]); + 152. else if (cmd->in) + 153. close(cmd->in); + +tools/lib/subcmd/run-command.c:105: error: UNINITIALIZED_VALUE + The value read from fdout[_] was never initialized. + 103. dup2(2, 1); + 104. else if (need_out) { + 105. > dup2(fdout[1], 1); + 106. close_pair(fdout); + 107. } else if (cmd->out > 1) { + +tools/lib/subcmd/run-command.c:156: error: UNINITIALIZED_VALUE + The value read from fdout[_] was never initialized. + 154. + 155. if (need_out) + 156. > close(fdout[1]); + 157. else if (cmd->out) + 158. close(cmd->out); + +kernel/locking/qrwlock.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. * without waiting in the queue. + 41. */ + 42. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 43. return; + 44. } + +kernel/locking/qrwlock.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. * section in the case that the lock is currently held for write. + 57. */ + 58. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 59. + 60. /* + +lib/zlib_inflate/inffast.c:38: error: UNINITIALIZED_VALUE + The value read from mm.us was never initialized. + 36. mm.b[0] = b[0]; + 37. mm.b[1] = b[1]; + 38. > return mm.us; + 39. } + 40. + +net/core/stream.c:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. + 38. rcu_read_lock(); + 39. > wq = rcu_dereference(sk->sk_wq); + 40. if (skwq_has_sleeper(wq)) + 41. wake_up_interruptible_poll(&wq->wait, EPOLLOUT | + +tools/objtool/warn.h:48: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 48, column 3. + 46. + 47. if (func) + 48. > sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. sprintf(str, "%s+0x%lx", name, name_off); + +tools/objtool/warn.h:50: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 50, column 3. + 48. sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. > sprintf(str, "%s+0x%lx", name, name_off); + 51. + 52. return str; + +drivers/dma-buf/seqno-fence.c:35: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 33 could be null and is dereferenced at line 35, column 9. + 33. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 34. + 35. > return seqno_fence->ops->get_timeline_name(fence); + 36. } + 37. + +drivers/edac/edac_pci.c:40: error: DEAD_STORE + The value written to &pci (type edac_pci_ctl_info*) is never used. + 38. edac_dbg(1, "\n"); + 39. + 40. > pci = edac_align_ptr(&p, sizeof(*pci), 1); + 41. pvt = edac_align_ptr(&p, 1, sz_pvt); + 42. size = ((unsigned long)pvt) + sz_pvt; + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +kernel/power/process.c:44: error: DEAD_STORE + The value written to &end_time (type unsigned long) is never used. + 42. start = ktime_get_boottime(); + 43. + 44. > end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs); + 45. + 46. if (!user_only) + +kernel/power/process.c:40: error: DEAD_STORE + The value written to &sleep_usecs (type int) is never used. + 38. unsigned int elapsed_msecs; + 39. bool wakeup = false; + 40. > int sleep_usecs = USEC_PER_MSEC; + 41. + 42. start = ktime_get_boottime(); + +kernel/power/process.c:81: error: DEAD_STORE + The value written to &sleep_usecs (type int) is never used. + 79. usleep_range(sleep_usecs / 2, sleep_usecs); + 80. if (sleep_usecs < 8 * USEC_PER_MSEC) + 81. > sleep_usecs *= 2; + 82. } + 83. + +kernel/power/process.c:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. todo = 0; + 51. read_lock(&tasklist_lock); + 52. > for_each_process_thread(g, p) { + 53. if (p == current || !freeze_task(p)) + 54. continue; + +kernel/power/process.c:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. if (!wakeup) { + 100. read_lock(&tasklist_lock); + 101. > for_each_process_thread(g, p) { + 102. if (p != current && !freezer_should_skip(p) + 103. && freezing(p) && !frozen(p)) + +kernel/tsacct.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. stats->ac_pid = task_pid_nr_ns(tsk, pid_ns); + 63. rcu_read_lock(); + 64. > tcred = __task_cred(tsk); + 65. stats->ac_uid = from_kuid_munged(user_ns, tcred->uid); + 66. stats->ac_gid = from_kgid_munged(user_ns, tcred->gid); + +kernel/tsacct.c:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. stats->ac_gid = from_kgid_munged(user_ns, tcred->gid); + 67. stats->ac_ppid = pid_alive(tsk) ? + 68. > task_tgid_nr_ns(rcu_dereference(tsk->real_parent), pid_ns) : 0; + 69. rcu_read_unlock(); + 70. + +net/ipv6/inet6_connection_sock.c:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. fl6->daddr = ireq->ir_v6_rmt_addr; + 44. rcu_read_lock(); + 45. > final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final); + 46. rcu_read_unlock(); + 47. fl6->saddr = ireq->ir_v6_loc_addr; + +sound/hda/trace.h:31: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +net/ipv4/tcp_ulp.c:36: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 34. struct tcp_ulp_ops *e; + 35. + 36. > list_for_each_entry_rcu(e, &tcp_ulp_list, list) { + 37. if (e->uid == ulp) + 38. return e; + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +drivers/base/module.c:62: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 60. + 61. /* Don't check return codes; these calls are idempotent */ + 62. > no_warn = sysfs_create_link(&drv->p->kobj, &mk->kobj, "module"); + 63. driver_name = make_driver_name(drv); + 64. if (driver_name) { + +drivers/base/module.c:66: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 64. if (driver_name) { + 65. module_create_drivers_dir(mk); + 66. > no_warn = sysfs_create_link(mk->drivers_dir, &drv->p->kobj, + 67. driver_name); + 68. kfree(driver_name); + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +kernel/compat.c:57: error: UNINITIALIZED_VALUE + The value read from tx32.calcnt was never initialized. + 55. txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + 57. > txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + 59. txc->stbcnt = tx32.stbcnt; + +kernel/compat.c:46: error: UNINITIALIZED_VALUE + The value read from tx32.constant was never initialized. + 44. txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + 46. > txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + 48. txc->tolerance = tx32.tolerance; + +kernel/compat.c:58: error: UNINITIALIZED_VALUE + The value read from tx32.errcnt was never initialized. + 56. txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + 58. > txc->errcnt = tx32.errcnt; + 59. txc->stbcnt = tx32.stbcnt; + 60. + +kernel/compat.c:44: error: UNINITIALIZED_VALUE + The value read from tx32.esterror was never initialized. + 42. txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + 44. > txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + 46. txc->constant = tx32.constant; + +kernel/compat.c:42: error: UNINITIALIZED_VALUE + The value read from tx32.freq was never initialized. + 40. txc->modes = tx32.modes; + 41. txc->offset = tx32.offset; + 42. > txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + +kernel/compat.c:56: error: UNINITIALIZED_VALUE + The value read from tx32.jitcnt was never initialized. + 54. txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + 56. > txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + +kernel/compat.c:53: error: UNINITIALIZED_VALUE + The value read from tx32.jitter was never initialized. + 51. txc->tick = tx32.tick; + 52. txc->ppsfreq = tx32.ppsfreq; + 53. > txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + +kernel/compat.c:43: error: UNINITIALIZED_VALUE + The value read from tx32.maxerror was never initialized. + 41. txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + 43. > txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + +kernel/compat.c:40: error: UNINITIALIZED_VALUE + The value read from tx32.modes was never initialized. + 38. return -EFAULT; + 39. + 40. > txc->modes = tx32.modes; + 41. txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + +kernel/compat.c:41: error: UNINITIALIZED_VALUE + The value read from tx32.offset was never initialized. + 39. + 40. txc->modes = tx32.modes; + 41. > txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + +kernel/compat.c:52: error: UNINITIALIZED_VALUE + The value read from tx32.ppsfreq was never initialized. + 50. txc->time.tv_usec = tx32.time.tv_usec; + 51. txc->tick = tx32.tick; + 52. > txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + +kernel/compat.c:47: error: UNINITIALIZED_VALUE + The value read from tx32.precision was never initialized. + 45. txc->status = tx32.status; + 46. txc->constant = tx32.constant; + 47. > txc->precision = tx32.precision; + 48. txc->tolerance = tx32.tolerance; + 49. txc->time.tv_sec = tx32.time.tv_sec; + +kernel/compat.c:54: error: UNINITIALIZED_VALUE + The value read from tx32.shift was never initialized. + 52. txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + 54. > txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + +kernel/compat.c:55: error: UNINITIALIZED_VALUE + The value read from tx32.stabil was never initialized. + 53. txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + 55. > txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + +kernel/compat.c:45: error: UNINITIALIZED_VALUE + The value read from tx32.status was never initialized. + 43. txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + 45. > txc->status = tx32.status; + 46. txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + +kernel/compat.c:59: error: UNINITIALIZED_VALUE + The value read from tx32.stbcnt was never initialized. + 57. txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + 59. > txc->stbcnt = tx32.stbcnt; + 60. + 61. return 0; + +kernel/compat.c:51: error: UNINITIALIZED_VALUE + The value read from tx32.tick was never initialized. + 49. txc->time.tv_sec = tx32.time.tv_sec; + 50. txc->time.tv_usec = tx32.time.tv_usec; + 51. > txc->tick = tx32.tick; + 52. txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + +kernel/compat.c:48: error: UNINITIALIZED_VALUE + The value read from tx32.tolerance was never initialized. + 46. txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + 48. > txc->tolerance = tx32.tolerance; + 49. txc->time.tv_sec = tx32.time.tv_sec; + 50. txc->time.tv_usec = tx32.time.tv_usec; + +security/integrity/iint.c:51: error: UNINITIALIZED_VALUE + The value read from iint was never initialized. + 49. return NULL; + 50. + 51. > return iint; + 52. } + 53. + +net/ipv6/ip6_icmp.c:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. + 38. rcu_read_lock(); + 39. > send = rcu_dereference(ip6_icmp_send); + 40. + 41. if (!send) + +net/netfilter/nf_queue.c:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. { + 36. /* should never happen, we only have one queueing backend in kernel */ + 37. > WARN_ON(rcu_access_pointer(net->nf.queue_handler)); + 38. rcu_assign_pointer(net->nf.queue_handler, qh); + 39. } + +block/ioprio.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. + 41. rcu_read_lock(); + 42. > tcred = __task_cred(task); + 43. if (!uid_eq(tcred->uid, cred->euid) && + 44. !uid_eq(tcred->uid, cred->uid) && !capable(CAP_SYS_NICE)) { + +drivers/scsi/scsi_debugfs.c:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. int alloc_ms = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc); + 39. int timeout_ms = jiffies_to_msecs(rq->timeout); + 40. > const u8 *const cdb = READ_ONCE(cmd->cmnd); + 41. char buf[80] = "(?)"; + 42. + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +init/calibrate.c:138: error: UNINITIALIZED_VALUE + The value read from measured_times[_] was never initialized. + 136. if ((measured_times[max] - estimate) < + 137. (estimate - measured_times[min])) { + 138. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 139. "min bogoMips estimate %d = %lu\n", + 140. min, measured_times[min]); + +init/calibrate.c:144: error: UNINITIALIZED_VALUE + The value read from measured_times[_] was never initialized. + 142. min = max; + 143. } else { + 144. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 145. "max bogoMips estimate %d = %lu\n", + 146. max, measured_times[max]); + +net/compat.c:58: error: UNINITIALIZED_VALUE + The value read from msg.msg_control was never initialized. + 56. kmsg->msg_namelen = sizeof(struct sockaddr_storage); + 57. + 58. > kmsg->msg_control = compat_ptr(msg.msg_control); + 59. kmsg->msg_controllen = msg.msg_controllen; + 60. + +net/compat.c:59: error: UNINITIALIZED_VALUE + The value read from msg.msg_controllen was never initialized. + 57. + 58. kmsg->msg_control = compat_ptr(msg.msg_control); + 59. > kmsg->msg_controllen = msg.msg_controllen; + 60. + 61. if (save_addr) + +net/compat.c:46: error: UNINITIALIZED_VALUE + The value read from msg.msg_flags was never initialized. + 44. return -EFAULT; + 45. + 46. > kmsg->msg_flags = msg.msg_flags; + 47. kmsg->msg_namelen = msg.msg_namelen; + 48. + +net/compat.c:83: error: UNINITIALIZED_VALUE + The value read from msg.msg_iov was never initialized. + 81. + 82. return compat_import_iovec(save_addr ? READ : WRITE, + 83. > compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + 85. } + +net/compat.c:82: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 80. kmsg->msg_iocb = NULL; + 81. + 82. > return compat_import_iovec(save_addr ? READ : WRITE, + 83. compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + +net/compat.c:62: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 60. + 61. if (save_addr) + 62. > *save_addr = compat_ptr(msg.msg_name); + 63. + 64. if (msg.msg_name && kmsg->msg_namelen) { + +net/compat.c:66: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 64. if (msg.msg_name && kmsg->msg_namelen) { + 65. if (!save_addr) { + 66. > err = move_addr_to_kernel(compat_ptr(msg.msg_name), + 67. kmsg->msg_namelen, + 68. kmsg->msg_name); + +net/compat.c:47: error: UNINITIALIZED_VALUE + The value read from msg.msg_namelen was never initialized. + 45. + 46. kmsg->msg_flags = msg.msg_flags; + 47. > kmsg->msg_namelen = msg.msg_namelen; + 48. + 49. if (!msg.msg_name) + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +lib/mpi/mpi-pow.c:56: error: DEAD_STORE + The value written to &esign (type int) is never used. + 54. msize = mod->nlimbs; + 55. size = 2 * msize; + 56. > esign = exp->sign; + 57. msign = mod->sign; + 58. + +drivers/dma-buf/seqno-fence.c:42: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 40 could be null and is dereferenced at line 42, column 9. + 40. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 41. + 42. > return seqno_fence->ops->enable_signaling(fence); + 43. } + 44. + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +ipc/compat.c:45: error: UNINITIALIZED_VALUE + The value read from v.gid was never initialized. + 43. return -EFAULT; + 44. to->uid = v.uid; + 45. > to->gid = v.gid; + 46. to->mode = v.mode; + 47. return 0; + +ipc/compat.c:46: error: UNINITIALIZED_VALUE + The value read from v.mode was never initialized. + 44. to->uid = v.uid; + 45. to->gid = v.gid; + 46. > to->mode = v.mode; + 47. return 0; + 48. } + +ipc/compat.c:44: error: UNINITIALIZED_VALUE + The value read from v.uid was never initialized. + 42. if (copy_from_user(&v, from, sizeof(v))) + 43. return -EFAULT; + 44. > to->uid = v.uid; + 45. to->gid = v.gid; + 46. to->mode = v.mode; + +kernel/irq/spurious.c:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. bool irq_wait_for_poll(struct irq_desc *desc) + 39. { + 40. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 41. "irq poll in progress on cpu %d for irq %d\n", + 42. smp_processor_id(), desc->irq_data.irq)) + +kernel/irq/spurious.c:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. bool irq_wait_for_poll(struct irq_desc *desc) + 39. { + 40. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 41. "irq poll in progress on cpu %d for irq %d\n", + 42. smp_processor_id(), desc->irq_data.irq)) + +lib/llist.c:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. + 43. do { + 44. > new_last->next = first = READ_ONCE(head->first); + 45. } while (cmpxchg(&head->first, first, new_first) != first); + 46. + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +include/net/netns/generic.h:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. + 44. rcu_read_lock(); + 45. > ng = rcu_dereference(net->gen); + 46. ptr = ng->ptr[id]; + 47. rcu_read_unlock(); + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +kernel/smpboot.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. void __init idle_thread_set_boot_cpu(void) + 40. { + 41. > per_cpu(idle_threads, smp_processor_id()) = current; + 42. } + 43. + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/percpu-rwsem.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. * release in percpu_up_write(). + 63. */ + 64. > if (likely(!smp_load_acquire(&sem->readers_block))) + 65. return 1; + 66. + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +drivers/clk/clk-gate.c:46: error: DEAD_STORE + The value written to &flags (type unsigned long) is never used. + 44. struct clk_gate *gate = to_clk_gate(hw); + 45. int set = gate->flags & CLK_GATE_SET_TO_DISABLE ? 1 : 0; + 46. > unsigned long uninitialized_var(flags); + 47. u32 reg; + 48. + +net/netfilter/nf_conntrack_extend.c:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. + 62. rcu_read_lock(); + 63. > t = rcu_dereference(nf_ct_ext_types[id]); + 64. if (!t) { + 65. rcu_read_unlock(); + +sound/hda/trace.h:43: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +lib/genalloc.c:54: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 52. return -EBUSY; + 53. cpu_relax(); + 54. > } while ((nval = cmpxchg(addr, val, val | mask_to_set)) != val); + 55. + 56. return 0; + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +drivers/dma-buf/seqno-fence.c:49: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 47 could be null and is dereferenced at line 49, column 9. + 47. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 48. + 49. > return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence); + 50. } + 51. + +drivers/usb/core/otg_whitelist.h:47: error: DEAD_STORE + The value written to &id (type usb_device_id*) is never used. + 45. static int is_targeted(struct usb_device *dev) + 46. { + 47. > struct usb_device_id *id = whitelist_table; + 48. + 49. /* HNP test device is _never_ targeted (see OTG spec 6.6.6) */ + +kernel/time/tick-broadcast-hrtimer.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. if (bc_moved) { + 70. /* Bind the "device" to the cpu */ + 71. > bc->bound_on = smp_processor_id(); + 72. } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + +kernel/time/tick-broadcast-hrtimer.c:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. /* Bind the "device" to the cpu */ + 71. bc->bound_on = smp_processor_id(); + 72. > } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + 74. } + +kernel/time/tick-broadcast-hrtimer.c:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. if (bc_moved) { + 70. /* Bind the "device" to the cpu */ + 71. > bc->bound_on = smp_processor_id(); + 72. } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + +net/netfilter/nf_nat_core.c:48: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 46. __nf_nat_l3proto_find(u8 family) + 47. { + 48. > return rcu_dereference(nf_nat_l3protos[family]); + 49. } + 50. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +lib/list_sort.c:58: error: MEMORY_LEAK + `tail->next` is not reachable after line 58, column 4. + 56. /* if equal, take 'a' -- important for sort stability */ + 57. if ((*cmp)(priv, a, b) <= 0) { + 58. > tail->next = a; + 59. a->prev = tail; + 60. a = a->next; + +lib/list_sort.c:62: error: MEMORY_LEAK + `tail->next` is not reachable after line 62, column 4. + 60. a = a->next; + 61. } else { + 62. > tail->next = b; + 63. b->prev = tail; + 64. b = b->next; + +net/sunrpc/sunrpc.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. int loopback = 0; + 50. rcu_read_lock(); + 51. > dst = rcu_dereference(sk->sk_dst_cache); + 52. if (dst && dst->dev && + 53. (dst->dev->features & NETIF_F_LOOPBACK)) + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +kernel/power/user.c:79: error: DEAD_STORE + The value written to &nr_calls (type int) is never used. + 77. error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls); + 78. if (error) + 79. > __pm_notifier_call_chain(PM_POST_HIBERNATION, --nr_calls, NULL); + 80. } else { + 81. /* + +drivers/gpu/drm/i915/i915_ioc32.c:59: error: UNINITIALIZED_VALUE + The value read from req32.param was never initialized. + 57. request = compat_alloc_user_space(sizeof(*request)); + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. > || __put_user(req32.param, &request->param) + 60. || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + +drivers/gpu/drm/i915/i915_ioc32.c:60: error: UNINITIALIZED_VALUE + The value read from req32.value was never initialized. + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. || __put_user(req32.param, &request->param) + 60. > || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + 62. return -EFAULT; + +drivers/usb/core/message.c:64: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 62. if (!wait_for_completion_timeout(&ctx.done, expire)) { + 63. usb_kill_urb(urb); + 64. > retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status); + 65. + 66. dev_dbg(&urb->dev->dev, + +drivers/usb/core/message.c:74: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 72. urb->transfer_buffer_length); + 73. } else + 74. > retval = ctx.status; + 75. out: + 76. if (actual_length) + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +kernel/sched/membarrier.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. * iteration. + 85. */ + 86. > if (cpu == raw_smp_processor_id()) + 87. continue; + 88. rcu_read_lock(); + +net/ipv4/xfrm4_protocol.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. return 0; + 57. + 58. > for_each_protocol_rcu(*head, handler) + 59. if ((ret = handler->cb_handler(skb, err)) <= 0) + 60. return ret; + +net/ipv6/xfrm6_protocol.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. return 0; + 57. + 58. > for_each_protocol_rcu(*proto_handlers(protocol), handler) + 59. if ((ret = handler->cb_handler(skb, err)) <= 0) + 60. return ret; + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +block/blk-stat.c:67: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 65. + 66. rcu_read_lock(); + 67. > list_for_each_entry_rcu(cb, &q->stats->callbacks, list) { + 68. if (!blk_stat_is_active(cb)) + 69. continue; + +drivers/edac/edac_device.c:78: error: DEAD_STORE + The value written to &dev_ctl (type edac_device_ctl_info*) is never used. + 76. */ + 77. p = NULL; + 78. > dev_ctl = edac_align_ptr(&p, sizeof(*dev_ctl), 1); + 79. + 80. /* Calc the 'end' offset past end of ONE ctl_info structure + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +ipc/compat.c:57: error: UNINITIALIZED_VALUE + The value read from v.gid was never initialized. + 55. return -EFAULT; + 56. to->uid = v.uid; + 57. > to->gid = v.gid; + 58. to->mode = v.mode; + 59. return 0; + +ipc/compat.c:58: error: UNINITIALIZED_VALUE + The value read from v.mode was never initialized. + 56. to->uid = v.uid; + 57. to->gid = v.gid; + 58. > to->mode = v.mode; + 59. return 0; + 60. } + +ipc/compat.c:56: error: UNINITIALIZED_VALUE + The value read from v.uid was never initialized. + 54. if (copy_from_user(&v, from, sizeof(v))) + 55. return -EFAULT; + 56. > to->uid = v.uid; + 57. to->gid = v.gid; + 58. to->mode = v.mode; + +net/ipv6/ip6_input.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. const struct inet6_protocol *ipprot; + 63. + 64. > ipprot = rcu_dereference(inet6_protos[ipv6_hdr(skb)->nexthdr]); + 65. if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) + 66. edemux(skb); + +net/ipv6/ip6_input.c:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. + 64. ipprot = rcu_dereference(inet6_protos[ipv6_hdr(skb)->nexthdr]); + 65. > if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) + 66. edemux(skb); + 67. } + +net/sched/act_api.c:55: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 53. const struct tcf_chain *chain = a->goto_chain; + 54. + 55. > res->goto_tp = rcu_dereference_bh(chain->filter_chain); + 56. } + 57. + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +kernel/futex_compat.c:103: error: DEAD_STORE + The value written to &uentry (type unsigned int) is never used. + 101. if (rc) + 102. return; + 103. > uentry = next_uentry; + 104. entry = next_entry; + 105. pi = next_pi; + +net/core/fib_notifier.c:55: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 53. struct fib_notifier_ops *ops; + 54. + 55. > list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) { + 56. int err; + 57. + +net/ipv6/ping.c:118: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 116. fl6.flowi6_uid = sk->sk_uid; + 117. fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. > fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + 120. + +net/ipv6/ping.c:135: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 133. + 134. pfh.icmph.type = user_icmph.icmp6_type; + 135. > pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + 137. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv6/ping.c:117: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 115. fl6.flowi6_mark = sk->sk_mark; + 116. fl6.flowi6_uid = sk->sk_uid; + 117. > fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + +net/ipv6/ping.c:134: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 132. fl6.flowi6_oif = np->ucast_oif; + 133. + 134. > pfh.icmph.type = user_icmph.icmp6_type; + 135. pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + +net/netfilter/nf_nat_core.c:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. __nf_nat_l4proto_find(u8 family, u8 protonum) + 53. { + 54. > return rcu_dereference(nf_nat_l4protos[family][protonum]); + 55. } + 56. EXPORT_SYMBOL_GPL(__nf_nat_l4proto_find); + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. * counter for this CPU. + 78. */ + 79. > if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. cpu = smp_processor_id(); + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +arch/x86/pci/mmconfig-shared.c:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. + 56. /* keep list sorted by segment and starting bus number */ + 57. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) { + 58. if (cfg->segment > new->segment || + 59. (cfg->segment == new->segment && + +drivers/dma-buf/seqno-fence.c:56: error: NULL_DEREFERENCE + pointer `f` last assigned on line 54 could be null and is dereferenced at line 56, column 14. + 54. struct seqno_fence *f = to_seqno_fence(fence); + 55. + 56. > dma_buf_put(f->sync_buf); + 57. if (f->ops->release) + 58. f->ops->release(fence); + +include/linux/netfilter_ipv6.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. static inline const struct nf_ipv6_ops *nf_get_ipv6_ops(void) + 53. { + 54. > return rcu_dereference(nf_ipv6_ops); + 55. } + 56. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +drivers/hid/hid-generic.c:57: error: DEAD_STORE + The value written to &ret (type int) is never used. + 55. int ret; + 56. + 57. > ret = driver_attach(&hid_generic.driver); + 58. } + 59. + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +net/ipv4/tcp_cong.c:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. struct tcp_congestion_ops *e; + 56. + 57. > list_for_each_entry_rcu(e, &tcp_cong_list, list) { + 58. if (e->key == key) + 59. return e; + +net/ipv6/inet6_hashtables.c:63: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 61. struct sock *sk; + 62. const struct hlist_nulls_node *node; + 63. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 64. /* Optimize here for direct hit, only listening connections can + 65. * have wildcards anyways. + +net/ipv6/inet6_hashtables.c:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. + 72. begin: + 73. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 74. if (sk->sk_hash != hash) + 75. continue; + +net/netfilter/utils.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. break; + 63. case AF_INET6: + 64. > v6ops = rcu_dereference(nf_ipv6_ops); + 65. if (v6ops) + 66. ret = v6ops->route(net, dst, fl, strict); + +drivers/gpu/drm/drm_lock.c:71: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 69. _DRM_LOCK_CONT : 0); + 70. } + 71. > prev = cmpxchg(lock, old, new); + 72. } while (prev != old); + 73. spin_unlock_bh(&lock_data->spinlock); + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +kernel/time/tick-oneshot.c:56: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 54. void tick_resume_oneshot(void) + 55. { + 56. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 57. + 58. clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT); + +kernel/time/tick-oneshot.c:56: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 54. void tick_resume_oneshot(void) + 55. { + 56. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 57. + 58. clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT); + +drivers/dma-buf/dma-fence-array.c:61: error: NULL_DEREFERENCE + pointer `array` last assigned on line 57 could be null and is dereferenced at line 61, column 18. + 59. unsigned i; + 60. + 61. > for (i = 0; i < array->num_fences; ++i) { + 62. cb[i].array = array; + 63. /* + +kernel/task_work.c:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. */ + 70. raw_spin_lock_irqsave(&task->pi_lock, flags); + 71. > while ((work = READ_ONCE(*pprev))) { + 72. if (work->func != func) + 73. pprev = &work->next; + +sound/hda/trace.h:55: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 53. ); + 54. + 55. > DECLARE_EVENT_CLASS(hdac_stream, + 56. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 57. + +lib/decompress_unlzo.c:82: error: DEAD_STORE + The value written to &level (type unsigned char) is never used. + 80. parse += 7; + 81. if (version >= 0x0940) + 82. > level = *parse++; + 83. if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) + 84. parse += 8; /* flags + filter info */ + +kernel/rcu/rcu_segcblist.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. static inline long rcu_segcblist_n_cbs(struct rcu_segcblist *rsclp) + 57. { + 58. > return READ_ONCE(rsclp->len); + 59. } + 60. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +kernel/time/tick-sched.c:88: error: DEAD_STORE + The value written to &ticks (type unsigned long) is never used. + 86. incr * ticks); + 87. } + 88. > do_timer(++ticks); + 89. + 90. /* Keep the tick_next_period variable up to date */ + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/connector/cn_proc.c:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. + 62. msg->seq = __this_cpu_inc_return(proc_event_counts) - 1; + 63. > ((struct proc_event *)msg->data)->cpu = smp_processor_id(); + 64. + 65. /* + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +lib/errseq.c:94: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 92. + 93. /* Try to swap the new value into place */ + 94. > cur = cmpxchg(eseq, old, new); + 95. + 96. /* + +lib/errseq.c:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. * previous error. + 70. */ + 71. > old = READ_ONCE(*eseq); + 72. + 73. if (WARN(unlikely(err == 0 || (unsigned int)-err > MAX_ERRNO), + +lib/errseq.c:106: error: UNINITIALIZED_VALUE + The value read from cur was never initialized. + 104. old = cur; + 105. } + 106. > return cur; + 107. } + 108. EXPORT_SYMBOL(errseq_set); + +net/ipv6/ip6_offload.c:95: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 93. udpfrag = proto == IPPROTO_UDP && !skb->encapsulation; + 94. + 95. > ops = rcu_dereference(inet6_offloads[proto]); + 96. if (likely(ops && ops->callbacks.gso_segment)) { + 97. skb_reset_transport_header(skb); + +drivers/cpuidle/cpuidle.c:61: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 59. int cpuidle_play_dead(void) + 60. { + 61. > struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices); + 62. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 63. int i; + +drivers/cpuidle/cpuidle.c:61: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 59. int cpuidle_play_dead(void) + 60. { + 61. > struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices); + 62. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 63. int i; + +lib/genalloc.c:69: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 67. return -EBUSY; + 68. cpu_relax(); + 69. > } while ((nval = cmpxchg(addr, val, val & ~mask_to_clear)) != val); + 70. + 71. return 0; + +arch/x86/pci/amd_bus.c:128: error: DEAD_STORE + The value written to &info (type pci_root_info*) is never used. + 126. link = (reg >> 8) & 0x03; + 127. + 128. > info = alloc_pci_root_info(min_bus, max_bus, node, link); + 129. } + 130. + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +drivers/tty/tty_audit.c:66: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 64. struct task_struct *tsk = current; + 65. pid_t pid = task_pid_nr(tsk); + 66. > uid_t uid = from_kuid(&init_user_ns, task_uid(tsk)); + 67. uid_t loginuid = from_kuid(&init_user_ns, audit_get_loginuid(tsk)); + 68. unsigned int sessionid = audit_get_sessionid(tsk); + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +net/netlabel/netlabel_addrlist.c:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. struct netlbl_af4list *iter; + 64. + 65. > list_for_each_entry_rcu(iter, head, list) + 66. if (iter->valid && (addr & iter->mask) == iter->addr) + 67. return iter; + +sound/core/pcm_lib.c:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. if (runtime->silence_size < runtime->boundary) { + 67. snd_pcm_sframes_t noise_dist, n; + 68. > snd_pcm_uframes_t appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 69. if (runtime->silence_start != appl_ptr) { + 70. n = appl_ptr - runtime->silence_start; + +block/badblocks.c:76: error: DEAD_STORE + The value written to §ors (type int) is never used. + 74. target += (1<shift) - 1; + 75. target >>= bb->shift; + 76. > sectors = target - s; + 77. } + 78. /* 'target' is now the first block after the bad range */ + +drivers/char/agp/compat_ioctl.c:75: error: UNINITIALIZED_VALUE + The value read from ureserve.pid was never initialized. + 73. return -EFAULT; + 74. + 75. > kreserve.pid = ureserve.pid; + 76. kreserve.seg_count = ureserve.seg_count; + 77. + +drivers/char/agp/compat_ioctl.c:76: error: UNINITIALIZED_VALUE + The value read from ureserve.seg_count was never initialized. + 74. + 75. kreserve.pid = ureserve.pid; + 76. > kreserve.seg_count = ureserve.seg_count; + 77. + 78. client = agp_find_client_by_pid(kreserve.pid); + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +sound/core/vmaster.c:70: error: DEAD_STORE + The value written to &err (type int) is never used. + 68. return -ENOMEM; + 69. uctl->id = slave->slave.id; + 70. > err = slave->slave.get(&slave->slave, uctl); + 71. for (ch = 0; ch < slave->info.count; ch++) + 72. slave->vals[ch] = uctl->value.integer.value[ch]; + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +block/blk-ioc.c:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. * will. Hint assignment itself can race safely. + 79. */ + 80. > if (rcu_access_pointer(ioc->icq_hint) == icq) + 81. rcu_assign_pointer(ioc->icq_hint, NULL); + 82. + +drivers/dma-buf/seqno-fence.c:68: error: NULL_DEREFERENCE + pointer `f` last assigned on line 66 could be null and is dereferenced at line 68, column 9. + 66. struct seqno_fence *f = to_seqno_fence(fence); + 67. + 68. > return f->ops->wait(fence, intr, timeout); + 69. } + 70. + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +block/ioprio.c:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. else + 110. pgrp = find_vpid(who); + 111. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 112. ret = set_task_ioprio(p, ioprio); + 113. if (ret) + +block/ioprio.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. break; + 128. + 129. > for_each_process_thread(g, p) { + 130. if (!uid_eq(task_uid(p), uid) || + 131. !task_pid_vnr(p)) + +block/ioprio.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. + 129. for_each_process_thread(g, p) { + 130. > if (!uid_eq(task_uid(p), uid) || + 131. !task_pid_vnr(p)) + 132. continue; + +drivers/char/agp/isoch.c:140: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 138. dev = cur->dev; + 139. + 140. > mcapndx = cur->capndx; + 141. + 142. pci_read_config_dword(dev, cur->capndx+AGPNISTAT, &mnistat); + +drivers/char/agp/isoch.c:253: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 251. dev = cur->dev; + 252. + 253. > mcapndx = cur->capndx; + 254. + 255. master[cdev].rq += (cdev == ndevs - 1) + +include/linux/idr.h:66: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 64. static inline unsigned int idr_get_cursor(const struct idr *idr) + 65. { + 66. > return READ_ONCE(idr->idr_next); + 67. } + 68. + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +drivers/gpu/drm/i915/intel_lspcon.c:77: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 75. lspcon_mode_name(mode)); + 76. + 77. > wait_for((current_mode = lspcon_get_current_mode(lspcon)) == mode, 100); + 78. if (current_mode != mode) + 79. DRM_ERROR("LSPCON mode hasn't settled\n"); + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +kernel/time/tick-common.c:67: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 65. int tick_is_oneshot_available(void) + 66. { + 67. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 68. + 69. if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT)) + +kernel/time/tick-common.c:67: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 65. int tick_is_oneshot_available(void) + 66. { + 67. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 68. + 69. if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT)) + +kernel/trace/trace_events_trigger.c:75: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 73. return tt; + 74. + 75. > list_for_each_entry_rcu(data, &file->triggers, list) { + 76. if (data->paused) + 77. continue; + +kernel/trace/trace_events_trigger.c:82: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 80. continue; + 81. } + 82. > filter = rcu_dereference_sched(data->filter); + 83. if (filter && !filter_match_preds(filter, rec)) + 84. continue; + +lib/llist.c:75: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 73. old_entry = entry; + 74. next = READ_ONCE(entry->next); + 75. > entry = cmpxchg(&head->first, old_entry, next); + 76. if (entry == old_entry) + 77. break; + +lib/llist.c:69: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 67. struct llist_node *entry, *old_entry, *next; + 68. + 69. > entry = smp_load_acquire(&head->first); + 70. for (;;) { + 71. if (entry == NULL) + +lib/llist.c:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. return NULL; + 73. old_entry = entry; + 74. > next = READ_ONCE(entry->next); + 75. entry = cmpxchg(&head->first, old_entry, next); + 76. if (entry == old_entry) + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +lib/bug.c:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. + 71. rcu_read_lock_sched(); + 72. > list_for_each_entry_rcu(mod, &module_bug_list, bug_list) { + 73. unsigned i; + 74. + +net/ipv4/xfrm4_protocol.c:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. goto out; + 79. + 80. > for_each_protocol_rcu(*head, handler) + 81. if ((ret = handler->input_handler(skb, nexthdr, spi, encap_type)) != -EINVAL) + 82. return ret; + +net/ipv6/xfrm6_protocol.c:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 72. + 73. > for_each_protocol_rcu(esp6_handlers, handler) + 74. if ((ret = handler->handler(skb)) != -EINVAL) + 75. return ret; + +kernel/events/core.c:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. if (p) { + 73. /* -EAGAIN */ + 74. > if (task_cpu(p) != smp_processor_id()) + 75. return; + 76. + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +lib/earlycpio.c:140: error: UNINITIALIZED_VALUE + The value read from ch[_] was never initialized. + 138. + 139. cd.data = (void *)dptr; + 140. > cd.size = ch[C_FILESIZE]; + 141. return cd; /* Found it! */ + 142. } + +drivers/gpu/drm/i915/dvo_sil164.c:94: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 92. + 93. if (i2c_transfer(adapter, msgs, 2) == 2) { + 94. > *ch = in_buf[0]; + 95. return true; + 96. } + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +kernel/locking/rtmutex.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. * still set. + 132. */ + 133. > owner = READ_ONCE(*p); + 134. if (owner & RT_MUTEX_HAS_WAITERS) + 135. WRITE_ONCE(*p, owner & ~RT_MUTEX_HAS_WAITERS); + +lib/rhashtable.c:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. unsigned int i; + 73. + 74. > ntbl = rcu_dereference_raw(ntbl->table); + 75. if (!ntbl) + 76. return; + +net/core/sock_diag.c:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. + 82. rcu_read_lock(); + 83. > filter = rcu_dereference(sk->sk_filter); + 84. if (!filter) + 85. goto out; + +net/ipv6/datagram.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. + 86. rcu_read_lock(); + 87. > opt = flowlabel ? flowlabel->opt : rcu_dereference(np->opt); + 88. final_p = fl6_update_dst(&fl6, opt, &final); + 89. rcu_read_unlock(); + +net/ipv6/xfrm6_mode_transport.c:77: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 74 could be null and is dereferenced at line 77, column 8. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +net/ipv6/xfrm6_mode_transport.c:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +crypto/sha256_generic.c:230: error: DEAD_STORE + The value written to &a (type unsigned int) is never used. + 228. + 229. /* clear any sensitive info... */ + 230. > a = b = c = d = e = f = g = h = t1 = t2 = 0; + 231. memzero_explicit(W, 64 * sizeof(u32)); + 232. } + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +kernel/locking/qrwlock.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. /* When no more readers or writers, set the locked flag */ + 85. do { + 86. > atomic_cond_read_acquire(&lock->cnts, VAL == _QW_WAITING); + 87. } while (atomic_cmpxchg_relaxed(&lock->cnts, _QW_WAITING, + 88. _QW_LOCKED) != _QW_WAITING); + +kernel/softirq.c:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. { + 73. /* Interrupts are disabled: no need to stop preemption */ + 74. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 75. + 76. if (tsk && tsk->state != TASK_RUNNING) + +kernel/softirq.c:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. { + 73. /* Interrupts are disabled: no need to stop preemption */ + 74. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 75. + 76. if (tsk && tsk->state != TASK_RUNNING) + +security/selinux/netif.c:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. struct sel_netif *netif; + 76. + 77. > list_for_each_entry_rcu(netif, &sel_netif_hash[idx], list) + 78. if (net_eq(netif->nsec.ns, ns) && + 79. netif->nsec.ifindex == ifindex) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +arch/x86/platform/efi/efi_64.c:104: error: DEAD_STORE + The value written to &vaddr (type unsigned long) is never used. + 102. for (pgd = 0; pgd < n_pgds; pgd++) { + 103. addr_pgd = (unsigned long)(pgd * PGDIR_SIZE); + 104. > vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. save_pgd[pgd] = *pgd_efi; + +arch/x86/platform/efi/efi_64.c:106: error: NULL_DEREFERENCE + pointer `save_pgd` last assigned on line 92 could be null and is dereferenced at line 106, column 3. + 104. vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. > save_pgd[pgd] = *pgd_efi; + 107. + 108. p4d = p4d_alloc(&init_mm, pgd_efi, addr_pgd); + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +drivers/gpu/drm/drm_info.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. rcu_read_lock(); /* locks pid_task()->comm */ + 97. task = pid_task(priv->pid, PIDTYPE_PID); + 98. > uid = task ? __task_cred(task)->euid : GLOBAL_ROOT_UID; + 99. seq_printf(m, "%20s %5d %3d %c %c %5d %10u\n", + 100. task ? task->comm : "", + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +kernel/notifier.c:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. struct notifier_block *nb, *next_nb; + 80. + 81. > nb = rcu_dereference_raw(*nl); + 82. + 83. while (nb && nr_to_call) { + +kernel/notifier.c:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. + 83. while (nb && nr_to_call) { + 84. > next_nb = rcu_dereference_raw(nb->next); + 85. + 86. #ifdef CONFIG_DEBUG_NOTIFIERS + +net/core/filter.c:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. + 96. rcu_read_lock(); + 97. > filter = rcu_dereference(sk->sk_filter); + 98. if (filter) { + 99. struct sock *save_sk = skb->sk; + +net/ipv6/ip6_flowlabel.c:78: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 76. struct ip6_flowlabel *fl; + 77. + 78. > for_each_fl_rcu(FL_HASH(label), fl) { + 79. if (fl->label == label && net_eq(fl->fl_net, net)) + 80. return fl; + +net/netfilter/utils.c:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. break; + 83. case AF_INET6: + 84. > v6ops = rcu_dereference(nf_ipv6_ops); + 85. if (v6ops) + 86. ret = v6ops->reroute(skb, entry); + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +tools/objtool/orc_dump.c:102: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 102, column 3. + 100. elf = elf_begin(fd, ELF_C_READ_MMAP, NULL); + 101. if (!elf) { + 102. > WARN_ELF("elf_begin"); + 103. return -1; + 104. } + +tools/objtool/orc_dump.c:107: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 107, column 3. + 105. + 106. if (elf_getshdrnum(elf, &nr_sections)) { + 107. > WARN_ELF("elf_getshdrnum"); + 108. return -1; + 109. } + +tools/objtool/orc_dump.c:112: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 112, column 3. + 110. + 111. if (elf_getshdrstrndx(elf, &shstrtab_idx)) { + 112. > WARN_ELF("elf_getshdrstrndx"); + 113. return -1; + 114. } + +tools/objtool/orc_dump.c:119: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 119, column 4. + 117. scn = elf_getscn(elf, i); + 118. if (!scn) { + 119. > WARN_ELF("elf_getscn"); + 120. return -1; + 121. } + +tools/objtool/orc_dump.c:124: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 124, column 4. + 122. + 123. if (!gelf_getshdr(scn, &sh)) { + 124. > WARN_ELF("gelf_getshdr"); + 125. return -1; + 126. } + +tools/objtool/orc_dump.c:130: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 130, column 4. + 128. name = elf_strptr(elf, shstrtab_idx, sh.sh_name); + 129. if (!name) { + 130. > WARN_ELF("elf_strptr"); + 131. return -1; + 132. } + +tools/objtool/orc_dump.c:136: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 136, column 4. + 134. data = elf_getdata(scn, NULL); + 135. if (!data) { + 136. > WARN_ELF("elf_getdata"); + 137. return -1; + 138. } + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +drivers/ptp/ptp_sysfs.c:101: error: UNINITIALIZED_VALUE + The value read from event.index was never initialized. + 99. goto out; + 100. + 101. > cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n", + 102. event.index, event.t.sec, event.t.nsec); + 103. out: + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +drivers/connector/cn_proc.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. ev->what = PROC_EVENT_FORK; + 91. rcu_read_lock(); + 92. > parent = rcu_dereference(task->real_parent); + 93. ev->event_data.fork.parent_pid = parent->pid; + 94. ev->event_data.fork.parent_tgid = parent->tgid; + +drivers/power/supply/power_supply_sysfs.c:122: error: UNINITIALIZED_VALUE + The value read from value.strval was never initialized. + 120. power_supply_scope_text[value.intval]); + 121. else if (off >= POWER_SUPPLY_PROP_MODEL_NAME) + 122. > return sprintf(buf, "%s\n", value.strval); + 123. + 124. return sprintf(buf, "%d\n", value.intval); + +include/net/netfilter/nf_conntrack_l3proto.h:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. if (unlikely(l3proto >= NFPROTO_NUMPROTO)) + 80. return &nf_conntrack_l3proto_generic; + 81. > return rcu_dereference(nf_ct_l3protos[l3proto]); + 82. } + 83. + +kernel/cgroup/stat.c:96: error: NULL_DEREFERENCE + pointer `pos` last assigned on line 92 could be null and is dereferenced by call to `cgroup_cpu_stat()` at line 96, column 11. + 94. /* walk down to the first leaf */ + 95. while (true) { + 96. > cstat = cgroup_cpu_stat(pos, cpu); + 97. if (cstat->updated_children == pos) + 98. break; + +net/wireless/scan.c:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. return; + 82. + 83. > ies = (void *)rcu_access_pointer(bss->pub.beacon_ies); + 84. if (ies && !bss->pub.hidden_beacon_bss) + 85. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. if (ies && !bss->pub.hidden_beacon_bss) + 85. kfree_rcu(ies, rcu_head); + 86. > ies = (void *)rcu_access_pointer(bss->pub.proberesp_ies); + 87. if (ies) + 88. kfree_rcu(ies, rcu_head); + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +drivers/pps/kapi.c:88: error: DEAD_STORE + The value written to &err (type int) is never used. + 86. pr_err("%s: unsupported default parameters\n", + 87. info->name); + 88. > err = -EINVAL; + 89. goto pps_register_source_exit; + 90. } + +drivers/pps/kapi.c:94: error: DEAD_STORE + The value written to &err (type int) is never used. + 92. pr_err("%s: unspecified time format\n", + 93. info->name); + 94. > err = -EINVAL; + 95. goto pps_register_source_exit; + 96. } + +drivers/pps/kapi.c:101: error: DEAD_STORE + The value written to &err (type int) is never used. + 99. pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL); + 100. if (pps == NULL) { + 101. > err = -ENOMEM; + 102. goto pps_register_source_exit; + 103. } + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +kernel/ptrace.c:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. { + 80. rcu_read_lock(); + 81. > __ptrace_link(child, new_parent, __task_cred(new_parent)); + 82. rcu_read_unlock(); + 83. } + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +net/netfilter/nf_log.c:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. if (pf == NFPROTO_UNSPEC) { + 89. for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { + 90. > if (rcu_access_pointer(loggers[i][logger->type])) { + 91. ret = -EEXIST; + 92. goto unlock; + +net/netfilter/nf_log.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. rcu_assign_pointer(loggers[i][logger->type], logger); + 97. } else { + 98. > if (rcu_access_pointer(loggers[pf][logger->type])) { + 99. ret = -EEXIST; + 100. goto unlock; + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:90: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 84 could be null and is dereferenced at line 90, column 6. + 88. + 89. /* Write the MSB and/or LSB */ + 90. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) { + 91. vals[0] = (level & 0xFF00) >> 8; + 92. vals[1] = (level & 0xFF); + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +net/core/net-sysfs.c:87: error: DEAD_STORE + The value written to &ret (type int) is never used. + 85. struct net *net = dev_net(netdev); + 86. unsigned long new; + 87. > int ret = -EINVAL; + 88. + 89. if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) + +security/selinux/ibpkey.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. + 86. idx = sel_ib_pkey_hashfn(pkey_num); + 87. > list_for_each_entry_rcu(pkey, &sel_ib_pkey_hash[idx].list, list) { + 88. if (pkey->psec.pkey == pkey_num && + 89. pkey->psec.subnet_prefix == subnet_prefix) + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +lib/sbitmap.c:111: error: UNINITIALIZED_VALUE + The value read from nr was never initialized. + 109. } + 110. + 111. > return nr; + 112. } + 113. + +net/ipv6/icmp.c:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline struct sock *icmpv6_sk(struct net *net) + 83. { + 84. > return net->ipv6.icmp_sk[smp_processor_id()]; + 85. } + 86. + +drivers/base/devtmpfs.c:119: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 117. kfree(tmp); + 118. + 119. > return req.err; + 120. } + 121. + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +lib/percpu_counter.c:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. + 87. preempt_disable(); + 88. > count = __this_cpu_read(*fbc->counters) + amount; + 89. if (count >= batch || count <= -batch) { + 90. unsigned long flags; + +net/core/fib_notifier.c:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. + 93. rcu_read_lock(); + 94. > for_each_net_rcu(net) { + 95. err = fib_net_dump(net, nb); + 96. if (err) + +net/ipv6/inet6_connection_sock.c:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. + 104. rcu_read_lock(); + 105. > final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final); + 106. rcu_read_unlock(); + 107. + +net/ipv6/xfrm6_protocol.c:88: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 86. struct xfrm6_protocol *handler; + 87. + 88. > for_each_protocol_rcu(esp6_handlers, handler) + 89. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 90. break; + +sound/core/hwdep.c:158: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 156. module_put(hw->card->module); + 157. snd_card_unref(hw->card); + 158. > return err; + 159. } + 160. + +drivers/i2c/algos/i2c-algo-bit.c:94: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 92. goto done; + 93. + 94. > start = jiffies; + 95. while (!getscl(adap)) { + 96. /* This hw knows how to read the clock line, so we wait + +drivers/usb/core/usb-acpi.c:100: error: DEAD_STORE + The value written to &status (type unsigned int) is never used. + 98. * no connectable, the port would be not used. + 99. */ + 100. > status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer); + 101. upc = buffer.pointer; + 102. if (!upc || (upc->type != ACPI_TYPE_PACKAGE) + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +kernel/softirq.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. static bool ksoftirqd_running(void) + 85. { + 86. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 87. + 88. return tsk && (tsk->state == TASK_RUNNING); + +kernel/softirq.c:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. static bool ksoftirqd_running(void) + 85. { + 86. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 87. + 88. return tsk && (tsk->state == TASK_RUNNING); + +net/netlabel/netlabel_addrlist.c:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. struct netlbl_af4list *iter; + 89. + 90. > list_for_each_entry_rcu(iter, head, list) + 91. if (iter->valid && iter->addr == addr && iter->mask == mask) + 92. return iter; + +net/netlabel/netlabel_addrlist.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. struct netlbl_af4list *n = __af4list_entry(s); + 89. while (i != h && !n->valid) { + 90. > i = rcu_dereference(list_next_rcu(i)); + 91. n = __af4list_entry(i); + 92. } + +net/xfrm/xfrm_input.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. + 91. rcu_read_lock(); + 92. > afinfo = rcu_dereference(xfrm_input_afinfo[family]); + 93. if (unlikely(!afinfo)) + 94. rcu_read_unlock(); + +sound/hda/hdac_controller.c:88: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 86. unsigned long timeout; + 87. + 88. > timeout = jiffies + msecs_to_jiffies(100); + 89. while ((snd_hdac_chip_readb(bus, RIRBCTL) & AZX_RBCTL_DMA_EN) + 90. && time_before(jiffies, timeout)) + +sound/hda/hdac_controller.c:93: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 91. udelay(10); + 92. + 93. > timeout = jiffies + msecs_to_jiffies(100); + 94. while ((snd_hdac_chip_readb(bus, CORBCTL) & AZX_CORBCTL_RUN) + 95. && time_before(jiffies, timeout)) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +block/genhd.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. struct hd_struct *__disk_get_part(struct gendisk *disk, int partno) + 86. { + 87. > struct disk_part_tbl *ptbl = rcu_dereference(disk->part_tbl); + 88. + 89. if (unlikely(partno < 0 || partno >= ptbl->len)) + +block/genhd.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. if (unlikely(partno < 0 || partno >= ptbl->len)) + 90. return NULL; + 91. > return rcu_dereference(ptbl->part[partno]); + 92. } + 93. + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +lib/rhashtable.c:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. unsigned int i; + 93. + 94. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 95. + 96. for (i = 0; i < len; i++) + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/zlib_inflate/inffast.c:257: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 255. PUP(out) = PUP(from); + 256. if (len > 1) + 257. > PUP(out) = PUP(from); + 258. } + 259. } + +lib/zlib_inflate/inffast.c:304: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 302. } + 303. if (len & 1) + 304. > PUP(out) = PUP(from); + 305. } + 306. } + +net/core/fib_rules.c:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. + 92. rcu_read_lock(); + 93. > list_for_each_entry_rcu(ops, &net->rules_ops, list) { + 94. if (ops->family == family) { + 95. if (!try_module_get(ops->owner)) + +sound/hda/hdac_bus.c:115: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 113. trace_hda_get_response(bus, addr, *res); + 114. } + 115. > return err; + 116. } + 117. EXPORT_SYMBOL_GPL(snd_hdac_bus_exec_verb_unlocked); + +crypto/algapi.c:96: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 94. struct crypto_spawn *spawn, *n; + 95. + 96. > spawn = list_first_entry_or_null(stack, struct crypto_spawn, list); + 97. if (!spawn) + 98. return NULL; + +drivers/gpu/drm/drm_ioc32.c:103: error: UNINITIALIZED_VALUE + The value read from v32.date was never initialized. + 101. .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. > .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. .desc = compat_ptr(v32.desc), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.date_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:105: error: UNINITIALIZED_VALUE + The value read from v32.desc was never initialized. + 103. .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. > .desc = compat_ptr(v32.desc), + 106. }; + 107. err = drm_ioctl_kernel(file, drm_version, &v, + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.desc_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:101: error: UNINITIALIZED_VALUE + The value read from v32.name was never initialized. + 99. v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. > .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. .date = compat_ptr(v32.date), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.name_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/i915/intel_sprite.c:169: error: UNINITIALIZED_VALUE + The value read from scanline was never initialized. + 167. scanline = intel_get_crtc_scanline(crtc); + 168. + 169. > crtc->debug.scanline_start = scanline; + 170. crtc->debug.start_vbl_time = ktime_get(); + 171. crtc->debug.start_vbl_count = intel_crtc_get_vblank_counter(crtc); + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +security/keys/permission.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int key_validate(const struct key *key) + 90. { + 91. > unsigned long flags = READ_ONCE(key->flags); + 92. time64_t expiry = READ_ONCE(key->expiry); + 93. + +security/keys/permission.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. { + 91. unsigned long flags = READ_ONCE(key->flags); + 92. > time64_t expiry = READ_ONCE(key->expiry); + 93. + 94. if (flags & (1 << KEY_FLAG_INVALIDATED)) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/dma-buf/dma-fence-array.c:95: error: NULL_DEREFERENCE + pointer `array` last assigned on line 92 could be null and is dereferenced at line 95, column 18. + 93. unsigned i; + 94. + 95. > for (i = 0; i < array->num_fences; ++i) + 96. dma_fence_put(array->fences[i]); + 97. + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +kernel/exit.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. u64 utime, stime; + 97. + 98. > sighand = rcu_dereference_check(tsk->sighand, + 99. lockdep_tasklist_lock_is_held()); + 100. spin_lock(&sighand->siglock); + +kernel/locking/osq_lock.c:169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 167. * true. + 168. */ + 169. > if (smp_load_acquire(&node->locked)) + 170. return true; + 171. + +kernel/locking/osq_lock.c:178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 176. * case its step-C will write us a new @node->prev pointer. + 177. */ + 178. > prev = READ_ONCE(node->prev); + 179. } + 180. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +kernel/task_work.c:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. raw_spin_lock_irq(&task->pi_lock); + 101. do { + 102. > work = READ_ONCE(task->task_works); + 103. head = !work && (task->flags & PF_EXITING) ? + 104. &work_exited : NULL; + +net/ipv4/ip_options.c:178: error: UNINITIALIZED_VALUE + The value read from faddr was never initialized. + 176. } + 177. if (doffset > 3) { + 178. > dopt->faddr = faddr; + 179. dptr[0] = start[0]; + 180. dptr[1] = doffset+3; + +net/ipv4/tcp_minisocks.c:148: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 146. if (tmp_opt.saw_tstamp) { + 147. tcptw->tw_ts_recent_stamp = get_seconds(); + 148. > tcptw->tw_ts_recent = tmp_opt.rcv_tsval; + 149. } + 150. + +net/ipv4/tcp_minisocks.c:191: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 189. + 190. if (tmp_opt.saw_tstamp) { + 191. > tcptw->tw_ts_recent = tmp_opt.rcv_tsval; + 192. tcptw->tw_ts_recent_stamp = get_seconds(); + 193. } + +net/netfilter/nf_nat_sip.c:112: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 99 could be null and is dereferenced at line 112, column 13. + 110. ct->tuplehash[dir].tuple.dst.u.udp.port == port) { + 111. newaddr = ct->tuplehash[!dir].tuple.src.u3; + 112. > newport = ct_sip_info->forced_dport ? : + 113. ct->tuplehash[!dir].tuple.src.u.udp.port; + 114. } else + +drivers/gpu/drm/drm_hashtab.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. hashed_key = hash_long(key, ht->order); + 99. h_list = &ht->table[hashed_key]; + 100. > hlist_for_each_entry_rcu(entry, h_list, head) { + 101. if (entry->key == key) + 102. return &entry->head; + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +net/ipv4/xfrm4_protocol.c:99: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 97. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 98. + 99. > for_each_protocol_rcu(esp4_handlers, handler) + 100. if ((ret = handler->handler(skb)) != -EINVAL) + 101. return ret; + +drivers/gpu/drm/i915/dvo_tfp410.c:119: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 117. + 118. if (i2c_transfer(adapter, msgs, 2) == 2) { + 119. > *ch = in_buf[0]; + 120. return true; + 121. } + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +net/ipv6/sit.c:104: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 102. int ifindex = dev ? dev->ifindex : 0; + 103. + 104. > for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) { + 105. if (local == t->parms.iph.saddr && + 106. remote == t->parms.iph.daddr && + +net/ipv6/sit.c:112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 110. return t; + 111. } + 112. > for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) { + 113. if (remote == t->parms.iph.daddr && + 114. (!dev || !t->parms.link || ifindex == t->parms.link || + +net/ipv6/sit.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. return t; + 118. } + 119. > for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) { + 120. if (local == t->parms.iph.saddr && + 121. (!dev || !t->parms.link || ifindex == t->parms.link || + +net/ipv6/sit.c:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. return t; + 125. } + 126. > t = rcu_dereference(sitn->tunnels_wc[0]); + 127. if (t && (t->dev->flags & IFF_UP)) + 128. return t; + +net/ipv6/xfrm6_protocol.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 99. + 100. > for_each_protocol_rcu(ah6_handlers, handler) + 101. if ((ret = handler->handler(skb)) != -EINVAL) + 102. return ret; + +drivers/tty/tty_jobctrl.c:105: error: MEMORY_LEAK + `tty->pgrp` is not reachable after line 105, column 2. + 103. put_pid(tty->session); + 104. put_pid(tty->pgrp); + 105. > tty->pgrp = get_pid(task_pgrp(current)); + 106. spin_unlock_irqrestore(&tty->ctrl_lock, flags); + 107. tty->session = get_pid(task_session(current)); + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +net/ipv4/tunnel4.c:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. goto drop; + 100. + 101. > for_each_tunnel_rcu(tunnel4_handlers, handler) + 102. if (!handler->handler(skb)) + 103. return 0; + +security/keys/request_key.c:99: error: DEAD_STORE + The value written to &cred (type cred const *) is never used. + 97. { + 98. static char const request_key[] = "/sbin/request-key"; + 99. > const struct cred *cred = current_cred(); + 100. key_serial_t prkey, sskey; + 101. struct key *key = cons->key, *authkey = cons->authkey, *keyring, + +security/keys/request_key.c:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. + 148. rcu_read_lock(); + 149. > session = rcu_dereference(cred->session_keyring); + 150. if (!session) + 151. session = cred->user->session_keyring; + +security/selinux/netport.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. + 99. idx = sel_netport_hashfn(pnum); + 100. > list_for_each_entry_rcu(port, &sel_netport_hash[idx].list, list) + 101. if (port->psec.port == pnum && port->psec.protocol == protocol) + 102. return port; + +drivers/gpu/drm/i915/i915_gem_batch_pool.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. * than replace the existing fence. + 132. */ + 133. > if (rcu_access_pointer(resv->fence)) { + 134. reservation_object_lock(resv, NULL); + 135. reservation_object_add_excl_fence(resv, NULL); + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c:114: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 112. + 113. /* rcu_read_lock()ed by nf_hook_thresh */ + 114. > helper = rcu_dereference(help->helper); + 115. if (!helper) + 116. return NF_ACCEPT; + +drivers/gpu/drm/i915/i915_gem_context.c:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. rcu_read_lock(); + 108. radix_tree_for_each_slot(slot, &ctx->handles_vma, &iter, 0) { + 109. > struct i915_vma *vma = rcu_dereference_raw(*slot); + 110. + 111. radix_tree_iter_delete(&ctx->handles_vma, &iter, slot); + +drivers/scsi/scsi_logging.c:115: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 113. if (!WARN_ON(off >= logbuf_len)) { + 114. va_start(args, fmt); + 115. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 116. va_end(args); + 117. } + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +net/ipv4/ip_tunnel.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. head = &itn->tunnels[hash]; + 107. + 108. > hlist_for_each_entry_rcu(t, head, hash_node) { + 109. if (local != t->parms.iph.saddr || + 110. remote != t->parms.iph.daddr || + +net/ipv4/ip_tunnel.c:123: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 121. } + 122. + 123. > hlist_for_each_entry_rcu(t, head, hash_node) { + 124. if (remote != t->parms.iph.daddr || + 125. t->parms.iph.saddr != 0 || + +net/ipv4/ip_tunnel.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. head = &itn->tunnels[hash]; + 140. + 141. > hlist_for_each_entry_rcu(t, head, hash_node) { + 142. if ((local != t->parms.iph.saddr || t->parms.iph.daddr != 0) && + 143. (local != t->parms.iph.daddr || !ipv4_is_multicast(local))) + +net/ipv4/ip_tunnel.c:161: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 159. goto skip_key_lookup; + 160. + 161. > hlist_for_each_entry_rcu(t, head, hash_node) { + 162. if (t->parms.i_key != key || + 163. t->parms.iph.saddr != 0 || + +net/ipv4/ip_tunnel.c:178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 176. return cand; + 177. + 178. > t = rcu_dereference(itn->collect_md_tun); + 179. if (t && t->dev->flags & IFF_UP) + 180. return t; + +net/ipv6/inet6_hashtables.c:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. score++; + 120. } + 121. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 122. score++; + 123. } + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +net/ipv4/inetpeer.c:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. int cmp; + 112. + 113. > next = rcu_dereference_raw(*pp); + 114. if (!next) + 115. break; + +net/netfilter/nf_conntrack_core.c:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. * It pairs with the smp_store_release() in nf_conntrack_all_unlock() + 104. */ + 105. > if (likely(smp_load_acquire(&nf_conntrack_locks_all) == false)) + 106. return; + 107. + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +include/net/busy_poll.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. { + 101. #ifdef CONFIG_NET_RX_BUSY_POLL + 102. > unsigned long bp_usec = READ_ONCE(sk->sk_ll_usec); + 103. + 104. if (bp_usec) { + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. return NF_ACCEPT; + 118. /* rcu_read_lock()ed by nf_hook_thresh */ + 119. > helper = rcu_dereference(help->helper); + 120. if (!helper) + 121. return NF_ACCEPT; + +drivers/char/agp/frontend.c:112: error: DEAD_STORE + The value written to &num_segments (type int) is never used. + 110. pg_count = size / 4096; + 111. seg = *(client->segments); + 112. > num_segments = client->num_segments; + 113. + 114. for (i = 0; i < client->num_segments; i++) { + +drivers/md/dm-kcopyd.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. spin_lock_irq(&throttle_spinlock); + 109. + 110. > throttle = READ_ONCE(t->throttle); + 111. + 112. if (likely(throttle >= 100)) + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +kernel/rcu/rcu.h:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. static inline unsigned long rcu_seq_current(unsigned long *sp) + 100. { + 101. > return READ_ONCE(*sp); + 102. } + 103. + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +drivers/gpu/drm/i915/intel_dp_mst.c:110: error: NULL_DEREFERENCE + pointer `old_conn_state` last assigned on line 109 could be null and is dereferenced at line 110, column 13. + 108. + 109. old_conn_state = drm_atomic_get_old_connector_state(state, connector); + 110. > old_crtc = old_conn_state->crtc; + 111. if (!old_crtc) + 112. return ret; + +kernel/sched/cpuacct.c:104: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 102 could be null and is dereferenced at line 104, column 14. + 102. struct cpuacct *ca = css_ca(css); + 103. + 104. > free_percpu(ca->cpustat); + 105. free_percpu(ca->cpuusage); + 106. kfree(ca); + +drivers/pci/vc.c:150: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 148. if (ctrl2 & PCI_VC_RES_CTRL_ENABLE) { + 149. ctrl2 &= ~PCI_VC_RES_CTRL_ENABLE; + 150. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 151. } + 152. + +drivers/pci/vc.c:155: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 153. /* Enable on both ends */ + 154. ctrl2 |= PCI_VC_RES_CTRL_ENABLE; + 155. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 156. enable: + 157. ctrl |= PCI_VC_RES_CTRL_ENABLE; + +drivers/pci/vc.c:163: error: UNINITIALIZED_VALUE + The value read from status_pos2 was never initialized. + 161. pci_err(dev, "VC%d negotiation stuck pending\n", id); + 162. + 163. > if (link && !pci_wait_for_pending(link, status_pos2, + 164. PCI_VC_RES_STATUS_NEGO)) + 165. pci_err(link, "VC%d negotiation stuck pending\n", id); + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +net/netfilter/nf_queue.c:106: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 104. + 105. rcu_read_lock(); + 106. > qh = rcu_dereference(net->nf.queue_handler); + 107. if (qh) + 108. qh->nf_hook_drop(net); + +net/netfilter/nfnetlink.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. return NULL; + 107. + 108. > return rcu_dereference(table[subsys_id].subsys); + 109. } + 110. + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +net/ipv4/datagram.c:118: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 116. return; + 117. } + 118. > inet_opt = rcu_dereference(inet->inet_opt); + 119. if (inet_opt && inet_opt->opt.srr) + 120. daddr = inet_opt->opt.faddr; + +arch/x86/include/asm/mmu_context.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. + 108. /* READ_ONCE synchronizes with smp_store_release */ + 109. > ldt = READ_ONCE(mm->context.ldt); + 110. + 111. /* + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +net/ipv4/netfilter/nf_reject_ipv4.c:128: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 126. + 127. skb_reserve(nskb, LL_MAX_HEADER); + 128. > niph = nf_reject_iphdr_put(nskb, oldskb, IPPROTO_TCP, + 129. ip4_dst_hoplimit(skb_dst(nskb))); + 130. nf_reject_ip_tcphdr_put(nskb, oldskb, oth); + +net/ipv4/netfilter/nf_reject_ipv4.c:135: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 133. goto free_nskb; + 134. + 135. > niph = ip_hdr(nskb); + 136. + 137. /* "Never happens" */ + +net/netfilter/nfnetlink_log.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. + 109. head = &log->instance_table[instance_hashfn(group_num)]; + 110. > hlist_for_each_entry_rcu(inst, head, hlist) { + 111. if (inst->group_num == group_num) + 112. return inst; + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/gpu/drm/drm_lock.c:114: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 112. old = *lock; + 113. new = context | _DRM_LOCK_HELD; + 114. > prev = cmpxchg(lock, old, new); + 115. } while (prev != old); + 116. return 1; + +drivers/pps/pps.c:227: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 225. /* Check for supported capabilities */ + 226. if ((bind_args.edge & ~pps->info.mode) != 0) { + 227. > dev_err(pps->dev, "unsupported capabilities (%x)\n", + 228. bind_args.edge); + 229. return -EINVAL; + +drivers/pps/pps.c:236: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 234. (bind_args.edge & ~PPS_CAPTUREBOTH) != 0 || + 235. bind_args.consumer != PPS_KC_HARDPPS) { + 236. > dev_err(pps->dev, "invalid kernel consumer bind" + 237. " parameters (%x)\n", bind_args.edge); + 238. return -EINVAL; + +drivers/pps/pps.c:141: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 139. return -EFAULT; + 140. if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) { + 141. > dev_dbg(pps->dev, "capture mode unspecified (%x)\n", + 142. params.mode); + 143. return -EINVAL; + +drivers/pps/pps.c:148: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 146. /* Check for supported capabilities */ + 147. if ((params.mode & ~pps->info.mode) != 0) { + 148. > dev_dbg(pps->dev, "unsupported capabilities (%x)\n", + 149. params.mode); + 150. return -EINVAL; + +drivers/pps/pps.c:161: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 159. if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + 160. /* section 3.3 of RFC 2783 interpreted */ + 161. > dev_dbg(pps->dev, "time format unspecified (%x)\n", + 162. params.mode); + 163. pps->params.mode |= PPS_TSFMT_TSPEC; + +include/linux/rbtree_latch.h:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. int (*comp)(void *key, struct latch_tree_node *node)) + 107. { + 108. > struct rb_node *node = rcu_dereference_raw(ltr->tree[idx].rb_node); + 109. struct latch_tree_node *ltn; + 110. int c; + +include/linux/rbtree_latch.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. + 116. if (c < 0) + 117. > node = rcu_dereference_raw(node->rb_left); + 118. else if (c > 0) + 119. node = rcu_dereference_raw(node->rb_right); + +include/linux/rbtree_latch.h:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. node = rcu_dereference_raw(node->rb_left); + 118. else if (c > 0) + 119. > node = rcu_dereference_raw(node->rb_right); + 120. else + 121. return ltn; + +drivers/pnp/support.c:126: error: DEAD_STORE + The value written to &len (type int) is never used. + 124. case IORESOURCE_IO: + 125. port = &option->u.port; + 126. > len += scnprintf(buf + len, sizeof(buf) - len, "io min %#llx " + 127. "max %#llx align %lld size %lld flags %#x", + 128. (unsigned long long) port->min, + +drivers/pnp/support.c:135: error: DEAD_STORE + The value written to &len (type int) is never used. + 133. case IORESOURCE_MEM: + 134. mem = &option->u.mem; + 135. > len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx " + 136. "max %#llx align %lld size %lld flags %#x", + 137. (unsigned long long) mem->min, + +drivers/pnp/support.c:158: error: DEAD_STORE + The value written to &len (type int) is never used. + 156. irq->flags); + 157. if (irq->flags & IORESOURCE_IRQ_OPTIONAL) + 158. > len += scnprintf(buf + len, sizeof(buf) - len, + 159. " (optional)"); + 160. break; + +drivers/pnp/support.c:174: error: DEAD_STORE + The value written to &len (type int) is never used. + 172. " %d", i); + 173. } + 174. > len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) " + 175. "flags %#x", dma->map, dma->flags); + 176. break; + +kernel/cgroup/freezer.c:108: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 107 could be null and is dereferenced by call to `parent_freezer()` at line 108, column 27. + 106. { + 107. struct freezer *freezer = css_freezer(css); + 108. > struct freezer *parent = parent_freezer(freezer); + 109. + 110. mutex_lock(&freezer_mutex); + +drivers/tty/serial/serial_core.c:115: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 113. if (port) + 114. port->ops->stop_tx(port); + 115. > uart_port_unlock(port, flags); + 116. } + 117. + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +kernel/smp.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. static __always_inline void csd_lock_wait(call_single_data_t *csd) + 107. { + 108. > smp_cond_load_acquire(&csd->flags, !(VAL & CSD_FLAG_LOCK)); + 109. } + 110. + +kernel/smpboot.c:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. preempt_enable(); + 127. if (ht->park && td->status == HP_THREAD_ACTIVE) { + 128. > BUG_ON(td->cpu != smp_processor_id()); + 129. ht->park(td->cpu); + 130. td->status = HP_THREAD_PARKED; + +kernel/smpboot.c:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. } + 136. + 137. > BUG_ON(td->cpu != smp_processor_id()); + 138. + 139. /* Check for state change setup */ + +net/core/sysctl_net_core.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. for_each_possible_cpu(i) { + 158. sd = &per_cpu(softnet_data, i); + 159. > if (rcu_dereference(sd->flow_limit)) + 160. cpumask_set_cpu(i, mask); + 161. } + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +kernel/locking/rtmutex_common.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock) + 108. { + 109. > unsigned long owner = (unsigned long) READ_ONCE(lock->owner); + 110. + 111. return (struct task_struct *) (owner & ~RT_MUTEX_HAS_WAITERS); + +net/ipv4/tcp_ulp.c:114: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 112. *buf = '\0'; + 113. rcu_read_lock(); + 114. > list_for_each_entry_rcu(ulp_ops, &tcp_ulp_list, list) { + 115. offs += snprintf(buf + offs, maxlen - offs, + 116. "%s%s", + +drivers/pci/pci-acpi.c:119: error: UNINITIALIZED_VALUE + The value read from mcfg_addr was never initialized. + 117. return 0; + 118. + 119. > return (phys_addr_t)mcfg_addr; + 120. } + 121. + +include/linux/seqlock.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. + 112. repeat: + 113. > ret = READ_ONCE(s->sequence); + 114. if (unlikely(ret & 1)) { + 115. cpu_relax(); + +kernel/trace/trace_events_trigger.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct event_trigger_data *data; + 114. + 115. > list_for_each_entry_rcu(data, &file->triggers, list) { + 116. if (data->paused) + 117. continue; + +net/netfilter/nf_conntrack_irc.c:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. IPPROTO_TCP, NULL, &port); + 211. + 212. > nf_nat_irc = rcu_dereference(nf_nat_irc_hook); + 213. if (nf_nat_irc && ct->status & IPS_NAT_MASK) + 214. ret = nf_nat_irc(skb, ctinfo, protoff, + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +lib/hexdump.c:205: error: DEAD_STORE + The value written to &lx (type int) is never used. + 203. return lx; + 204. overflow2: + 205. > linebuf[lx++] = '\0'; + 206. overflow1: + 207. return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1; + +net/ipv4/xfrm4_protocol.c:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. struct xfrm4_protocol *handler; + 112. + 113. > for_each_protocol_rcu(esp4_handlers, handler) + 114. if (!handler->err_handler(skb, info)) + 115. break; + +net/xfrm/xfrm_policy.c:116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 114. return NULL; + 115. rcu_read_lock(); + 116. > afinfo = rcu_dereference(xfrm_policy_afinfo[family]); + 117. if (unlikely(!afinfo)) + 118. rcu_read_unlock(); + +net/ipv6/af_inet6.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. err = -ESOCKTNOSUPPORT; + 128. rcu_read_lock(); + 129. > list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) { + 130. + 131. err = 0; + +net/ipv6/xfrm6_protocol.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct xfrm6_protocol *handler; + 114. + 115. > for_each_protocol_rcu(ah6_handlers, handler) + 116. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 117. break; + +net/netlabel/netlabel_addrlist.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct netlbl_af6list *iter; + 114. + 115. > list_for_each_entry_rcu(iter, head, list) + 116. if (iter->valid && + 117. ipv6_masked_addr_cmp(&iter->addr, &iter->mask, addr) == 0) + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/pci/proc.c:173: error: DEAD_STORE + The value written to &buf (type char const *) is never used. + 171. __get_user(val, buf); + 172. pci_user_write_config_byte(dev, pos, val); + 173. > buf++; + 174. pos++; + 175. cnt--; + +drivers/pci/proc.c:175: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 173. buf++; + 174. pos++; + 175. > cnt--; + 176. } + 177. + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +kernel/time/tick-oneshot.c:117: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 115. + 116. local_irq_save(flags); + 117. > ret = __this_cpu_read(tick_cpu_device.mode) == TICKDEV_MODE_ONESHOT; + 118. local_irq_restore(flags); + 119. + +net/netfilter/nf_conntrack_standalone.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. st->bucket < st->htable_size; + 118. st->bucket++) { + 119. > n = rcu_dereference( + 120. hlist_nulls_first_rcu(&st->hash[st->bucket])); + 121. if (!is_a_nulls(n)) + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +net/ipv6/xfrm6_mode_tunnel.c:116: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 114 could be null and is dereferenced at line 116, column 6. + 114. struct xfrm_offload *xo = xfrm_offload(skb); + 115. + 116. > if (xo->flags & XFRM_GSO_SEGMENT) + 117. skb->transport_header = skb->network_header + sizeof(struct ipv6hdr); + 118. + +net/sched/act_api.c:121: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 119. struct idr *idr = &idrinfo->action_idr; + 120. struct tc_action *p; + 121. > unsigned long id = 1; + 122. + 123. spin_lock_bh(&idrinfo->lock); + +arch/x86/include/asm/syscall.h:138: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 136. case 5: + 137. if (!n--) break; + 138. > *args++ = regs->bp; + 139. case 6: + 140. if (!n--) break; + +arch/x86/include/asm/syscall.h:165: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 163. case 5: + 164. if (!n--) break; + 165. > *args++ = regs->r9; + 166. case 6: + 167. if (!n--) break; + +arch/x86/include/asm/syscall.h:140: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 138. *args++ = regs->bp; + 139. case 6: + 140. > if (!n--) break; + 141. default: + 142. BUG(); + +arch/x86/include/asm/syscall.h:167: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 165. *args++ = regs->r9; + 166. case 6: + 167. > if (!n--) break; + 168. default: + 169. BUG(); + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +net/core/sock_reuseport.c:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. struct sock_reuseport *old_reuse, *reuse; + 116. + 117. > if (!rcu_access_pointer(sk2->sk_reuseport_cb)) { + 118. int err = reuseport_alloc(sk2); + 119. + +net/ipv4/tunnel4.c:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. goto drop; + 119. + 120. > for_each_tunnel_rcu(tunnel64_handlers, handler) + 121. if (!handler->handler(skb)) + 122. return 0; + +net/ipv6/udp.c:157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 155. } + 156. + 157. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 158. score++; + 159. + +drivers/iommu/dmar.c:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. + 119. if (*devices && *cnt) { + 120. > for_each_active_dev_scope(*devices, *cnt, i, tmp_dev) + 121. put_device(tmp_dev); + 122. kfree(*devices); + +include/net/busy_poll.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. { + 116. #ifdef CONFIG_NET_RX_BUSY_POLL + 117. > unsigned int napi_id = READ_ONCE(sk->sk_napi_id); + 118. + 119. if (napi_id >= MIN_NAPI_ID) + +net/ipv4/tcp_fastopen.c:122: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 120. rcu_read_lock(); + 121. + 122. > ctx = rcu_dereference(inet_csk(sk)->icsk_accept_queue.fastopenq.ctx); + 123. if (!ctx) + 124. ctx = rcu_dereference(sock_net(sk)->ipv4.tcp_fastopen_ctx); + +net/ipv4/tcp_fastopen.c:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. ctx = rcu_dereference(inet_csk(sk)->icsk_accept_queue.fastopenq.ctx); + 123. if (!ctx) + 124. > ctx = rcu_dereference(sock_net(sk)->ipv4.tcp_fastopen_ctx); + 125. + 126. if (ctx) { + +security/selinux/netnode.c:131: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 129. } + 130. + 131. > list_for_each_entry_rcu(node, &sel_netnode_hash[idx].list, list) + 132. if (node->nsec.family == family) + 133. switch (family) { + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgtyp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +net/netfilter/nf_conntrack_helper.c:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. + 125. h = helper_hash(tuple); + 126. > hlist_for_each_entry_rcu(helper, &nf_ct_helper_hash[h], hnode) { + 127. if (nf_ct_tuple_src_mask_cmp(tuple, &helper->tuple, &mask)) + 128. return helper; + +net/netfilter/nf_conntrack_proto.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. return &nf_conntrack_l4proto_generic; + 120. + 121. > return rcu_dereference(nf_ct_protos[l3proto][l4proto]); + 122. } + 123. EXPORT_SYMBOL_GPL(__nf_ct_l4proto_find); + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +kernel/events/ring_buffer.c:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. event = event->parent; + 136. + 137. > rb = rcu_dereference(event->rb); + 138. if (unlikely(!rb)) + 139. goto out; + +kernel/events/ring_buffer.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. + 159. do { + 160. > tail = READ_ONCE(rb->user_page->data_tail); + 161. offset = head = local_read(&rb->head); + 162. if (!rb->overwrite) { + +kernel/sched/membarrier.c:165: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 163. * iteration. + 164. */ + 165. > if (cpu == raw_smp_processor_id()) + 166. continue; + 167. rcu_read_lock(); + +lib/rhashtable.c:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. int i; + 123. + 124. > ntbl = rcu_dereference(*prev); + 125. if (ntbl) + 126. return ntbl; + +arch/x86/pci/mmconfig-shared.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. struct pci_mmcfg_region *cfg; + 120. + 121. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) + 122. if (cfg->segment == segment && + 123. cfg->start_bus <= bus && bus <= cfg->end_bus) + +include/linux/ptrace.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. { + 119. if (unlikely(task->ptrace)) + 120. > return rcu_dereference(task->parent); + 121. return NULL; + 122. } + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +net/netfilter/nf_conntrack_expect.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. + 128. h = nf_ct_expect_dst_hash(net, tuple); + 129. > hlist_for_each_entry_rcu(i, &nf_ct_expect_hash[h], hnode) { + 130. if (nf_ct_exp_equal(tuple, i, zone, net)) + 131. return i; + +block/partition-generic.c:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. int cpu; + 125. + 126. > cpu = part_stat_lock(); + 127. part_round_stats(q, cpu, p); + 128. part_stat_unlock(); + +block/partition-generic.c:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. int cpu; + 125. + 126. > cpu = part_stat_lock(); + 127. part_round_stats(q, cpu, p); + 128. part_stat_unlock(); + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/gpu/drm/i915/intel_dsi.c:136: error: DEAD_STORE + The value written to &data (type unsigned char const *) is never used. + 134. + 135. header = packet.header; + 136. > data = packet.payload; + 137. + 138. if (msg->flags & MIPI_DSI_MSG_USE_LPM) { + +net/ipv4/xfrm4_protocol.c:125: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 123. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 124. + 125. > for_each_protocol_rcu(ah4_handlers, handler) + 126. if ((ret = handler->handler(skb)) != -EINVAL) + 127. return ret; + +net/ipv6/inet6_connection_sock.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. fl6.daddr = sk->sk_v6_daddr; + 138. + 139. > res = ip6_xmit(sk, skb, &fl6, sk->sk_mark, rcu_dereference(np->opt), + 140. np->tclass); + 141. rcu_read_unlock(); + +net/netlabel/netlabel_domainhash.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. for (iter = 0, val = 0, len = strlen(key); iter < len; iter++) + 128. val = (val << 4 | (val >> (8 * sizeof(u32) - 4))) ^ key[iter]; + 129. > return val & (netlbl_domhsh_rcu_deref(netlbl_domhsh)->size - 1); + 130. } + 131. + +drivers/gpu/drm/drm_lock.c:137: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 135. old = *lock; + 136. new = _DRM_LOCKING_CONTEXT(old); + 137. > prev = cmpxchg(lock, old, new); + 138. } while (prev != old); + 139. + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.chan was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.func was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:245: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 243. break; + 244. } + 245. > pin_index = pd.index; + 246. if (pin_index >= ops->n_pins) { + 247. err = -EINVAL; + +drivers/ptp/ptp_chardev.c:263: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 261. break; + 262. } + 263. > pin_index = pd.index; + 264. if (pin_index >= ops->n_pins) { + 265. err = -EINVAL; + +kernel/irq/spurious.c:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. goto out; + 126. + 127. > irq_poll_cpu = smp_processor_id(); + 128. + 129. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. goto out; + 126. + 127. > irq_poll_cpu = smp_processor_id(); + 128. + 129. for_each_irq_desc(i, desc) { + +lib/errseq.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. errseq_t errseq_sample(errseq_t *eseq) + 120. { + 121. > errseq_t old = READ_ONCE(*eseq); + 122. errseq_t new = old; + 123. + +net/ipv4/fib_frontend.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. + 129. head = &net->ipv4.fib_table_hash[h]; + 130. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 131. if (tb->tb_id == id) + 132. return tb; + +drivers/scsi/scsi_transport_spi.c:143: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 141. break; + 142. } + 143. > return result; + 144. } + 145. + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +net/ipv6/tcp_ipv6.c:198: error: UNINITIALIZED_VALUE + The value read from fl6.flowlabel was never initialized. + 196. + 197. sk->sk_v6_daddr = usin->sin6_addr; + 198. > np->flow_label = fl6.flowlabel; + 199. + 200. /* + +net/ipv6/xfrm6_protocol.c:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 126. + 127. > for_each_protocol_rcu(ipcomp6_handlers, handler) + 128. if ((ret = handler->handler(skb)) != -EINVAL) + 129. return ret; + +net/sunrpc/clnt.c:147: error: UNINITIALIZED_VALUE + The value read from dentry was never initialized. + 145. } + 146. dput(dir); + 147. > return dentry; + 148. } + 149. + +sound/core/info.c:130: error: DEAD_STORE + The value written to &offset (type long long) is never used. + 128. mutex_lock(&entry->access); + 129. if (entry->c.ops->llseek) { + 130. > offset = entry->c.ops->llseek(entry, + 131. data->file_private_data, + 132. file, offset, orig); + +block/blk-mq.h:129: error: DEAD_STORE + The value written to &new_val (type unsigned long long) is never used. + 127. if (state == MQ_RQ_IN_FLIGHT) { + 128. WARN_ON_ONCE((old_val & MQ_RQ_STATE_MASK) != MQ_RQ_IDLE); + 129. > new_val += MQ_RQ_GEN_INC; + 130. } + 131. + +block/blk-mq.h:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. enum mq_rq_state state) + 123. { + 124. > u64 old_val = READ_ONCE(rq->gstate); + 125. u64 new_val = (old_val & ~MQ_RQ_STATE_MASK) | state; + 126. + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +drivers/base/devtmpfs.c:148: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 146. + 147. kfree(tmp); + 148. > return req.err; + 149. } + 150. + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +arch/x86/entry/vsyscall/vsyscall_64.c:208: error: UNINITIALIZED_VALUE + The value read from syscall_nr was never initialized. + 206. * here doesn't matter. + 207. */ + 208. > regs->orig_ax = syscall_nr; + 209. regs->ax = -ENOSYS; + 210. tmp = secure_computing(NULL); + +drivers/scsi/scsi_logging.c:140: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 138. if (off < logbuf_len) { + 139. va_start(args, fmt); + 140. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 141. va_end(args); + 142. } + +kernel/compat.c:134: error: UNINITIALIZED_VALUE + The value read from ts.tv_nsec was never initialized. + 132. + 133. ts64->tv_sec = ts.tv_sec; + 134. > ts64->tv_nsec = ts.tv_nsec; + 135. + 136. return 0; + +kernel/compat.c:133: error: UNINITIALIZED_VALUE + The value read from ts.tv_sec was never initialized. + 131. return -EFAULT; + 132. + 133. > ts64->tv_sec = ts.tv_sec; + 134. ts64->tv_nsec = ts.tv_nsec; + 135. + +net/ipv6/xfrm6_policy.c:165: error: DEAD_STORE + The value written to &exthdr (type ipv6_opt_hdr*) is never used. + 163. offset += ipv6_optlen(exthdr); + 164. nexthdr = exthdr->nexthdr; + 165. > exthdr = (struct ipv6_opt_hdr *)(nh + offset); + 166. break; + 167. + +drivers/input/ff-memless.c:127: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 125. { + 126. struct ml_effect_state *state; + 127. > unsigned long now = jiffies; + 128. unsigned long earliest = 0; + 129. unsigned long next_at; + +net/sched/cls_api.c:135: error: DEAD_STORE + The value written to &err (type int) is never used. + 133. return ERR_PTR(-ENOBUFS); + 134. + 135. > err = -ENOENT; + 136. tp->ops = tcf_proto_lookup_ops(kind); + 137. if (!tp->ops) { + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +lib/radix-tree.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. { + 129. unsigned int offset = (index >> parent->shift) & RADIX_TREE_MAP_MASK; + 130. > void __rcu **entry = rcu_dereference_raw(parent->slots[offset]); + 131. + 132. #ifdef CONFIG_RADIX_TREE_MULTIORDER + +drivers/base/power/runtime.c:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. goto out; + 136. + 137. > autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); + 138. if (autosuspend_delay < 0) + 139. goto out; + +drivers/base/power/runtime.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. goto out; + 140. + 141. > last_busy = READ_ONCE(dev->power.last_busy); + 142. elapsed = jiffies - last_busy; + 143. if (elapsed < 0) + +drivers/tty/serial/serial_core.c:135: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 133. port = uart_port_lock(state, flags); + 134. __uart_start(tty); + 135. > uart_port_unlock(port, flags); + 136. } + 137. + +drivers/usb/storage/sierra_ms.c:197: error: DEAD_STORE + The value written to &result (type int) is never used. + 195. } + 196. complete: + 197. > result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); + 198. + 199. return 0; + +drivers/usb/storage/sierra_ms.c:134: error: DEAD_STORE + The value written to &retries (type int) is never used. + 132. struct Scsi_Host *sh; + 133. + 134. > retries = 3; + 135. result = 0; + 136. udev = us->pusb_dev; + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +net/ipv6/addrlabel.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. struct ip6addrlbl_entry *p; + 132. + 133. > hlist_for_each_entry_rcu(p, &net->ipv6.ip6addrlbl_table.head, list) { + 134. if (__ip6addrlbl_match(p, addr, type, ifindex)) + 135. return p; + +net/netfilter/nf_conntrack_standalone.c:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. struct ct_iter_state *st = seq->private; + 131. + 132. > head = rcu_dereference(hlist_nulls_next_rcu(head)); + 133. while (is_a_nulls(head)) { + 134. if (likely(get_nulls_value(head) == st->bucket)) { + +net/netfilter/nf_conntrack_standalone.c:138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 136. return NULL; + 137. } + 138. > head = rcu_dereference( + 139. hlist_nulls_first_rcu(&st->hash[st->bucket])); + 140. } + +drivers/gpu/drm/drm_ioc32.c:139: error: UNINITIALIZED_VALUE + The value read from uq32.unique was never initialized. + 137. uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. > .unique = compat_ptr(uq32.unique), + 140. }; + 141. + +drivers/gpu/drm/drm_ioc32.c:137: error: UNINITIALIZED_VALUE + The value read from uq32.unique_len was never initialized. + 135. if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32))) + 136. return -EFAULT; + 137. > uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. .unique = compat_ptr(uq32.unique), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +net/ipv4/inet_connection_sock.c:152: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 150. sk2->sk_state == TCP_LISTEN) && + 151. (!reuseport || !sk2->sk_reuseport || + 152. > rcu_access_pointer(sk->sk_reuseport_cb) || + 153. (sk2->sk_state != TCP_TIME_WAIT && + 154. !uid_eq(uid, sock_i_uid(sk2))))) { + +net/ipv6/inet6_hashtables.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. u32 phash = 0; + 140. + 141. > inet_lhash2_for_each_icsk_rcu(icsk, &ilb2->head) { + 142. sk = (struct sock *)icsk; + 143. score = compute_score(sk, net, hnum, daddr, dif, sdif, + +drivers/char/hw_random/via-rng.c:177: error: DEAD_STORE + The value written to &hi (type unsigned int) is never used. + 175. /* perhaps-unnecessary sanity check; remove after testing if + 176. unneeded */ + 177. > rdmsr(MSR_VIA_RNG, lo, hi); + 178. if ((lo & VIA_RNG_ENABLE) == 0) { + 179. pr_err(PFX "cannot enable VIA C3 RNG, aborting\n"); + +drivers/connector/cn_proc.c:147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 145. ev->event_data.id.process_tgid = task->tgid; + 146. rcu_read_lock(); + 147. > cred = __task_cred(task); + 148. if (which_id == PROC_EVENT_UID) { + 149. ev->event_data.id.r.ruid = from_kuid_munged(&init_user_ns, cred->uid); + +include/linux/seqlock.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. static inline unsigned raw_read_seqcount(const seqcount_t *s) + 131. { + 132. > unsigned ret = READ_ONCE(s->sequence); + 133. smp_rmb(); + 134. return ret; + +kernel/cgroup/freezer.c:136: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 132 could be null and is dereferenced at line 136, column 6. + 134. mutex_lock(&freezer_mutex); + 135. + 136. > if (freezer->state & CGROUP_FREEZING) + 137. atomic_dec(&system_freezing_cnt); + 138. + +drivers/input/input.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. rcu_read_lock(); + 141. + 142. > handle = rcu_dereference(dev->grab); + 143. if (handle) { + 144. count = input_to_handler(handle, vals, count); + +drivers/input/input.c:146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 144. count = input_to_handler(handle, vals, count); + 145. } else { + 146. > list_for_each_entry_rcu(handle, &dev->h_list, d_node) + 147. if (handle->open) { + 148. count = input_to_handler(handle, vals, count); + +init/initramfs.c:137: error: NULL_DEREFERENCE + pointer `de` last assigned on line 133 could be null and is dereferenced at line 137, column 2. + 135. panic("can't allocate dir_entry buffer"); + 136. INIT_LIST_HEAD(&de->list); + 137. > de->name = kstrdup(name, GFP_KERNEL); + 138. de->mtime = mtime; + 139. list_add(&de->list, &dir_list); + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +net/core/gen_stats.c:149: error: UNINITIALIZED_VALUE + The value read from seq was never initialized. + 147. bstats->bytes = b->bytes; + 148. bstats->packets = b->packets; + 149. > } while (running && read_seqcount_retry(running, seq)); + 150. } + 151. EXPORT_SYMBOL(__gnet_stats_copy_basic); + +net/ipv6/netfilter/nf_reject_ipv6.c:187: error: DEAD_STORE + The value written to &ip6h (type ipv6hdr*) is never used. + 185. + 186. skb_reserve(nskb, hh_len + dst->header_len); + 187. > ip6h = nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP, + 188. ip6_dst_hoplimit(dst)); + 189. nf_reject_ip6_tcphdr_put(nskb, oldskb, otcph, otcplen); + +block/genhd.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. + 138. rcu_read_lock(); + 139. > ptbl = rcu_dereference(disk->part_tbl); + 140. + 141. piter->disk = disk; + +drivers/gpu/drm/i915/intel_lspcon.c:154: error: UNINITIALIZED_VALUE + The value read from adaptor_type was never initialized. + 152. + 153. if (adaptor_type != DRM_DP_DUAL_MODE_LSPCON) { + 154. > DRM_DEBUG_KMS("No LSPCON detected, found %s\n", + 155. drm_dp_get_dual_mode_type_name(adaptor_type)); + 156. return false; + +include/net/inet_sock.h:135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 133. static inline struct ip_options_rcu *ireq_opt_deref(const struct inet_request_sock *ireq) + 134. { + 135. > return rcu_dereference_check(ireq->ireq_opt, + 136. refcount_read(&ireq->req.rsk_refcnt) > 0); + 137. } + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +net/ipv6/syncookies.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. fl6.flowi6_proto = IPPROTO_TCP; + 233. fl6.daddr = ireq->ir_v6_rmt_addr; + 234. > final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), &final); + 235. fl6.saddr = ireq->ir_v6_loc_addr; + 236. fl6.flowi6_oif = ireq->ir_iif; + +net/netfilter/nf_conntrack_helper.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. + 139. for (i = 0; i < nf_ct_helper_hsize; i++) { + 140. > hlist_for_each_entry_rcu(h, &nf_ct_helper_hash[i], hnode) { + 141. if (strcmp(h->name, name)) + 142. continue; + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +net/ipv4/af_inet.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. + 158. kfree(rcu_dereference_protected(inet->inet_opt, 1)); + 159. > dst_release(rcu_dereference_check(sk->sk_dst_cache, 1)); + 160. dst_release(sk->sk_rx_dst); + 161. sk_refcnt_debug_dec(sk); + +net/netlabel/netlabel_cipso_v4.c:137: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 135. struct netlbl_audit *audit_info) + 136. { + 137. > int ret_val = -EINVAL; + 138. struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + +drivers/gpu/drm/i915/dvo_ch7xxx.c:161: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 159. + 160. if (i2c_transfer(adapter, msgs, 2) == 2) { + 161. > *ch = in_buf[0]; + 162. return true; + 163. } + +drivers/tty/sysrq.c:147: error: NULL_DEREFERENCE + pointer `killer` last assigned on line 137 could be null and is dereferenced at line 147, column 2. + 145. panic_on_oops = 1; /* force panic */ + 146. wmb(); + 147. > *killer = 1; + 148. } + 149. static struct sysrq_key_op sysrq_crash_op = { + +net/ipv4/xfrm4_protocol.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. struct xfrm4_protocol *handler; + 138. + 139. > for_each_protocol_rcu(ah4_handlers, handler) + 140. if (!handler->err_handler(skb, info)) + 141. break; + +net/ipv6/mcast.c:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. + 148. rcu_read_lock(); + 149. > for_each_pmc_rcu(np, mc_lst) { + 150. if ((ifindex == 0 || mc_lst->ifindex == ifindex) && + 151. ipv6_addr_equal(&mc_lst->addr, addr)) { + +net/netlabel/netlabel_addrlist.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. struct netlbl_af6list *iter; + 140. + 141. > list_for_each_entry_rcu(iter, head, list) + 142. if (iter->valid && + 143. ipv6_addr_equal(&iter->addr, addr) && + +drivers/usb/core/devio.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. u64 lim; + 139. + 140. > lim = READ_ONCE(usbfs_memory_mb); + 141. lim <<= 20; + 142. + +include/linux/percpu-refcount.h:152: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 150. * with smp_store_release() in __percpu_ref_switch_to_percpu(). + 151. */ + 152. > percpu_ptr = READ_ONCE(ref->percpu_count_ptr); + 153. + 154. /* + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +lib/assoc_array.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. void *iterator_data) + 141. { + 142. > struct assoc_array_ptr *root = READ_ONCE(array->root); /* Address dependency. */ + 143. + 144. if (!root) + +net/ipv6/xfrm6_protocol.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. struct xfrm6_protocol *handler; + 141. + 142. > for_each_protocol_rcu(ipcomp6_handlers, handler) + 143. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 144. break; + +net/netfilter/nf_conntrack_sip.c:174: error: UNINITIALIZED_VALUE + The value read from end was never initialized. + 172. + 173. if (endp) + 174. > *endp = end; + 175. return 1; + 176. } + +arch/x86/entry/common.c:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. local_irq_disable(); + 174. + 175. > cached_flags = READ_ONCE(current_thread_info()->flags); + 176. + 177. if (!(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +kernel/nsproxy.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. { + 140. struct nsproxy *old_ns = tsk->nsproxy; + 141. > struct user_namespace *user_ns = task_cred_xxx(tsk, user_ns); + 142. struct nsproxy *new_ns; + 143. + +block/blk-mq-sched.c:143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 141. struct request_queue *q = hctx->queue; + 142. LIST_HEAD(rq_list); + 143. > struct blk_mq_ctx *ctx = READ_ONCE(hctx->dispatch_from); + 144. + 145. do { + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +security/commoncap.c:147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 145. rcu_read_lock(); + 146. cred = current_cred(); + 147. > child_cred = __task_cred(child); + 148. if (mode & PTRACE_MODE_FSCREDS) + 149. caller_caps = &cred->cap_effective; + +include/linux/page-flags.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. static inline struct page *compound_head(struct page *page) + 141. { + 142. > unsigned long head = READ_ONCE(page->compound_head); + 143. + 144. if (unlikely(head & 1)) + +kernel/smp.c:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. smp_call_func_t func, void *info) + 143. { + 144. > if (cpu == smp_processor_id()) { + 145. unsigned long flags; + 146. + +net/ipv6/ip6_offload.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. for (;;) { + 149. if (proto != NEXTHDR_HOP) { + 150. > *opps = rcu_dereference(inet6_offloads[proto]); + 151. if (unlikely(!(*opps))) + 152. break; + +net/ipv6/ipv6_sockglue.c:821: error: DEAD_STORE + The value written to &retv (type int) is never used. + 819. goto e_inval; + 820. + 821. > retv = -EINVAL; + 822. + 823. /* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */ + +net/ipv6/ipv6_sockglue.c:685: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 683. psin6 = (struct sockaddr_in6 *)&greq.gr_group; + 684. if (optname == MCAST_JOIN_GROUP) + 685. > retv = ipv6_sock_mc_join(sk, greq.gr_interface, + 686. &psin6->sin6_addr); + 687. else + +net/ipv6/ipv6_sockglue.c:688: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 686. &psin6->sin6_addr); + 687. else + 688. > retv = ipv6_sock_mc_drop(sk, greq.gr_interface, + 689. &psin6->sin6_addr); + 690. break; + +net/ipv6/ipv6_sockglue.c:721: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 719. + 720. psin6 = (struct sockaddr_in6 *)&greqs.gsr_group; + 721. > retv = ipv6_sock_mc_join(sk, greqs.gsr_interface, + 722. &psin6->sin6_addr); + 723. /* prior join w/ different source is ok */ + +net/ipv6/ipv6_sockglue.c:644: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 642. + 643. if (optname == IPV6_ADD_MEMBERSHIP) + 644. > retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + +net/ipv6/ipv6_sockglue.c:646: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 644. retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. > retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 647. break; + 648. } + +net/ipv6/ipv6_sockglue.c:662: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 660. + 661. if (optname == IPV6_JOIN_ANYCAST) + 662. > retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + +net/ipv6/ipv6_sockglue.c:664: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 662. retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. > retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 665. break; + 666. } + +net/ipv6/ipv6_sockglue.c:481: error: UNINITIALIZED_VALUE + The value read from pkt.ipi6_ifindex was never initialized. + 479. goto e_inval; + 480. + 481. > np->sticky_pktinfo.ipi6_ifindex = pkt.ipi6_ifindex; + 482. np->sticky_pktinfo.ipi6_addr = pkt.ipi6_addr; + 483. retv = 0; + +drivers/char/hpet.c:167: error: DEAD_STORE + The value written to &m (type unsigned long) is never used. + 165. + 166. t = devp->hd_ireqfreq; + 167. > m = read_counter(&devp->hd_timer->hpet_compare); + 168. mc = read_counter(&hpet->hpet_mc); + 169. /* The time for the next interrupt would logically be t + m, + +drivers/clk/clk.c:159: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 157. if (!IS_ENABLED(CONFIG_SMP)) + 158. local_save_flags(flags); + 159. > return flags; + 160. } + 161. spin_lock_irqsave(&enable_lock, flags); + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/rtc/rtc-dev.c:194: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 192. sizeof(unsigned long); + 193. } + 194. > return ret; + 195. } + 196. + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +net/netfilter/nf_queue.c:146: error: DEAD_STORE + The value written to &status (type int) is never used. + 144. unsigned int index, unsigned int queuenum) + 145. { + 146. > int status = -ENOENT; + 147. struct nf_queue_entry *entry = NULL; + 148. const struct nf_queue_handler *qh; + +net/netfilter/nf_queue.c:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. + 152. /* QUEUE == DROP if no one is waiting, to be safe. */ + 153. > qh = rcu_dereference(net->nf.queue_handler); + 154. if (!qh) { + 155. status = -ESRCH; + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +crypto/scompress.c:149: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 147. struct crypto_scomp *scomp = *tfm_ctx; + 148. void **ctx = acomp_request_ctx(req); + 149. > const int cpu = get_cpu(); + 150. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 151. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +crypto/scompress.c:149: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 147. struct crypto_scomp *scomp = *tfm_ctx; + 148. void **ctx = acomp_request_ctx(req); + 149. > const int cpu = get_cpu(); + 150. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 151. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +drivers/gpu/drm/drm_modes.c:252: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 250. vsyncandback_porch = tmp1; + 251. /* 10. Find number of lines in back porch */ + 252. > vback_porch = vsyncandback_porch - vsync; + 253. drm_mode->vtotal = vdisplay_rnd + 2 * vmargin + + 254. vsyncandback_porch + CVT_MIN_V_PORCH; + +drivers/gpu/drm/drm_sysfs.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. enum drm_connector_status status; + 149. + 150. > status = READ_ONCE(connector->status); + 151. + 152. return snprintf(buf, PAGE_SIZE, "%s\n", + +drivers/gpu/drm/i915/i915_gem_shrinker.c:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. spin_lock(&i915->mm.obj_lock); + 225. while (count < target && + 226. > (obj = list_first_entry_or_null(phase->list, + 227. typeof(*obj), + 228. mm.link))) { + +drivers/hid/hid-ntrig.c:162: error: DEAD_STORE + The value written to &ret (type int) is never used. + 160. + 161. if (ret == 8) { + 162. > ret = ntrig_version_string(&data[2], buf); + 163. + 164. hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n", + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +kernel/kprobes.c:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. retry: + 152. rcu_read_lock(); + 153. > list_for_each_entry_rcu(kip, &c->pages, list) { + 154. if (kip->nused < slots_per_page(c)) { + 155. int i; + +net/ipv4/xfrm4_protocol.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 150. + 151. > for_each_protocol_rcu(ipcomp4_handlers, handler) + 152. if ((ret = handler->handler(skb)) != -EINVAL) + 153. return ret; + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +drivers/gpu/drm/i915/intel_dsi_pll.c:166: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 164. vlv_cck_write(dev_priv, CCK_REG_DSI_PLL_CONTROL, config->dsi_pll.ctrl); + 165. + 166. > if (wait_for(vlv_cck_read(dev_priv, CCK_REG_DSI_PLL_CONTROL) & + 167. DSI_PLL_LOCK, 20)) { + 168. + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +kernel/irq/spurious.c:152: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 150. if (atomic_inc_return(&irq_poll_active) != 1) + 151. goto out; + 152. > irq_poll_cpu = smp_processor_id(); + 153. + 154. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:152: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 150. if (atomic_inc_return(&irq_poll_active) != 1) + 151. goto out; + 152. > irq_poll_cpu = smp_processor_id(); + 153. + 154. for_each_irq_desc(i, desc) { + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +arch/x86/platform/efi/efi_64.c:183: error: DEAD_STORE + The value written to &p4d (type p4d_t*) is never used. + 181. } + 182. + 183. > p4d = (p4d_t *)pgd_page_vaddr(*pgd); + 184. p4d_free(&init_mm, p4d); + 185. } + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +kernel/time/posix-timers.c:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. struct k_itimer *timer; + 152. + 153. > hlist_for_each_entry_rcu(timer, head, t_hash) { + 154. if ((timer->it_signal == sig) && (timer->it_id == id)) + 155. return timer; + +net/core/net-procfs.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. + 155. rcu_read_lock(); + 156. > fl = rcu_dereference(sd->flow_limit); + 157. if (fl) + 158. flow_limit_count = fl->count; + +block/blk-mq.h:150: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 148. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 149. { + 150. > return __blk_mq_get_ctx(q, get_cpu()); + 151. } + 152. + +block/blk-mq.h:150: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 148. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 149. { + 150. > return __blk_mq_get_ctx(q, get_cpu()); + 151. } + 152. + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +net/core/rtnetlink.c:155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 153. protocol = PF_UNSPEC; + 154. + 155. > tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]); + 156. if (!tab) + 157. tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]); + +net/core/rtnetlink.c:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]); + 156. if (!tab) + 157. > tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]); + 158. + 159. return tab[msgtype]; + +net/ipv4/udp.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. inet_rcv_saddr_equal(sk, sk2, true)) { + 164. if (sk2->sk_reuseport && sk->sk_reuseport && + 165. > !rcu_access_pointer(sk->sk_reuseport_cb) && + 166. uid_eq(uid, sock_i_uid(sk2))) { + 167. if (!bitmap) + +net/sunrpc/auth_gss/gss_rpc_xdr.c:158: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 156. if (unlikely(p == NULL)) + 157. return -ENOSPC; + 158. > count = be32_to_cpup(p++); + 159. memset(&dummy, 0, sizeof(dummy)); + 160. for (i = 0; i < count; i++) { + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +kernel/sys.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. static bool set_one_prio_perm(struct task_struct *p) + 150. { + 151. > const struct cred *cred = current_cred(), *pcred = __task_cred(p); + 152. + 153. if (uid_eq(pcred->uid, cred->euid) || + +lib/errseq.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. int errseq_check(errseq_t *eseq, errseq_t since) + 150. { + 151. > errseq_t cur = READ_ONCE(*eseq); + 152. + 153. if (likely(cur == since)) + +net/core/dst.c:153: error: DEAD_STORE + The value written to &dst (type dst_entry*) is never used. + 151. struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head); + 152. + 153. > dst = dst_destroy(dst); + 154. } + 155. + +net/netlabel/netlabel_domainhash.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. if (domain != NULL) { + 158. bkt = netlbl_domhsh_hash(domain); + 159. > bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt]; + 160. list_for_each_entry_rcu(iter, bkt_list, list) + 161. if (iter->valid && + +net/netlabel/netlabel_domainhash.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. bkt = netlbl_domhsh_hash(domain); + 159. bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt]; + 160. > list_for_each_entry_rcu(iter, bkt_list, list) + 161. if (iter->valid && + 162. netlbl_family_match(iter->family, family) && + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +net/ipv4/udp_offload.c:171: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 169. case ENCAP_TYPE_IPPROTO: + 170. offloads = is_ipv6 ? inet6_offloads : inet_offloads; + 171. > ops = rcu_dereference(offloads[skb->inner_ipproto]); + 172. if (!ops || !ops->callbacks.gso_segment) + 173. goto out_unlock; + +net/netlabel/netlabel_addrlist.h:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. struct netlbl_af6list *n = __af6list_entry(s); + 156. while (i != h && !n->valid) { + 157. > i = rcu_dereference(list_next_rcu(i)); + 158. n = __af6list_entry(i); + 159. } + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +drivers/gpu/drm/drm_drv.c:158: error: NULL_DEREFERENCE + pointer `slot` last assigned on line 157 could be null and is dereferenced at line 158, column 10. + 156. + 157. slot = drm_minor_get_slot(dev, type); + 158. > minor = *slot; + 159. if (!minor) + 160. return; + +net/ipv4/tunnel4.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. struct xfrm_tunnel *handler; + 155. + 156. > for_each_tunnel_rcu(tunnel4_handlers, handler) + 157. if (!handler->err_handler(skb, info)) + 158. break; + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/ksysfs.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. struct kobj_attribute *attr, char *buf) + 155. { + 156. > return sprintf(buf, "%d\n", READ_ONCE(rcu_expedited)); + 157. } + 158. static ssize_t rcu_expedited_store(struct kobject *kobj, + +drivers/dma-buf/reservation.c:207: error: UNINITIALIZED_VALUE + The value read from k was never initialized. + 205. + 206. /* Drop the references to the signaled fences */ + 207. > for (i = k; i < fobj->shared_max; ++i) { + 208. struct dma_fence *f; + 209. + +kernel/printk/printk.c:183: error: UNINITIALIZED_VALUE + The value read from old was never initialized. + 181. + 182. /* ... and restore old setting. */ + 183. > devkmsg_log = old; + 184. strncpy(devkmsg_log_str, old_str, DEVKMSG_STR_MAX_SIZE); + 185. + +net/ipv4/ip_input.c:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. struct net *net = dev_net(dev); + 161. + 162. > for (ra = rcu_dereference(ip_ra_chain); ra; ra = rcu_dereference(ra->next)) { + 163. struct sock *sk = ra->sk; + 164. + +net/ipv4/ip_input.c:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. struct net *net = dev_net(dev); + 161. + 162. > for (ra = rcu_dereference(ip_ra_chain); ra; ra = rcu_dereference(ra->next)) { + 163. struct sock *sk = ra->sk; + 164. + +drivers/gpu/drm/drm_framebuffer.c:184: error: NULL_DEREFERENCE + pointer `info` last assigned on line 172 could be null and is dereferenced at line 184, column 18. + 182. } + 183. + 184. > for (i = 0; i < info->num_planes; i++) { + 185. unsigned int width = fb_plane_width(r->width, info, i); + 186. unsigned int height = fb_plane_height(r->height, info, i); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:166: error: DEAD_STORE + The value written to &ret_val (type unsigned int) is never used. + 164. * at the end of this routine. + 165. */ + 166. > ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data); + 167. + 168. /* Disabled the PHY transmitter */ + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +lib/decompress_bunzip2.c:271: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 269. } + 270. /* Find largest and smallest lengths in this group */ + 271. > minLen = maxLen = length[0]; + 272. + 273. for (i = 1; i < symCount; i++) { + +lib/decompress_bunzip2.c:275: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 273. for (i = 1; i < symCount; i++) { + 274. if (length[i] > maxLen) + 275. > maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. minLen = length[i]; + +lib/decompress_bunzip2.c:277: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 275. maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. > minLen = length[i]; + 278. } + 279. + +drivers/gpu/drm/drm_sysfs.c:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. int dpms; + 162. + 163. > dpms = READ_ONCE(connector->dpms); + 164. + 165. return snprintf(buf, PAGE_SIZE, "%s\n", + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +kernel/events/callchain.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. return NULL; + 164. + 165. > entries = rcu_dereference(callchain_cpus_entries); + 166. if (!entries) + 167. return NULL; + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +net/ipv4/tcp_cong.c:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. + 162. rcu_read_lock(); + 163. > ca = rcu_dereference(net->ipv4.tcp_congestion_control); + 164. if (unlikely(!try_module_get(ca->owner))) + 165. ca = &tcp_reno; + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.addr was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.fd was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.flags was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.len was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.prot was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +kernel/time/timekeeping.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. static inline u64 tk_clock_read(struct tk_read_base *tkr) + 158. { + 159. > struct clocksource *clock = READ_ONCE(tkr->clock); + 160. + 161. return clock->read(clock); + +drivers/dma/virt-dma.h:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. static inline struct virt_dma_desc *vchan_next_desc(struct virt_dma_chan *vc) + 159. { + 160. > return list_first_entry_or_null(&vc->desc_issued, + 161. struct virt_dma_desc, node); + 162. } + +include/linux/cpuidle.h:159: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 157. extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev); + 158. static inline struct cpuidle_device *cpuidle_get_device(void) + 159. > {return __this_cpu_read(cpuidle_devices); } + 160. #else + 161. static inline void disable_cpuidle(void) { } + +include/linux/cpuidle.h:159: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 157. extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev); + 158. static inline struct cpuidle_device *cpuidle_get_device(void) + 159. > {return __this_cpu_read(cpuidle_devices); } + 160. #else + 161. static inline void disable_cpuidle(void) { } + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +net/ipv4/inet_fragment.c:170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 168. local_bh_disable(); + 169. + 170. > for (i = READ_ONCE(f->next_bucket); budget; --budget) { + 171. evicted += inet_evict_bucket(f, &f->hash[i]); + 172. i = (i + 1) & (INETFRAGS_HASHSZ - 1); + +kernel/softirq.c:177: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 175. preempt_count_sub(cnt - 1); + 176. + 177. > if (unlikely(!in_interrupt() && local_softirq_pending())) { + 178. /* + 179. * Run softirq if any pending. And do it in its own stack + +lib/ioremap.c:170: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 168. BUG_ON(addr >= end); + 169. + 170. > start = addr; + 171. phys_addr -= addr; + 172. pgd = pgd_offset_k(addr); + +drivers/dma-buf/dma-buf.c:185: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 183. rcu_read_lock(); + 184. + 185. > fobj = rcu_dereference(resv->fence); + 186. if (fobj) + 187. shared_count = fobj->shared_count; + +drivers/dma-buf/dma-buf.c:190: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 188. else + 189. shared_count = 0; + 190. > fence_excl = rcu_dereference(resv->fence_excl); + 191. if (read_seqcount_retry(&resv->seq, seq)) { + 192. rcu_read_unlock(); + +drivers/dma-buf/dma-buf.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. + 246. for (i = 0; i < shared_count; ++i) { + 247. > struct dma_fence *fence = rcu_dereference(fobj->shared[i]); + 248. + 249. if (!dma_fence_get_rcu(fence)) { + +net/netfilter/nf_log.c:179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 177. } + 178. + 179. > if (rcu_access_pointer(loggers[pf][type]) == NULL) + 180. request_module("nf-logger-%u-%u", pf, type); + 181. + +net/netfilter/nf_log.c:183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 181. + 182. rcu_read_lock(); + 183. > logger = rcu_dereference(loggers[pf][type]); + 184. if (logger == NULL) + 185. goto out; + +tools/lib/subcmd/exec-cmd.c:169: error: NULL_DEREFERENCE + pointer `nargv` last assigned on line 167 could be null and is dereferenced at line 169, column 2. + 167. nargv = malloc(sizeof(*nargv) * (argc + 2)); + 168. + 169. > nargv[0] = subcmd_config.exec_name; + 170. for (argc = 0; argv[argc]; argc++) + 171. nargv[argc + 1] = argv[argc]; + +net/ipv4/xfrm4_protocol.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. struct xfrm4_protocol *handler; + 164. + 165. > for_each_protocol_rcu(ipcomp4_handlers, handler) + 166. if (!handler->err_handler(skb, info)) + 167. break; + +arch/x86/lib/msr-smp.c:174: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 172. *h = rv.reg.h; + 173. + 174. > return err ? err : rv.err; + 175. } + 176. EXPORT_SYMBOL(rdmsr_safe_on_cpu); + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +net/ipv4/tunnel4.c:166: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 164. struct xfrm_tunnel *handler; + 165. + 166. > for_each_tunnel_rcu(tunnel64_handlers, handler) + 167. if (!handler->err_handler(skb, info)) + 168. break; + +net/netlabel/netlabel_addrlist.c:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. * address mask such that the entry with the widest mask (smallest + 174. * numerical value) appears first in the list */ + 175. > list_for_each_entry_rcu(iter, head, list) + 176. if (iter->valid && + 177. ntohl(entry->mask) > ntohl(iter->mask)) { + +drivers/net/ethernet/intel/e1000e/netdev.c:189: error: UNINITIALIZED_VALUE + The value read from regs[_] was never initialized. + 187. + 188. snprintf(rname, 16, "%s%s", reginfo->name, "[0-1]"); + 189. > pr_info("%-15s %08x %08x\n", rname, regs[0], regs[1]); + 190. } + 191. + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +drivers/input/ff-memless.c:168: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 166. { + 167. struct ff_effect *effect = state->effect; + 168. > unsigned long now = jiffies; + 169. int time_from_level; + 170. int time_of_envelope; + +init/initramfs.c:175: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 173. parsed[i] = simple_strtoul(buf, NULL, 16); + 174. } + 175. > ino = parsed[0]; + 176. mode = parsed[1]; + 177. uid = parsed[2]; + +init/initramfs.c:176: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 174. } + 175. ino = parsed[0]; + 176. > mode = parsed[1]; + 177. uid = parsed[2]; + 178. gid = parsed[3]; + +init/initramfs.c:177: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 175. ino = parsed[0]; + 176. mode = parsed[1]; + 177. > uid = parsed[2]; + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + +init/initramfs.c:178: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 176. mode = parsed[1]; + 177. uid = parsed[2]; + 178. > gid = parsed[3]; + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + +init/initramfs.c:179: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 177. uid = parsed[2]; + 178. gid = parsed[3]; + 179. > nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + +init/initramfs.c:180: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + 180. > mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. major = parsed[7]; + +init/initramfs.c:181: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. > body_len = parsed[6]; + 182. major = parsed[7]; + 183. minor = parsed[8]; + +init/initramfs.c:182: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. > major = parsed[7]; + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + +init/initramfs.c:183: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 181. body_len = parsed[6]; + 182. major = parsed[7]; + 183. > minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. name_len = parsed[11]; + +init/initramfs.c:185: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. > name_len = parsed[11]; + 186. } + 187. + +net/ipv6/ip6_offload.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. rcu_read_lock(); + 193. proto = iph->nexthdr; + 194. > ops = rcu_dereference(inet6_offloads[proto]); + 195. if (!ops || !ops->callbacks.gro_receive) { + 196. __pskb_pull(skb, skb_gro_offset(skb)); + +net/ipv6/ip6_offload.c:203: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 201. __skb_push(skb, skb_gro_offset(skb)); + 202. + 203. > ops = rcu_dereference(inet6_offloads[proto]); + 204. if (!ops || !ops->callbacks.gro_receive) + 205. goto out_unlock; + +net/ipv6/udp.c:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. result = NULL; + 175. badness = -1; + 176. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 177. score = compute_score(sk, net, saddr, sport, + 178. daddr, hnum, dif, sdif, exact_dif); + +arch/x86/lib/delay.c:175: error: DEAD_STORE + The value written to &xloops (type unsigned long) is never used. + 173. :"1" (xloops), "0" (lpj * (HZ / 4))); + 174. + 175. > __delay(++xloops); + 176. } + 177. EXPORT_SYMBOL(__const_udelay); + +arch/x86/lib/delay.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. void __const_udelay(unsigned long xloops) + 166. { + 167. > unsigned long lpj = this_cpu_read(cpu_info.loops_per_jiffy) ? : loops_per_jiffy; + 168. int d0; + 169. + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +block/genhd.c:177: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 175. /* get part_tbl */ + 176. rcu_read_lock(); + 177. > ptbl = rcu_dereference(piter->disk->part_tbl); + 178. + 179. /* determine iteration parameters */ + +block/genhd.c:196: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 194. struct hd_struct *part; + 195. + 196. > part = rcu_dereference(ptbl->part[piter->idx]); + 197. if (!part) + 198. continue; + +kernel/sched/cpuacct.c:174: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 169 could be null and is dereferenced by call to `cpuacct_cpuusage_read()` at line 174, column 20. + 172. + 173. for_each_possible_cpu(i) + 174. > totalcpuusage += cpuacct_cpuusage_read(ca, i, index); + 175. + 176. return totalcpuusage; + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +drivers/gpu/drm/drm_ioc32.c:179: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 177. return -EFAULT; + 178. + 179. > map.offset = m32.offset; + 180. err = drm_ioctl_kernel(file, drm_legacy_getmap_ioctl, &map, DRM_UNLOCKED); + 181. if (err) + +drivers/gpu/drm/drm_ioc32.c:187: error: UNINITIALIZED_VALUE + The value read from map.flags was never initialized. + 185. m32.size = map.size; + 186. m32.type = map.type; + 187. > m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. m32.mtrr = map.mtrr; + +drivers/gpu/drm/drm_ioc32.c:189: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. > m32.mtrr = map.mtrr; + 190. if (copy_to_user(argp, &m32, sizeof(m32))) + 191. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:185: error: UNINITIALIZED_VALUE + The value read from map.size was never initialized. + 183. + 184. m32.offset = map.offset; + 185. > m32.size = map.size; + 186. m32.type = map.type; + 187. m32.flags = map.flags; + +drivers/gpu/drm/drm_ioc32.c:186: error: UNINITIALIZED_VALUE + The value read from map.type was never initialized. + 184. m32.offset = map.offset; + 185. m32.size = map.size; + 186. > m32.type = map.type; + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +drivers/gpu/drm/drm_sysfs.c:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. bool enabled; + 175. + 176. > enabled = READ_ONCE(connector->encoder); + 177. + 178. return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n"); + +net/core/dev_ioctl.c:184: error: UNINITIALIZED_VALUE + The value read from cfg.rx_filter was never initialized. + 182. + 183. tx_type = cfg.tx_type; + 184. > rx_filter = cfg.rx_filter; + 185. + 186. switch (tx_type) { + +net/core/dev_ioctl.c:183: error: UNINITIALIZED_VALUE + The value read from cfg.tx_type was never initialized. + 181. return -EINVAL; + 182. + 183. > tx_type = cfg.tx_type; + 184. rx_filter = cfg.rx_filter; + 185. + +net/ipv4/devinet.c:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. struct in_ifaddr *ifa; + 173. + 174. > hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) + 175. if (ifa->ifa_local == addr && + 176. net_eq(dev_net(ifa->ifa_dev->dev), net)) + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/md/dm.c:172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 170. static int __dm_get_module_param_int(int *module_param, int min, int max) + 171. { + 172. > int param = READ_ONCE(*module_param); + 173. int modified_param = 0; + 174. bool modified = true; + +kernel/ksysfs.c:173: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 171. struct kobj_attribute *attr, char *buf) + 172. { + 173. > return sprintf(buf, "%d\n", READ_ONCE(rcu_normal)); + 174. } + 175. static ssize_t rcu_normal_store(struct kobject *kobj, + +net/sched/act_api.c:178: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 176. struct idr *idr = &idrinfo->action_idr; + 177. struct tc_action *p; + 178. > unsigned long id = 1; + 179. + 180. nest = nla_nest_start(skb, 0); + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +drivers/tty/tty_jobctrl.c:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. { + 173. struct task_struct *p; + 174. > do_each_pid_task(session, PIDTYPE_SID, p) { + 175. proc_clear_tty(p); + 176. } while_each_pid_task(session, PIDTYPE_SID, p); + +include/linux/ptrace.h:183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 181. + 182. rcu_read_lock(); + 183. > ns = task_active_pid_ns(rcu_dereference(current->parent)); + 184. if (ns) + 185. message = pid_nr_ns(pid, ns); + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +lib/asn1_decoder.c:400: error: UNINITIALIZED_VALUE + The value read from cons_datalen_stack[_] was never initialized. + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. > datalen = cons_datalen_stack[csp]; + 401. pr_debug("- end cons t=%zu dp=%zu l=%zu/%zu\n", + 402. tdp, dp, len, datalen); + +lib/asn1_decoder.c:397: error: UNINITIALIZED_VALUE + The value read from cons_dp_stack[_] was never initialized. + 395. goto cons_stack_underflow; + 396. csp--; + 397. > tdp = cons_dp_stack[csp]; + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + +lib/asn1_decoder.c:398: error: UNINITIALIZED_VALUE + The value read from cons_hdrlen_stack[_] was never initialized. + 396. csp--; + 397. tdp = cons_dp_stack[csp]; + 398. > hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. datalen = cons_datalen_stack[csp]; + +lib/asn1_decoder.c:463: error: UNINITIALIZED_VALUE + The value read from jump_stack[_] was never initialized. + 461. if (unlikely(jsp <= 0)) + 462. goto jump_stack_underflow; + 463. > pc = jump_stack[--jsp]; + 464. flags |= FLAG_MATCHED | FLAG_LAST_MATCHED; + 465. goto next_op; + +drivers/ata/libata-scsi.c:197: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 195. + 196. link = dev->link; + 197. > now = jiffies; + 198. if (ap->pflags & ATA_PFLAG_EH_IN_PROGRESS && + 199. link->eh_context.unloaded_mask & (1 << dev->devno) && + +drivers/char/agp/compat_ioctl.c:181: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 179. return -EFAULT; + 180. + 181. > memory = agp_find_mem_by_key(bind_info.key); + 182. + 183. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:186: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 184. return -EINVAL; + 185. + 186. > return agp_bind_memory(memory, bind_info.pg_start); + 187. } + 188. + +include/linux/ptr_ring.h:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. { + 175. if (likely(r->size)) + 176. > return READ_ONCE(r->queue[r->consumer_head]); + 177. return NULL; + 178. } + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +lib/assoc_array.c:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. pr_devel("-->%s()\n", __func__); + 188. + 189. > cursor = READ_ONCE(array->root); /* Address dependency. */ + 190. if (!cursor) + 191. return assoc_array_walk_tree_empty; + +lib/assoc_array.c:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. slot = segments >> (level & ASSOC_ARRAY_KEY_CHUNK_MASK); + 212. slot &= ASSOC_ARRAY_FAN_MASK; + 213. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 214. + 215. pr_devel("consider slot %x [ix=%d type=%lu]\n", + +lib/assoc_array.c:286: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 284. + 285. /* The shortcut matches the leaf's index to this point. */ + 286. > cursor = READ_ONCE(shortcut->next_node); /* Address dependency. */ + 287. if (((level ^ sc_level) & ~ASSOC_ARRAY_KEY_CHUNK_MASK) != 0) { + 288. level = sc_level; + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +kernel/time/clocksource.c:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. /* Check the deviation from the watchdog clocksource. */ + 225. if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) { + 226. > pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n", + 227. smp_processor_id(), cs->name); + 228. pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n", + +kernel/time/clocksource.c:280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 278. * to each other. + 279. */ + 280. > next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); + 281. if (next_cpu >= nr_cpu_ids) + 282. next_cpu = cpumask_first(cpu_online_mask); + +kernel/time/clocksource.c:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. /* Check the deviation from the watchdog clocksource. */ + 225. if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) { + 226. > pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n", + 227. smp_processor_id(), cs->name); + 228. pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n", + +kernel/time/clocksource.c:280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 278. * to each other. + 279. */ + 280. > next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); + 281. if (next_cpu >= nr_cpu_ids) + 282. next_cpu = cpumask_first(cpu_online_mask); + +arch/x86/include/asm/atomic64_64.h:177: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 175. static inline long atomic64_cmpxchg(atomic64_t *v, long old, long new) + 176. { + 177. > return cmpxchg(&v->counter, old, new); + 178. } + 179. + +block/ioprio.c:199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 197. else + 198. pgrp = find_vpid(who); + 199. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 200. tmpio = get_task_ioprio(p); + 201. if (tmpio < 0) + +block/ioprio.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. break; + 218. + 219. > for_each_process_thread(g, p) { + 220. if (!uid_eq(task_uid(p), user->uid) || + 221. !task_pid_vnr(p)) + +block/ioprio.c:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. + 219. for_each_process_thread(g, p) { + 220. > if (!uid_eq(task_uid(p), user->uid) || + 221. !task_pid_vnr(p)) + 222. continue; + +drivers/md/md-bitmap.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. rdev_dec_pending(rdev, mddev); + 197. } + 198. > list_for_each_entry_continue_rcu(rdev, &mddev->disks, same_set) { + 199. if (rdev->raid_disk >= 0 && + 200. !test_bit(Faulty, &rdev->flags)) { + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +net/sched/sch_mq.c:179: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 177 could be null and is dereferenced at line 179, column 9. + 177. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 178. + 179. > return dev_queue->qdisc_sleeping; + 180. } + 181. + +net/sunrpc/xprtmultipath.c:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. if (xpi->xpi_ops != NULL) + 180. return xpi->xpi_ops; + 181. > return rcu_dereference(xpi->xpi_xpswitch)->xps_iter_ops; + 182. } + 183. + +security/commoncap.c:182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 180. + 181. rcu_read_lock(); + 182. > cred = __task_cred(parent); + 183. child_cred = current_cred(); + 184. if (cred->user_ns == child_cred->user_ns && + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +security/keys/proc.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. /* come up with a suitable timeout value */ + 222. > expiry = READ_ONCE(key->expiry); + 223. if (expiry == 0) { + 224. memcpy(xbuf, "perm", 5); + +security/keys/proc.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. ((FLAGS & (1 << FLAG)) ? LETTER : '-') + 246. + 247. > flags = READ_ONCE(key->flags); + 248. seq_printf(m, "%08x %c%c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ", + 249. key->serial, + +arch/x86/lib/msr-smp.c:190: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 188. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 189. + 190. > return err ? err : rv.err; + 191. } + 192. EXPORT_SYMBOL(wrmsr_safe_on_cpu); + +drivers/firmware/dmi-id.c:206: error: DEAD_STORE + The value written to &i (type int) is never used. + 204. ADD_DMI_ATTR(chassis_serial, DMI_CHASSIS_SERIAL); + 205. ADD_DMI_ATTR(chassis_asset_tag, DMI_CHASSIS_ASSET_TAG); + 206. > sys_dmi_attributes[i++] = &sys_dmi_modalias_attr.attr; + 207. } + 208. + +drivers/gpu/drm/i915/intel_hdmi.c:189: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 183 could be null and is dereferenced at line 189, column 37. + 187. return false; + 188. + 189. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 190. return false; + 191. + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +lib/errseq.c:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. * to take the lock that protects the "since" value. + 188. */ + 189. > old = READ_ONCE(*eseq); + 190. if (old != *since) { + 191. /* + +net/sunrpc/auth_gss/auth_gss.c:186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 184. + 185. rcu_read_lock(); + 186. > ctx = rcu_dereference(gss_cred->gc_ctx); + 187. if (ctx) + 188. gss_get_ctx(ctx); + +drivers/pci/probe.c:254: error: UNINITIALIZED_VALUE + The value read from orig_cmd was never initialized. + 252. + 253. if (!dev->mmio_always_on && (orig_cmd & PCI_COMMAND_DECODE_ENABLE)) + 254. > pci_write_config_word(dev, PCI_COMMAND, orig_cmd); + 255. + 256. if (!sz64) + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +include/linux/seqlock.h:184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 182. static inline unsigned raw_seqcount_begin(const seqcount_t *s) + 183. { + 184. > unsigned ret = READ_ONCE(s->sequence); + 185. smp_rmb(); + 186. return ret & ~1; + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +arch/x86/entry/common.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. lockdep_sys_exit(); + 192. + 193. > cached_flags = READ_ONCE(ti->flags); + 194. + 195. if (unlikely(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +kernel/exit.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. * can't be modifying its own credentials. But shut RCU-lockdep up */ + 191. rcu_read_lock(); + 192. > atomic_dec(&__task_cred(p)->user->processes); + 193. rcu_read_unlock(); + 194. + +net/ipv4/udp.c:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. inet_rcv_saddr_equal(sk, sk2, true)) { + 201. if (sk2->sk_reuseport && sk->sk_reuseport && + 202. > !rcu_access_pointer(sk->sk_reuseport_cb) && + 203. uid_eq(uid, sock_i_uid(sk2))) { + 204. res = 0; + +net/netlabel/netlabel_domainhash.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. return entry; + 192. if (family == AF_INET || family == AF_UNSPEC) { + 193. > entry = netlbl_domhsh_rcu_deref(netlbl_domhsh_def_ipv4); + 194. if (entry != NULL && entry->valid) + 195. return entry; + +net/netlabel/netlabel_domainhash.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. } + 197. if (family == AF_INET6 || family == AF_UNSPEC) { + 198. > entry = netlbl_domhsh_rcu_deref(netlbl_domhsh_def_ipv6); + 199. if (entry != NULL && entry->valid) + 200. return entry; + +net/netlink/genetlink.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. netlink_table_grab(); + 233. rcu_read_lock(); + 234. > for_each_net_rcu(net) { + 235. err = __netlink_change_ngroups(net->genl_sock, + 236. mc_groups_longs * BITS_PER_LONG); + +arch/x86/include/asm/atomic.h:187: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 185. static __always_inline int atomic_cmpxchg(atomic_t *v, int old, int new) + 186. { + 187. > return cmpxchg(&v->counter, old, new); + 188. } + 189. + +net/netfilter/nf_conntrack_netlink.c:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. return 0; + 194. + 195. > helper = rcu_dereference(help->helper); + 196. if (!helper) + 197. goto out; + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +kernel/seccomp.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. u32 ret = SECCOMP_RET_ALLOW; + 191. /* Make sure cross-thread synced filter points somewhere sane. */ + 192. > struct seccomp_filter *f = + 193. READ_ONCE(current->seccomp.filter); + 194. + +scripts/mod/file2alias.c:196: error: DEAD_STORE + The value written to &bcdDevice_lo (type unsigned short) is never used. + 194. DEF_FIELD(symval, usb_device_id, idVendor); + 195. DEF_FIELD(symval, usb_device_id, idProduct); + 196. > DEF_FIELD(symval, usb_device_id, bcdDevice_lo); + 197. DEF_FIELD(symval, usb_device_id, bDeviceClass); + 198. DEF_FIELD(symval, usb_device_id, bDeviceSubClass); + +drivers/video/fbdev/core/fbcvt.c:192: error: DEAD_STORE + The value written to &aspect (type unsigned int) is never used. + 190. u32 xres = cvt->xres; + 191. u32 yres = cvt->yres; + 192. > u32 aspect = -1; + 193. + 194. if (xres == (yres * 4)/3 && !((yres * 4) % 3)) + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +kernel/cred.c:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. + 194. do { + 195. > cred = __task_cred((task)); + 196. BUG_ON(!cred); + 197. } while (!atomic_inc_not_zero(&((struct cred *)cred)->usage)); + +net/netfilter/nf_nat_core.c:200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 198. const struct nf_conn *ct; + 199. + 200. > hlist_for_each_entry_rcu(ct, &nf_nat_bysource[h], nat_bysource) { + 201. if (same_src(ct, tuple) && + 202. net_eq(net, nf_ct_net(ct)) && + +drivers/char/agp/compat_ioctl.c:198: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 196. return -EFAULT; + 197. + 198. > memory = agp_find_mem_by_key(unbind.key); + 199. + 200. if (memory == NULL) + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +kernel/power/process.c:210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 208. + 209. read_lock(&tasklist_lock); + 210. > for_each_process_thread(g, p) { + 211. /* No other threads should have PF_SUSPEND_TASK set */ + 212. WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK)); + +kernel/sys.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. else + 223. pgrp = task_pgrp(current); + 224. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 225. error = set_one_prio(p, niceval, error); + 226. } while_each_pid_thread(pgrp, PIDTYPE_PGID, p); + +kernel/sys.c:238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 236. goto out_unlock; /* No processes for this user */ + 237. } + 238. > do_each_thread(g, p) { + 239. if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) + 240. error = set_one_prio(p, niceval, error); + +kernel/sys.c:239: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 237. } + 238. do_each_thread(g, p) { + 239. > if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) + 240. error = set_one_prio(p, niceval, error); + 241. } while_each_thread(g, p); + +net/core/netpoll.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. { + 192. const struct net_device_ops *ops; + 193. > struct netpoll_info *ni = rcu_dereference_bh(dev->npinfo); + 194. + 195. /* Don't do any rx activity if the dev_lock mutex is held + +security/selinux/hooks.c:199: error: NULL_DEREFERENCE + pointer `tsec` last assigned on line 195 could be null and is dereferenced at line 199, column 15. + 197. panic("SELinux: Failed to initialize initial task.\n"); + 198. + 199. > tsec->osid = tsec->sid = SECINITSID_KERNEL; + 200. cred->security = tsec; + 201. } + +drivers/md/dm.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. unsigned def, unsigned max) + 193. { + 194. > unsigned param = READ_ONCE(*module_param); + 195. unsigned modified_param = 0; + 196. + +drivers/tty/tty_jobctrl.c:199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 197. read_lock(&tasklist_lock); + 198. if (tty->session) { + 199. > do_each_pid_task(tty->session, PIDTYPE_SID, p) { + 200. spin_lock_irq(&p->sighand->siglock); + 201. if (p->signal->tty == tty) { + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +net/sched/sch_mq.c:198: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 194 could be null and is dereferenced at line 198, column 18. + 196. tcm->tcm_parent = TC_H_ROOT; + 197. tcm->tcm_handle |= TC_H_MIN(cl); + 198. > tcm->tcm_info = dev_queue->qdisc_sleeping->handle; + 199. return 0; + 200. } + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +net/ipv4/ip_input.c:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. raw = raw_local_deliver(skb, protocol); + 204. + 205. > ipprot = rcu_dereference(inet_protos[protocol]); + 206. if (ipprot) { + 207. int ret; + +net/wireless/reg.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. static struct regulatory_request *get_last_request(void) + 193. { + 194. > return rcu_dereference_rtnl(last_request); + 195. } + 196. + +scripts/kconfig/menu.c:195: error: MEMORY_LEAK + memory dynamically allocated by call to `expr_alloc_symbol()` at line 195, column 28 is not reachable after line 195, column 2. + 193. void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep) + 194. { + 195. > menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep); + 196. } + 197. + +arch/x86/lib/msr-smp.c:206: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 204. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 205. + 206. > return err ? err : rv.err; + 207. } + 208. EXPORT_SYMBOL(wrmsrl_safe_on_cpu); + +include/linux/netfilter.h:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. switch (pf) { + 211. case NFPROTO_IPV4: + 212. > hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]); + 213. break; + 214. case NFPROTO_IPV6: + +include/linux/netfilter.h:215: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 213. break; + 214. case NFPROTO_IPV6: + 215. > hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]); + 216. break; + 217. case NFPROTO_ARP: + +net/ipv6/proc.c:206: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 204. snmp_get_cpu_field_batch(buff, itemlist, pcpumib); + 205. for (i = 0; itemlist[i].name; i++) + 206. > seq_printf(seq, "%-32s\t%lu\n", + 207. itemlist[i].name, buff[i]); + 208. } else { + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +kernel/ucount.c:204: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 202. int max; + 203. tns = iter->ns; + 204. > max = READ_ONCE(tns->ucount_max[type]); + 205. if (!atomic_inc_below(&iter->ucount[type], max)) + 206. goto fail; + +net/netfilter/nf_log.c:208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 206. + 207. rcu_read_lock(); + 208. > logger = rcu_dereference(loggers[pf][type]); + 209. module_put(logger->me); + 210. rcu_read_unlock(); + +net/sunrpc/xprtmultipath.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. struct rpc_xprt *xprt_switch_find_first_entry(struct list_head *head) + 197. { + 198. > return list_first_or_null_rcu(head, struct rpc_xprt, xprt_switch); + 199. } + 200. + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +drivers/gpu/drm/drm_ioc32.c:210: error: UNINITIALIZED_VALUE + The value read from m32.flags was never initialized. + 208. map.size = m32.size; + 209. map.type = m32.type; + 210. > map.flags = m32.flags; + 211. + 212. err = drm_ioctl_kernel(file, drm_legacy_addmap_ioctl, &map, + +drivers/gpu/drm/drm_ioc32.c:207: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 205. return -EFAULT; + 206. + 207. > map.offset = m32.offset; + 208. map.size = m32.size; + 209. map.type = m32.type; + +drivers/gpu/drm/drm_ioc32.c:208: error: UNINITIALIZED_VALUE + The value read from m32.size was never initialized. + 206. + 207. map.offset = m32.offset; + 208. > map.size = m32.size; + 209. map.type = m32.type; + 210. map.flags = m32.flags; + +drivers/gpu/drm/drm_ioc32.c:209: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 207. map.offset = m32.offset; + 208. map.size = m32.size; + 209. > map.type = m32.type; + 210. map.flags = m32.flags; + 211. + +drivers/gpu/drm/drm_ioc32.c:221: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + 221. > pr_err_ratelimited("compat_drm_addmap truncated handle %p for type %d offset %x\n", + 222. map.handle, m32.type, m32.offset); + 223. + +drivers/gpu/drm/drm_ioc32.c:218: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 216. + 217. m32.offset = map.offset; + 218. > m32.mtrr = map.mtrr; + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + +kernel/sched/cpuacct.c:209: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 199 could be null and is dereferenced by call to `cpuacct_cpuusage_write()` at line 209, column 3. + 207. + 208. for_each_possible_cpu(cpu) + 209. > cpuacct_cpuusage_write(ca, cpu, 0); + 210. + 211. return 0; + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/kthread.c:219: error: NULL_DEREFERENCE + pointer `done` last assigned on line 211 could be null and is dereferenced by call to `complete()` at line 219, column 3. + 217. if (!self) { + 218. create->result = ERR_PTR(-ENOMEM); + 219. > complete(done); + 220. do_exit(-ENOMEM); + 221. } + +net/ipv6/udp.c:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. result = NULL; + 242. badness = -1; + 243. > sk_for_each_rcu(sk, &hslot->head) { + 244. score = compute_score(sk, net, saddr, sport, daddr, hnum, dif, + 245. sdif, exact_dif); + +lib/idr.c:211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 209. if (WARN_ON_ONCE(id > INT_MAX)) + 210. break; + 211. > ret = fn(id, rcu_dereference_raw(*slot), data); + 212. if (ret) + 213. return ret; + +net/ipv6/seg6.c:215: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 213. + 214. rcu_read_lock(); + 215. > tun_src = rcu_dereference(seg6_pernet(net)->tun_src); + 216. + 217. if (nla_put(msg, SEG6_ATTR_DST, sizeof(struct in6_addr), tun_src)) + +kernel/power/user.c:373: error: UNINITIALIZED_VALUE + The value read from swap_area.dev was never initialized. + 371. * so we need to recode them + 372. */ + 373. > swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. offset = swap_area.offset; + +kernel/power/user.c:375: error: UNINITIALIZED_VALUE + The value read from swap_area.offset was never initialized. + 373. swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. > offset = swap_area.offset; + 376. data->swap = swap_type_of(swdev, offset, NULL); + 377. if (data->swap < 0) + +net/netlabel/netlabel_addrlist.c:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. * address mask such that the entry with the widest mask (smallest + 212. * numerical value) appears first in the list */ + 213. > list_for_each_entry_rcu(iter, head, list) + 214. if (iter->valid && + 215. ipv6_addr_cmp(&entry->mask, &iter->mask) > 0) { + +block/ioctl.c:218: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 216. return -EFAULT; + 217. + 218. > start = range[0]; + 219. len = range[1]; + 220. + +block/ioctl.c:219: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 217. + 218. start = range[0]; + 219. > len = range[1]; + 220. + 221. if (start & 511) + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +net/netlabel/netlabel_unlabeled.c:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. static u32 netlbl_unlhsh_hash(int ifindex) + 201. { + 202. > return ifindex & (netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->size - 1); + 203. } + 204. + +drivers/char/hpet.c:254: error: UNINITIALIZED_VALUE + The value read from gsi was never initialized. + 252. v |= irq << Tn_INT_ROUTE_CNF_SHIFT; + 253. writel(v, &timer->hpet_config); + 254. > devp->hd_hdwirq = gsi; + 255. spin_unlock_irq(&hpet_lock); + 256. } + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +kernel/sched/loadavg.c:208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 206. * If we're still before the pending sample window, we're done. + 207. */ + 208. > this_rq->calc_load_update = READ_ONCE(calc_load_update); + 209. if (time_before(jiffies, this_rq->calc_load_update)) + 210. return; + +net/sunrpc/xprtmultipath.c:204: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 202. struct rpc_xprt *xprt_iter_first_entry(struct rpc_xprt_iter *xpi) + 203. { + 204. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 205. + 206. if (xps == NULL) + +crypto/rsa.c:218: error: DEAD_STORE + The value written to &ret (type int) is never used. + 216. } + 217. + 218. > ret = -ENOMEM; + 219. s = mpi_read_raw_from_sgl(req->src, req->src_len); + 220. if (!s) { + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/tty/tty_audit.c:209: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 207. dev_t dev; + 208. + 209. > audit_tty = READ_ONCE(current->signal->audit_tty); + 210. if (~audit_tty & AUDIT_TTY_ENABLE) + 211. return; + +net/sched/sch_mq.c:207: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 205 could be null and is dereferenced at line 207, column 8. + 205. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 206. + 207. > sch = dev_queue->qdisc_sleeping; + 208. if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || + 209. gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) + +security/selinux/avc.c:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. slots_used++; + 216. chain_len = 0; + 217. > hlist_for_each_entry_rcu(node, head, list) + 218. chain_len++; + 219. if (chain_len > max_chain_len) + +drivers/input/mouse/synaptics.c:215: error: UNINITIALIZED_VALUE + The value read from resp.be_val was never initialized. + 213. return error; + 214. + 215. > *val = be32_to_cpu(resp.be_val); + 216. return 0; + 217. } + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +kernel/cgroup/freezer.c:221: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 220 could be null and is dereferenced at line 221, column 6. + 219. + 220. freezer = task_freezer(task); + 221. > if (freezer->state & CGROUP_FREEZING) + 222. freeze_task(task); + 223. + +drivers/gpu/drm/i915/intel_dp_mst.c:245: error: DEAD_STORE + The value written to &ret (type int) is never used. + 243. I915_WRITE(DP_TP_STATUS(port), temp); + 244. + 245. > ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); + 246. } + 247. + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/fork.c:214: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 212. struct vm_struct *s; + 213. + 214. > s = this_cpu_xchg(cached_stacks[i], NULL); + 215. + 216. if (!s) + +kernel/fork.c:214: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 212. struct vm_struct *s; + 213. + 214. > s = this_cpu_xchg(cached_stacks[i], NULL); + 215. + 216. if (!s) + +net/sunrpc/stats.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. + 218. rcu_read_lock(); + 219. > xprt = rcu_dereference(clnt->cl_xprt); + 220. if (xprt) + 221. xprt->ops->print_stats(xprt, seq); + +security/commoncap.c:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. /* Derived from kernel/capability.c:sys_capget. */ + 211. rcu_read_lock(); + 212. > cred = __task_cred(target); + 213. *effective = cred->cap_effective; + 214. *inheritable = cred->cap_inheritable; + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +drivers/pci/pcie/aspm.c:256: error: DEAD_STORE + The value written to &start_jiffies (type unsigned long) is never used. + 254. + 255. /* Wait for link training end. Break out after waiting for timeout */ + 256. > start_jiffies = jiffies; + 257. for (;;) { + 258. pcie_capability_read_word(parent, PCI_EXP_LNKSTA, ®16); + +drivers/pci/pcie/aspm.c:271: error: UNINITIALIZED_VALUE + The value read from child_reg[_] was never initialized. + 269. pci_err(parent, "ASPM: Could not configure common clock\n"); + 270. list_for_each_entry(child, &linkbus->devices, bus_list) + 271. > pcie_capability_write_word(child, PCI_EXP_LNKCTL, + 272. child_reg[PCI_FUNC(child->devfn)]); + 273. pcie_capability_write_word(parent, PCI_EXP_LNKCTL, parent_reg); + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +kernel/audit_tree.c:214: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 212. struct audit_chunk *p; + 213. + 214. > list_for_each_entry_rcu(p, list, hash) { + 215. if (chunk_to_key(p) == key) { + 216. atomic_long_inc(&p->refs); + +kernel/rcu/tree.c:211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 209. unsigned long rcu_rnp_online_cpus(struct rcu_node *rnp) + 210. { + 211. > return READ_ONCE(rnp->qsmaskinitnext); + 212. } + 213. + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +arch/x86/lib/msr-smp.c:221: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 219. *q = rv.reg.q; + 220. + 221. > return err ? err : rv.err; + 222. } + 223. EXPORT_SYMBOL(rdmsrl_safe_on_cpu); + +crypto/algboss.c:213: error: DEAD_STORE + The value written to &type (type unsigned int) is never used. + 211. { + 212. struct crypto_test_param *param = data; + 213. > u32 type = param->type; + 214. int err = 0; + 215. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:224: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 222. */ + 223. ret = wait_for(guc_ready(guc, &status), 100); + 224. > DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + 226. if ((status & GS_BOOTROM_MASK) == GS_BOOTROM_RSA_FAILED) { + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +lib/bug.c:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. + 215. rcu_read_lock_sched(); + 216. > list_for_each_entry_rcu(mod, &module_bug_list, bug_list) + 217. clear_once_table(mod->bug_table, + 218. mod->bug_table + mod->num_bugs); + +net/core/dst.c:222: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 220. + 221. new = (unsigned long) p; + 222. > prev = cmpxchg(&dst->_metrics, old, new); + 223. + 224. if (prev != old) { + +net/core/net-procfs.c:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. int t; + 215. + 216. > list_for_each_entry_rcu(pt, &ptype_all, list) { + 217. if (i == pos) + 218. return pt; + +net/core/net-procfs.c:223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 221. + 222. for (t = 0; t < PTYPE_HASH_SIZE; t++) { + 223. > list_for_each_entry_rcu(pt, &ptype_base[t], list) { + 224. if (i == pos) + 225. return pt; + +net/ipv4/tcp_metrics.c:218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 216. int depth = 0; + 217. + 218. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 219. tm = rcu_dereference(tm->tcpm_next)) { + 220. if (addr_same(&tm->tcpm_saddr, saddr) && + +net/ipv4/tcp_metrics.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. + 218. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 219. > tm = rcu_dereference(tm->tcpm_next)) { + 220. if (addr_same(&tm->tcpm_saddr, saddr) && + 221. addr_same(&tm->tcpm_daddr, daddr) && + +net/sunrpc/xprtmultipath.c:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. struct rpc_xprt *pos; + 216. + 217. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 218. if (cur == pos) + 219. return pos; + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +net/wireless/radiotap.c:304: error: UNINITIALIZED_VALUE + The value read from size was never initialized. + 302. iterator->this_arg_index = iterator->_arg_index; + 303. iterator->this_arg = iterator->_arg; + 304. > iterator->this_arg_size = size; + 305. + 306. /* internally move on the size of this arg */ + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/tty/tty_buffer.c:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. * no pending memory accesses to the freed buffer + 225. */ + 226. > while ((next = smp_load_acquire(&buf->head->next)) != NULL) { + 227. tty_buffer_free(port, buf->head); + 228. buf->head = next; + +drivers/video/fbdev/core/fbcvt.c:261: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 259. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. > cnt -= read; + 262. offset += read; + 263. } + +drivers/video/fbdev/core/fbcvt.c:262: error: DEAD_STORE + The value written to &offset (type int) is never used. + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. cnt -= read; + 262. > offset += read; + 263. } + 264. } + +include/linux/inetdevice.h:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. static inline struct in_device *__in_dev_get_rcu(const struct net_device *dev) + 215. { + 216. > return rcu_dereference(dev->ip_ptr); + 217. } + 218. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +lib/genalloc.c:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. + 219. rcu_read_lock(); + 220. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 221. if (addr >= chunk->start_addr && addr <= chunk->end_addr) { + 222. paddr = chunk->phys_addr + (addr - chunk->start_addr); + +lib/rhashtable.c:221: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 219. do { + 220. new_tbl = tbl; + 221. > tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 222. } while (tbl); + 223. + +net/netfilter/nf_log.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. rcu_read_lock(); + 228. if (loginfo != NULL) + 229. > logger = rcu_dereference(loggers[pf][loginfo->type]); + 230. else + 231. logger = rcu_dereference(net->nf.nf_loggers[pf]); + +net/netfilter/nf_log.c:231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 229. logger = rcu_dereference(loggers[pf][loginfo->type]); + 230. else + 231. > logger = rcu_dereference(net->nf.nf_loggers[pf]); + 232. + 233. if (logger) { + +drivers/ata/libata-sff.c:223: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 221. status = ata_sff_busy_wait(ap, ATA_BUSY, 300); + 222. timer_start = jiffies; + 223. > timeout = ata_deadline(timer_start, tmout_pat); + 224. while (status != 0xff && (status & ATA_BUSY) && + 225. time_before(jiffies, timeout)) { + +drivers/ata/libata-sff.c:235: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 233. status); + 234. + 235. > timeout = ata_deadline(timer_start, tmout); + 236. while (status != 0xff && (status & ATA_BUSY) && + 237. time_before(jiffies, timeout)) { + +net/ipv6/proc.c:225: error: UNINITIALIZED_VALUE + The value read from buff64[_] was never initialized. + 223. snmp_get_cpu_field64_batch(buff64, itemlist, mib, syncpoff); + 224. for (i = 0; itemlist[i].name; i++) + 225. > seq_printf(seq, "%-32s\t%llu\n", itemlist[i].name, buff64[i]); + 226. } + 227. + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +kernel/audit.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. rcu_read_lock(); + 222. > ac = rcu_dereference(auditd_conn); + 223. rc = (ac && ac->pid == task_tgid(task) ? 1 : 0); + 224. rcu_read_unlock(); + +net/netlabel/netlabel_unlabeled.c:223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 221. + 222. bkt = netlbl_unlhsh_hash(ifindex); + 223. > bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]; + 224. list_for_each_entry_rcu(iter, bkt_list, list) + 225. if (iter->valid && iter->ifindex == ifindex) + +net/netlabel/netlabel_unlabeled.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. bkt = netlbl_unlhsh_hash(ifindex); + 223. bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]; + 224. > list_for_each_entry_rcu(iter, bkt_list, list) + 225. if (iter->valid && iter->ifindex == ifindex) + 226. return iter; + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +net/wireless/trace.h:217: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +security/selinux/hooks.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. rcu_read_lock(); + 222. > sid = cred_sid(__task_cred(task)); + 223. rcu_read_unlock(); + 224. return sid; + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +net/core/sock_reuseport.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. + 228. rcu_read_lock(); + 229. > reuse = rcu_dereference(sk->sk_reuseport_cb); + 230. + 231. /* if memory allocation failed or add call is not yet complete */ + +net/core/sock_reuseport.c:235: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 233. goto out; + 234. + 235. > prog = rcu_dereference(reuse->prog); + 236. socks = READ_ONCE(reuse->num_socks); + 237. if (likely(socks)) { + +net/core/sock_reuseport.c:236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 234. + 235. prog = rcu_dereference(reuse->prog); + 236. > socks = READ_ONCE(reuse->num_socks); + 237. if (likely(socks)) { + 238. /* paired with smp_wmb() in reuseport_add_sock() */ + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +drivers/scsi/scsi_logging.c:249: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 247. if (cmd->cmd_len > 16) { + 248. /* Print opcode in one line and use separate lines for CDB */ + 249. > off += scnprintf(logbuf + off, logbuf_len - off, "\n"); + 250. dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf); + 251. scsi_log_release_buffer(logbuf); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +drivers/iommu/dmar.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. } + 263. + 264. > for_each_dev_scope(devices, devices_cnt, i, tmp) + 265. if (tmp == NULL) { + 266. devices[i].bus = info->dev->bus->number; + +net/xfrm/xfrm_state.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. typemap = afinfo->type_map; + 233. + 234. > type = READ_ONCE(typemap[proto]); + 235. if (unlikely(type && !try_module_get(type->owner))) + 236. type = NULL; + +security/selinux/ss/conditional.c:238: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 236. goto err; + 237. + 238. > booldatum->value = le32_to_cpu(buf[0]); + 239. booldatum->state = le32_to_cpu(buf[1]); + 240. + +security/selinux/ss/conditional.c:239: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 237. + 238. booldatum->value = le32_to_cpu(buf[0]); + 239. > booldatum->state = le32_to_cpu(buf[1]); + 240. + 241. rc = -EINVAL; + +security/selinux/ss/conditional.c:245: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 243. goto err; + 244. + 245. > len = le32_to_cpu(buf[2]); + 246. if (((len == 0) || (len == (u32)-1))) + 247. goto err; + +drivers/tty/vt/vt_ioctl.c:240: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 238. op->width = 8; + 239. op->height = cfdarg.charheight; + 240. > op->charcount = cfdarg.charcount; + 241. op->data = cfdarg.chardata; + 242. return con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:248: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 246. op->width = 8; + 247. op->height = cfdarg.charheight; + 248. > op->charcount = cfdarg.charcount; + 249. op->data = cfdarg.chardata; + 250. i = con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:241: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 239. op->height = cfdarg.charheight; + 240. op->charcount = cfdarg.charcount; + 241. > op->data = cfdarg.chardata; + 242. return con_font_op(vc_cons[fg_console].d, op); + 243. case GIO_FONTX: { + +drivers/tty/vt/vt_ioctl.c:249: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 247. op->height = cfdarg.charheight; + 248. op->charcount = cfdarg.charcount; + 249. > op->data = cfdarg.chardata; + 250. i = con_font_op(vc_cons[fg_console].d, op); + 251. if (i) + +drivers/tty/vt/vt_ioctl.c:239: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 237. op->flags = KD_FONT_FLAG_OLD; + 238. op->width = 8; + 239. > op->height = cfdarg.charheight; + 240. op->charcount = cfdarg.charcount; + 241. op->data = cfdarg.chardata; + +drivers/tty/vt/vt_ioctl.c:247: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 245. op->flags = KD_FONT_FLAG_OLD; + 246. op->width = 8; + 247. > op->height = cfdarg.charheight; + 248. op->charcount = cfdarg.charcount; + 249. op->data = cfdarg.chardata; + +include/net/ip6_fib.h:230: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 228. + 229. rcu_read_lock(); + 230. > fn = rcu_dereference(rt->rt6i_node); + 231. + 232. if (fn) { + +net/core/netpoll.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. might_sleep(); + 228. idx = srcu_read_lock(&netpoll_srcu); + 229. > ni = srcu_dereference(dev->npinfo, &netpoll_srcu); + 230. if (ni) + 231. down(&ni->dev_lock); + +net/ipv4/ip_tunnel.c:236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 234. struct hlist_head *head = ip_bucket(itn, parms); + 235. + 236. > hlist_for_each_entry_rcu(t, head, hash_node) { + 237. if (local == t->parms.iph.saddr && + 238. remote == t->parms.iph.daddr && + +net/ipv6/ip6_input.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. resubmit_final: + 246. raw = raw6_local_deliver(skb, nexthdr); + 247. > ipprot = rcu_dereference(inet6_protos[nexthdr]); + 248. if (ipprot) { + 249. int ret; + +net/sunrpc/xprtmultipath.c:227: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 225. struct rpc_xprt *xprt_iter_current_entry(struct rpc_xprt_iter *xpi) + 226. { + 227. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 228. struct list_head *head; + 229. + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +arch/x86/events/intel/bts.c:232: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 229 could be null and is dereferenced at line 232, column 7. + 230. u64 config = 0; + 231. + 232. > if (!buf->snapshot) + 233. config |= ARCH_PERFMON_EVENTSEL_INT; + 234. if (!event->attr.exclude_kernel) + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +net/ipv4/inet_hashtables.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. score += 4; + 250. } + 251. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 252. score++; + 253. } + +net/ipv4/netfilter/ip_tables.c:263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 261. local_bh_disable(); + 262. addend = xt_write_recseq_begin(); + 263. > private = READ_ONCE(table->private); /* Address dependency. */ + 264. cpu = smp_processor_id(); + 265. table_base = private->entries; + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = READ_ONCE(table->private); /* Address dependency. */ + 264. > cpu = smp_processor_id(); + 265. table_base = private->entries; + 266. jumpstack = (struct ipt_entry **)private->jumpstack[cpu]; + +net/ipv4/netfilter/ip_tables.c:276: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 274. */ + 275. if (static_key_false(&xt_tee_enabled)) + 276. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 277. + 278. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = READ_ONCE(table->private); /* Address dependency. */ + 264. > cpu = smp_processor_id(); + 265. table_base = private->entries; + 266. jumpstack = (struct ipt_entry **)private->jumpstack[cpu]; + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:233: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 230 could be null and is dereferenced at line 233, column 6. + 231. struct intel_panel *panel = &connector->panel; + 232. + 233. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) + 234. panel->backlight.max = 0xFFFF; + 235. else + +kernel/power/process.c:237: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 235. + 236. read_lock(&tasklist_lock); + 237. > for_each_process_thread(g, p) { + 238. if (p->flags & (PF_KTHREAD | PF_WQ_WORKER)) + 239. __thaw_task(p); + +lib/rhashtable.c:261: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 259. + 260. spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING); + 261. > head = rht_dereference_bucket(new_tbl->buckets[new_hash], + 262. new_tbl, new_hash); + 263. + +lib/rhashtable.c:231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 229. struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht); + 230. struct bucket_table *new_tbl = rhashtable_last_table(ht, + 231. > rht_dereference_rcu(old_tbl->future_tbl, ht)); + 232. struct rhash_head __rcu **pprev = rht_bucket_var(old_tbl, old_hash); + 233. int err = -EAGAIN; + +lib/rhashtable.c:269: error: UNINITIALIZED_VALUE + The value read from next was never initialized. + 267. spin_unlock(new_bucket_lock); + 268. + 269. > rcu_assign_pointer(*pprev, next); + 270. + 271. out: + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +net/ipv4/tcp_metrics.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. hash = hash_32(hash, tcp_metrics_hash_log); + 259. + 260. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 261. tm = rcu_dereference(tm->tcpm_next)) { + 262. if (addr_same(&tm->tcpm_saddr, &saddr) && + +net/ipv4/tcp_metrics.c:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. + 260. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 261. > tm = rcu_dereference(tm->tcpm_next)) { + 262. if (addr_same(&tm->tcpm_saddr, &saddr) && + 263. addr_same(&tm->tcpm_daddr, &daddr) && + +kernel/rcu/tree.c:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. { + 232. RCU_LOCKDEP_WARN(preemptible(), "rcu_sched_qs() invoked with preemption enabled!!!"); + 233. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + +kernel/rcu/tree.c:236: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + 236. > __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + 239. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 240. return; + 241. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.exp, false); + +kernel/rcu/tree.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. > trace_rcu_grace_period(TPS("rcu_sched"), + 236. __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + +lib/idr.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. + 246. *nextid = id; + 247. > return rcu_dereference_raw(*slot); + 248. } + 249. EXPORT_SYMBOL(idr_get_next); + +net/netfilter/nf_conntrack_helper.c:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. * we cannot reallocate the helper extension area. + 272. */ + 273. > struct nf_conntrack_helper *tmp = rcu_dereference(help->helper); + 274. + 275. if (tmp && tmp->help != helper->help) { + +block/blk-lib.c:253: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 252 could be null and is dereferenced at line 253, column 3. + 251. while (nr_sects) { + 252. bio = next_bio(bio, 0, gfp_mask); + 253. > bio->bi_iter.bi_sector = sector; + 254. bio_set_dev(bio, bdev); + 255. bio->bi_opf = REQ_OP_WRITE_ZEROES; + +drivers/video/backlight/backlight.c:234: error: DEAD_STORE + The value written to &rc (type int) is never used. + 232. struct device_attribute *attr, char *buf) + 233. { + 234. > int rc = -ENXIO; + 235. struct backlight_device *bd = to_backlight_device(dev); + 236. + +sound/hda/hdac_controller.c:239: error: DEAD_STORE + The value written to &loopcounter (type unsigned long) is never used. + 237. timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. > for (loopcounter = 0;; loopcounter++) { + 240. spin_lock_irq(&bus->reg_lock); + 241. if (!bus->rirb.cmds[addr]) { + +sound/hda/hdac_controller.c:237: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 235. unsigned long loopcounter; + 236. + 237. > timeout = jiffies + msecs_to_jiffies(1000); + 238. + 239. for (loopcounter = 0;; loopcounter++) { + +kernel/rcu/srcutree.c:238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 236. WARN_ON_ONCE(rcu_scheduler_active == RCU_SCHEDULER_INIT); + 237. /* The smp_load_acquire() pairs with the smp_store_release(). */ + 238. > if (!rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq_needed))) /*^^^*/ + 239. return; /* Already initialized. */ + 240. spin_lock_irqsave_rcu_node(sp, flags); + +block/ioctl.c:246: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 244. return -EFAULT; + 245. + 246. > start = range[0]; + 247. len = range[1]; + 248. end = start + len - 1; + +block/ioctl.c:247: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 245. + 246. start = range[0]; + 247. > len = range[1]; + 248. end = start + len - 1; + 249. + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +kernel/exit.c:245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 243. */ + 244. retry: + 245. > task = rcu_dereference(*ptask); + 246. if (!task) + 247. return NULL; + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +drivers/gpu/drm/i915/i915_debugfs.c:245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 243. int ret; + 244. + 245. > total = READ_ONCE(dev_priv->mm.object_count); + 246. objects = kvmalloc_array(total, sizeof(*objects), GFP_KERNEL); + 247. if (!objects) + +kernel/audit.c:241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 239. + 240. rcu_read_lock(); + 241. > ac = rcu_dereference(auditd_conn); + 242. if (!ac || !ac->pid) + 243. pid = 0; + +security/selinux/ss/mls.c:366: error: DEAD_STORE + The value written to &p (type char*) is never used. + 364. goto out; + 365. } + 366. > *scontext = ++p; + 367. rc = 0; + 368. out: + +drivers/gpu/drm/i915/intel_hdmi.c:248: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 240 could be null and is dereferenced at line 248, column 37. + 246. return false; + 247. + 248. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 249. return false; + 250. + +drivers/video/fbdev/core/bitblit.c:252: error: DEAD_STORE + The value written to &mode (type int) is never used. + 250. if (softback_lines) { + 251. if (y + softback_lines >= vc->vc_rows) { + 252. > mode = CM_ERASE; + 253. ops->cursor_flash = 0; + 254. return; + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +kernel/trace/trace_events.c:242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 240. struct trace_pid_list *pid_list; + 241. + 242. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 243. if (!pid_list) + 244. return false; + +net/core/netpoll.c:240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 238. struct netpoll_info *ni; + 239. rcu_read_lock(); + 240. > ni = rcu_dereference(dev->npinfo); + 241. if (ni) + 242. up(&ni->dev_lock); + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +drivers/firmware/efi/esrt.c:305: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_count was never initialized. + 303. */ + 304. if (tmpesrt.fw_resource_count > 128) { + 305. > pr_err("ESRT says fw_resource_count has very large value %d.\n", + 306. tmpesrt.fw_resource_count); + 307. goto err_memunmap; + +drivers/firmware/efi/esrt.c:286: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_version was never initialized. + 284. entry_size = sizeof (*v1_entries); + 285. } else { + 286. > pr_err("Unsupported ESRT version %lld.\n", + 287. tmpesrt.fw_resource_version); + 288. return; + +lib/sbitmap.c:246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 244. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. > unsigned long word = READ_ONCE(sb->map[i].word); + 247. unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + +lib/sbitmap.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. unsigned long word = READ_ONCE(sb->map[i].word); + 247. > unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + 249. while (word_bits > 0) { + +net/core/gen_estimator.c:240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 238. bool gen_estimator_active(struct net_rate_estimator __rcu **rate_est) + 239. { + 240. > return !!rcu_access_pointer(*rate_est); + 241. } + 242. EXPORT_SYMBOL(gen_estimator_active); + +net/sunrpc/xprtmultipath.c:248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 246. + 247. head = &xps->xps_xprt_list; + 248. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 249. if (rpc_cmp_addr_port(sap, (struct sockaddr *)&pos->addr)) { + 250. pr_info("RPC: addr %s already in xprt switch\n", + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +net/core/dst.c:245: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 243. + 244. new = ((unsigned long) &dst_default_metrics) | DST_METRICS_READ_ONLY; + 245. > prev = cmpxchg(&dst->_metrics, old, new); + 246. if (prev == old) + 247. kfree(__DST_METRICS_PTR(old)); + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +kernel/kexec.c:265: error: UNINITIALIZED_VALUE + The value read from in.buf was never initialized. + 263. return -EFAULT; + 264. + 265. > out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + +kernel/kexec.c:266: error: UNINITIALIZED_VALUE + The value read from in.bufsz was never initialized. + 264. + 265. out.buf = compat_ptr(in.buf); + 266. > out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. out.memsz = in.memsz; + +kernel/kexec.c:267: error: UNINITIALIZED_VALUE + The value read from in.mem was never initialized. + 265. out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. > out.mem = in.mem; + 268. out.memsz = in.memsz; + 269. + +kernel/kexec.c:268: error: UNINITIALIZED_VALUE + The value read from in.memsz was never initialized. + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. > out.memsz = in.memsz; + 269. + 270. result = copy_to_user(&ksegments[i], &out, sizeof(out)); + +lib/random32.c:250: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 248. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. > state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + +lib/random32.c:251: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. state->s1 = __seed(seeds[0], 2U); + 251. > state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + +lib/random32.c:252: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 250. state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. > state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + 254. + +lib/random32.c:253: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. > state->s4 = __seed(seeds[3], 128U); + 254. + 255. prandom_warmup(state); + +net/ipv6/ip6_flowlabel.c:249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 247. + 248. rcu_read_lock_bh(); + 249. > for_each_sk_fl_rcu(np, sfl) { + 250. struct ip6_flowlabel *fl = sfl->fl; + 251. if (fl->label == label) { + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +net/sunrpc/auth_gss/gss_rpc_xdr.c:253: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 251. if (unlikely(p == NULL)) + 252. return -ENOSPC; + 253. > count = be32_to_cpup(p++); + 254. if (!count) + 255. return 0; + +kernel/softirq.c:244: error: DEAD_STORE + The value written to &end (type unsigned long) is never used. + 242. asmlinkage __visible void __softirq_entry __do_softirq(void) + 243. { + 244. > unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. int max_restart = MAX_SOFTIRQ_RESTART; + +kernel/softirq.c:246: error: DEAD_STORE + The value written to &max_restart (type int) is never used. + 244. unsigned long end = jiffies + MAX_SOFTIRQ_TIME; + 245. unsigned long old_flags = current->flags; + 246. > int max_restart = MAX_SOFTIRQ_RESTART; + 247. struct softirq_action *h; + 248. bool in_hardirq; + +kernel/softirq.c:303: error: DEAD_STORE + The value written to &max_restart (type int) is never used. + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + 303. > --max_restart) + 304. goto restart; + 305. + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/md/dm-stripe.c:255: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 253. sector = *result; + 254. if (sc->chunk_size_shift < 0) + 255. > *result -= sector_div(sector, sc->chunk_size); + 256. else + 257. *result = sector & ~(sector_t)(sc->chunk_size - 1); + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +net/netfilter/nf_log.c:256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 254. + 255. rcu_read_lock(); + 256. > logger = rcu_dereference(net->nf.nf_loggers[pf]); + 257. if (logger) { + 258. va_start(args, fmt); + +arch/x86/events/intel/uncore.c:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. box = container_of(hrtimer, struct intel_uncore_box, hrtimer); + 252. > if (!box->n_active || box->cpu != smp_processor_id()) + 253. return HRTIMER_NORESTART; + 254. /* + +include/linux/dma-fence.h:250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 248. struct dma_fence *fence; + 249. + 250. > fence = rcu_dereference(*fencep); + 251. if (!fence) + 252. return NULL; + +include/linux/dma-fence.h:271: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 269. * the right fence, as below. + 270. */ + 271. > if (fence == rcu_access_pointer(*fencep)) + 272. return rcu_pointer_handoff(fence); + 273. + +init/main.c:254: error: DEAD_STORE + The value written to &val (type char*) is never used. + 252. val[-2] = '='; + 253. memmove(val-1, val, strlen(val)+1); + 254. > val--; + 255. } else + 256. BUG(); + +kernel/cgroup/freezer.c:253: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 246 could be null and is dereferenced at line 253, column 8. + 251. lockdep_assert_held(&freezer_mutex); + 252. + 253. > if (!(freezer->state & CGROUP_FREEZING) || + 254. (freezer->state & CGROUP_FROZEN)) + 255. return; + +net/core/gen_estimator.c:251: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 249. + 250. rcu_read_lock(); + 251. > est = rcu_dereference(*rate_est); + 252. if (!est) { + 253. rcu_read_unlock(); + +net/ipv6/inet6_hashtables.c:255: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 253. struct net *net = sock_net(sk); + 254. const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + 257. inet->inet_dport); + +net/ipv6/inet6_hashtables.c:254: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 252. const int dif = sk->sk_bound_dev_if; + 253. struct net *net = sock_net(sk); + 254. > const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + +net/packet/af_packet.c:265: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 263. local_bh_disable(); + 264. + 265. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 266. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 267. ret = netdev_start_xmit(skb, dev, txq, false); + +net/packet/af_packet.c:265: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 263. local_bh_disable(); + 264. + 265. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 266. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 267. ret = netdev_start_xmit(skb, dev, txq, false); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:254: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 249 could be null and is dereferenced at line 254, column 6. + 252. * the panel can support backlight control over the aux channel + 253. */ + 254. > if (intel_dp->edp_dpcd[1] & DP_EDP_TCON_BACKLIGHT_ADJUSTMENT_CAP && + 255. (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP) && + 256. !(intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_PWM_PIN_CAP)) { + +kernel/profile.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. + 250. mutex_lock(&profile_flip_mutex); + 251. > j = per_cpu(cpu_profile_flip, get_cpu()); + 252. put_cpu(); + 253. on_each_cpu(__profile_flip_buffers, NULL, 1); + +kernel/rcu/tree.c:249: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 247. { + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. > if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + +kernel/rcu/tree.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. > __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + 253. __this_cpu_write(rcu_bh_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. > trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + +net/ipv4/af_inet.c:266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 264. err = -ESOCKTNOSUPPORT; + 265. rcu_read_lock(); + 266. > list_for_each_entry_rcu(answer, &inetsw[sock->type], list) { + 267. + 268. err = 0; + +net/ipv4/inet_connection_sock.c:255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 253. if (!sk->sk_reuseport) + 254. return 0; + 255. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 256. return 0; + 257. if (!uid_eq(tb->fastuid, uid)) + +arch/x86/entry/common.c:249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 247. { + 248. struct thread_info *ti = current_thread_info(); + 249. > u32 cached_flags = READ_ONCE(ti->flags); + 250. + 251. CT_WARN_ON(ct_state() != CONTEXT_KERNEL); + +drivers/gpu/drm/i915/intel_dp_mst.c:268: error: DEAD_STORE + The value written to &ret (type int) is never used. + 266. DRM_ERROR("Timed out waiting for ACT sent\n"); + 267. + 268. > ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + +drivers/gpu/drm/i915/intel_dp_mst.c:270: error: DEAD_STORE + The value written to &ret (type int) is never used. + 268. ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. > ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + 271. if (pipe_config->has_audio) + 272. intel_audio_codec_enable(encoder, pipe_config, conn_state); + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +kernel/kprobes.c:256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 254. mutex_lock(&c->mutex); + 255. rcu_read_lock(); + 256. > list_for_each_entry_rcu(kip, &c->pages, list) { + 257. idx = ((long)slot - (long)kip->insns) / + 258. (c->insn_size * sizeof(kprobe_opcode_t)); + +kernel/kprobes.c:277: error: UNINITIALIZED_VALUE + The value read from idx was never initialized. + 275. collect_garbage_slots(c); + 276. } else { + 277. > collect_one_slot(kip, idx); + 278. } + 279. } + +lib/iomap.c:250: error: DEAD_STORE + The value written to &port (type unsigned long) is never used. + 248. void pci_iounmap(struct pci_dev *dev, void __iomem * addr) + 249. { + 250. > IO_COND(addr, /* nothing */, iounmap(addr)); + 251. } + 252. EXPORT_SYMBOL(pci_iounmap); + +net/ipv4/tcp_cong.c:254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 252. + 253. rcu_read_lock(); + 254. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) { + 255. offs += snprintf(buf + offs, maxlen - offs, + 256. "%s%s", + +sound/core/pcm_native.c:268: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 266. + 267. if (trace_hw_mask_param_enabled()) + 268. > old_mask = *m; + 269. + 270. changed = snd_mask_refine(m, constrs_mask(constrs, k)); + +kernel/events/core.c:252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 250. { + 251. struct perf_event_context *ctx = event->ctx; + 252. > struct task_struct *task = READ_ONCE(ctx->task); /* verified in event_function */ + 253. struct event_function_struct efs = { + 254. .event = event, + +kernel/fork.c:256: error: UNINITIALIZED_VALUE + The value read from pco_ret__ was never initialized. + 254. + 255. for (i = 0; i < NR_CACHED_STACKS; i++) { + 256. > if (this_cpu_cmpxchg(cached_stacks[i], + 257. NULL, tsk->stack_vm_area) != NULL) + 258. continue; + +drivers/base/power/main.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. * walking. + 263. */ + 264. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 265. if (READ_ONCE(link->status) != DL_STATE_DORMANT) + 266. dpm_wait(link->supplier, async); + +drivers/gpu/drm/i915/intel_guc_log.c:280: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.read_ptr was never initialized. + 278. sizeof(struct guc_log_buffer_state)); + 279. buffer_size = guc_get_log_buffer_size(type); + 280. > read_offset = log_buf_state_local.read_ptr; + 281. write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + +drivers/gpu/drm/i915/intel_guc_log.c:281: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.sampled_write_ptr was never initialized. + 279. buffer_size = guc_get_log_buffer_size(type); + 280. read_offset = log_buf_state_local.read_ptr; + 281. > write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + 283. + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +net/ipv6/netfilter/ip6_tables.c:285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 283. local_bh_disable(); + 284. addend = xt_write_recseq_begin(); + 285. > private = READ_ONCE(table->private); /* Address dependency. */ + 286. cpu = smp_processor_id(); + 287. table_base = private->entries; + +net/ipv6/netfilter/ip6_tables.c:286: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 284. addend = xt_write_recseq_begin(); + 285. private = READ_ONCE(table->private); /* Address dependency. */ + 286. > cpu = smp_processor_id(); + 287. table_base = private->entries; + 288. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +net/ipv6/netfilter/ip6_tables.c:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. */ + 297. if (static_key_false(&xt_tee_enabled)) + 298. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 299. + 300. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv6/netfilter/ip6_tables.c:286: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 284. addend = xt_write_recseq_begin(); + 285. private = READ_ONCE(table->private); /* Address dependency. */ + 286. > cpu = smp_processor_id(); + 287. table_base = private->entries; + 288. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +drivers/gpu/drm/drm_ioc32.c:263: error: UNINITIALIZED_VALUE + The value read from c32.idx was never initialized. + 261. return -EFAULT; + 262. + 263. > client.idx = c32.idx; + 264. + 265. err = drm_ioctl_kernel(file, drm_getclient, &client, DRM_UNLOCKED); + +drivers/gpu/drm/drm_ioc32.c:270: error: UNINITIALIZED_VALUE + The value read from client.auth was never initialized. + 268. + 269. c32.idx = client.idx; + 270. > c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + +drivers/gpu/drm/drm_ioc32.c:274: error: UNINITIALIZED_VALUE + The value read from client.iocs was never initialized. + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. > c32.iocs = client.iocs; + 275. + 276. if (copy_to_user(argp, &c32, sizeof(c32))) + +drivers/gpu/drm/drm_ioc32.c:273: error: UNINITIALIZED_VALUE + The value read from client.magic was never initialized. + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. > c32.magic = client.magic; + 274. c32.iocs = client.iocs; + 275. + +drivers/gpu/drm/drm_ioc32.c:271: error: UNINITIALIZED_VALUE + The value read from client.pid was never initialized. + 269. c32.idx = client.idx; + 270. c32.auth = client.auth; + 271. > c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + +drivers/gpu/drm/drm_ioc32.c:272: error: UNINITIALIZED_VALUE + The value read from client.uid was never initialized. + 270. c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. > c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. c32.iocs = client.iocs; + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +kernel/sched/core.c:257: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 255. struct rq_flags rf; + 256. + 257. > WARN_ON_ONCE(cpu_of(rq) != smp_processor_id()); + 258. + 259. rq_lock(rq, &rf); + +net/netfilter/nf_queue.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. #endif + 259. case NFPROTO_IPV4: + 260. > return rcu_dereference(net->nf.hooks_ipv4[hooknum]); + 261. case NFPROTO_IPV6: + 262. return rcu_dereference(net->nf.hooks_ipv6[hooknum]); + +net/netfilter/nf_queue.c:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. return rcu_dereference(net->nf.hooks_ipv4[hooknum]); + 261. case NFPROTO_IPV6: + 262. > return rcu_dereference(net->nf.hooks_ipv6[hooknum]); + 263. default: + 264. WARN_ON_ONCE(1); + +include/linux/reservation.h:258: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 256. struct dma_fence *fence; + 257. + 258. > if (!rcu_access_pointer(obj->fence_excl)) + 259. return NULL; + 260. + +net/core/fib_rules.c:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. rcu_read_lock(); + 260. + 261. > list_for_each_entry_rcu(rule, &ops->rules_list, list) { + 262. jumped: + 263. if (!fib_rule_match(rule, ops, fl, flags, arg)) + +net/core/fib_rules.c:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. struct fib_rule *target; + 268. + 269. > target = rcu_dereference(rule->ctarget); + 270. if (target == NULL) { + 271. continue; + +block/genhd.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. int i; + 259. + 260. > ptbl = rcu_dereference(disk->part_tbl); + 261. + 262. part = rcu_dereference(ptbl->last_lookup); + +block/genhd.c:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. ptbl = rcu_dereference(disk->part_tbl); + 261. + 262. > part = rcu_dereference(ptbl->last_lookup); + 263. if (part && sector_in_part(part, sector)) + 264. return part; + +block/genhd.c:267: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 265. + 266. for (i = 1; i < ptbl->len; i++) { + 267. > part = rcu_dereference(ptbl->part[i]); + 268. + 269. if (part && sector_in_part(part, sector)) { + +drivers/cpufreq/acpi-cpufreq.c:258: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 256. u32 val, dummy; + 257. + 258. > rdmsr(MSR_IA32_PERF_CTL, val, dummy); + 259. return val; + 260. } + +drivers/pcmcia/ds.c:282: error: UNINITIALIZED_VALUE + The value read from cis_config.base was never initialized. + 280. &cis_config); + 281. if (!ret) { + 282. > p_dev->config_base = cis_config.base; + 283. p_dev->config_regs = cis_config.rmask[0]; + 284. dev_dbg(dev, "base %x, regs %x", p_dev->config_base, + +security/keys/request_key.c:272: error: NULL_DEREFERENCE + pointer `cred` last assigned on line 257 could be null and is dereferenced at line 272, column 11. + 270. /* use a default keyring; falling through the cases until we + 271. * find one that we actually have */ + 272. > switch (cred->jit_keyring) { + 273. case KEY_REQKEY_DEFL_DEFAULT: + 274. case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: + +security/keys/request_key.c:303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 301. rcu_read_lock(); + 302. dest_keyring = key_get( + 303. > rcu_dereference(cred->session_keyring)); + 304. rcu_read_unlock(); + 305. + +net/ipv4/inet_timewait_sock.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. rcu_read_lock(); + 267. restart: + 268. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 269. if (sk->sk_state != TCP_TIME_WAIT) + 270. continue; + +net/ipv6/xfrm6_policy.c:274: error: NULL_DEREFERENCE + pointer `xdst` last assigned on line 273 could be null and is dereferenced at line 274, column 12. + 272. in6_dev_hold(loopback_idev); + 273. xdst = (struct xfrm_dst *)xfrm_dst_child(&xdst->u.dst); + 274. > } while (xdst->u.dst.xfrm); + 275. + 276. __in6_dev_put(loopback_idev); + +net/wireless/trace.h:255: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +arch/x86/include/asm/tlbflush.h:263: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 261. + 262. local_irq_save(flags); + 263. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 264. if ((cr4 | mask) != cr4) + 265. __cr4_set(cr4 | mask); + +arch/x86/include/asm/tlbflush.h:263: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 261. + 262. local_irq_save(flags); + 263. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 264. if ((cr4 | mask) != cr4) + 265. __cr4_set(cr4 | mask); + +net/ipv4/sysctl_net_ipv4.c:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. + 273. rcu_read_lock(); + 274. > ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx); + 275. if (ctxt) + 276. memcpy(user_key, ctxt->key, TCP_FASTOPEN_KEY_LENGTH); + +net/ipv4/sysctl_net_ipv4.c:281: error: UNINITIALIZED_VALUE + The value read from user_key[_] was never initialized. + 279. rcu_read_unlock(); + 280. + 281. > snprintf(tbl.data, tbl.maxlen, "%08x-%08x-%08x-%08x", + 282. user_key[0], user_key[1], user_key[2], user_key[3]); + 283. ret = proc_dostring(&tbl, write, buffer, lenp, ppos); + +net/ipv4/sysctl_net_ipv4.c:296: error: UNINITIALIZED_VALUE + The value read from user_key[_] was never initialized. + 294. + 295. bad_key: + 296. > pr_debug("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n", + 297. user_key[0], user_key[1], user_key[2], user_key[3], + 298. (char *)tbl.data, ret); + +net/sunrpc/xprtmultipath.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. struct rpc_xprt *pos, *prev = NULL; + 263. + 264. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 265. if (cur == prev) + 266. return pos; + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +kernel/sys.c:290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 288. else + 289. pgrp = task_pgrp(current); + 290. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 291. niceval = nice_to_rlimit(task_nice(p)); + 292. if (niceval > retval) + +kernel/sys.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. goto out_unlock; /* No processes for this user */ + 305. } + 306. > do_each_thread(g, p) { + 307. if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) { + 308. niceval = nice_to_rlimit(task_nice(p)); + +kernel/sys.c:307: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 305. } + 306. do_each_thread(g, p) { + 307. > if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) { + 308. niceval = nice_to_rlimit(task_nice(p)); + 309. if (niceval > retval) + +drivers/gpu/drm/i915/intel_uc.c:359: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 357. ret = -EINVAL; + 358. + 359. > dev_err(dev_priv->drm.dev, "GuC initialization failed %d\n", ret); + 360. return ret; + 361. } + +drivers/gpu/drm/i915/intel_uc.c:360: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 358. + 359. dev_err(dev_priv->drm.dev, "GuC initialization failed %d\n", ret); + 360. > return ret; + 361. } + 362. + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +lib/idr.c:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. + 273. *nextid = iter.index + base; + 274. > return rcu_dereference_raw(*slot); + 275. } + 276. EXPORT_SYMBOL(idr_get_next_ul); + +drivers/tty/serial/serial_core.c:283: error: NULL_DEREFERENCE + pointer `uport` last assigned on line 264 could be null and is dereferenced by call to `uart_port_dtr_rts()` at line 283, column 4. + 281. + 282. if (!tty || C_HUPCL(tty)) + 283. > uart_port_dtr_rts(uport, 0); + 284. + 285. uart_port_shutdown(port); + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +net/netlink/genetlink.c:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. netlink_table_grab(); + 268. rcu_read_lock(); + 269. > for_each_net_rcu(net) { + 270. for (i = 0; i < family->n_mcgrps; i++) + 271. __netlink_clear_multicast_users( + +net/sched/sch_api.c:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. return root; + 272. + 273. > hash_for_each_possible_rcu(qdisc_dev(root)->qdisc_hash, q, hash, handle) { + 274. if (q->handle == handle) + 275. return q; + +drivers/gpu/drm/i915/intel_opregion.c:330: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 328. /* Poll for the result. */ + 329. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 330. > if (wait_for(C, dslp)) { + 331. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 332. return -ETIMEDOUT; + +drivers/gpu/drm/i915/intel_opregion.c:330: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 328. /* Poll for the result. */ + 329. #define C (((scic = swsci->scic) & SWSCI_SCIC_INDICATOR) == 0) + 330. > if (wait_for(C, dslp)) { + 331. DRM_DEBUG_DRIVER("SWSCI request timed out\n"); + 332. return -ETIMEDOUT; + +drivers/tty/vt/vt_ioctl.c:274: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 272. if (!perm) + 273. return -EPERM; + 274. > return con_set_unimap(vc, tmp.entry_ct, tmp.entries); + 275. case GIO_UNIMAP: + 276. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:278: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 276. if (!perm && fg_console != vc->vc_num) + 277. return -EPERM; + 278. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries); + 279. } + 280. return 0; + +net/ipv4/tcp_cong.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. + 267. rcu_read_lock(); + 268. > ca = rcu_dereference(net->ipv4.tcp_congestion_control); + 269. strncpy(name, ca->name, TCP_CA_NAME_MAX); + 270. rcu_read_unlock(); + +net/ipv6/ip6_flowlabel.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. struct ipv6_fl_socklist *sfl; + 267. + 268. > if (!rcu_access_pointer(np->ipv6_fl_list)) + 269. return; + 270. + +drivers/base/power/runtime.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. struct device_link *link; + 267. + 268. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) { + 269. int retval; + 270. + +sound/core/pcm_lib.c:408: error: DEAD_STORE + The value written to &hw_base (type unsigned long) is never used. + 406. /* move new_hw_ptr according jiffies not pos variable */ + 407. new_hw_ptr = old_hw_ptr; + 408. > hw_base = delta; + 409. /* use loop to avoid checks for delta overflows */ + 410. /* the delta value is small or zero in most cases */ + +kernel/power/swap.c:273: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 272 could be null and is dereferenced at line 273, column 2. + 271. + 272. bio = bio_alloc(__GFP_RECLAIM | __GFP_HIGH, 1); + 273. > bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >> 9); + 274. bio_set_dev(bio, hib_resume_bdev); + 275. bio_set_op_attrs(bio, op, op_flags); + +net/ipv4/inet_hashtables.c:278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 276. u32 phash = 0; + 277. + 278. > inet_lhash2_for_each_icsk_rcu(icsk, &ilb2->head) { + 279. sk = (struct sock *)icsk; + 280. score = compute_score(sk, net, hnum, daddr, + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +kernel/sched/wait_bit.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. __sched int bit_wait_timeout(struct wait_bit_key *word, int mode) + 267. { + 268. > unsigned long now = READ_ONCE(jiffies); + 269. if (time_after_eq(now, word->timeout)) + 270. return -EAGAIN; + +kernel/seccomp.c:276: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 274. /* Validate all threads being eligible for synchronization. */ + 275. caller = current; + 276. > for_each_thread(caller, thread) { + 277. pid_t failed; + 278. + +scripts/sortextable.c:313: error: DEAD_STORE + The value written to &custom_sort (type _fn_(*)) is never used. + 311. case EM_386: + 312. case EM_X86_64: + 313. > custom_sort = x86_sort_relative_table; + 314. break; + 315. + +scripts/sortextable.c:321: error: DEAD_STORE + The value written to &custom_sort (type _fn_(*)) is never used. + 319. case EM_PPC: + 320. case EM_PPC64: + 321. > custom_sort = sort_relative_table; + 322. break; + 323. case EM_ARCOMPACT: + +kernel/irq/matrix.c:280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 278. cm->available--; + 279. m->global_available--; + 280. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 281. } + 282. + +kernel/irq/matrix.c:280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 278. cm->available--; + 279. m->global_available--; + 280. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 281. } + 282. + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +drivers/gpu/drm/drm_crtc_helper.c:281: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 279. bool saved_enabled; + 280. struct drm_encoder *encoder; + 281. > bool ret = true; + 282. + 283. drm_warn_on_modeset_not_all_locked(dev); + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/net/ethernet/intel/e1000e/ethtool.c:321: error: DEAD_STORE + The value written to &advertising (type unsigned int) is never used. + 319. hw->phy.autoneg_advertised = advertising | + 320. ADVERTISED_TP | ADVERTISED_Autoneg; + 321. > advertising = hw->phy.autoneg_advertised; + 322. if (adapter->fc_autoneg) + 323. hw->fc.requested_mode = e1000_fc_default; + +kernel/profile.c:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. + 273. mutex_lock(&profile_flip_mutex); + 274. > i = per_cpu(cpu_profile_flip, get_cpu()); + 275. put_cpu(); + 276. on_each_cpu(__profile_flip_buffers, NULL, 1); + +kernel/time/posix-cpu-timers.c:285: error: UNINITIALIZED_VALUE + The value read from rtn was never initialized. + 283. + 284. if (!err) + 285. > *tp = ns_to_timespec64(rtn); + 286. + 287. return err; + +net/wireless/trace.h:269: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +arch/x86/include/asm/tlbflush.h:275: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 273. + 274. local_irq_save(flags); + 275. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 276. if ((cr4 & ~mask) != cr4) + 277. __cr4_set(cr4 & ~mask); + +arch/x86/include/asm/tlbflush.h:275: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 273. + 274. local_irq_save(flags); + 275. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 276. if ((cr4 & ~mask) != cr4) + 277. __cr4_set(cr4 & ~mask); + +drivers/net/ethernet/intel/e1000/e1000_param.c:283: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 281. struct e1000_tx_ring *tx_ring = adapter->tx_ring; + 282. int i; + 283. > e1000_mac_type mac_type = adapter->hw.mac_type; + 284. + 285. opt = (struct e1000_option) { + +drivers/net/ethernet/intel/e1000/e1000_param.c:311: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 309. struct e1000_rx_ring *rx_ring = adapter->rx_ring; + 310. int i; + 311. > e1000_mac_type mac_type = adapter->hw.mac_type; + 312. + 313. opt = (struct e1000_option) { + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +drivers/cpufreq/acpi-cpufreq.c:275: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 273. u32 val, dummy; + 274. + 275. > rdmsr(MSR_AMD_PERF_CTL, val, dummy); + 276. return val; + 277. } + +kernel/ptrace.c:311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 309. caller_gid = cred->gid; + 310. } + 311. > tcred = __task_cred(task); + 312. if (uid_eq(caller_uid, tcred->euid) && + 313. uid_eq(caller_uid, tcred->suid) && + +include/net/neighbour.h:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. struct net_device *dev) + 280. { + 281. > struct neigh_hash_table *nht = rcu_dereference_bh(tbl->nht); + 282. struct neighbour *n; + 283. u32 hash_val; + +include/net/neighbour.h:286: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 284. + 285. hash_val = hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift); + 286. > for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 287. n != NULL; + 288. n = rcu_dereference_bh(n->next)) { + +include/net/neighbour.h:288: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 286. for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 287. n != NULL; + 288. > n = rcu_dereference_bh(n->next)) { + 289. if (n->dev == dev && key_eq(n, pkey)) + 290. return n; + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +net/sunrpc/xprtmultipath.c:285: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 283. if (pos == NULL) + 284. break; + 285. > cur = cmpxchg_relaxed(cursor, old, pos); + 286. if (cur == old) + 287. break; + +net/sunrpc/xprtmultipath.c:279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 277. struct rpc_xprt *cur, *pos, *old; + 278. + 279. > cur = READ_ONCE(*cursor); + 280. for (;;) { + 281. old = cur; + +net/sunrpc/xprtmultipath.c:289: error: UNINITIALIZED_VALUE + The value read from pos was never initialized. + 287. break; + 288. } + 289. > return pos; + 290. } + 291. + +drivers/gpu/drm/i915/intel_uncore.c:278: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 276. * thread to wake up. + 277. */ + 278. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 279. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 280. DRM_ERROR("GT thread status wait timed out\n"); + +drivers/gpu/drm/i915/intel_uncore.c:278: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 276. * thread to wake up. + 277. */ + 278. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 279. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 280. DRM_ERROR("GT thread status wait timed out\n"); + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +drivers/cpufreq/cpufreq_governor.c:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. */ + 297. smp_rmb(); + 298. > lst = READ_ONCE(policy_dbs->last_sample_time); + 299. delta_ns = time - lst; + 300. if ((s64)delta_ns < policy_dbs->sample_delay_ns) + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +net/ipv4/tcp_cong.c:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. *buf = '\0'; + 280. rcu_read_lock(); + 281. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) { + 282. if (!(ca->flags & TCP_CONG_NON_RESTRICTED)) + 283. continue; + +drivers/ata/libata-scsi.c:299: error: UNINITIALIZED_VALUE + The value read from ncq_prio_enable was never initialized. + 297. spin_unlock_irq(ap->lock); + 298. + 299. > return rc ? rc : snprintf(buf, 20, "%u\n", ncq_prio_enable); + 300. } + 301. + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +net/ipv6/calipso.c:278: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 276. const struct netlbl_lsm_secattr *secattr) + 277. { + 278. > int ret_val = -EPERM; + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + +drivers/base/power/main.c:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. * unregistration). + 292. */ + 293. > list_for_each_entry_rcu(link, &dev->links.consumers, s_node) + 294. if (READ_ONCE(link->status) != DL_STATE_DORMANT) + 295. dpm_wait(link->consumer, async); + +drivers/gpu/drm/i915/i915_gem_request.h:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. i915_gem_request_global_seqno(const struct drm_i915_gem_request *request) + 280. { + 281. > return READ_ONCE(request->global_seqno); + 282. } + 283. + +drivers/iommu/dmar.c:287: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 285. return 0; + 286. + 287. > for_each_active_dev_scope(devices, count, index, tmp) + 288. if (tmp == &info->dev->dev) { + 289. RCU_INIT_POINTER(devices[index].dev, NULL); + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +kernel/sched/wait_bit.c:280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 278. __sched int bit_wait_io_timeout(struct wait_bit_key *word, int mode) + 279. { + 280. > unsigned long now = READ_ONCE(jiffies); + 281. if (time_after_eq(now, word->timeout)) + 282. return -EAGAIN; + +scripts/kconfig/symbol.c:290: error: NULL_DEREFERENCE + pointer `def_sym` last assigned on line 289 could be null and is dereferenced at line 290, column 7. + 288. continue; + 289. def_sym = prop_get_symbol(prop); + 290. > if (def_sym->visible != no) + 291. return def_sym; + 292. } + +sound/hda/hdac_regmap.c:348: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 346. out: + 347. codec_pm_unlock(codec, pm_lock); + 348. > return err; + 349. } + 350. + +drivers/video/fbdev/core/fbmem.c:286: error: DEAD_STORE + The value written to &fg (type unsigned char) is never used. + 284. const u8 *src = logo->data; + 285. u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0; + 286. > u8 fg = 1, d; + 287. + 288. switch (fb_get_color_depth(&info->var, &info->fix)) { + +include/linux/seqlock.h:282: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 280. { + 281. /* Pairs with the first smp_wmb() in raw_write_seqcount_latch() */ + 282. > int seq = READ_ONCE(s->sequence); /* ^^^ */ + 283. return seq; + 284. } + +kernel/sched/cpuacct.c:301: error: UNINITIALIZED_VALUE + The value read from val[_] was never initialized. + 299. seq_printf(sf, "%s %lld\n", + 300. cpuacct_stat_desc[stat], + 301. > (long long)nsec_to_clock_t(val[stat])); + 302. } + 303. + +net/wireless/trace.h:281: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 279. ); + 280. + 281. > DECLARE_EVENT_CLASS(wiphy_only_evt, + 282. TP_PROTO(struct wiphy *wiphy), + 283. TP_ARGS(wiphy), + +net/packet/af_packet.c:287: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 285. + 286. rcu_read_lock(); + 287. > dev = rcu_dereference(po->cached_dev); + 288. if (likely(dev)) + 289. dev_hold(dev); + +drivers/cpuidle/governors/menu.c:294: error: NULL_DEREFERENCE + pointer `device` last assigned on line 286 could be null and is dereferenced by call to `dev_pm_qos_raw_read_value()` at line 294, column 23. + 292. unsigned int expected_interval; + 293. unsigned long nr_iowaiters, cpu_load; + 294. > int resume_latency = dev_pm_qos_raw_read_value(device); + 295. + 296. if (data->needs_update) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +net/ipv6/sit.c:289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 287. struct ip_tunnel_prl_entry *prl; + 288. + 289. > for_each_prl_rcu(t->prl) + 290. if (prl->addr == addr) + 291. break; + +sound/core/pcm_native.c:304: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 302. + 303. if (trace_hw_interval_param_enabled()) + 304. > old_interval = *i; + 305. + 306. changed = snd_interval_refine(i, constrs_interval(constrs, k)); + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +security/selinux/ss/services.c:456: error: UNINITIALIZED_VALUE + The value read from s[_] was never initialized. + 454. + 455. BUG_ON(sp != 0); + 456. > return s[0]; + 457. } + 458. + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +block/blk-lib.c:305: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 303 could be null and is dereferenced at line 305, column 3. + 303. bio = next_bio(bio, __blkdev_sectors_to_bio_pages(nr_sects), + 304. gfp_mask); + 305. > bio->bi_iter.bi_sector = sector; + 306. bio_set_dev(bio, bdev); + 307. bio_set_op_attrs(bio, REQ_OP_WRITE, 0); + +drivers/dma-buf/reservation.c:343: error: DEAD_STORE + The value written to &new (type dma_fence*) is never used. + 341. } + 342. + 343. > new = dma_fence_get_rcu_safe(&src->fence_excl); + 344. rcu_read_unlock(); + 345. + +drivers/dma-buf/reservation.c:296: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 294. + 295. rcu_read_lock(); + 296. > src_list = rcu_dereference(src->fence); + 297. + 298. retry: + +drivers/dma-buf/reservation.c:310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 308. + 309. rcu_read_lock(); + 310. > src_list = rcu_dereference(src->fence); + 311. if (!src_list || src_list->shared_count > shared_count) { + 312. kfree(dst_list); + +drivers/dma-buf/reservation.c:321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 319. struct dma_fence *fence; + 320. + 321. > fence = rcu_dereference(src_list->shared[i]); + 322. if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, + 323. &fence->flags)) + +drivers/dma-buf/reservation.c:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. if (!dma_fence_get_rcu(fence)) { + 327. kfree(dst_list); + 328. > src_list = rcu_dereference(src->fence); + 329. goto retry; + 330. } + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +kernel/kprobes.c:294: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 292. + 293. rcu_read_lock(); + 294. > list_for_each_entry_rcu(kip, &c->pages, list) { + 295. if (addr >= (unsigned long)kip->insns && + 296. addr < (unsigned long)kip->insns + PAGE_SIZE) { + +net/netfilter/nf_conntrack_helper.c:292: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 290. struct nf_conn_help *help = nfct_help(ct); + 291. + 292. > if (help && rcu_dereference_raw(help->helper) == me) { + 293. nf_conntrack_event(IPCT_HELPER, ct); + 294. RCU_INIT_POINTER(help->helper, NULL); + +drivers/base/power/runtime.c:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. struct device_link *link; + 292. + 293. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 294. if (link->rpm_active && + 295. READ_ONCE(link->status) != DL_STATE_SUPPLIER_UNBIND) { + +drivers/gpu/drm/drm_fb_helper.c:291: error: DEAD_STORE + The value written to &helper (type drm_fb_helper*) is never used. + 289. int drm_fb_helper_debug_enter(struct fb_info *info) + 290. { + 291. > struct drm_fb_helper *helper = info->par; + 292. const struct drm_crtc_helper_funcs *funcs; + 293. int i; + +lib/genalloc.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. nbits = (size + (1UL << order) - 1) >> order; + 305. rcu_read_lock(); + 306. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 307. if (size > atomic_long_read(&chunk->avail)) + 308. continue; + +arch/x86/events/amd/core.c:319: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 317. if (new == -1 || hwc->idx == idx) + 318. /* assign free slot, prefer hwc->idx */ + 319. > old = cmpxchg(nb->owners + idx, NULL, event); + 320. else if (nb->owners[idx] == event) + 321. /* event already present */ + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +kernel/exit.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. * see comment in rcuwait_wait_event() regarding ->exit_state. + 314. */ + 315. > task = rcu_dereference(w->task); + 316. if (task) + 317. wake_up_process(task); + +net/ipv4/tcp_cong.c:313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 311. + 312. /* pass 2 clear old values */ + 313. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) + 314. ca->flags &= ~TCP_CONG_NON_RESTRICTED; + 315. + +net/sunrpc/xprtmultipath.c:296: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 294. xprt_switch_find_xprt_t find_next) + 295. { + 296. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 297. + 298. if (xps == NULL) + +net/netlabel/netlabel_calipso.c:295: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 293. static int netlbl_calipso_remove(struct sk_buff *skb, struct genl_info *info) + 294. { + 295. > int ret_val = -EINVAL; + 296. struct netlbl_domhsh_walk_arg cb_arg; + 297. struct netlbl_audit audit_info; + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +kernel/locking/qspinlock.c:467: error: UNINITIALIZED_VALUE + The value read from VAL was never initialized. + 465. goto locked; + 466. + 467. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 468. + 469. locked: + +kernel/locking/qspinlock.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. * implementations imply full barriers. + 361. */ + 362. > smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_MASK)); + 363. + 364. /* + +kernel/locking/qspinlock.c:430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 428. + 429. pv_wait_node(node, prev); + 430. > arch_mcs_spin_lock_contended(&node->locked); + 431. + 432. /* + +kernel/locking/qspinlock.c:438: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 436. * to reduce latency in the upcoming MCS unlock operation. + 437. */ + 438. > next = READ_ONCE(node->next); + 439. if (next) + 440. prefetchw(next); + +kernel/locking/qspinlock.c:467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 465. goto locked; + 466. + 467. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 468. + 469. locked: + +kernel/locking/qspinlock.c:502: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 500. */ + 501. if (!next) { + 502. > while (!(next = READ_ONCE(node->next))) + 503. cpu_relax(); + 504. } + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +arch/x86/platform/efi/efi.c:342: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 340. efi_systab.tables = data ? (unsigned long)data->tables : + 341. systab64->tables; + 342. > tmp |= data ? data->tables : systab64->tables; + 343. + 344. early_memunmap(systab64, sizeof(*systab64)); + +drivers/char/hw_random/core.c:297: error: DEAD_STORE + The value written to &ret (type int) is never used. + 295. static int enable_best_rng(void) + 296. { + 297. > int ret = -ENODEV; + 298. + 299. BUG_ON(!mutex_is_locked(&rng_mutex)); + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/intel_i2c.c:312: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_lpe_audio.c:302: error: DEAD_STORE + The value written to &desc (type irq_desc*) is never used. + 300. return; + 301. + 302. > desc = irq_to_desc(dev_priv->lpe_audio.irq); + 303. + 304. lpe_audio_platdev_destroy(dev_priv); + +drivers/md/dm-io.c:314: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 314, column 29. + 312. */ + 313. if (op == REQ_OP_DISCARD) + 314. > special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + +drivers/md/dm-io.c:316: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 316, column 29. + 314. special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. > special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. special_cmd_max_sectors = q->limits.max_write_same_sectors; + +drivers/md/dm-io.c:318: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 318, column 29. + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. > special_cmd_max_sectors = q->limits.max_write_same_sectors; + 319. if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES || + 320. op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) { + +usr/gen_init_cpio.c:303: error: DEAD_STORE + The value written to &file (type int) is never used. + 301. struct stat buf; + 302. long size; + 303. > int file = -1; + 304. int retval; + 305. int rc = -1; + +kernel/capability.c:302: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 300. + 301. rcu_read_lock(); + 302. > ret = security_capable(__task_cred(t), ns, cap); + 303. rcu_read_unlock(); + 304. + +kernel/sched/cputime.c:325: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 323. times->sum_exec_runtime = sig->sum_sched_runtime; + 324. + 325. > for_each_thread(tsk, t) { + 326. task_cputime(t, &utime, &stime); + 327. times->utime += utime; + +net/ipv6/sit.c:329: error: DEAD_STORE + The value written to &ret (type int) is never used. + 327. kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC); + 328. if (!kp) { + 329. > ret = -ENOMEM; + 330. goto out; + 331. } + +net/ipv6/sit.c:335: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 333. + 334. c = 0; + 335. > for_each_prl_rcu(t->prl) { + 336. if (c >= cmax) + 337. break; + +lib/rhashtable.c:305: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 303. + 304. /* Did somebody beat us to it? */ + 305. > if (rcu_access_pointer(old_tbl->future_tbl)) { + 306. spin_unlock_bh(old_tbl->locks); + 307. return -EEXIST; + +drivers/char/hpet.c:335: error: UNINITIALIZED_VALUE + The value read from data was never initialized. + 333. } + 334. + 335. > retval = put_user(data, (unsigned long __user *)buf); + 336. if (!retval) + 337. retval = sizeof(unsigned long); + +drivers/iommu/dmar.c:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. struct acpi_dmar_hardware_unit *drhd; + 303. + 304. > for_each_drhd_unit(dmaru) { + 305. if (dmaru->include_all) + 306. continue; + +include/net/addrconf.h:300: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 298. static inline struct inet6_dev *__in6_dev_get(const struct net_device *dev) + 299. { + 300. > return rcu_dereference_rtnl(dev->ip6_ptr); + 301. } + 302. + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +arch/x86/events/intel/bts.c:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 303. struct bts_buffer *buf = NULL; + 304. > int state = READ_ONCE(bts->state); + 305. + 306. if (state == BTS_STATE_ACTIVE) + +drivers/gpu/drm/i915/intel_uncore.c:311: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 309. + 310. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 311. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 312. GT_FIFO_NUM_RESERVED_ENTRIES, + 313. GT_FIFO_TIMEOUT_MS)) { + +drivers/gpu/drm/i915/intel_uncore.c:311: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 309. + 310. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 311. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 312. GT_FIFO_NUM_RESERVED_ENTRIES, + 313. GT_FIFO_TIMEOUT_MS)) { + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +net/ipv4/inet_hashtables.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. + 344. port_lookup: + 345. > sk_for_each_rcu(sk, &ilb->head) { + 346. score = compute_score(sk, net, hnum, daddr, + 347. dif, sdif, exact_dif); + +net/sched/sch_generic.c:325: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 323. + 324. if (likely(skb)) { + 325. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 326. if (!netif_xmit_frozen_or_stopped(txq)) + 327. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +net/sched/sch_generic.c:325: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 323. + 324. if (likely(skb)) { + 325. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 326. if (!netif_xmit_frozen_or_stopped(txq)) + 327. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +include/net/inet_sock.h:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. { + 303. /* state change might impact lockless readers. */ + 304. > return smp_load_acquire(&sk->sk_state); + 305. } + 306. + +net/netfilter/nf_conntrack_helper.c:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. if (help) { + 307. rcu_read_lock(); + 308. > helper = rcu_dereference(help->helper); + 309. if (helper && helper->destroy) + 310. helper->destroy(ct); + +kernel/events/core.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. struct perf_event_context *ctx = event->ctx; + 305. struct perf_cpu_context *cpuctx = __get_cpu_context(ctx); + 306. > struct task_struct *task = READ_ONCE(ctx->task); + 307. struct perf_event_context *task_ctx = NULL; + 308. + +include/net/ipv6.h:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. + 307. rcu_read_lock(); + 308. > opt = rcu_dereference(np->opt); + 309. if (opt) { + 310. if (!refcount_inc_not_zero(&opt->refcnt)) + +net/ipv4/sysctl_net_ipv4.c:312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 310. rcu_read_lock(); + 311. + 312. > ipprot = rcu_dereference(inet_protos[protocol]); + 313. if (ipprot) + 314. ipprot->early_demux = enabled ? ipprot->early_demux_handler : + +net/ipv4/sysctl_net_ipv4.c:318: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 316. + 317. #if IS_ENABLED(CONFIG_IPV6) + 318. > ip6prot = rcu_dereference(inet6_protos[protocol]); + 319. if (ip6prot) + 320. ip6prot->early_demux = enabled ? ip6prot->early_demux_handler : + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +kernel/notifier.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. * is, we re-check the list after having taken the lock anyway: + 314. */ + 315. > if (rcu_access_pointer(nh->head)) { + 316. down_read(&nh->rwsem); + 317. ret = notifier_call_chain(&nh->head, val, v, nr_to_call, + +scripts/kconfig/symbol.c:314: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 313 could be null and is dereferenced at line 314, column 2. + 312. flags = sym->flags; + 313. prop = sym_get_choice_prop(sym); + 314. > expr_list_for_each_sym(prop->expr, e, def_sym) { + 315. sym_calc_visibility(def_sym); + 316. if (def_sym->visible != no) + +drivers/edac/edac_mc.c:345: error: DEAD_STORE + The value written to &mci (type mem_ctl_info*) is never used. + 343. * hardcode everything into a single struct. + 344. */ + 345. > mci = edac_align_ptr(&ptr, sizeof(*mci), 1); + 346. layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers); + 347. for (i = 0; i < n_layers; i++) { + +drivers/edac/edac_mc.c:431: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 429. for (i = 0; i < tot_dimms; i++) { + 430. chan = mci->csrows[row]->channels[chn]; + 431. > off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]); + 432. if (off < 0 || off >= tot_dimms) { + 433. edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n"); + +drivers/edac/edac_mc.c:452: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 450. len -= n; + 451. for (j = 0; j < n_layers; j++) { + 452. > n = snprintf(p, len, "%s#%u", + 453. edac_layer_name[layers[j].type], + 454. pos[j]); + +drivers/edac/edac_mc.c:457: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 455. p += n; + 456. len -= n; + 457. > dimm->location[j] = pos[j]; + 458. + 459. if (len <= 0) + +drivers/gpu/drm/drm_lock.c:316: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 314. do { + 315. old = *lock; + 316. > prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT); + 317. } while (prev != old); + 318. wake_up_interruptible(&lock_data->lock_queue); + +kernel/printk/printk_safe.c:313: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 311. * the lock must be taken on another CPU and we could wait for it. + 312. */ + 313. > if ((this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) && + 314. raw_spin_is_locked(&logbuf_lock)) { + 315. this_cpu_or(printk_context, PRINTK_NMI_CONTEXT_MASK); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:316: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 314. if (unlikely(p == NULL)) + 315. return -ENOSPC; + 316. > p = xdr_decode_hyper(p, &status->major_status); + 317. + 318. /* status->mech */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:327: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 325. if (unlikely(p == NULL)) + 326. return -ENOSPC; + 327. > p = xdr_decode_hyper(p, &status->minor_status); + 328. + 329. /* status->major_status_string */ + +include/net/ip_fib.h:321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 319. res->tclassid = 0; + 320. + 321. > tb = rcu_dereference_rtnl(net->ipv4.fib_main); + 322. if (tb) + 323. err = fib_table_lookup(tb, flp, res, flags); + +include/net/ip_fib.h:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. goto out; + 327. + 328. > tb = rcu_dereference_rtnl(net->ipv4.fib_default); + 329. if (tb) + 330. err = fib_table_lookup(tb, flp, res, flags); + +kernel/reboot.c:315: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 310 could be null and is dereferenced at line 315, column 18. + 313. + 314. /* We only trust the superuser with rebooting the system. */ + 315. > if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT)) + 316. return -EPERM; + 317. + +net/ipv6/mcast.c:311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 309. struct ipv6_pinfo *np = inet6_sk(sk); + 310. + 311. > if (!rcu_access_pointer(np->ipv6_mc_list)) + 312. return; + 313. rtnl_lock(); + +drivers/input/evdev.c:322: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 320. rcu_read_lock(); + 321. + 322. > client = rcu_dereference(evdev->grab); + 323. + 324. if (client) + +drivers/input/evdev.c:327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 325. evdev_pass_values(client, vals, count, ev_time); + 326. else + 327. > list_for_each_entry_rcu(client, &evdev->client_list, node) + 328. evdev_pass_values(client, vals, count, ev_time); + 329. + +kernel/seccomp.c:317: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 315. /* Synchronize all threads. */ + 316. caller = current; + 317. > for_each_thread(caller, thread) { + 318. /* Skip current, since it needs no changes. */ + 319. if (thread == caller) + +lib/assoc_array.c:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. */ + 327. for (slot = 0; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 328. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 329. if (ptr && assoc_array_ptr_is_leaf(ptr)) { + 330. /* We need a barrier between the read of the pointer + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +drivers/gpu/drm/i915/intel_pm.c:324: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 322. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 323. + 324. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 325. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 326. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +drivers/gpu/drm/i915/intel_pm.c:324: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 322. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 323. + 324. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 325. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) + 326. DRM_ERROR("timed out waiting for Punit DDR DVFS request\n"); + +kernel/sched/loadavg.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. long delta, active, n; + 314. + 315. > sample_window = READ_ONCE(calc_load_update); + 316. if (!time_before(jiffies, sample_window + 10)) { + 317. /* + +include/net/addrconf.h:316: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 314. + 315. rcu_read_lock(); + 316. > idev = rcu_dereference(dev->ip6_ptr); + 317. if (idev) + 318. refcount_inc(&idev->refcnt); + +include/net/ip_tunnels.h:323: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 321. + 322. rcu_read_lock(); + 323. > ops = rcu_dereference(iptun_encaps[e->type]); + 324. if (likely(ops && ops->encap_hlen)) + 325. hlen = ops->encap_hlen(e); + +net/ipv4/cipso_ipv4.c:314: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 312. const struct netlbl_lsm_secattr *secattr) + 313. { + 314. > int ret_val = -EPERM; + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + +net/ipv4/ip_input.c:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. int protocol = iph->protocol; + 332. + 333. > ipprot = rcu_dereference(inet_protos[protocol]); + 334. if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) { + 335. err = edemux(skb); + +net/ipv4/ip_input.c:334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 332. + 333. ipprot = rcu_dereference(inet_protos[protocol]); + 334. > if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) { + 335. err = edemux(skb); + 336. if (unlikely(err)) + +net/netlink/af_netlink.c:319: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 317. return; + 318. + 319. > list_for_each_entry_rcu(tmp, &nn->netlink_tap_all, list) { + 320. ret = __netlink_deliver_tap_skb(skb, tmp->dev); + 321. if (unlikely(ret)) + +net/packet/af_packet.c:313: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 311. static u16 __packet_pick_tx_queue(struct net_device *dev, struct sk_buff *skb) + 312. { + 313. > return (u16) raw_smp_processor_id() % dev->real_num_tx_queues; + 314. } + 315. + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.agp_start was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.count was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.flags was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.high_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.low_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.size was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/i2c/i2c-core-smbus.c:479: error: UNINITIALIZED_VALUE + The value read from msgbuf1[_] was never initialized. + 477. break; + 478. case I2C_SMBUS_BYTE_DATA: + 479. > data->byte = msgbuf1[0]; + 480. break; + 481. case I2C_SMBUS_WORD_DATA: + +net/netfilter/nf_conntrack_core.c:318: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 316. + 317. /* add this conntrack to the (per cpu) dying list */ + 318. > ct->cpu = smp_processor_id(); + 319. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 320. + +net/netfilter/nf_conntrack_core.c:318: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 316. + 317. /* add this conntrack to the (per cpu) dying list */ + 318. > ct->cpu = smp_processor_id(); + 319. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 320. + +net/wireless/trace.h:313: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 311. ); + 312. + 313. > DECLARE_EVENT_CLASS(wiphy_enabled_evt, + 314. TP_PROTO(struct wiphy *wiphy, bool enabled), + 315. TP_ARGS(wiphy, enabled), + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +drivers/char/agp/isoch.c:336: error: DEAD_STORE + The value written to &arqsz (type unsigned int) is never used. + 334. return -ENODEV; + 335. + 336. > arqsz = (tstatus >> 13) & 0x7; + 337. + 338. /* + +kernel/pid.c:322: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 320. if (pid) { + 321. struct hlist_node *first; + 322. > first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]), + 323. lockdep_tasklist_lock_is_held()); + 324. if (first) + +kernel/rcu/tree_exp.h:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. rnp = rdp->mynode; + 325. if (!(READ_ONCE(rnp->expmask) & rdp->grpmask) || + 326. > __this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 327. return; + 328. if (rcu_is_cpu_rrupt_from_idle()) { + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +lib/zlib_inflate/inflate.c:494: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 492. NEEDBITS(this.bits); + 493. DROPBITS(this.bits); + 494. > state->lens[state->have++] = this.val; + 495. } + 496. else { + +lib/zlib_inflate/inflate.c:580: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 578. } + 579. DROPBITS(this.bits); + 580. > state->length = (unsigned)this.val; + 581. if ((int)(this.op) == 0) { + 582. state->mode = LIT; + +lib/zlib_inflate/inflate.c:625: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 623. break; + 624. } + 625. > state->offset = (unsigned)this.val; + 626. state->extra = (unsigned)(this.op) & 15; + 627. state->mode = DISTEXT; + +net/core/netpoll.c:322: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 320. + 321. list_for_each_entry(napi, &dev->napi_list, dev_list) { + 322. > if (napi->poll_owner == smp_processor_id()) + 323. return 1; + 324. } + +drivers/char/hw_random/core.c:322: error: DEAD_STORE + The value written to &err (type int) is never used. + 320. const char *buf, size_t len) + 321. { + 322. > int err = -ENODEV; + 323. struct hwrng *rng; + 324. + +net/ipv6/mcast.c:427: error: DEAD_STORE + The value written to &rv (type int) is never used. + 425. pmc->sflist = psl = newpsl; + 426. } + 427. > rv = 1; /* > 0 for insert logic below if sl_count is 0 */ + 428. for (i = 0; i < psl->sl_count; i++) { + 429. rv = !ipv6_addr_equal(&psl->sl_addr[i], source); + +net/ipv6/mcast.c:347: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 345. err = -EADDRNOTAVAIL; + 346. + 347. > for_each_pmc_rcu(inet6, pmc) { + 348. if (pgsr->gsr_interface && pmc->ifindex != pgsr->gsr_interface) + 349. continue; + +net/compat.c:330: error: UNINITIALIZED_VALUE + The value read from f32.filter was never initialized. + 328. memset(&f, 0, sizeof(f)); + 329. f.len = f32.len; + 330. > f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + 332. return NULL; + +net/compat.c:329: error: UNINITIALIZED_VALUE + The value read from f32.len was never initialized. + 327. return NULL; + 328. memset(&f, 0, sizeof(f)); + 329. > f.len = f32.len; + 330. f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + +drivers/gpu/drm/i915/i915_gem.c:337: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 335. return ret; + 336. + 337. > while ((vma = list_first_entry_or_null(&obj->vma_list, + 338. struct i915_vma, + 339. obj_link))) { + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +sound/core/pcm_native.c:397: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 395. if (trace_hw_interval_param_enabled()) { + 396. if (hw_is_interval(r->var)) + 397. > old_interval = *hw_param_interval(params, r->var); + 398. } + 399. + +sound/core/pcm_native.c:393: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 391. if (trace_hw_mask_param_enabled()) { + 392. if (hw_is_mask(r->var)) + 393. > old_mask = *hw_param_mask(params, r->var); + 394. } + 395. if (trace_hw_interval_param_enabled()) { + +net/wireless/scan.c:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 327. + 328. > list_for_each_entry_rcu(pos, &rdev->sched_scan_req_list, list) { + 329. if (pos->reqid == reqid) + 330. return pos; + +net/ipv6/ip6_fib.c:332: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 330. struct fib6_table *tb; + 331. + 332. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) + 333. fib_seq += tb->fib_seq; + 334. } + +drivers/iommu/dmar.c:329: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 327. struct dmar_drhd_unit *dmaru; + 328. + 329. > for_each_drhd_unit(dmaru) + 330. if (dmar_remove_dev_scope(info, dmaru->segment, + 331. dmaru->devices, dmaru->devices_cnt)) + +net/netfilter/nf_log.c:327: error: DEAD_STORE + The value written to &net (type net*) is never used. + 325. static void *seq_start(struct seq_file *seq, loff_t *pos) + 326. { + 327. > struct net *net = seq_file_net(seq); + 328. + 329. mutex_lock(&nf_log_mutex); + +net/netlabel/netlabel_unlabeled.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. goto add_iface_failure; + 344. list_add_tail_rcu(&iface->list, + 345. > &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]); + 346. } else { + 347. INIT_LIST_HEAD(&iface->list); + +net/netlabel/netlabel_unlabeled.c:348: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 346. } else { + 347. INIT_LIST_HEAD(&iface->list); + 348. > if (netlbl_unlhsh_rcu_deref(netlbl_unlhsh_def) != NULL) + 349. goto add_iface_failure; + 350. rcu_assign_pointer(netlbl_unlhsh_def, iface); + +drivers/gpu/drm/drm_dp_mst_topology.c:373: error: DEAD_STORE + The value written to &crc4 (type unsigned char) is never used. + 371. if (msg->curchunk_idx >= msg->curchunk_len) { + 372. /* do CRC */ + 373. > crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1); + 374. /* copy chunk into bigger msg */ + 375. memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1); + +include/linux/netfilter.h:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. + 332. rcu_read_lock(); + 333. > decodefn = rcu_dereference(nf_nat_decode_session_hook); + 334. if (decodefn) + 335. decodefn(skb, fl); + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +kernel/events/ring_buffer.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. */ + 383. if (!rb->aux_overwrite) { + 384. > aux_tail = READ_ONCE(rb->user_page->aux_tail); + 385. handle->wakeup = rb->aux_wakeup + rb->aux_watermark; + 386. if (aux_head - aux_tail < perf_aux_size(rb)) + +ipc/msg.c:348: error: UNINITIALIZED_VALUE + The value read from tbuf_old.msg_lqbytes was never initialized. + 346. + 347. if (tbuf_old.msg_qbytes == 0) + 348. > out->msg_qbytes = tbuf_old.msg_lqbytes; + 349. else + 350. out->msg_qbytes = tbuf_old.msg_qbytes; + +ipc/msg.c:350: error: UNINITIALIZED_VALUE + The value read from tbuf_old.msg_qbytes was never initialized. + 348. out->msg_qbytes = tbuf_old.msg_lqbytes; + 349. else + 350. > out->msg_qbytes = tbuf_old.msg_qbytes; + 351. + 352. return 0; + +net/netfilter/nf_conntrack_core.c:333: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 331. + 332. /* add this conntrack to the (per cpu) unconfirmed list */ + 333. > ct->cpu = smp_processor_id(); + 334. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 335. + +net/netfilter/nf_conntrack_core.c:333: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 331. + 332. /* add this conntrack to the (per cpu) unconfirmed list */ + 333. > ct->cpu = smp_processor_id(); + 334. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 335. + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +drivers/gpu/drm/drm_dp_helper.c:340: error: UNINITIALIZED_VALUE + The value read from values[_] was never initialized. + 338. return err; + 339. + 340. > link->revision = values[0]; + 341. link->rate = drm_dp_bw_code_to_link_rate(values[1]); + 342. link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK; + +drivers/gpu/drm/drm_dp_helper.c:341: error: UNINITIALIZED_VALUE + The value read from values[_] was never initialized. + 339. + 340. link->revision = values[0]; + 341. > link->rate = drm_dp_bw_code_to_link_rate(values[1]); + 342. link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK; + 343. + +kernel/exit.c:334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 332. struct task_struct *p; + 333. + 334. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 335. if ((p == ignored_task) || + 336. (p->exit_state && thread_group_empty(p)) || + +net/core/netpoll.c:339: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 337. lockdep_assert_irqs_disabled(); + 338. + 339. > npinfo = rcu_dereference_bh(np->dev->npinfo); + 340. if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) { + 341. dev_kfree_skb_irq(skb); + +drivers/gpu/drm/i915/i915_gem_request.c:350: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 348. * noops - they are safe to be replayed on a reset. + 349. */ + 350. > tail = READ_ONCE(request->ring->tail); + 351. } else { + 352. tail = request->postfix; + +drivers/dma-buf/sync_file.c:352: error: UNINITIALIZED_VALUE + The value read from data.fd2 was never initialized. + 350. } + 351. + 352. > fence2 = sync_file_fdget(data.fd2); + 353. if (!fence2) { + 354. err = -ENOENT; + +drivers/tty/vt/vt_ioctl.c:814: error: DEAD_STORE + The value written to &arg (type unsigned long) is never used. + 812. vt_disallocate_all(); + 813. else + 814. > ret = vt_disallocate(--arg); + 815. break; + 816. + +drivers/tty/vt/vt_ioctl.c:881: error: UNINITIALIZED_VALUE + The value read from v.v_clin was never initialized. + 879. vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. > vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_cols was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_rows was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:879: error: UNINITIALIZED_VALUE + The value read from v.v_vlin was never initialized. + 877. console_lock(); + 878. if (v.v_vlin) + 879. > vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. vc_cons[i].d->vc_font.height = v.v_clin; + +include/net/ip_tunnels.h:344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 342. + 343. rcu_read_lock(); + 344. > ops = rcu_dereference(iptun_encaps[t->encap.type]); + 345. if (likely(ops && ops->build_header)) + 346. ret = ops->build_header(skb, &t->encap, protocol, fl4); + +net/core/fib_rules.c:339: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 337. if (!ops) + 338. return -EAFNOSUPPORT; + 339. > list_for_each_entry_rcu(rule, &ops->rules_list, list) + 340. call_fib_rule_notifier(nb, net, FIB_EVENT_RULE_ADD, rule, + 341. family); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/gpu/drm/i915/intel_runtime_pm.c:335: error: DEAD_STORE + The value written to &id (type int) is never used. + 333. struct i915_power_well *power_well) + 334. { + 335. > enum i915_power_well_id id = power_well->id; + 336. bool disabled; + 337. u32 reqs; + +drivers/gpu/drm/i915/intel_runtime_pm.c:348: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 346. * diagnostic message. + 347. */ + 348. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 349. HSW_PWR_WELL_CTL_STATE(id))) || + 350. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +drivers/gpu/drm/i915/intel_runtime_pm.c:348: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 346. * diagnostic message. + 347. */ + 348. > wait_for((disabled = !(I915_READ(HSW_PWR_WELL_CTL_DRIVER(id)) & + 349. HSW_PWR_WELL_CTL_STATE(id))) || + 350. (reqs = hsw_power_well_requesters(dev_priv, id)), 1); + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +ipc/sem.c:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. + 366. /* pairs with smp_store_release() */ + 367. > if (!smp_load_acquire(&sma->use_global_lock)) { + 368. /* fast path successful! */ + 369. return sops->sem_num; + +arch/x86/events/intel/bts.c:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. { + 335. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 336. > int state = READ_ONCE(bts->state); + 337. + 338. /* + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &ret (type int) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/netfilter/nf_conntrack_helper.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. bool found = false; + 339. + 340. > list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) { + 341. if (!strcmp(cur->name, name)) { + 342. found = true; + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +kernel/kprobes.c:342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 340. + 341. head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)]; + 342. > hlist_for_each_entry_rcu(p, head, hlist) { + 343. if (p->addr == addr) + 344. return p; + +net/ipv6/calipso.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. struct calipso_doi *iter; + 339. + 340. > list_for_each_entry_rcu(iter, &calipso_doi_list, list) + 341. if (iter->doi == doi && refcount_read(&iter->refcount)) + 342. return iter; + +scripts/kconfig/symbol.c:352: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 351 could be null and is dereferenced by call to `prop_get_symbol()` at line 352, column 18. + 350. sym->flags &= ~SYMBOL_NEED_SET_CHOICE_VALUES; + 351. prop = sym_get_choice_prop(sym); + 352. > sym_calc_value(prop_get_symbol(prop)); + 353. } + 354. + +kernel/capability.c:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. + 342. rcu_read_lock(); + 343. > ret = security_capable_noaudit(__task_cred(t), ns, cap); + 344. rcu_read_unlock(); + 345. + +net/netfilter/nf_log.c:339: error: DEAD_STORE + The value written to &net (type net*) is never used. + 337. static void *seq_next(struct seq_file *s, void *v, loff_t *pos) + 338. { + 339. > struct net *net = seq_file_net(s); + 340. + 341. (*pos)++; + +drivers/input/ff-memless.c:354: error: DEAD_STORE + The value written to &effect (type ff_effect*) is never used. + 352. + 353. state = &ml->states[i]; + 354. > effect = state->effect; + 355. + 356. if (!test_bit(FF_EFFECT_STARTED, &state->flags)) + +include/net/ip.h:341: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 339. int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst) + 340. { + 341. > u8 pmtudisc = READ_ONCE(inet_sk(sk)->pmtudisc); + 342. + 343. return pmtudisc == IP_PMTUDISC_DO || + +sound/hda/hdmi_chmap.c:376: error: UNINITIALIZED_VALUE + The value read from non_pcm_mapping[_] was never initialized. + 374. + 375. for (i = 0; i < 8; i++) { + 376. > int slotsetup = non_pcm ? non_pcm_mapping[i] : hdmi_channel_mapping[ca][i]; + 377. int hdmi_slot = slotsetup & 0x0f; + 378. int channel = (slotsetup & 0xf0) >> 4; + +block/badblocks.c:356: error: DEAD_STORE + The value written to §ors (type int) is never used. + 354. s >>= bb->shift; + 355. target >>= bb->shift; + 356. > sectors = target - s; + 357. } + 358. + +drivers/base/power/wakeup.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. + 344. srcuidx = srcu_read_lock(&wakeup_srcu); + 345. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 346. dev_pm_arm_wake_irq(ws->wakeirq); + 347. srcu_read_unlock(&wakeup_srcu, srcuidx); + +security/keys/process_keys.c:396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 394. rcu_read_lock(); + 395. key_ref = keyring_search_aux( + 396. > make_key_ref(rcu_dereference(ctx->cred->session_keyring), 1), + 397. ctx); + 398. rcu_read_unlock(); + +block/blk-sysfs.c:343: error: DEAD_STORE + The value written to &ret (type long) is never used. + 341. queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) + 342. { + 343. > ssize_t ret = -EINVAL; + 344. #ifdef CONFIG_SMP + 345. unsigned long val; + +drivers/tty/sysrq.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. + 344. read_lock(&tasklist_lock); + 345. > for_each_process(p) { + 346. if (p->flags & PF_KTHREAD) + 347. continue; + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +drivers/gpu/drm/drm_ioc32.c:356: error: UNINITIALIZED_VALUE + The value read from b32.high_mark was never initialized. + 354. buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. > buf.high_mark = b32.high_mark; + 357. + 358. return drm_ioctl_kernel(file, drm_legacy_markbufs, &buf, + +drivers/gpu/drm/drm_ioc32.c:355: error: UNINITIALIZED_VALUE + The value read from b32.low_mark was never initialized. + 353. + 354. buf.size = b32.size; + 355. > buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + 357. + +drivers/gpu/drm/drm_ioc32.c:354: error: UNINITIALIZED_VALUE + The value read from b32.size was never initialized. + 352. return -EFAULT; + 353. + 354. > buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +security/selinux/ss/ebitmap.c:360: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 358. goto out; + 359. + 360. > mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. count = le32_to_cpu(buf[2]); + +security/selinux/ss/ebitmap.c:361: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 359. + 360. mapunit = le32_to_cpu(buf[0]); + 361. > e->highbit = le32_to_cpu(buf[1]); + 362. count = le32_to_cpu(buf[2]); + 363. + +security/selinux/ss/ebitmap.c:362: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 360. mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. > count = le32_to_cpu(buf[2]); + 363. + 364. if (mapunit != BITS_PER_U64) { + +lib/assoc_array.c:413: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr*) is never used. + 411. shortcut = assoc_array_ptr_to_shortcut(parent); + 412. BUG_ON(shortcut->next_node != cursor); + 413. > cursor = parent; + 414. parent = shortcut->back_pointer; + 415. slot = shortcut->parent_slot; + +net/sunrpc/xprtsock.c:382: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 380. err = 0; + 381. } + 382. > return err; + 383. } + 384. + +scripts/kallsyms.c:472: error: UNINITIALIZED_VALUE + The value read from best_idx[_] was never initialized. + 470. output_label("kallsyms_token_index"); + 471. for (i = 0; i < 256; i++) + 472. > printf("\t.short\t%d\n", best_idx[i]); + 473. printf("\n"); + 474. } + +net/sched/act_api.c:354: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 352. struct tc_action *p; + 353. int ret; + 354. > unsigned long id = 1; + 355. + 356. idr_for_each_entry_ul(idr, p, id) { + +net/xfrm/xfrm_policy.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. return &net->xfrm.policy_inexact[dir]; + 362. + 363. > return rcu_dereference_check(net->xfrm.policy_bydst[dir].table, + 364. lockdep_is_held(&net->xfrm.xfrm_policy_lock)) + hash; + 365. } + +block/blk-ioc.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. */ + 361. rcu_read_lock(); + 362. > icq = rcu_dereference(ioc->icq_hint); + 363. if (icq && icq->q == q) + 364. goto out; + +drivers/gpu/drm/i915/intel_uncore.c:415: error: UNINITIALIZED_VALUE + The value read from irqflags was never initialized. + 413. assert_forcewakes_inactive(dev_priv); + 414. + 415. > spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags); + 416. } + 417. + +lib/sbitmap.c:355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 353. + 354. hint = this_cpu_read(*sbq->alloc_hint); + 355. > depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + 357. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +kernel/locking/rwsem-xadd.c:353: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 351. { + 352. struct task_struct *owner; + 353. > bool ret = true; + 354. + 355. if (need_resched()) + +kernel/locking/rwsem-xadd.c:359: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 357. + 358. rcu_read_lock(); + 359. > owner = READ_ONCE(sem->owner); + 360. if (!rwsem_owner_is_writer(owner)) { + 361. /* + +net/ipv4/tcp_minisocks.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. + 362. mss = tcp_mss_clamp(tp, dst_metric_advmss(dst)); + 363. > window_clamp = READ_ONCE(tp->window_clamp); + 364. /* Set this up on the first call only */ + 365. req->rsk_window_clamp = window_clamp ? : dst_metric(dst, RTAX_WINDOW); + +net/wireless/trace.h:350: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 348. ); + 349. + 350. > DECLARE_EVENT_CLASS(wiphy_wdev_evt, + 351. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 352. TP_ARGS(wiphy, wdev), + +scripts/asn1_compiler.c:361: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 361, column 3. + 359. token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token)); + 360. if (!tokens) { + 361. > perror(NULL); + 362. exit(1); + 363. } + +arch/x86/include/asm/tlbflush.h:360: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 358. WARN_ON_ONCE(preemptible()); + 359. + 360. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 361. + 362. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +arch/x86/include/asm/tlbflush.h:360: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 358. WARN_ON_ONCE(preemptible()); + 359. + 360. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 361. + 362. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +net/netfilter/nf_conntrack_helper.c:357: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 355. bool found = false; + 356. + 357. > list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) { + 358. if (cur->expectfn == symbol) { + 359. found = true; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:378: error: DEAD_STORE + The value written to &err (type int) is never used. + 376. opt.value.data = LUCID_VALUE; + 377. opt.value.len = sizeof(LUCID_VALUE); + 378. > err = gssx_enc_option(xdr, &opt); + 379. + 380. /* ..and user creds */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:371: error: NULL_DEREFERENCE + pointer `p` last assigned on line 370 could be null and is dereferenced at line 371, column 2. + 369. /* ctx->options */ + 370. p = xdr_reserve_space(xdr, 4); + 371. > *p = cpu_to_be32(2); + 372. + 373. /* we want a lucid_v1 context */ + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +sound/hda/hdac_controller.c:360: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 358. snd_hdac_chip_updatel(bus, GCTL, AZX_GCTL_RESET, 0); + 359. + 360. > timeout = jiffies + msecs_to_jiffies(100); + 361. while ((snd_hdac_chip_readb(bus, GCTL) & AZX_GCTL_RESET) && + 362. time_before(jiffies, timeout)) + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +drivers/base/power/wakeup.c:361: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 359. + 360. srcuidx = srcu_read_lock(&wakeup_srcu); + 361. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 362. dev_pm_disarm_wake_irq(ws->wakeirq); + 363. srcu_read_unlock(&wakeup_srcu, srcuidx); + +security/selinux/ss/conditional.c:368: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 366. return rc; + 367. + 368. > len = le32_to_cpu(buf[0]); + 369. if (len == 0) + 370. return 0; + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +kernel/sched/loadavg.c:361: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 359. long active, delta; + 360. + 361. > sample_window = READ_ONCE(calc_load_update); + 362. if (time_before(jiffies, sample_window + 10)) + 363. return; + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/sched/clock.c:371: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 369. scd = cpu_sdc(cpu); + 370. + 371. > if (cpu != smp_processor_id()) + 372. clock = sched_clock_remote(scd); + 373. else + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:394: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 392. + 393. /* ...and verify the command was successful. */ + 394. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 395. + 396. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +drivers/dma/dmaengine.c:361: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 359. struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type) + 360. { + 361. > return this_cpu_read(channel_table[tx_type]->chan); + 362. } + 363. EXPORT_SYMBOL(dma_find_channel); + +drivers/dma/dmaengine.c:361: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 359. struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type) + 360. { + 361. > return this_cpu_read(channel_table[tx_type]->chan); + 362. } + 363. EXPORT_SYMBOL(dma_find_channel); + +kernel/exit.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. struct task_struct *p; + 362. + 363. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 364. if (p->signal->flags & SIGNAL_STOP_STOPPED) + 365. return true; + +kernel/pid.c:365: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 363. if (type != PIDTYPE_PID) + 364. task = task->group_leader; + 365. > pid = get_pid(rcu_dereference(task->pids[type].pid)); + 366. rcu_read_unlock(); + 367. return pid; + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +include/linux/key.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. { + 362. /* Barrier versus mark_key_instantiated(). */ + 363. > return smp_load_acquire(&key->state); + 364. } + 365. + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +include/linux/netfilter/x_tables.h:369: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 367. * called xt_write_recseq_begin(). + 368. */ + 369. > addend = (__this_cpu_read(xt_recseq.sequence) + 1) & 1; + 370. + 371. /* + +kernel/printk/printk_safe.c:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. { + 363. /* Use extra buffer in NMI when logbuf_lock is taken or in safe mode. */ + 364. > if (this_cpu_read(printk_context) & PRINTK_NMI_CONTEXT_MASK) + 365. return vprintk_nmi(fmt, args); + 366. + +kernel/printk/printk_safe.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Use extra buffer to prevent a recursion deadlock in safe mode. */ + 368. > if (this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) + 369. return vprintk_safe(fmt, args); + 370. + +kernel/printk/printk_safe.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. * But avoid calling console drivers that might have their own locks. + 374. */ + 375. > if (this_cpu_read(printk_context) & PRINTK_NMI_DEFERRED_CONTEXT_MASK) + 376. return vprintk_deferred(fmt, args); + 377. + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +drivers/scsi/scsi_logging.c:375: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 373. return; + 374. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 375. > off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr); + 376. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + 377. scsi_log_release_buffer(logbuf); + +drivers/scsi/scsi_logging.c:383: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 381. return; + 382. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 383. > off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, + 384. sshdr->asc, sshdr->ascq); + 385. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +drivers/gpu/drm/drm_modes.c:459: error: DEAD_STORE + The value written to &hperiod (type unsigned int) is never used. + 457. vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. > hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + 460. + 461. /* 13. Find the actual Vertical field frequency: */ + +drivers/gpu/drm/drm_modes.c:452: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 450. vsync_plus_bp = (vsync_plus_bp + 500) / 1000; + 451. /* 9. Find the number of lines in V back porch alone: */ + 452. > vback_porch = vsync_plus_bp - V_SYNC_RQD; + 453. /* 10. Find the total number of lines in Vertical field period: */ + 454. vtotal_lines = vdisplay_rnd + top_margin + bottom_margin + + +drivers/gpu/drm/drm_modes.c:457: error: DEAD_STORE + The value written to &vfieldrate_est (type unsigned int) is never used. + 455. vsync_plus_bp + GTF_MIN_V_PORCH; + 456. /* 11. Estimate the Vertical field frequency: */ + 457. > vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + +drivers/gpu/drm/drm_modes.c:465: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 463. /* 14. Find the Vertical frame frequency: */ + 464. if (interlaced) + 465. > vframe_rate = vfield_rate / 2; + 466. else + 467. vframe_rate = vfield_rate; + +drivers/gpu/drm/drm_modes.c:467: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 465. vframe_rate = vfield_rate / 2; + 466. else + 467. > vframe_rate = vfield_rate; + 468. /* 15. Find number of pixels in left margin: */ + 469. if (margins) + +include/net/ip.h:375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 373. return dst_mtu(dst); + 374. + 375. > return min(READ_ONCE(dst->dev->mtu), IP_MAX_MTU); + 376. } + 377. + +drivers/usb/core/message.c:455: error: DEAD_STORE + The value written to &i (type int) is never used. + 453. urb->transfer_buffer_length = len; + 454. } + 455. > io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; + 456. + 457. /* transaction state */ + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +drivers/md/dm-stripe.c:384: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 382. } + 383. buffer[i] = '\0'; + 384. > DMEMIT("1 %s", buffer); + 385. break; + 386. + +drivers/pcmcia/ti113x.h:417: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 415. dev_info(&socket->dev->dev, + 416. "TI: all-serial interrupts ok\n"); + 417. > mfunc_old = mfunc; + 418. goto out; + 419. } + +drivers/pcmcia/ti113x.h:462: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 460. pci_irq_status = yenta_probe_cb_irq(socket); + 461. if (pci_irq_status == 1) { + 462. > mfunc_old = mfunc; + 463. dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n"); + 464. } else { + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +net/netfilter/nf_conntrack_helper.c:385: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 383. + 384. /* rcu_read_lock()ed by nf_hook_thresh */ + 385. > helper = rcu_dereference(help->helper); + 386. + 387. nf_log_packet(nf_ct_net(ct), nf_ct_l3num(ct), 0, skb, NULL, NULL, NULL, + +net/xfrm/xfrm_policy.c:380: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 378. hash = __addr_hash(daddr, saddr, family, hmask, dbits, sbits); + 379. + 380. > return rcu_dereference_check(net->xfrm.policy_bydst[dir].table, + 381. lockdep_is_held(&net->xfrm.xfrm_policy_lock)) + hash; + 382. } + +drivers/dma/dmaengine.c:374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 372. + 373. rcu_read_lock(); + 374. > list_for_each_entry_rcu(device, &dma_device_list, global_node) { + 375. if (dma_has_cap(DMA_PRIVATE, device->cap_mask)) + 376. continue; + +include/net/sch_generic.h:370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 368. static inline struct Qdisc *qdisc_root(const struct Qdisc *qdisc) + 369. { + 370. > struct Qdisc *q = rcu_dereference_rtnl(qdisc->dev_queue->qdisc); + 371. + 372. return q; + +arch/x86/include/asm/tlbflush.h:391: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 389. raw_local_irq_save(flags); + 390. + 391. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 392. /* toggle PGE */ + 393. native_write_cr4(cr4 ^ X86_CR4_PGE); + +arch/x86/include/asm/tlbflush.h:391: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 389. raw_local_irq_save(flags); + 390. + 391. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 392. /* toggle PGE */ + 393. native_write_cr4(cr4 ^ X86_CR4_PGE); + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +kernel/signal.c:381: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 379. */ + 380. rcu_read_lock(); + 381. > user = get_uid(__task_cred(t)->user); + 382. atomic_inc(&user->sigpending); + 383. rcu_read_unlock(); + +kernel/sched/cpuacct.c:377: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 376 could be null and is dereferenced at line 377, column 3. + 375. rcu_read_lock(); + 376. for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca)) + 377. > this_cpu_ptr(ca->cpustat)->cpustat[index] += val; + 378. rcu_read_unlock(); + 379. } + +drivers/iommu/dmar.c:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. struct dmar_drhd_unit *dmaru; + 376. + 377. > list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list) + 378. if (dmaru->segment == drhd->segment && + 379. dmaru->reg_base_addr == drhd->address) + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +kernel/time/tick-common.c:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. void tick_handover_do_timer(void) + 373. { + 374. > if (tick_do_timer_cpu == smp_processor_id()) { + 375. int cpu = cpumask_first(cpu_online_mask); + 376. + +net/ipv4/udp.c:416: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 414. } + 415. + 416. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 417. score++; + 418. return score; + +kernel/params.c:384: error: UNINITIALIZED_VALUE + The value read from v was never initialized. + 382. ret = param_set_bool(val, &boolkp); + 383. if (ret == 0) + 384. > *(int *)kp->arg = v; + 385. return ret; + 386. } + +net/ipv4/cipso_ipv4.c:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. struct cipso_v4_doi *iter; + 376. + 377. > list_for_each_entry_rcu(iter, &cipso_v4_doi_list, list) + 378. if (iter->doi == doi && refcount_read(&iter->refcount)) + 379. return iter; + +sound/hda/hdac_controller.c:379: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 377. snd_hdac_chip_updateb(bus, GCTL, 0, AZX_GCTL_RESET); + 378. + 379. > timeout = jiffies + msecs_to_jiffies(100); + 380. while (!snd_hdac_chip_readb(bus, GCTL) && time_before(jiffies, timeout)) + 381. usleep_range(500, 1000); + +drivers/pci/access.c:378: error: DEAD_STORE + The value written to &max_sleep (type unsigned long) is never used. + 376. struct pci_vpd *vpd = dev->vpd; + 377. unsigned long timeout = jiffies + msecs_to_jiffies(125); + 378. > unsigned long max_sleep = 16; + 379. u16 status; + 380. int ret; + +drivers/pci/access.c:377: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 375. { + 376. struct pci_vpd *vpd = dev->vpd; + 377. > unsigned long timeout = jiffies + msecs_to_jiffies(125); + 378. unsigned long max_sleep = 16; + 379. u16 status; + +drivers/tty/vt/vc_screen.c:536: error: DEAD_STORE + The value written to &con_buf0 (type char*) is never used. + 534. unsigned char c; + 535. + 536. > c = *con_buf0++; + 537. #ifdef __BIG_ENDIAN + 538. vcs_scr_writew(vc, (vcs_scr_readw(vc, org) & 0xff) | (c << 8), org); + +lib/genalloc.c:386: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 384. nbits = (size + (1UL << order) - 1) >> order; + 385. rcu_read_lock(); + 386. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 387. if (addr >= chunk->start_addr && addr <= chunk->end_addr) { + 388. BUG_ON(addr + size - 1 > chunk->end_addr); + +net/netfilter/nf_conntrack_ftp.c:523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 521. /* Now, NAT might want to mangle the packet, and register the + 522. * (possibly changed) expectation itself. */ + 523. > nf_nat_ftp = rcu_dereference(nf_nat_ftp_hook); + 524. if (nf_nat_ftp && ct->status & IPS_NAT_MASK) + 525. ret = nf_nat_ftp(skb, ctinfo, search[dir][i].ftptype, + +net/wireless/trace.h:374: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/ipv4/proc.c:396: error: UNINITIALIZED_VALUE + The value read from buff64[_] was never initialized. + 394. offsetof(struct ipstats_mib, syncp)); + 395. for (i = 0; snmp4_ipstats_list[i].name; i++) + 396. > seq_printf(seq, " %llu", buff64[i]); + 397. + 398. return 0; + +kernel/rcu/srcutree.c:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. for_each_possible_cpu(cpu) + 386. flush_delayed_work(&per_cpu_ptr(sp->sda, cpu)->work); + 387. > if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 388. WARN_ON(srcu_readers_active(sp))) { + 389. pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + +kernel/rcu/srcutree.c:389: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 387. if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 388. WARN_ON(srcu_readers_active(sp))) { + 389. > pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + 390. return; /* Caller forgot to stop doing call_srcu()? */ + 391. } + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +lib/sbitmap.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. + 383. hint = this_cpu_read(*sbq->alloc_hint); + 384. > depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + 386. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +net/netlabel/netlabel_unlabeled.c:408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 406. } else { + 407. ifindex = 0; + 408. > iface = rcu_dereference(netlbl_unlhsh_def); + 409. } + 410. if (iface == NULL) { + +include/net/ip.h:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. } + 386. + 387. > return min(READ_ONCE(skb_dst(skb)->dev->mtu), IP_MAX_MTU); + 388. } + 389. + +net/sunrpc/svc_xprt.c:411: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 409. /* find a thread for this xprt */ + 410. rcu_read_lock(); + 411. > list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) { + 412. if (test_and_set_bit(RQ_BUSY, &rqstp->rq_flags)) + 413. continue; + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +sound/pci/hda/hda_controller.c:391: error: DEAD_STORE + The value written to &timeout (type unsigned int) is never used. + 389. bool direction; + 390. u32 dma_select; + 391. > u32 timeout = 200; + 392. u32 retry_count = 0; + 393. + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +drivers/dma-buf/reservation.c:400: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 398. seq = read_seqcount_begin(&obj->seq); + 399. + 400. > fence_excl = rcu_dereference(obj->fence_excl); + 401. if (fence_excl && !dma_fence_get_rcu(fence_excl)) + 402. goto unlock; + +drivers/dma-buf/reservation.c:404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 402. goto unlock; + 403. + 404. > fobj = rcu_dereference(obj->fence); + 405. if (fobj) { + 406. struct dma_fence **nshared; + +drivers/dma-buf/reservation.c:426: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 424. + 425. for (i = 0; i < shared_count; ++i) { + 426. > shared[i] = rcu_dereference(fobj->shared[i]); + 427. if (!dma_fence_get_rcu(shared[i])) + 428. break; + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +kernel/time/timer.c:382: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 380. unsigned long round_jiffies(unsigned long j) + 381. { + 382. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 383. } + 384. EXPORT_SYMBOL_GPL(round_jiffies); + +kernel/time/timer.c:382: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 380. unsigned long round_jiffies(unsigned long j) + 381. { + 382. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 383. } + 384. EXPORT_SYMBOL_GPL(round_jiffies); + +kernel/locking/rwsem-xadd.c:383: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 381. static noinline bool rwsem_spin_on_owner(struct rw_semaphore *sem) + 382. { + 383. > struct task_struct *owner = READ_ONCE(sem->owner); + 384. + 385. if (!rwsem_owner_is_writer(owner)) + +net/core/net_namespace.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. static void net_free(struct net *net) + 383. { + 384. > kfree(rcu_access_pointer(net->gen)); + 385. kmem_cache_free(net_cachep, net); + 386. } + +net/ipv4/inet_connection_sock.c:424: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 422. } + 423. finish_wait(sk_sleep(sk), &wait); + 424. > return err; + 425. } + 426. + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_base_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_top_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +kernel/kprobes.c:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. struct kprobe *kp; + 386. + 387. > list_for_each_entry_rcu(kp, &p->list, list) { + 388. if (kp->pre_handler && likely(!kprobe_disabled(kp))) { + 389. set_kprobe_instance(kp); + +kernel/sched/core.c:386: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 384. { + 385. struct thread_info *ti = task_thread_info(p); + 386. > return !(fetch_or(&ti->flags, _TIF_NEED_RESCHED) & _TIF_POLLING_NRFLAG); + 387. } + 388. + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +net/xfrm/xfrm_policy.c:413: error: DEAD_STORE + The value written to &entry0 (type hlist_node*) is never used. + 411. hlist_add_behind_rcu(&pol->bydst, entry0); + 412. } + 413. > entry0 = &pol->bydst; + 414. } + 415. if (!hlist_empty(list)) { + +net/xfrm/xfrm_policy.c:406: error: DEAD_STORE + The value written to &h0 (type unsigned int) is never used. + 404. hlist_del_rcu(&pol->bydst); + 405. hlist_add_head_rcu(&pol->bydst, ndsttable + h); + 406. > h0 = h; + 407. } else { + 408. if (h != h0) + +drivers/gpu/drm/drm_ioc32.c:402: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 400. return err; + 401. + 402. > if (put_user(req32.count, &argp->count)) + 403. return -EFAULT; + 404. + +drivers/gpu/drm/drm_mm.c:387: error: DEAD_STORE + The value written to &end (type unsigned long long) is never used. + 385. int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node) + 386. { + 387. > u64 end = node->start + node->size; + 388. struct drm_mm_node *hole; + 389. u64 hole_start, hole_end; + +kernel/cgroup/freezer.c:409: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 398 could be null and is dereferenced at line 409, column 10. + 407. else + 408. freezer_apply_state(pos_f, + 409. > parent->state & CGROUP_FREEZING, + 410. CGROUP_FREEZING_PARENT); + 411. + +net/ipv4/inet_hashtables.c:392: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 390. const int dif, const int sdif) + 391. { + 392. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + +net/ipv4/inet_hashtables.c:393: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 391. { + 392. INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + 395. const struct hlist_nulls_node *node; + +net/ipv4/inet_hashtables.c:404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 402. + 403. begin: + 404. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 405. if (sk->sk_hash != hash) + 406. continue; + +drivers/gpu/drm/i915/i915_gem_shrinker.c:392: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 390. int timeout_ms) + 391. { + 392. > unsigned long timeout = jiffies + msecs_to_jiffies_timeout(timeout_ms); + 393. + 394. do { + +drivers/net/ethernet/intel/e1000/e1000_main.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. struct e1000_rx_ring *ring = &adapter->rx_ring[i]; + 408. adapter->alloc_rx_buf(adapter, ring, + 409. > E1000_DESC_UNUSED(ring)); + 410. } + 411. } + +net/ipv4/tcp.c:391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 389. static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp) + 390. { + 391. > u32 rate = READ_ONCE(tp->rate_delivered); + 392. u32 intv = READ_ONCE(tp->rate_interval_us); + 393. u64 rate64 = 0; + +net/ipv4/tcp.c:392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 390. { + 391. u32 rate = READ_ONCE(tp->rate_delivered); + 392. > u32 intv = READ_ONCE(tp->rate_interval_us); + 393. u64 rate64 = 0; + 394. + +security/selinux/ss/avtab.c:489: error: DEAD_STORE + The value written to &items (type unsigned int) is never used. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:486: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 484. + 485. items = 0; + 486. > key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:487: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 485. items = 0; + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. > key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:488: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. > key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + 490. + +security/selinux/ss/avtab.c:489: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:413: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 411. return rc; + 412. } + 413. > items2 = le32_to_cpu(buf32[0]); + 414. if (items2 > ARRAY_SIZE(buf32)) { + 415. printk(KERN_ERR "SELinux: avtab: entry overflow\n"); + +security/selinux/ss/avtab.c:426: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 424. items = 0; + 425. + 426. > val = le32_to_cpu(buf32[items++]); + 427. key.source_type = (u16)val; + 428. if (key.source_type != val) { + +security/selinux/ss/avtab.c:432: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 430. return -EINVAL; + 431. } + 432. > val = le32_to_cpu(buf32[items++]); + 433. key.target_type = (u16)val; + 434. if (key.target_type != val) { + +security/selinux/ss/avtab.c:438: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 436. return -EINVAL; + 437. } + 438. > val = le32_to_cpu(buf32[items++]); + 439. key.target_class = (u16)val; + 440. if (key.target_class != val) { + +security/selinux/ss/avtab.c:445: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 443. } + 444. + 445. > val = le32_to_cpu(buf32[items++]); + 446. enabled = (val & AVTAB_ENABLED_OLD) ? AVTAB_ENABLED : 0; + 447. + +security/selinux/ss/avtab.c:465: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 463. if (val & spec_order[i]) { + 464. key.specified = spec_order[i] | enabled; + 465. > datum.u.data = le32_to_cpu(buf32[items++]); + 466. rc = insertf(a, &key, &datum, p); + 467. if (rc) + +security/selinux/ss/avtab.c:532: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 530. } + 531. for (i = 0; i < ARRAY_SIZE(xperms.perms.p); i++) + 532. > xperms.perms.p[i] = le32_to_cpu(buf32[i]); + 533. datum.u.xperms = &xperms; + 534. } else { + +lib/idr.c:422: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 420. } + 421. new = iter.index * IDA_BITMAP_BITS; + 422. > bitmap = rcu_dereference_raw(*slot); + 423. if (radix_tree_exception(bitmap)) { + 424. unsigned long tmp = (unsigned long)bitmap; + +lib/idr.c:432: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 430. return 0; + 431. } + 432. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 433. if (!bitmap) + 434. return -EAGAIN; + +lib/idr.c:464: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 462. return 0; + 463. } + 464. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 465. if (!bitmap) + 466. return -EAGAIN; + +lib/idr.c:432: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 430. return 0; + 431. } + 432. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 433. if (!bitmap) + 434. return -EAGAIN; + +lib/idr.c:464: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 462. return 0; + 463. } + 464. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 465. if (!bitmap) + 466. return -EAGAIN; + +net/ipv6/anycast.c:399: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 397. found = ipv6_chk_acast_dev(dev, addr); + 398. else + 399. > for_each_netdev_rcu(net, dev) + 400. if (ipv6_chk_acast_dev(dev, addr)) { + 401. found = true; + +block/blk-mq-sched.c:408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 406. + 407. rcu_read_lock(); + 408. > list_for_each_entry_rcu_rr(q, queue, &set->tag_list, + 409. tag_set_list) { + 410. queue_for_each_hw_ctx(q, hctx2, i) + +drivers/gpu/drm/i915/dvo_ns2501.c:418: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 416. + 417. if (i2c_transfer(adapter, msgs, 2) == 2) { + 418. > *ch = in_buf[0]; + 419. return true; + 420. } + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +init/main.c:411: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 409. rcu_read_lock(); + 410. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 411. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 412. rcu_read_unlock(); + 413. + +init/main.c:411: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 409. rcu_read_lock(); + 410. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 411. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 412. rcu_read_unlock(); + 413. + +net/wireless/trace.h:392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 390. ); + 391. + 392. > DECLARE_EVENT_CLASS(key_handle, + 393. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 394. bool pairwise, const u8 *mac_addr), + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +net/ipv6/raw.c:395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 393. static inline int rawv6_rcv_skb(struct sock *sk, struct sk_buff *skb) + 394. { + 395. > if ((raw6_sk(sk)->checksum || rcu_access_pointer(sk->sk_filter)) && + 396. skb_checksum_complete(skb)) { + 397. atomic_inc(&sk->sk_drops); + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +net/netlabel/netlabel_calipso.c:396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 394. static const struct netlbl_calipso_ops *netlbl_calipso_ops_get(void) + 395. { + 396. > return READ_ONCE(calipso_ops); + 397. } + 398. + +kernel/sched/core.c:405: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 403. if (val & _TIF_NEED_RESCHED) + 404. return true; + 405. > old = cmpxchg(&ti->flags, val, val | _TIF_NEED_RESCHED); + 406. if (old == val) + 407. break; + +kernel/sched/core.c:398: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 396. { + 397. struct thread_info *ti = task_thread_info(p); + 398. > typeof(ti->flags) old, val = READ_ONCE(ti->flags); + 399. + 400. for (;;) { + +kernel/softirq.c:404: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 402. account_irq_exit_time(current); + 403. preempt_count_sub(HARDIRQ_OFFSET); + 404. > if (!in_interrupt() && local_softirq_pending()) + 405. invoke_softirq(); + 406. + +net/xfrm/xfrm_state.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. return NULL; + 408. + 409. > mode = READ_ONCE(afinfo->mode_map[encap]); + 410. if (unlikely(mode && !try_module_get(mode->owner))) + 411. mode = NULL; + +drivers/cpuidle/sysfs.c:398: error: DEAD_STORE + The value written to &ret (type int) is never used. + 396. static int cpuidle_add_state_sysfs(struct cpuidle_device *device) + 397. { + 398. > int i, ret = -ENOMEM; + 399. struct cpuidle_state_kobj *kobj; + 400. struct cpuidle_device_kobj *kdev = device->kobj_dev; + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +net/ipv6/ip6_fib.c:416: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 414. struct fib6_table *tb; + 415. + 416. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) + 417. fib6_table_dump(net, tb, w); + 418. } + +usr/gen_init_cpio.c:448: error: MEMORY_LEAK + memory dynamically allocated by call to `malloc()` at line 422, column 11 is not reachable after line 448, column 6. + 446. mode, uid, gid, nlinks); + 447. fail: + 448. > if (dname_len) free(dname); + 449. return rc; + 450. } + +drivers/gpu/drm/i915/i915_gem_object.h:404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 402. i915_gem_object_is_framebuffer(const struct drm_i915_gem_object *obj) + 403. { + 404. > return READ_ONCE(obj->framebuffer_references); + 405. } + 406. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:530: error: DEAD_STORE + The value written to &icr (type unsigned int) is never used. + 528. + 529. /* Clear any pending interrupt events. */ + 530. > icr = er32(ICR); + 531. + 532. /* If MWI was previously enabled, reenable it. */ + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +kernel/time/timer.c:403: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 401. unsigned long round_jiffies_relative(unsigned long j) + 402. { + 403. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 404. } + 405. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +kernel/time/timer.c:403: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 401. unsigned long round_jiffies_relative(unsigned long j) + 402. { + 403. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 404. } + 405. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +net/ipv4/proc.c:419: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 417. /* MaxConn field is signed, RFC 2012 */ + 418. if (snmp4_tcp_list[i].entry == TCP_MIB_MAXCONN) + 419. > seq_printf(seq, " %ld", buff[i]); + 420. else + 421. seq_printf(seq, " %lu", buff[i]); + +net/ipv4/proc.c:421: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 419. seq_printf(seq, " %ld", buff[i]); + 420. else + 421. > seq_printf(seq, " %lu", buff[i]); + 422. } + 423. + +net/ipv4/proc.c:433: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 431. seq_puts(seq, "\nUdp:"); + 432. for (i = 0; snmp4_udp_list[i].name; i++) + 433. > seq_printf(seq, " %lu", buff[i]); + 434. + 435. memset(buff, 0, TCPUDP_MIB_MAX * sizeof(unsigned long)); + +net/ipv4/proc.c:445: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 443. seq_puts(seq, "\nUdpLite:"); + 444. for (i = 0; snmp4_udp_list[i].name; i++) + 445. > seq_printf(seq, " %lu", buff[i]); + 446. + 447. seq_putc(seq, '\n'); + +security/selinux/ss/conditional.c:412: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 410. goto err; + 411. + 412. > node->cur_state = le32_to_cpu(buf[0]); + 413. + 414. /* expr */ + +security/selinux/ss/conditional.c:415: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 413. + 414. /* expr */ + 415. > len = le32_to_cpu(buf[1]); + 416. + 417. for (i = 0; i < len; i++) { + +security/selinux/ss/conditional.c:427: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 425. goto err; + 426. + 427. > expr->expr_type = le32_to_cpu(buf[0]); + 428. expr->bool = le32_to_cpu(buf[1]); + 429. + +security/selinux/ss/conditional.c:428: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 426. + 427. expr->expr_type = le32_to_cpu(buf[0]); + 428. > expr->bool = le32_to_cpu(buf[1]); + 429. + 430. if (!expr_isvalid(p, expr)) { + +net/sunrpc/rpc_pipe.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. rcu_read_lock(); + 408. seq_printf(m, "RPC server: %s\n", + 409. > rcu_dereference(clnt->cl_xprt)->servername); + 410. seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_program->name, + 411. clnt->cl_prog, clnt->cl_vers); + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/power/user.c:422: error: UNINITIALIZED_VALUE + The value read from offset was never initialized. + 420. err = snapshot_ioctl(file, cmd, (unsigned long) &offset); + 421. set_fs(old_fs); + 422. > if (!err && put_user(offset, uoffset)) + 423. err = -EFAULT; + 424. return err; + +kernel/seccomp.c:416: error: UNINITIALIZED_VALUE + The value read from fprog32.filter was never initialized. + 414. goto out; + 415. fprog.len = fprog32.len; + 416. > fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + 418. #endif + +kernel/seccomp.c:415: error: UNINITIALIZED_VALUE + The value read from fprog32.len was never initialized. + 413. if (copy_from_user(&fprog32, user_filter, sizeof(fprog32))) + 414. goto out; + 415. > fprog.len = fprog32.len; + 416. fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/pcmcia/ds.c:430: error: UNINITIALIZED_VALUE + The value read from func_id.func was never initialized. + 428. CISTPL_FUNCID, &func_id)) { + 429. mutex_lock(&p_dev->socket->ops_mutex); + 430. > p_dev->func_id = func_id.func; + 431. p_dev->has_func_id = 1; + 432. mutex_unlock(&p_dev->socket->ops_mutex); + +drivers/pcmcia/ds.c:421: error: UNINITIALIZED_VALUE + The value read from manf_id.card was never initialized. + 419. mutex_lock(&p_dev->socket->ops_mutex); + 420. p_dev->manf_id = manf_id.manf; + 421. > p_dev->card_id = manf_id.card; + 422. p_dev->has_manf_id = 1; + 423. p_dev->has_card_id = 1; + +drivers/pcmcia/ds.c:420: error: UNINITIALIZED_VALUE + The value read from manf_id.manf was never initialized. + 418. CISTPL_MANFID, &manf_id)) { + 419. mutex_lock(&p_dev->socket->ops_mutex); + 420. > p_dev->manf_id = manf_id.manf; + 421. p_dev->card_id = manf_id.card; + 422. p_dev->has_manf_id = 1; + +crypto/api.c:439: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 437. } + 438. + 439. > return ERR_PTR(err); + 440. } + 441. EXPORT_SYMBOL_GPL(crypto_alloc_base); + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +drivers/base/cpu.c:416: error: DEAD_STORE + The value written to &retval (type int) is never used. + 414. { + 415. struct device *dev = NULL; + 416. > int retval = -ENODEV; + 417. + 418. dev = kzalloc(sizeof(*dev), GFP_KERNEL); + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +lib/kfifo.c:419: error: DEAD_STORE + The value written to &recsize (type unsigned long) is never used. + 417. l = __KFIFO_PEEK(data, fifo->out, mask); + 418. + 419. > if (--recsize) + 420. l |= __KFIFO_PEEK(data, fifo->out + 1, mask) << 8; + 421. + +lib/genalloc.c:419: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 417. + 418. rcu_read_lock(); + 419. > list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) + 420. func(pool, chunk, data); + 421. rcu_read_unlock(); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +net/compat.c:435: error: UNINITIALIZED_VALUE + The value read from ktime.tv_sec was never initialized. + 433. if (put_user(sizeof(*up), optlen) || + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. > __put_user(ktime.tv_sec, &up->tv_sec) || + 436. __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + +net/compat.c:436: error: UNINITIALIZED_VALUE + The value read from ktime.tv_usec was never initialized. + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. __put_user(ktime.tv_sec, &up->tv_sec) || + 436. > __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + 438. } + +kernel/pid.c:430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 428. task = task->group_leader; + 429. } + 430. > nr = pid_nr_ns(rcu_dereference(task->pids[type].pid), ns); + 431. } + 432. rcu_read_unlock(); + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +drivers/gpu/drm/i915/i915_debugfs.c:537: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 535. * Therefore, we need to protect this ->comm access using RCU. + 536. */ + 537. > request = list_first_entry_or_null(&file_priv->mm.request_list, + 538. struct drm_i915_gem_request, + 539. client_link); + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +net/netlabel/netlabel_domainhash.c:450: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 448. u32 bkt = netlbl_domhsh_hash(entry->domain); + 449. list_add_tail_rcu(&entry->list, + 450. > &rcu_dereference(netlbl_domhsh)->tbl[bkt]); + 451. } else { + 452. INIT_LIST_HEAD(&entry->list); + +net/ipv6/raw.c:430: error: NULL_DEREFERENCE + pointer `rp` last assigned on line 422 could be null and is dereferenced at line 430, column 7. + 428. } + 429. + 430. > if (!rp->checksum) + 431. skb->ip_summed = CHECKSUM_UNNECESSARY; + 432. + +kernel/time/posix-cpu-timers.c:424: error: DEAD_STORE + The value written to &head (type list_head*) is never used. + 422. cleanup_timers_list(head); + 423. cleanup_timers_list(++head); + 424. > cleanup_timers_list(++head); + 425. } + 426. + +crypto/jitterentropy.c:463: error: UNINITIALIZED_VALUE + The value read from mixer.u64 was never initialized. + 461. if ((entropy_collector->data >> i) & 1) + 462. mixer.u64 ^= constant.u64; + 463. > mixer.u64 = jent_rol64(mixer.u64, 1); + 464. } + 465. entropy_collector->data ^= mixer.u64; + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +kernel/events/core.c:428: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 426. tmp = div_u64(tmp, 100); + 427. if (!tmp) + 428. > tmp = 1; + 429. + 430. WRITE_ONCE(perf_sample_allowed_ns, tmp); + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +net/wireless/util.c:509: error: UNINITIALIZED_VALUE + The value read from payload.proto was never initialized. + 507. + 508. skb_copy_bits(skb, hdrlen, &payload, sizeof(payload)); + 509. > tmp.h_proto = payload.proto; + 510. + 511. if (likely((ether_addr_equal(payload.hdr, rfc1042_header) && + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +drivers/gpu/drm/i915/intel_guc_ct.c:426: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 424. int intel_guc_enable_ct(struct intel_guc *guc) + 425. { + 426. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 427. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 428. int err; + +block/blk-merge.c:444: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced at line 444, column 3. + 442. (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1; + 443. + 444. > sg->length += pad_len; + 445. rq->extra_len += pad_len; + 446. } + +block/blk-merge.c:452: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced by call to `sg_unmark_end()` at line 452, column 3. + 450. memset(q->dma_drain_buffer, 0, q->dma_drain_size); + 451. + 452. > sg_unmark_end(sg); + 453. sg = sg_next(sg); + 454. sg_set_page(sg, virt_to_page(q->dma_drain_buffer), + +net/ipv4/ip_output.c:440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 438. */ + 439. rcu_read_lock(); + 440. > inet_opt = rcu_dereference(inet->inet_opt); + 441. fl4 = &fl->u.ip4; + 442. rt = skb_rtable(skb); + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:463: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 461. + 462. /* ...and verify the command was successful. */ + 463. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 464. + 465. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:437: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 435. if (unlikely(p == NULL)) + 436. return -ENOSPC; + 437. > count = be32_to_cpup(p++); + 438. for (i = 0; i < count; i++) { + 439. gssx_dec_name_attr(xdr, &dummy); + +net/wireless/mlme.c:435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 433. + 434. spin_lock_bh(&rdev->mlme_unreg_lock); + 435. > while ((reg = list_first_entry_or_null(&rdev->mlme_unreg, + 436. struct cfg80211_mgmt_registration, + 437. list))) { + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/scsi/scsi_logging.c:476: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 474. + 475. if (db_string) + 476. > off += scnprintf(logbuf + off, logbuf_len - off, + 477. "driverbyte=%s", db_string); + 478. else + +drivers/scsi/scsi_logging.c:479: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 477. "driverbyte=%s", db_string); + 478. else + 479. > off += scnprintf(logbuf + off, logbuf_len - off, + 480. "driverbyte=0x%02x", driver_byte(cmd->result)); + 481. out_printk: + +lib/sbitmap.c:449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 447. wait_cnt = atomic_dec_return(&ws->wait_cnt); + 448. if (wait_cnt <= 0) { + 449. > wake_batch = READ_ONCE(sbq->wake_batch); + 450. /* + 451. * Pairs with the memory barrier in sbitmap_queue_resize() to + +net/ipv6/anycast.c:436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 434. + 435. state->idev = NULL; + 436. > for_each_netdev_rcu(net, state->dev) { + 437. struct inet6_dev *idev; + 438. idev = __in6_dev_get(state->dev); + +drivers/gpu/drm/i915/i915_pmu.c:457: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 455. + 456. if (!locked) + 457. > spin_unlock_irqrestore(&i915->pmu.lock, flags); + 458. } else { + 459. struct pci_dev *pdev = i915->drm.pdev; + +drivers/gpu/drm/i915/i915_pmu.c:490: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 488. + 489. if (!locked) + 490. > spin_unlock_irqrestore(&i915->pmu.lock, flags); + 491. } + 492. + +drivers/md/dm-io.c:460: error: UNINITIALIZED_VALUE + The value read from sio.error_bits was never initialized. + 458. + 459. if (error_bits) + 460. > *error_bits = sio.error_bits; + 461. + 462. return sio.error_bits ? -EIO : 0; + +drivers/gpu/drm/i915/intel_guc_submission.c:455: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 453. + 454. /* Free space is guaranteed. */ + 455. > wq_off = READ_ONCE(desc->tail); + 456. GEM_BUG_ON(CIRC_SPACE(wq_off, READ_ONCE(desc->head), + 457. GUC_WQ_SIZE) < wqi_size); + +drivers/md/md.c:440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 438. atomic_set(&mddev->flush_pending, 1); + 439. rcu_read_lock(); + 440. > rdev_for_each_rcu(rdev, mddev) + 441. if (rdev->raid_disk >= 0 && + 442. !test_bit(Faulty, &rdev->flags)) { + +net/wireless/trace.h:433: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +lib/genalloc.c:442: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 440. + 441. rcu_read_lock(); + 442. > list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) { + 443. if (start >= chunk->start_addr && start <= chunk->end_addr) { + 444. if (end <= chunk->end_addr) { + +net/ipv4/udp.c:447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 445. result = NULL; + 446. badness = 0; + 447. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 448. score = compute_score(sk, net, saddr, sport, + 449. daddr, hnum, dif, sdif, exact_dif); + +net/ipv4/inet_hashtables.c:446: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 444. struct net *net = sock_net(sk); + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + +net/ipv4/inet_hashtables.c:447: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + 449. saddr, inet->inet_dport); + +net/ipv4/inet_hashtables.c:445: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 443. int dif = sk->sk_bound_dev_if; + 444. struct net *net = sock_net(sk); + 445. > int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + +drivers/cpuidle/sysfs.c:441: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 438 could be null and is dereferenced at line 441, column 18. + 439. int i; + 440. + 441. > for (i = 0; i < drv->state_count; i++) + 442. cpuidle_free_state_kobj(device, i); + 443. } + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +kernel/cgroup/freezer.c:442: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 440 could be null and is dereferenced at line 442, column 16. + 440. struct freezer *freezer = css_freezer(css); + 441. + 442. > return (bool)(freezer->state & CGROUP_FREEZING_SELF); + 443. } + 444. + +kernel/rcu/srcutree.c:450: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 448. smp_mb(); /* Order prior store to ->srcu_gp_seq_needed vs. GP start. */ + 449. rcu_seq_start(&sp->srcu_gp_seq); + 450. > state = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 451. WARN_ON_ONCE(state != SRCU_STATE_SCAN1); + 452. } + +lib/rhashtable.c:447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 445. int err; + 446. + 447. > old_tbl = rht_dereference_rcu(ht->tbl, ht); + 448. + 449. size = tbl->size; + +lib/rhashtable.c:477: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 475. fail: + 476. /* Do not fail the insert if someone else did a rehash. */ + 477. > if (likely(rcu_dereference_raw(tbl->future_tbl))) + 478. return 0; + 479. + +kernel/auditsc.c:452: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 450. unsigned int sessionid; + 451. + 452. > cred = rcu_dereference_check(tsk->cred, tsk == current || task_creation); + 453. + 454. for (i = 0; i < rule->field_count; i++) { + +kernel/auditsc.c:632: error: UNINITIALIZED_VALUE + The value read from sid was never initialized. + 630. need_sid = 0; + 631. } + 632. > result = security_audit_rule_match(sid, f->type, + 633. f->op, + 634. f->lsm_rule, + +kernel/rcu/tree.c:447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 445. rcu_preempt_note_context_switch(preempt); + 446. /* Load rcu_urgent_qs before other flags. */ + 447. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) + 448. goto out; + 449. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + +kernel/rcu/tree.c:450: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 448. goto out; + 449. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 450. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) + 451. rcu_momentary_dyntick_idle(); + 452. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +net/netfilter/nf_conntrack_helper.c:449: error: NULL_DEREFERENCE + pointer `help` last assigned on line 442 could be null and is dereferenced at line 449, column 9. + 447. return true; + 448. + 449. > this = rcu_dereference_protected(help->helper, + 450. lockdep_is_held(&nf_conntrack_expect_lock)); + 451. return this == me; + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +net/ipv6/seg6.c:443: error: DEAD_STORE + The value written to &err (type int) is never used. + 441. int __init seg6_init(void) + 442. { + 443. > int err = -ENOMEM; + 444. + 445. err = genl_register_family(&seg6_genl_family); + +net/xfrm/xfrm_policy.c:456: error: DEAD_STORE + The value written to &odst (type hlist_head*) is never used. + 454. write_seqcount_begin(&xfrm_policy_hash_generation); + 455. + 456. > odst = rcu_dereference_protected(net->xfrm.policy_bydst[dir].table, + 457. lockdep_is_held(&net->xfrm.xfrm_policy_lock)); + 458. + +include/linux/tcp.h:445: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 443. { + 444. struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue; + 445. > int somaxconn = READ_ONCE(sock_net(sk)->core.sysctl_somaxconn); + 446. + 447. queue->fastopenq.max_qlen = min_t(unsigned int, backlog, somaxconn); + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +kernel/module.c:473: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 471. return true; + 472. + 473. > list_for_each_entry_rcu(mod, &modules, list) { + 474. struct symsearch arr[] = { + 475. { mod->syms, mod->syms + mod->num_syms, mod->crcs, + +net/ipv6/ip6_flowlabel.c:454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 452. + 453. rcu_read_lock_bh(); + 454. > for_each_sk_fl_rcu(np, sfl) + 455. count++; + 456. rcu_read_unlock_bh(); + +net/sched/sch_generic.c:461: error: DEAD_STORE + The value written to &trans_start (type unsigned long) is never used. + 459. + 460. txq = netdev_get_tx_queue(dev, i); + 461. > trans_start = txq->trans_start; + 462. if (netif_xmit_stopped(txq) && + 463. time_after(jiffies, (trans_start + + +kernel/cgroup/freezer.c:450: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 448 could be null and is dereferenced at line 450, column 16. + 448. struct freezer *freezer = css_freezer(css); + 449. + 450. > return (bool)(freezer->state & CGROUP_FREEZING_PARENT); + 451. } + 452. + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +drivers/gpu/drm/i915/intel_guc_ct.c:449: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 447. void intel_guc_disable_ct(struct intel_guc *guc) + 448. { + 449. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 450. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 451. + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +net/unix/af_unix.c:454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 452. rcu_read_lock(); + 453. if (unix_writable(sk)) { + 454. > wq = rcu_dereference(sk->sk_wq); + 455. if (skwq_has_sleeper(wq)) + 456. wake_up_interruptible_sync_poll(&wq->wait, + +drivers/gpu/drm/drm_ioc32.c:465: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 463. return err; + 464. + 465. > if (put_user(req32.count, &argp->count) + 466. || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:466: error: UNINITIALIZED_VALUE + The value read from req32.virtual was never initialized. + 464. + 465. if (put_user(req32.count, &argp->count) + 466. > || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + 468. + +net/ipv6/mcast.c:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. } + 483. + 484. > for_each_pmc_rcu(inet6, pmc) { + 485. if (pmc->ifindex != gsf->gf_interface) + 486. continue; + +drivers/gpu/drm/i915/intel_sdvo.c:457: error: DEAD_STORE + The value written to &ret (type int) is never used. + 455. u8 *buf, status; + 456. struct i2c_msg *msgs; + 457. > int i, ret = true; + 458. + 459. /* Would be simpler to allocate both in one go ? */ + +kernel/time/timer.c:453: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 451. unsigned long round_jiffies_up(unsigned long j) + 452. { + 453. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 454. } + 455. EXPORT_SYMBOL_GPL(round_jiffies_up); + +kernel/time/timer.c:453: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 451. unsigned long round_jiffies_up(unsigned long j) + 452. { + 453. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 454. } + 455. EXPORT_SYMBOL_GPL(round_jiffies_up); + +net/sunrpc/auth.c:456: error: DEAD_STORE + The value written to &expired (type unsigned long) is never used. + 454. spinlock_t *cache_lock; + 455. struct rpc_cred *cred, *next; + 456. > unsigned long expired = jiffies - RPC_AUTH_EXPIRY_MORATORIUM; + 457. long freed = 0; + 458. + +net/sunrpc/auth.c:461: error: DEAD_STORE + The value written to &nr_to_scan (type int) is never used. + 459. list_for_each_entry_safe(cred, next, &cred_unused, cr_lru) { + 460. + 461. > if (nr_to_scan-- == 0) + 462. break; + 463. /* + +drivers/input/input.c:464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 462. + 463. rcu_read_lock(); + 464. > grab = rcu_dereference(dev->grab); + 465. if (!grab || grab == handle) + 466. input_handle_event(dev, type, code, value); + +net/ipv4/igmp.c:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. return skb; + 468. + 469. > mtu = READ_ONCE(dev->mtu); + 470. if (mtu < IPV4_MIN_MTU) + 471. return skb; + +drivers/gpu/drm/drm_plane.c:466: error: DEAD_STORE + The value written to &config (type drm_mode_config*) is never used. + 464. return -EINVAL; + 465. + 466. > config = &dev->mode_config; + 467. plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr); + 468. + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +net/sunrpc/xprtsock.c:485: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 483. + 484. rcu_read_lock(); + 485. > wq = rcu_dereference(sk->sk_wq); + 486. set_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags); + 487. rcu_read_unlock(); + +security/selinux/ss/conditional.c:466: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 464. return rc; + 465. + 466. > len = le32_to_cpu(buf[0]); + 467. + 468. rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel); + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +kernel/cgroup/cgroup.c:460: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 458. { + 459. if (ss) + 460. > return rcu_dereference_check(cgrp->subsys[ss->id], + 461. lockdep_is_held(&cgroup_mutex)); + 462. else + +net/core/neighbour.c:467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 465. + 466. rcu_read_lock_bh(); + 467. > nht = rcu_dereference_bh(tbl->nht); + 468. hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); + 469. + +net/core/neighbour.c:470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 468. hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); + 469. + 470. > for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 471. n != NULL; + 472. n = rcu_dereference_bh(n->next)) { + +net/core/neighbour.c:472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 470. for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 471. n != NULL; + 472. > n = rcu_dereference_bh(n->next)) { + 473. if (!memcmp(n->primary_key, pkey, key_len) && + 474. net_eq(dev_net(n->dev), net)) { + +net/wireless/trace.h:457: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/ipv6/tcp_ipv6.c:489: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 487. opt = ireq->ipv6_opt; + 488. if (!opt) + 489. > opt = rcu_dereference(np->opt); + 490. err = ip6_xmit(sk, skb, fl6, sk->sk_mark, opt, np->tclass); + 491. rcu_read_unlock(); + +lib/genalloc.c:466: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 464. + 465. rcu_read_lock(); + 466. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) + 467. avail += atomic_long_read(&chunk->avail); + 468. rcu_read_unlock(); + +net/ipv6/addrlabel.c:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. + 468. rcu_read_lock(); + 469. > hlist_for_each_entry_rcu(p, &net->ipv6.ip6addrlbl_table.head, list) { + 470. if (idx >= s_idx) { + 471. err = ip6addrlbl_fill(skb, p, + +include/linux/cgroup.h:464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 462. static inline struct css_set *task_css_set(struct task_struct *task) + 463. { + 464. > return task_css_set_check(task, false); + 465. } + 466. + +kernel/softirq.c:469: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 467. local_irq_save(flags); + 468. t->next = NULL; + 469. > *__this_cpu_read(tasklet_vec.tail) = t; + 470. __this_cpu_write(tasklet_vec.tail, &(t->next)); + 471. raise_softirq_irqoff(TASKLET_SOFTIRQ); + +include/linux/tcp.h:470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 468. * This happens for listeners. + 469. */ + 470. > u16 user_mss = READ_ONCE(tp->rx_opt.user_mss); + 471. + 472. return (user_mss && user_mss < mss) ? user_mss : mss; + +kernel/time/timer.c:468: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 466. unsigned long round_jiffies_up_relative(unsigned long j) + 467. { + 468. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 469. } + 470. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +kernel/time/timer.c:468: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 466. unsigned long round_jiffies_up_relative(unsigned long j) + 467. { + 468. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 469. } + 470. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +net/ipv4/tcp_fastopen.c:468: error: DEAD_STORE + The value written to &tfo_bh_timeout (type unsigned int) is never used. + 466. bool tcp_fastopen_active_should_disable(struct sock *sk) + 467. { + 468. > unsigned int tfo_bh_timeout = sock_net(sk)->ipv4.sysctl_tcp_fastopen_blackhole_timeout; + 469. int tfo_da_times = atomic_read(&sock_net(sk)->ipv4.tfo_active_disable_times); + 470. unsigned long timeout; + +drivers/gpu/drm/i915/i915_sysfs.c:483: error: UNINITIALIZED_VALUE + The value read from val was never initialized. + 481. BUG(); + 482. + 483. > return snprintf(buf, PAGE_SIZE, "%d\n", val); + 484. } + 485. + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/dma-buf/reservation.c:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. i = -1; + 483. + 484. > fence = rcu_dereference(obj->fence_excl); + 485. if (fence && !test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags)) { + 486. if (!dma_fence_get_rcu(fence)) + +drivers/dma-buf/reservation.c:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. if (wait_all) { + 499. struct reservation_object_list *fobj = + 500. > rcu_dereference(obj->fence); + 501. + 502. if (fobj) + +drivers/dma-buf/reservation.c:506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 504. + 505. for (i = 0; !fence && i < shared_count; ++i) { + 506. > struct dma_fence *lfence = rcu_dereference(fobj->shared[i]); + 507. + 508. if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, + +drivers/iommu/dmar.c:475: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 473. + 474. rhsa = (struct acpi_dmar_rhsa *)header; + 475. > for_each_drhd_unit(drhd) { + 476. if (drhd->reg_base_addr == rhsa->base_address) { + 477. int node = acpi_map_pxm_to_node(rhsa->proximity_domain); + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +net/ipv4/udp.c:512: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 510. result = NULL; + 511. badness = 0; + 512. > sk_for_each_rcu(sk, &hslot->head) { + 513. score = compute_score(sk, net, saddr, sport, + 514. daddr, hnum, dif, sdif, exact_dif); + +include/linux/cgroup.h:477: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 475. int subsys_id) + 476. { + 477. > return task_css_check(task, subsys_id, false); + 478. } + 479. + +kernel/rcu/tree.c:482: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 480. preempt_disable(); + 481. /* Load rcu_urgent_qs before other flags. */ + 482. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) { + 483. preempt_enable(); + 484. return; + +kernel/rcu/tree.c:478: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 476. unsigned long flags; + 477. + 478. > if (!raw_cpu_read(rcu_dynticks.rcu_urgent_qs)) + 479. return; + 480. preempt_disable(); + +kernel/rcu/tree.c:488: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 486. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 487. barrier(); /* Avoid RCU read-side critical sections leaking down. */ + 488. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) { + 489. local_irq_save(flags); + 490. rcu_momentary_dyntick_idle(); + +kernel/rcu/tree.c:493: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 491. local_irq_restore(flags); + 492. } + 493. > if (unlikely(raw_cpu_read(rcu_sched_data.cpu_no_qs.b.exp))) + 494. rcu_sched_qs(); + 495. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +kernel/trace/trace.c:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. return -ENOMEM; + 499. + 500. > pid_list->pid_max = READ_ONCE(pid_max); + 501. + 502. /* Only truncating will shrink pid_max */ + +net/wireless/trace.h:474: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +security/selinux/ss/services.c:536: error: UNINITIALIZED_VALUE + The value read from permission_names[_] was never initialized. + 534. audit_log_format(ab, "%s%s", + 535. need_comma ? "," : "", + 536. > permission_names[index] + 537. ? permission_names[index] : "????"); + 538. need_comma = true; + +kernel/softirq.c:482: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 480. local_irq_save(flags); + 481. t->next = NULL; + 482. > *__this_cpu_read(tasklet_hi_vec.tail) = t; + 483. __this_cpu_write(tasklet_hi_vec.tail, &(t->next)); + 484. raise_softirq_irqoff(HI_SOFTIRQ); + +drivers/gpu/drm/drm_ioc32.c:487: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 485. return -EFAULT; + 486. + 487. > request.count = req32.count; + 488. request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:488: error: UNINITIALIZED_VALUE + The value read from req32.list was never initialized. + 486. + 487. request.count = req32.count; + 488. > request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + 490. } + +net/ipv6/ip6_flowlabel.c:495: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 493. rcu_read_lock_bh(); + 494. + 495. > for_each_sk_fl_rcu(np, sfl) { + 496. if (sfl->fl->label == (np->flow_label & IPV6_FLOWLABEL_MASK)) { + 497. spin_lock_bh(&ip6_fl_lock); + +lib/assoc_array.c:643: error: UNINITIALIZED_VALUE + The value read from j was never initialized. + 641. } + 642. found_slot_for_multiple_occupancy: + 643. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 644. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 645. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +lib/assoc_array.c:643: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 641. } + 642. found_slot_for_multiple_occupancy: + 643. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 644. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 645. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +lib/assoc_array.c:648: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 646. BUG_ON(slot >= ASSOC_ARRAY_FAN_OUT); + 647. + 648. > new_n1->parent_slot = slot; + 649. + 650. /* Metadata pointers cannot change slot */ + +drivers/cpuidle/cpuidle.c:484: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 482 could be null and is dereferenced at line 484, column 22. + 482. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 483. + 484. > if (!try_module_get(drv->owner)) + 485. return -EINVAL; + 486. + +kernel/trace/trace_events_trigger.c:486: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 484. list_for_each_entry(file, &tr->events, list) { + 485. struct event_trigger_data *data; + 486. > list_for_each_entry_rcu(data, &file->triggers, list) { + 487. trace_event_trigger_enable_disable(file, 0); + 488. if (data->ops->free) + +lib/genalloc.c:485: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 483. + 484. rcu_read_lock(); + 485. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) + 486. size += chunk_size(chunk); + 487. rcu_read_unlock(); + +kernel/sched/core.c:493: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 491. cpu = cpu_of(rq); + 492. + 493. > if (cpu == smp_processor_id()) { + 494. set_tsk_need_resched(curr); + 495. set_preempt_need_resched(); + +drivers/firmware/dmi_scan.c:502: error: DEAD_STORE + The value written to &c (type int) is never used. + 500. dmi_get_system_info(DMI_BIOS_VERSION)); + 501. c += scnprintf(buf + c, len - c, " "); + 502. > c += print_filtered(buf + c, len - c, + 503. dmi_get_system_info(DMI_BIOS_DATE)); + 504. } + +net/ipv6/exthdrs.c:496: error: DEAD_STORE + The value written to &accept_source_route (type int) is never used. + 494. idev = __in6_dev_get(skb->dev); + 495. if (idev && accept_source_route > idev->cnf.accept_source_route) + 496. > accept_source_route = idev->cnf.accept_source_route; + 497. + 498. if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) || + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +net/ipv4/ping.c:511: error: UNINITIALIZED_VALUE + The value read from family was never initialized. + 509. /* We assume the packet has already been checked by icmp_unreach */ + 510. + 511. > if (!ping_supported(family, icmph->type, icmph->code)) + 512. return; + 513. + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +lib/idr.c:497: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 495. goto err; + 496. + 497. > bitmap = rcu_dereference_raw(*slot); + 498. if (radix_tree_exception(bitmap)) { + 499. btmp = (unsigned long *)slot; + +lib/idr.c:512: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 510. radix_tree_iter_tag_set(&ida->ida_rt, &iter, IDR_FREE); + 511. if (radix_tree_exception(bitmap)) { + 512. > if (rcu_dereference_raw(*slot) == + 513. (void *)RADIX_TREE_EXCEPTIONAL_ENTRY) + 514. radix_tree_iter_delete(&ida->ida_rt, &iter, slot); + +net/ipv6/esp6.c:508: error: UNINITIALIZED_VALUE + The value read from nexthdr[_] was never initialized. + 506. + 507. ret = -EINVAL; + 508. > padlen = nexthdr[0]; + 509. if (padlen + 2 + alen >= elen) { + 510. net_dbg_ratelimited("ipsec esp packet is garbage padlen=%d, elen=%d\n", + +net/ipv6/esp6.c:523: error: UNINITIALIZED_VALUE + The value read from nexthdr[_] was never initialized. + 521. pskb_trim(skb, skb->len - trimlen); + 522. + 523. > ret = nexthdr[1]; + 524. + 525. out: + +drivers/gpu/drm/i915/intel_guc_submission.c:499: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 497. * we also need to treat 0 as a reserved value. + 498. */ + 499. > cookie = READ_ONCE(db->cookie); + 500. WARN_ON_ONCE(xchg(&db->cookie, cookie + 1 ?: cookie + 2) != cookie); + 501. + +kernel/time/tick-common.c:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. trace_suspend_resume(TPS("timekeeping_freeze"), + 492. > smp_processor_id(), true); + 493. timekeeping_suspend(); + 494. } else { + +kernel/time/tick-common.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. tick_freeze_depth++; + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. > trace_suspend_resume(TPS("timekeeping_freeze"), + 492. smp_processor_id(), true); + 493. timekeeping_suspend(); + +net/ipv6/route.c:497: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 495. return rt; + 496. + 497. > for (sprt = rt; sprt; sprt = rcu_dereference(sprt->rt6_next)) { + 498. struct net_device *dev = sprt->dst.dev; + 499. + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:525: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 523. * only the first byte of the word is being modified + 524. */ + 525. > ret_val = e1000_read_eeprom(hw, last_word, 1, + 526. &eeprom_buff[last_word - first_word]); + 527. } + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +lib/rhashtable.c:521: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 519. + 520. RCU_INIT_POINTER(list->next, plist); + 521. > head = rht_dereference_bucket(head->next, tbl, hash); + 522. RCU_INIT_POINTER(list->rhead.next, head); + 523. rcu_assign_pointer(*pprev, obj); + +lib/rhashtable.c:518: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 516. + 517. list = container_of(obj, struct rhlist_head, rhead); + 518. > plist = container_of(head, struct rhlist_head, rhead); + 519. + 520. RCU_INIT_POINTER(list->next, plist); + +net/ipv6/sit.c:492: error: DEAD_STORE + The value written to &code (type int) is never used. + 490. const struct iphdr *iph = (const struct iphdr *)skb->data; + 491. const int type = icmp_hdr(skb)->type; + 492. > const int code = icmp_hdr(skb)->code; + 493. unsigned int data_len = 0; + 494. struct ip_tunnel *t; + +net/ipv6/sit.c:490: error: DEAD_STORE + The value written to &iph (type iphdr const *) is never used. + 488. static int ipip6_err(struct sk_buff *skb, u32 info) + 489. { + 490. > const struct iphdr *iph = (const struct iphdr *)skb->data; + 491. const int type = icmp_hdr(skb)->type; + 492. const int code = icmp_hdr(skb)->code; + +drivers/pci/pcie/aer/aerdrv_core.c:491: error: DEAD_STORE + The value written to &result (type unsigned int) is never used. + 489. static void do_recovery(struct pci_dev *dev, int severity) + 490. { + 491. > pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED; + 492. enum pci_channel_state state; + 493. + +include/linux/cgroup.h:502: error: UNINITIALIZED_VALUE + The value read from css was never initialized. + 500. } + 501. rcu_read_unlock(); + 502. > return css; + 503. } + 504. + +kernel/softirq.c:494: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 492. + 493. local_irq_disable(); + 494. > list = __this_cpu_read(tasklet_vec.head); + 495. __this_cpu_write(tasklet_vec.head, NULL); + 496. __this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head)); + +kernel/softirq.c:518: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 516. local_irq_disable(); + 517. t->next = NULL; + 518. > *__this_cpu_read(tasklet_vec.tail) = t; + 519. __this_cpu_write(tasklet_vec.tail, &(t->next)); + 520. __raise_softirq_irqoff(TASKLET_SOFTIRQ); + +kernel/softirq.c:494: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 492. + 493. local_irq_disable(); + 494. > list = __this_cpu_read(tasklet_vec.head); + 495. __this_cpu_write(tasklet_vec.head, NULL); + 496. __this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head)); + +drivers/tty/tty_buffer.c:511: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 509. * is advancing to the next buffer + 510. */ + 511. > next = smp_load_acquire(&head->next); + 512. /* paired w/ release in __tty_buffer_request_room() or in + 513. * tty_buffer_flush(); ensures we see the committed buffer data + +drivers/tty/tty_buffer.c:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. * tty_buffer_flush(); ensures we see the committed buffer data + 514. */ + 515. > count = smp_load_acquire(&head->commit) - head->read; + 516. if (!count) { + 517. if (next == NULL) + +drivers/gpu/drm/drm_lease.c:504: error: DEAD_STORE + The value written to &fd (type int) is never used. + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + 504. > int fd = -1; + 505. uint32_t *object_ids; + 506. + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/umh.c:535: error: UNINITIALIZED_VALUE + The value read from cap_array[_] was never initialized. + 533. */ + 534. for (i = 0; i < _KERNEL_CAPABILITY_U32S; i++) + 535. > new_cap.cap[i] = cap_array[i]; + 536. + 537. /* + +net/ipv4/route.c:496: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 494. u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ; + 495. atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ; + 496. > u32 old = READ_ONCE(*p_tstamp); + 497. u32 now = (u32)jiffies; + 498. u32 new, delta = 0; + +kernel/locking/rwsem-xadd.c:504: error: DEAD_STORE + The value written to &count (type long) is never used. + 502. + 503. /* undo write bias from down_write operation, stop active locking */ + 504. > count = atomic_long_sub_return(RWSEM_ACTIVE_WRITE_BIAS, &sem->count); + 505. + 506. /* do optimistic spinning and steal lock if possible */ + +block/blk-core.c:535: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 535, column 33. + 533. */ + 534. if (drain_all) { + 535. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 536. drain |= !list_empty(&q->queue_head); + 537. for (i = 0; i < 2; i++) { + +drivers/usb/early/ehci-dbgp.c:572: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugInEndpoint was never initialized. + 570. } + 571. dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. > dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + 574. /* Move the device to 127 if it isn't already there */ + +drivers/usb/early/ehci-dbgp.c:571: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugOutEndpoint was never initialized. + 569. goto err; + 570. } + 571. > dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + +drivers/gpu/drm/drm_ioc32.c:507: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 505. return -EFAULT; + 506. + 507. > request.ctx_id = req32.ctx_id; + 508. request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + +drivers/gpu/drm/drm_ioc32.c:508: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 506. + 507. request.ctx_id = req32.ctx_id; + 508. > request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + 510. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +kernel/capability.c:504: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 502. const struct cred *cred; + 503. rcu_read_lock(); + 504. > cred = rcu_dereference(tsk->ptracer_cred); + 505. if (cred) + 506. ret = security_capable_noaudit(cred, ns, CAP_SYS_PTRACE); + +kernel/futex.c:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. tail = page; + 574. page = compound_head(page); + 575. > mapping = READ_ONCE(page->mapping); + 576. + 577. /* + +kernel/futex.c:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. } + 659. + 660. > inode = READ_ONCE(mapping->host); + 661. if (!inode) { + 662. rcu_read_unlock(); + +net/sched/ematch.c:529: error: UNINITIALIZED_VALUE + The value read from stack[_] was never initialized. + 527. pop_stack: + 528. if (stackp > 0) { + 529. > match_idx = stack[--stackp]; + 530. cur_match = tcf_em_get_match(tree, match_idx); + 531. + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +net/ipv4/raw.c:527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 525. */ + 526. hdrincl = inet->hdrincl; + 527. > hdrincl = READ_ONCE(hdrincl); + 528. /* + 529. * Check the flags. + +net/ipv4/raw.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. + 588. rcu_read_lock(); + 589. > inet_opt = rcu_dereference(inet->inet_opt); + 590. if (inet_opt) { + 591. memcpy(&opt_copy, inet_opt, + +kernel/events/core.c:506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 504. void perf_sample_event_took(u64 sample_len_ns) + 505. { + 506. > u64 max_len = READ_ONCE(perf_sample_allowed_ns); + 507. u64 running_len; + 508. u64 avg_len; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +kernel/trace/trace_events_trigger.c:509: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 507. bool set_cond = false; + 508. + 509. > list_for_each_entry_rcu(data, &file->triggers, list) { + 510. if (data->filter || event_command_post_trigger(data->cmd_ops) || + 511. event_command_needs_rec(data->cmd_ops)) { + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +kernel/sched/core.c:511: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 509. + 510. raw_spin_lock_irqsave(&rq->lock, flags); + 511. > if (cpu_online(cpu) || cpu == smp_processor_id()) + 512. resched_curr(rq); + 513. raw_spin_unlock_irqrestore(&rq->lock, flags); + +kernel/rcu/update.c:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. int rcu_jiffies_till_stall_check(void) + 507. { + 508. > int till_stall_check = READ_ONCE(rcu_cpu_stall_timeout); + 509. + 510. /* + +net/socket.c:528: error: DEAD_STORE + The value written to &buffer (type char*) is never used. + 526. return -ERANGE; + 527. memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len); + 528. > buffer += len; + 529. } + 530. + +drivers/gpu/drm/i915/i915_gem_request.h:559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 557. struct drm_i915_gem_request *request; + 558. + 559. > request = rcu_dereference(active->request); + 560. if (!request || i915_gem_request_completed(request)) + 561. return NULL; + +drivers/gpu/drm/i915/i915_gem_request.h:604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 602. * rcu_assign_pointer(). + 603. */ + 604. > if (!request || request == rcu_access_pointer(active->request)) + 605. return rcu_pointer_handoff(request); + 606. + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +include/linux/dma-mapping.h:519: error: UNINITIALIZED_VALUE + The value read from cpu_addr was never initialized. + 517. + 518. if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr)) + 519. > return cpu_addr; + 520. + 521. /* + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +kernel/trace/trace_events.c:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. struct trace_array *tr = data; + 514. + 515. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 516. trace_filter_add_remove_task(pid_list, NULL, task); + 517. } + +arch/x86/events/intel/pt.c:513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 511. { + 512. struct pt *pt = this_cpu_ptr(&pt_ctx); + 513. > u64 ctl = READ_ONCE(event->hw.config); + 514. + 515. /* may be already stopped by a PMI */ + +kernel/time/tick-common.c:517: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 515. timekeeping_resume(); + 516. trace_suspend_resume(TPS("timekeeping_freeze"), + 517. > smp_processor_id(), false); + 518. } else { + 519. tick_resume_local(); + +kernel/time/tick-common.c:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. if (tick_freeze_depth == num_online_cpus()) { + 515. timekeeping_resume(); + 516. > trace_suspend_resume(TPS("timekeeping_freeze"), + 517. smp_processor_id(), false); + 518. } else { + +block/blk-mq-sched.c:513: error: DEAD_STORE + The value written to &set (type blk_mq_tag_set*) is never used. + 511. static void blk_mq_sched_tags_teardown(struct request_queue *q) + 512. { + 513. > struct blk_mq_tag_set *set = q->tag_set; + 514. struct blk_mq_hw_ctx *hctx; + 515. int i; + +include/linux/interrupt.h:514: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 512. static inline struct task_struct *this_cpu_ksoftirqd(void) + 513. { + 514. > return this_cpu_read(ksoftirqd); + 515. } + 516. + +include/linux/interrupt.h:514: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 512. static inline struct task_struct *this_cpu_ksoftirqd(void) + 513. { + 514. > return this_cpu_read(ksoftirqd); + 515. } + 516. + +include/net/sock.h:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. { + 514. if (unlikely(flags & MSG_PEEK)) { + 515. > return READ_ONCE(sk->sk_peek_off); + 516. } + 517. + +block/kyber-iosched.c:516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 514. void *key) + 515. { + 516. > struct blk_mq_hw_ctx *hctx = READ_ONCE(wait->private); + 517. + 518. list_del_init(&wait->entry); + +drivers/gpu/drm/drm_ioc32.c:524: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 522. return -EFAULT; + 523. + 524. > req.ctx_id = req32.ctx_id; + 525. err = drm_ioctl_kernel(file, drm_legacy_getsareactx, &req, DRM_AUTH); + 526. if (err) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +include/linux/cgroup.h:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. static inline bool task_css_is_root(struct task_struct *task, int subsys_id) + 514. { + 515. > return task_css_check(task, subsys_id, true) == + 516. init_css_set.subsys[subsys_id]; + 517. } + +lib/bitmap.c:525: error: DEAD_STORE + The value written to &group_size (type unsigned int) is never used. + 523. totaldigits = c = 0; + 524. old_a = old_b = 0; + 525. > group_size = used_size = 0; + 526. bitmap_zero(maskp, nmaskbits); + 527. do { + +drivers/md/dm-stats.c:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. preempt_disable(); + 542. #endif + 543. > p = &s->stat_percpu[smp_processor_id()][entry]; + 544. + 545. if (!end) { + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +net/ipv6/ip6_flowlabel.c:563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 561. case IPV6_FL_A_RENEW: + 562. rcu_read_lock_bh(); + 563. > for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + +net/ipv6/ip6_flowlabel.c:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. err = -EEXIST; + 612. rcu_read_lock_bh(); + 613. > for_each_sk_fl_rcu(np, sfl) { + 614. if (sfl->fl->label == freq.flr_label) { + 615. if (freq.flr_flags&IPV6_FL_F_EXCL) { + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +net/ipv6/ip6_flowlabel.c:574: error: UNINITIALIZED_VALUE + The value read from freq.flr_label was never initialized. + 572. if (freq.flr_share == IPV6_FL_S_NONE && + 573. ns_capable(net->user_ns, CAP_NET_ADMIN)) { + 574. > fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +net/core/rtnetlink.c:520: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 518. const struct rtnl_af_ops *ops; + 519. + 520. > list_for_each_entry_rcu(ops, &rtnl_af_ops, list) { + 521. if (ops->family == family) + 522. return ops; + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &ret (type int) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +drivers/gpu/drm/i915/intel_cdclk.c:548: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 546. val |= (cmd << DSPFREQGUAR_SHIFT); + 547. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 548. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 549. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 550. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:569: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 567. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 568. + 569. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 570. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 571. 50)) + +drivers/gpu/drm/i915/intel_cdclk.c:548: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 546. val |= (cmd << DSPFREQGUAR_SHIFT); + 547. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 548. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 549. DSPFREQSTAT_MASK) == (cmd << DSPFREQSTAT_SHIFT), + 550. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:569: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 567. vlv_cck_write(dev_priv, CCK_DISPLAY_CLOCK_CONTROL, val); + 568. + 569. > if (wait_for((vlv_cck_read(dev_priv, CCK_DISPLAY_CLOCK_CONTROL) & + 570. CCK_FREQUENCY_STATUS) == (divider << CCK_FREQUENCY_STATUS_SHIFT), + 571. 50)) + +drivers/i2c/i2c-core-smbus.c:539: error: DEAD_STORE + The value written to &orig_jiffies (type unsigned long) is never used. + 537. + 538. /* Retry automatically on arbitration loss */ + 539. > orig_jiffies = jiffies; + 540. for (res = 0, try = 0; try <= adapter->retries; try++) { + 541. res = adapter->algo->smbus_xfer(adapter, addr, flags, + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +net/ipv6/ip6_fib.c:560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 558. e = 0; + 559. head = &net->ipv6.fib_table_hash[h]; + 560. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) { + 561. if (e < s_e) + 562. goto next; + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +kernel/trace/trace_events.c:527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 525. struct trace_array *tr = data; + 526. + 527. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 528. trace_filter_add_remove_task(pid_list, self, task); + 529. } + +net/ipv6/netfilter/nf_conntrack_reasm.c:554: error: UNINITIALIZED_VALUE + The value read from hdr.nexthdr was never initialized. + 552. prev_nhoff = start; + 553. + 554. > nexthdr = hdr.nexthdr; + 555. len -= hdrlen; + 556. start += hdrlen; + +net/ipv6/tcp_ipv6.c:557: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 555. + 556. if (ipv6_addr_v4mapped(&sin6->sin6_addr)) + 557. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3], + 558. AF_INET, prefixlen, cmd.tcpm_key, + 559. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:561: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 559. cmd.tcpm_keylen, GFP_KERNEL); + 560. + 561. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr, + 562. AF_INET6, prefixlen, cmd.tcpm_key, + 563. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:537: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 535. if (optname == TCP_MD5SIG_EXT && + 536. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 537. > prefixlen = cmd.tcpm_prefixlen; + 538. if (prefixlen > 128 || (ipv6_addr_v4mapped(&sin6->sin6_addr) && + 539. prefixlen > 32)) + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +block/blk-flush.c:545: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 544 could be null and is dereferenced at line 545, column 2. + 543. + 544. bio = bio_alloc(gfp_mask, 0); + 545. > bio_set_dev(bio, bdev); + 546. bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; + 547. + +include/net/sock.h:526: error: DEAD_STORE + The value written to &off (type int) is never used. + 524. + 525. if (unlikely(off >= 0)) { + 526. > off = max_t(s32, off - val, 0); + 527. WRITE_ONCE(sk->sk_peek_off, off); + 528. } + +include/net/sock.h:523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 521. static inline void sk_peek_offset_bwd(struct sock *sk, int val) + 522. { + 523. > s32 off = READ_ONCE(sk->sk_peek_off); + 524. + 525. if (unlikely(off >= 0)) { + +usr/gen_init_cpio.c:568: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 568, column 9. + 566. } + 567. + 568. > while (fgets(line, LINE_SIZE, cpio_list)) { + 569. int type_idx; + 570. size_t slen = strlen(line); + +usr/gen_init_cpio.c:580: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 580, column 12. + 578. + 579. if (! (type = strtok(line, " \t"))) { + 580. > fprintf(stderr, + 581. "ERROR: incorrect format, could not locate file type line %d: '%s'\n", + 582. line_nr, line); + +drivers/gpu/drm/i915/intel_hotplug.c:535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 533. mutex_lock(&dev->mode_config.mutex); + 534. + 535. > enabled = READ_ONCE(dev_priv->hotplug.poll_enabled); + 536. + 537. drm_connector_list_iter_begin(dev, &conn_iter); + +include/linux/radix-tree.h:562: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 560. + 561. found: + 562. > if (unlikely(radix_tree_is_internal_node(rcu_dereference_raw(*slot)))) + 563. return __radix_tree_next_slot(slot, iter, flags); + 564. return slot; + +crypto/api.c:556: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 554. } + 555. + 556. > return ERR_PTR(err); + 557. } + 558. EXPORT_SYMBOL_GPL(crypto_alloc_tfm); + +kernel/softirq.c:530: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 528. + 529. local_irq_disable(); + 530. > list = __this_cpu_read(tasklet_hi_vec.head); + 531. __this_cpu_write(tasklet_hi_vec.head, NULL); + 532. __this_cpu_write(tasklet_hi_vec.tail, this_cpu_ptr(&tasklet_hi_vec.head)); + +kernel/softirq.c:554: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 552. local_irq_disable(); + 553. t->next = NULL; + 554. > *__this_cpu_read(tasklet_hi_vec.tail) = t; + 555. __this_cpu_write(tasklet_hi_vec.tail, &(t->next)); + 556. __raise_softirq_irqoff(HI_SOFTIRQ); + +kernel/softirq.c:530: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 528. + 529. local_irq_disable(); + 530. > list = __this_cpu_read(tasklet_hi_vec.head); + 531. __this_cpu_write(tasklet_hi_vec.head, NULL); + 532. __this_cpu_write(tasklet_hi_vec.tail, this_cpu_ptr(&tasklet_hi_vec.head)); + +kernel/rcu/srcutree.c:558: error: DEAD_STORE + The value written to &idxnext (type int) is never used. + 556. /* Initiate callback invocation as needed. */ + 557. idx = rcu_seq_ctr(gpseq) % ARRAY_SIZE(snp->srcu_have_cbs); + 558. > idxnext = (idx + 1) % ARRAY_SIZE(snp->srcu_have_cbs); + 559. rcu_for_each_node_breadth_first(sp, snp) { + 560. spin_lock_irq_rcu_node(snp); + +kernel/sched/core.c:535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 533. + 534. rcu_read_lock(); + 535. > for_each_domain(cpu, sd) { + 536. for_each_cpu(i, sched_domain_span(sd)) { + 537. if (cpu == i) + +kernel/sched/core.c:528: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 526. int get_nohz_timer_target(void) + 527. { + 528. > int i, cpu = smp_processor_id(); + 529. struct sched_domain *sd; + 530. + +kernel/sched/core.c:528: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 526. int get_nohz_timer_target(void) + 527. { + 528. > int i, cpu = smp_processor_id(); + 529. struct sched_domain *sd; + 530. + +net/netfilter/nf_conntrack_core.c:539: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 537. bucket = reciprocal_scale(hash, hsize); + 538. + 539. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[bucket], hnnode) { + 540. struct nf_conn *ct; + 541. + +drivers/tty/serial/serial_core.c:545: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 543. ret = 1; + 544. } + 545. > uart_port_unlock(port, flags); + 546. return ret; + 547. } + +block/blk-mq.c:549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 547. } + 548. + 549. > cpu = get_cpu(); + 550. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 551. shared = cpus_share_cache(cpu, ctx->cpu); + +block/blk-mq.c:549: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 547. } + 548. + 549. > cpu = get_cpu(); + 550. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 551. shared = cpus_share_cache(cpu, ctx->cpu); + +net/sunrpc/svc_xprt.c:536: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 534. + 535. rcu_read_lock(); + 536. > list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) { + 537. /* skip any that aren't queued */ + 538. if (test_bit(RQ_BUSY, &rqstp->rq_flags)) + +net/wireless/scan.c:540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 538. return true; + 539. + 540. > ies = rcu_access_pointer(a->ies); + 541. if (!ies) + 542. return false; + +drivers/gpu/drm/i915/intel_hdmi.c:541: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 537 could be null and is dereferenced at line 541, column 13. + 539. i915_reg_t reg = VIDEO_DIP_CTL; + 540. u32 val = I915_READ(reg); + 541. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 542. + 543. assert_hdmi_port_disabled(intel_hdmi); + +kernel/power/swap.c:572: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 570. pr_info("Image saving done\n"); + 571. swsusp_show_speed(start, stop, nr_to_write, "Wrote"); + 572. > return ret; + 573. } + 574. + +security/keys/process_keys.c:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. + 612. rcu_read_lock(); + 613. > key = rcu_dereference(ctx.cred->session_keyring); + 614. __key_get(key); + 615. rcu_read_unlock(); + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +lib/idr.c:540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 538. + 539. radix_tree_for_each_slot(slot, &ida->ida_rt, &iter, 0) { + 540. > struct ida_bitmap *bitmap = rcu_dereference_raw(*slot); + 541. if (!radix_tree_exception(bitmap)) + 542. kfree(bitmap); + +lib/rhashtable.c:567: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 565. return ERR_PTR(-ENOMEM); + 566. + 567. > head = rht_dereference_bucket(*pprev, tbl, hash); + 568. + 569. RCU_INIT_POINTER(obj->next, head); + +lib/rhashtable.c:550: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 548. return ERR_CAST(data); + 549. + 550. > new_tbl = rcu_dereference(tbl->future_tbl); + 551. if (new_tbl) + 552. return new_tbl; + +net/sched/act_api.c:537: error: DEAD_STORE + The value written to &err (type int) is never used. + 535. tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) + 536. { + 537. > int err = -EINVAL; + 538. unsigned char *b = skb_tail_pointer(skb); + 539. struct nlattr *nest; + +drivers/gpu/drm/i915/intel_fbdev.c:633: error: DEAD_STORE + The value written to &intel_crtc (type intel_crtc*) is never used. + 631. /* Final pass to check if any active pipes don't have fbs */ + 632. for_each_crtc(dev, crtc) { + 633. > intel_crtc = to_intel_crtc(crtc); + 634. + 635. if (!crtc->state->active) + +kernel/tracepoint.c:542: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 540. if (!sys_tracepoint_refcount) { + 541. read_lock(&tasklist_lock); + 542. > for_each_process_thread(p, t) { + 543. set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); + 544. } + +net/netfilter/nf_conntrack_expect.c:542: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 540. + 541. for (st->bucket = 0; st->bucket < nf_ct_expect_hsize; st->bucket++) { + 542. > n = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket])); + 543. if (n) + 544. return n; + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +kernel/trace/trace_events_trigger.c:544: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 542. int ret = 0; + 543. + 544. > list_for_each_entry_rcu(test, &file->triggers, list) { + 545. if (test->cmd_ops->trigger_type == data->cmd_ops->trigger_type) { + 546. ret = -EEXIST; + +lib/decompress_unlzma.c:592: error: UNINITIALIZED_VALUE + The value read from header.pos was never initialized. + 590. + 591. mi = 0; + 592. > lc = header.pos; + 593. while (lc >= 9) { + 594. mi++; + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +net/ipv6/mcast.c:569: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 567. */ + 568. + 569. > for_each_pmc_rcu(inet6, pmc) { + 570. if (pmc->ifindex != gsf->gf_interface) + 571. continue; + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +drivers/gpu/drm/drm_ioc32.c:553: error: UNINITIALIZED_VALUE + The value read from res32.contexts was never initialized. + 551. + 552. res.count = res32.count; + 553. > res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + 555. if (err) + +drivers/gpu/drm/drm_ioc32.c:552: error: UNINITIALIZED_VALUE + The value read from res32.count was never initialized. + 550. return -EFAULT; + 551. + 552. > res.count = res32.count; + 553. res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + +drivers/usb/core/config.c:701: error: UNINITIALIZED_VALUE + The value read from inums[_] was never initialized. + 699. j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. > dev_warn(ddev, "too many alternate settings for " + 702. "config %d interface %d: %d, " + 703. "using maximum allowed: %d\n", + +drivers/usb/core/config.c:750: error: UNINITIALIZED_VALUE + The value read from inums[_] was never initialized. + 748. } + 749. if (n >= intfc->num_altsetting) + 750. > dev_warn(ddev, "config %d interface %d has no " + 751. "altsetting %d\n", cfgno, inums[i], j); + 752. } + +drivers/usb/core/config.c:699: error: UNINITIALIZED_VALUE + The value read from nalts[_] was never initialized. + 697. /* Allocate the usb_interface_caches and altsetting arrays */ + 698. for (i = 0; i < nintf; ++i) { + 699. > j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. dev_warn(ddev, "too many alternate settings for " + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +drivers/gpu/drm/drm_dp_helper.c:600: error: UNINITIALIZED_VALUE + The value read from rev[_] was never initialized. + 598. len = drm_dp_dpcd_read(aux, DP_BRANCH_SW_REV, rev, 2); + 599. if (len > 0) + 600. > seq_printf(m, "\t\tSW: %d.%d\n", rev[0], rev[1]); + 601. + 602. if (detailed_cap_info) { + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +drivers/gpu/drm/i915/i915_gem_gtt.c:600: error: UNINITIALIZED_VALUE + The value read from addr was never initialized. + 598. + 599. vm->scratch_page.page = page; + 600. > vm->scratch_page.daddr = addr; + 601. vm->scratch_page.order = order; + 602. + +drivers/gpu/drm/i915/i915_gem_gtt.c:601: error: UNINITIALIZED_VALUE + The value read from order was never initialized. + 599. vm->scratch_page.page = page; + 600. vm->scratch_page.daddr = addr; + 601. > vm->scratch_page.order = order; + 602. + 603. return 0; + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/intel_guc_submission.c:568: error: DEAD_STORE + The value written to &cs (type unsigned int*) is never used. + 566. } + 567. *cs++ = MI_USER_INTERRUPT; + 568. > *cs++ = MI_NOOP; + 569. + 570. GEM_BUG_ON(!IS_ALIGNED(ring->size, + +net/ipv6/calipso.c:555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 553. + 554. rcu_read_lock(); + 555. > list_for_each_entry_rcu(iter_doi, &calipso_doi_list, list) + 556. if (refcount_read(&iter_doi->refcount) > 0) { + 557. if (doi_cnt++ < *skip_cnt) + +kernel/trace/trace_events.c:553: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 551. struct trace_pid_list *pid_list; + 552. + 553. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 554. + 555. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +net/netfilter/core.c:552: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 550. if (skb->_nfct) { + 551. rcu_read_lock(); + 552. > attach = rcu_dereference(ip_ct_attach); + 553. if (attach) + 554. attach(new, skb); + +net/sunrpc/auth.c:560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 558. + 559. rcu_read_lock(); + 560. > hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) { + 561. if (!entry->cr_ops->crmatch(acred, entry, flags)) + 562. continue; + +kernel/exit.c:553: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 551. struct task_struct *t; + 552. + 553. > for_each_thread(p, t) { + 554. if (!(t->flags & PF_EXITING)) + 555. return t; + +net/netfilter/nf_conntrack_expect.c:554: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 552. struct ct_expect_iter_state *st = seq->private; + 553. + 554. > head = rcu_dereference(hlist_next_rcu(head)); + 555. while (head == NULL) { + 556. if (++st->bucket >= nf_ct_expect_hsize) + +net/netfilter/nf_conntrack_expect.c:558: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 556. if (++st->bucket >= nf_ct_expect_hsize) + 557. return NULL; + 558. > head = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket])); + 559. } + 560. return head; + +net/netfilter/nf_conntrack_ftp.c:557: error: NULL_DEREFERENCE + pointer `ftp` last assigned on line 551 could be null and is dereferenced at line 557, column 2. + 555. * failover breaks. + 556. */ + 557. > ftp->flags[IP_CT_DIR_ORIGINAL] |= NF_CT_FTP_SEQ_PICKUP; + 558. ftp->flags[IP_CT_DIR_REPLY] |= NF_CT_FTP_SEQ_PICKUP; + 559. return 0; + +security/keys/keyring.c:555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 553. struct keyring_search_context *ctx = iterator_data; + 554. const struct key *key = keyring_ptr_to_key(object); + 555. > unsigned long kflags = READ_ONCE(key->flags); + 556. short state = READ_ONCE(key->state); + 557. + +security/keys/keyring.c:556: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 554. const struct key *key = keyring_ptr_to_key(object); + 555. unsigned long kflags = READ_ONCE(key->flags); + 556. > short state = READ_ONCE(key->state); + 557. + 558. kenter("{%d}", key->serial); + +security/keys/keyring.c:568: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 566. /* skip invalidated, revoked and expired keys */ + 567. if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) { + 568. > time64_t expiry = READ_ONCE(key->expiry); + 569. + 570. if (kflags & ((1 << KEY_FLAG_INVALIDATED) | + +kernel/tracepoint.c:559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 557. if (!sys_tracepoint_refcount) { + 558. read_lock(&tasklist_lock); + 559. > for_each_process_thread(p, t) { + 560. clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); + 561. } + +net/ipv4/devinet.c:561: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 559. dev = dev_get_by_index_rcu(net, ifindex); + 560. if (dev) + 561. > in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 562. rcu_read_unlock(); + 563. return in_dev; + +drivers/gpu/drm/i915/i915_debugfs.c:565: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 563. int count, ret; + 564. + 565. > nobject = READ_ONCE(dev_priv->mm.object_count); + 566. objects = kvmalloc_array(nobject, sizeof(*objects), GFP_KERNEL); + 567. if (!objects) + +drivers/tty/serial/serial_core.c:591: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 589. + 590. __uart_start(tty); + 591. > uart_port_unlock(port, flags); + 592. return ret; + 593. } + +net/ipv4/inet_hashtables.c:562: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 560. kuid_t uid = sock_i_uid(sk); + 561. + 562. > sk_for_each_rcu(sk2, &ilb->head) { + 563. if (sk2 != sk && + 564. sk2->sk_family == sk->sk_family && + +net/core/rtnetlink.c:566: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 564. + 565. rcu_read_lock(); + 566. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 567. if (af_ops->get_link_af_size) { + 568. /* AF_* + nested data */ + +net/ipv6/udp.c:579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 577. + 578. /* if we're overly short, let UDP handle it */ + 579. > encap_rcv = READ_ONCE(up->encap_rcv); + 580. if (encap_rcv) { + 581. int ret; + +net/ipv6/udp.c:617: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 615. + 616. prefetch(&sk->sk_rmem_alloc); + 617. > if (rcu_access_pointer(sk->sk_filter) && + 618. udp_lib_checksum_complete(skb)) + 619. goto csum_error; + +security/selinux/ss/avtab.c:568: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 566. goto bad; + 567. } + 568. > nel = le32_to_cpu(buf[0]); + 569. if (!nel) { + 570. printk(KERN_ERR "SELinux: avtab: table is empty\n"); + +drivers/input/mouse/alps.c:586: error: DEAD_STORE + The value written to &z (type int) is never used. + 584. x = (s8)(((packet[0] & 0x20) << 2) | (packet[1] & 0x7f)); + 585. y = (s8)(((packet[0] & 0x10) << 3) | (packet[2] & 0x7f)); + 586. > z = (packet[4] & 0x7c) >> 2; + 587. + 588. /* + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +drivers/ata/libata-sff.c:584: error: UNINITIALIZED_VALUE + The value read from pad[_] was never initialized. + 582. if (rw == READ) { + 583. ioread16_rep(data_addr, pad, 1); + 584. > *buf = pad[0]; + 585. } else { + 586. pad[0] = *buf; + +kernel/cgroup/cgroup.c:572: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 570. */ + 571. if (cft->ss) + 572. > return rcu_dereference_raw(cgrp->subsys[cft->ss->id]); + 573. else + 574. return &cgrp->self; + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +drivers/gpu/drm/i915/i915_pmu.c:595: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 591 could be null and is dereferenced at line 595, column 3. + 593. engine_event_instance(event)); + 594. GEM_BUG_ON(!engine); + 595. > engine->pmu.enable |= BIT(sample); + 596. + 597. GEM_BUG_ON(sample >= I915_PMU_SAMPLE_BITS); + +kernel/exit.c:565: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 564 could be null and is dereferenced at line 565, column 31. + 563. { + 564. struct pid_namespace *pid_ns = task_active_pid_ns(father); + 565. > struct task_struct *reaper = pid_ns->child_reaper; + 566. + 567. if (likely(reaper != father)) + +kernel/trace/trace_events.c:567: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 565. struct trace_pid_list *pid_list; + 566. + 567. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 568. + 569. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +block/scsi_ioctl.c:643: error: UNINITIALIZED_VALUE + The value read from cgc.buffer was never initialized. + 641. break; + 642. + 643. > hdr.dxferp = cgc.buffer; + 644. hdr.sbp = cgc.sense; + 645. if (hdr.sbp) + +block/scsi_ioctl.c:622: error: UNINITIALIZED_VALUE + The value read from cgc.buflen was never initialized. + 620. hdr.interface_id = 'S'; + 621. hdr.cmd_len = sizeof(cgc.cmd); + 622. > hdr.dxfer_len = cgc.buflen; + 623. err = 0; + 624. switch (cgc.data_direction) { + +block/scsi_ioctl.c:644: error: UNINITIALIZED_VALUE + The value read from cgc.sense was never initialized. + 642. + 643. hdr.dxferp = cgc.buffer; + 644. > hdr.sbp = cgc.sense; + 645. if (hdr.sbp) + 646. hdr.mx_sb_len = sizeof(struct request_sense); + +block/scsi_ioctl.c:618: error: UNINITIALIZED_VALUE + The value read from cgc.timeout was never initialized. + 616. if (copy_from_user(&cgc, arg, sizeof(cgc))) + 617. break; + 618. > cgc.timeout = clock_t_to_jiffies(cgc.timeout); + 619. memset(&hdr, 0, sizeof(hdr)); + 620. hdr.interface_id = 'S'; + +net/wireless/trace.h:561: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 559. ); + 560. + 561. > DECLARE_EVENT_CLASS(wiphy_netdev_evt, + 562. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 563. TP_ARGS(wiphy, netdev), + +kernel/workqueue.c:576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 574. return wq->dfl_pwq; + 575. + 576. > return rcu_dereference_raw(wq->numa_pwq_tbl[node]); + 577. } + 578. + +net/core/sock.c:566: error: DEAD_STORE + The value written to &ret (type int) is never used. + 564. int optlen) + 565. { + 566. > int ret = -ENOPROTOOPT; + 567. #ifdef CONFIG_NETDEVICES + 568. struct net *net = sock_net(sk); + +net/ipv4/route.c:570: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 568. + 569. rcu_read_lock(); + 570. > inet_opt = rcu_dereference(inet->inet_opt); + 571. if (inet_opt && inet_opt->opt.srr) + 572. daddr = inet_opt->opt.faddr; + +net/netfilter/core.c:568: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 566. + 567. rcu_read_lock(); + 568. > destroy = rcu_dereference(nf_ct_destroy); + 569. BUG_ON(destroy == NULL); + 570. destroy(nfct); + +net/wireless/scan.c:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. return b->channel->center_freq - a->channel->center_freq; + 574. + 575. > a_ies = rcu_access_pointer(a->ies); + 576. if (!a_ies) + 577. return -1; + +net/wireless/scan.c:578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 576. if (!a_ies) + 577. return -1; + 578. > b_ies = rcu_access_pointer(b->ies); + 579. if (!b_ies) + 580. return 1; + +kernel/sched/core.c:568: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 566. struct rq *rq = cpu_rq(cpu); + 567. + 568. > if (cpu == smp_processor_id()) + 569. return; + 570. + +drivers/ata/ata_piix.c:638: error: UNINITIALIZED_VALUE + The value read from slave_data was never initialized. + 636. pci_write_config_word(dev, master_port, master_data); + 637. if (is_slave) + 638. > pci_write_config_byte(dev, slave_port, slave_data); + 639. + 640. /* Ensure the UDMA bit is off - it will be turned back on if + +drivers/gpu/drm/i915/i915_gem_stolen.c:625: error: DEAD_STORE + The value written to &ret (type int) is never used. + 623. vma = i915_vma_instance(obj, &ggtt->base, NULL); + 624. if (IS_ERR(vma)) { + 625. > ret = PTR_ERR(vma); + 626. goto err_pages; + 627. } + +net/sched/act_api.c:570: error: DEAD_STORE + The value written to &err (type int) is never used. + 568. { + 569. struct tc_action *a; + 570. > int err = -EINVAL; + 571. struct nlattr *nest; + 572. + +net/ipv4/inet_connection_sock.c:578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 576. struct rtable *rt; + 577. + 578. > opt = rcu_dereference(ireq->ireq_opt); + 579. fl4 = &newinet->cork.fl.u.ip4; + 580. + +net/netfilter/nf_conntrack_proto.c:577: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 570 could be null and is dereferenced by call to `nf_ct_l4proto_register_sysctl()` at line 577, column 8. + 575. if (err < 0) + 576. return err; + 577. > err = nf_ct_l4proto_register_sysctl(net, + 578. pn, + 579. &nf_conntrack_l4proto_generic); + +arch/x86/events/intel/rapl.c:578: error: NULL_DEREFERENCE + pointer `pmu` last assigned on line 571 could be null and is dereferenced at line 578, column 2. + 576. return 0; + 577. + 578. > pmu->cpu = -1; + 579. /* Find a new cpu to collect rapl events */ + 580. target = cpumask_any_but(topology_core_cpumask(cpu), cpu); + +block/kyber-iosched.c:581: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 579. + 580. rqs = &khd->rqs[khd->cur_domain]; + 581. > rq = list_first_entry_or_null(rqs, struct request, queuelist); + 582. + 583. /* + +block/kyber-iosched.c:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. kyber_flush_busy_ctxs(khd, hctx); + 589. *flushed = true; + 590. > rq = list_first_entry_or_null(rqs, struct request, queuelist); + 591. } + 592. + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +kernel/cgroup/cpuset.c:577: error: MEMORY_LEAK + `pos_css` is not reachable after line 577, column 2. + 575. + 576. rcu_read_lock(); + 577. > cpuset_for_each_descendant_pre(cp, pos_css, root_cs) { + 578. /* skip the whole subtree if @cp doesn't have any CPU */ + 579. if (cpumask_empty(cp->cpus_allowed)) { + +drivers/gpu/drm/drm_vblank.c:657: error: UNINITIALIZED_VALUE + The value read from duration_ns was never initialized. + 655. + 656. /* Return upper bound of timestamp precision error. */ + 657. > *max_error = duration_ns; + 658. + 659. /* Convert scanout position into elapsed time at raw_time query + +drivers/gpu/drm/drm_vblank.c:674: error: UNINITIALIZED_VALUE + The value read from etime was never initialized. + 672. return true; + 673. + 674. > ts_etime = ktime_to_timespec64(etime); + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + +drivers/gpu/drm/drm_vblank.c:677: error: UNINITIALIZED_VALUE + The value read from hpos was never initialized. + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + 677. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 678. pipe, hpos, vpos, + 679. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/drm_vblank.c:677: error: UNINITIALIZED_VALUE + The value read from vpos was never initialized. + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + 677. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 678. pipe, hpos, vpos, + 679. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +security/selinux/avc.c:579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 577. hvalue = avc_hash(ssid, tsid, tclass); + 578. head = &avc_cache.slots[hvalue]; + 579. > hlist_for_each_entry_rcu(node, head, list) { + 580. if (ssid == node->ae.ssid && + 581. tclass == node->ae.tclass && + +drivers/scsi/sg.c:668: error: UNINITIALIZED_VALUE + The value read from cmnd[_] was never initialized. + 666. */ + 667. if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) { + 668. > printk_ratelimited(KERN_WARNING + 669. "sg_write: data in/out %d/%d bytes " + 670. "for SCSI command 0x%x-- guessing " + +drivers/scsi/sg.c:658: error: UNINITIALIZED_VALUE + The value read from old_hdr.pack_id was never initialized. + 656. hp->timeout = old_hdr.reply_len; /* structure abuse ... */ + 657. hp->flags = input_size; /* structure abuse ... */ + 658. > hp->pack_id = old_hdr.pack_id; + 659. hp->usr_ptr = NULL; + 660. if (__copy_from_user(cmnd, buf, cmd_size)) + +drivers/scsi/sg.c:632: error: UNINITIALIZED_VALUE + The value read from old_hdr.reply_len was never initialized. + 630. /* Determine buffer size. */ + 631. input_size = count - cmd_size; + 632. > mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len; + 633. mxsize -= SZ_SG_HEADER; + 634. input_size -= SZ_SG_HEADER; + +drivers/scsi/sg.c:656: error: UNINITIALIZED_VALUE + The value read from old_hdr.reply_len was never initialized. + 654. hp->dxferp = NULL; + 655. hp->sbp = NULL; + 656. > hp->timeout = old_hdr.reply_len; /* structure abuse ... */ + 657. hp->flags = input_size; /* structure abuse ... */ + 658. hp->pack_id = old_hdr.pack_id; + +drivers/dma-buf/reservation.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. + 588. struct reservation_object_list *fobj = + 589. > rcu_dereference(obj->fence); + 590. + 591. if (fobj) + +drivers/dma-buf/reservation.c:595: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 593. + 594. for (i = 0; i < shared_count; ++i) { + 595. > struct dma_fence *fence = rcu_dereference(fobj->shared[i]); + 596. + 597. ret = reservation_object_test_signaled_single(fence); + +drivers/dma-buf/reservation.c:609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 607. + 608. if (!shared_count) { + 609. > struct dma_fence *fence_excl = rcu_dereference(obj->fence_excl); + 610. + 611. if (fence_excl) { + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +kernel/trace/trace_events.c:583: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 581. return; + 582. + 583. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 584. + 585. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +kernel/trace/trace_events.c:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. + 579. /* Nothing to do if we are already tracing */ + 580. > if (!this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 581. return; + 582. + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +drivers/char/hpet.c:594: error: DEAD_STORE + The value written to &hpet (type hpet*) is never used. + 592. case HPET_IRQFREQ: + 593. timer = devp->hd_timer; + 594. > hpet = devp->hd_hpet; + 595. hpetp = devp->hd_hpets; + 596. break; + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +kernel/sched/core.c:588: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 586. return true; /* Don't try to wake offline CPUs. */ + 587. if (tick_nohz_full_cpu(cpu)) { + 588. > if (cpu != smp_processor_id() || + 589. tick_nohz_tick_stopped()) + 590. tick_nohz_full_kick_cpu(cpu); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:620: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 618. + 619. /* ctx->ctx_flags */ + 620. > p = xdr_encode_hyper(p, ctx->ctx_flags); + 621. + 622. /* ctx->locally_initiated */ + +arch/x86/events/amd/ibs.c:645: error: DEAD_STORE + The value written to &buf (type unsigned long long*) is never used. + 643. } + 644. if (ibs_caps & IBS_CAPS_OPDATA4) { + 645. > rdmsrl(MSR_AMD64_IBSOPDATA4, *buf++); + 646. size++; + 647. } + +drivers/char/hw_random/core.c:580: error: DEAD_STORE + The value written to &ret (type int) is never used. + 578. static int __init hwrng_modinit(void) + 579. { + 580. > int ret = -ENOMEM; + 581. + 582. /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ + +drivers/gpu/drm/drm_ioc32.c:602: error: UNINITIALIZED_VALUE + The value read from d.granted_count was never initialized. + 600. + 601. if (put_user(d.request_size, &argp->request_size) + 602. > || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + 604. + +drivers/gpu/drm/drm_ioc32.c:601: error: UNINITIALIZED_VALUE + The value read from d.request_size was never initialized. + 599. return err; + 600. + 601. > if (put_user(d.request_size, &argp->request_size) + 602. || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:589: error: UNINITIALIZED_VALUE + The value read from d32.context was never initialized. + 587. return -EFAULT; + 588. + 589. > d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + +drivers/gpu/drm/drm_ioc32.c:593: error: UNINITIALIZED_VALUE + The value read from d32.flags was never initialized. + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. > d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + +drivers/gpu/drm/drm_ioc32.c:594: error: UNINITIALIZED_VALUE + The value read from d32.request_count was never initialized. + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. > d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + +drivers/gpu/drm/drm_ioc32.c:595: error: UNINITIALIZED_VALUE + The value read from d32.request_indices was never initialized. + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. > d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:596: error: UNINITIALIZED_VALUE + The value read from d32.request_sizes was never initialized. + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. > d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + 598. if (err) + +drivers/gpu/drm/drm_ioc32.c:590: error: UNINITIALIZED_VALUE + The value read from d32.send_count was never initialized. + 588. + 589. d.context = d32.context; + 590. > d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + +drivers/gpu/drm/drm_ioc32.c:591: error: UNINITIALIZED_VALUE + The value read from d32.send_indices was never initialized. + 589. d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. > d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + +drivers/gpu/drm/drm_ioc32.c:592: error: UNINITIALIZED_VALUE + The value read from d32.send_sizes was never initialized. + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. > d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + +drivers/gpu/drm/i915/intel_fbc.c:582: error: DEAD_STORE + The value written to &compressed_llb (type drm_mm_node*) is never used. + 580. struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 581. struct intel_fbc *fbc = &dev_priv->fbc; + 582. > struct drm_mm_node *uninitialized_var(compressed_llb); + 583. int size, fb_cpp, ret; + 584. + +kernel/module.c:594: error: UNINITIALIZED_VALUE + The value read from fsa.crc was never initialized. + 592. *owner = fsa.owner; + 593. if (crc) + 594. > *crc = fsa.crc; + 595. return fsa.sym; + 596. } + +kernel/module.c:592: error: UNINITIALIZED_VALUE + The value read from fsa.owner was never initialized. + 590. if (each_symbol_section(find_symbol_in_section, &fsa)) { + 591. if (owner) + 592. > *owner = fsa.owner; + 593. if (crc) + 594. *crc = fsa.crc; + +kernel/module.c:595: error: UNINITIALIZED_VALUE + The value read from fsa.sym was never initialized. + 593. if (crc) + 594. *crc = fsa.crc; + 595. > return fsa.sym; + 596. } + 597. + +kernel/time/posix-timers.c:587: error: MEMORY_LEAK + `return` is not reachable after line 587, column 3. + 585. if (copy_from_user(&event, timer_event_spec, sizeof (event))) + 586. return -EFAULT; + 587. > return do_timer_create(which_clock, &event, created_timer_id); + 588. } + 589. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:589: error: MEMORY_LEAK + `return` is not reachable after line 589, column 2. + 587. return do_timer_create(which_clock, &event, created_timer_id); + 588. } + 589. > return do_timer_create(which_clock, NULL, created_timer_id); + 590. } + 591. + +net/ipv4/tcp_minisocks.c:736: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 734. + 735. if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_nxt)) + 736. > req->ts_recent = tmp_opt.rcv_tsval; + 737. + 738. if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn) { + +drivers/md/md-bitmap.c:588: error: DEAD_STORE + The value written to &err (type int) is never used. + 586. int nodes = 0; + 587. unsigned long sectors_reserved = 0; + 588. > int err = -EINVAL; + 589. struct page *sb_page; + 590. loff_t offset = bitmap->mddev->bitmap_info.offset; + +net/ipv4/igmp.c:588: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 586. if (!pmc) { + 587. rcu_read_lock(); + 588. > for_each_pmc_rcu(in_dev, pmc) { + 589. if (pmc->multiaddr == IGMP_ALL_HOSTS) + 590. continue; + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +kernel/trace/trace_events_trigger.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. bool unregistered = false; + 588. + 589. > list_for_each_entry_rcu(data, &file->triggers, list) { + 590. if (data->cmd_ops->trigger_type == test->cmd_ops->trigger_type) { + 591. unregistered = true; + +sound/core/pcm_native.c:609: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 607. if (trace_hw_interval_param_enabled()) { + 608. if (hw_is_interval(*v)) + 609. > old_interval = *hw_param_interval(params, *v); + 610. } + 611. if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) + +sound/core/pcm_native.c:605: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 603. if (trace_hw_mask_param_enabled()) { + 604. if (hw_is_mask(*v)) + 605. > old_mask = *hw_param_mask(params, *v); + 606. } + 607. if (trace_hw_interval_param_enabled()) { + +include/net/sch_generic.h:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. for (i = 0; i < dev->num_tx_queues; i++) { + 589. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + 590. > if (rcu_access_pointer(txq->qdisc) != txq->qdisc_sleeping) + 591. return true; + 592. } + +ipc/mqueue.c:623: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 621. spin_unlock(&info->lock); + 622. out: + 623. > return retval; + 624. } + 625. + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +include/linux/sched/signal.h:588: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 586. static inline struct task_struct *next_thread(const struct task_struct *p) + 587. { + 588. > return list_entry_rcu(p->thread_group.next, + 589. struct task_struct, thread_group); + 590. } + +lib/rhashtable.c:595: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 593. void *data; + 594. + 595. > tbl = rcu_dereference(ht->tbl); + 596. + 597. /* All insertions must grab the oldest table containing + +lib/rhashtable.c:609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 607. + 608. spin_unlock_bh(lock); + 609. > tbl = rcu_dereference(tbl->future_tbl); + 610. } + 611. + +lib/rhashtable.c:612: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 610. } + 611. + 612. > data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 613. new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 614. if (PTR_ERR(new_tbl) != -EEXIST) + +lib/rhashtable.c:613: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 611. + 612. data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 613. > new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 614. if (PTR_ERR(new_tbl) != -EEXIST) + 615. data = ERR_CAST(new_tbl); + +drivers/hid/usbhid/hiddev.c:748: error: UNINITIALIZED_VALUE + The value read from finfo.report_id was never initialized. + 746. + 747. rinfo.report_type = finfo.report_type; + 748. > rinfo.report_id = finfo.report_id; + 749. + 750. report = hiddev_lookup_report(hid, &rinfo); + +drivers/hid/usbhid/hiddev.c:747: error: UNINITIALIZED_VALUE + The value read from finfo.report_type was never initialized. + 745. } + 746. + 747. > rinfo.report_type = finfo.report_type; + 748. rinfo.report_id = finfo.report_id; + 749. + +net/netfilter/nf_conntrack_proto.c:592: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 589 could be null and is dereferenced at line 592, column 2. + 590. &nf_conntrack_l4proto_generic); + 591. + 592. > pn->users--; + 593. nf_ct_l4proto_unregister_sysctl(net, + 594. pn, + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +include/linux/pagemap.h:609: error: DEAD_STORE + The value written to &c (type char) is never used. + 607. if (((unsigned long)uaddr & PAGE_MASK) == + 608. ((unsigned long)end & PAGE_MASK)) { + 609. > return __get_user(c, end); + 610. } + 611. + +kernel/trace/trace_events.c:599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 597. return; + 598. + 599. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 600. + 601. /* Set tracing if current is enabled */ + +kernel/trace/trace_events.c:596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 594. + 595. /* Nothing to do if we are not tracing */ + 596. > if (this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 597. return; + 598. + +net/ipv6/ip6_fib.c:642: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 640. /* remove null_entry in the root node */ + 641. } else if (fn->fn_flags & RTN_TL_ROOT && + 642. > rcu_access_pointer(fn->leaf) == + 643. net->ipv6.ip6_null_entry) { + 644. RCU_INIT_POINTER(fn->leaf, NULL); + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +drivers/usb/host/ohci-q.c:682: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 680. && cnt < urb_priv->length) { + 681. td_fill (ohci, info, 0, 0, urb, cnt); + 682. > cnt++; + 683. } + 684. /* maybe kickstart bulk list */ + +drivers/usb/host/ohci-q.c:706: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 704. ? TD_CC | TD_DP_IN | TD_T_DATA1 + 705. : TD_CC | TD_DP_OUT | TD_T_DATA1; + 706. > td_fill (ohci, info, data, 0, urb, cnt++); + 707. /* maybe kickstart control list */ + 708. wmb (); + +net/netlabel/netlabel_domainhash.c:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. if (entry->valid) { + 602. entry->valid = 0; + 603. > if (entry == rcu_dereference(netlbl_domhsh_def_ipv4)) + 604. RCU_INIT_POINTER(netlbl_domhsh_def_ipv4, NULL); + 605. else if (entry == rcu_dereference(netlbl_domhsh_def_ipv6)) + +net/netlabel/netlabel_domainhash.c:605: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 603. if (entry == rcu_dereference(netlbl_domhsh_def_ipv4)) + 604. RCU_INIT_POINTER(netlbl_domhsh_def_ipv4, NULL); + 605. > else if (entry == rcu_dereference(netlbl_domhsh_def_ipv6)) + 606. RCU_INIT_POINTER(netlbl_domhsh_def_ipv6, NULL); + 607. else + +net/ipv4/route.c:596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 594. struct rtable *rt; + 595. + 596. > rt = rcu_dereference(fnhe->fnhe_rth_input); + 597. if (rt) { + 598. RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL); + +net/ipv4/route.c:602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 600. dst_release(&rt->dst); + 601. } + 602. > rt = rcu_dereference(fnhe->fnhe_rth_output); + 603. if (rt) { + 604. RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL); + +net/netfilter/nf_conntrack_expect.c:625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 623. seq_printf(s, "%sUSERSPACE", delim); + 624. + 625. > helper = rcu_dereference(nfct_help(expect->master)->helper); + 626. if (helper) { + 627. seq_printf(s, "%s%s", expect->flags ? " " : "", helper->name); + +drivers/dma/dmaengine.c:595: error: DEAD_STORE + The value written to &err (type int) is never used. + 593. struct dma_chan *dma_get_slave_channel(struct dma_chan *chan) + 594. { + 595. > int err = -EBUSY; + 596. + 597. /* lock against __dma_request_channel */ + +kernel/time/posix-timers.c:602: error: MEMORY_LEAK + `return` is not reachable after line 602, column 3. + 600. if (get_compat_sigevent(&event, timer_event_spec)) + 601. return -EFAULT; + 602. > return do_timer_create(which_clock, &event, created_timer_id); + 603. } + 604. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:604: error: MEMORY_LEAK + `return` is not reachable after line 604, column 2. + 602. return do_timer_create(which_clock, &event, created_timer_id); + 603. } + 604. > return do_timer_create(which_clock, NULL, created_timer_id); + 605. } + 606. #endif + +kernel/sched/cputime.c:624: error: DEAD_STORE + The value written to &utime (type unsigned long long) is never used. + 622. */ + 623. if (stime == 0) { + 624. > utime = rtime; + 625. goto update; + 626. } + +drivers/tty/serial/serial_core.c:604: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 602. port = uart_port_lock(state, flags); + 603. ret = uart_circ_chars_free(&state->xmit); + 604. > uart_port_unlock(port, flags); + 605. return ret; + 606. } + +net/ipv4/ip_sockglue.c:1021: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 1019. memset(&mreq, 0, sizeof(mreq)); + 1020. mreq.imr_multiaddr = psin->sin_addr; + 1021. > mreq.imr_ifindex = greq.gr_interface; + 1022. + 1023. if (optname == MCAST_JOIN_GROUP) + +net/ipv4/ip_sockglue.c:1068: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1066. mreq.imr_multiaddr = psin->sin_addr; + 1067. mreq.imr_address.s_addr = 0; + 1068. > mreq.imr_ifindex = greqs.gsr_interface; + 1069. err = ip_mc_join_group(sk, &mreq); + 1070. if (err && err != -EADDRINUSE) + +net/ipv4/ip_sockglue.c:1079: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1077. add = 0; + 1078. } + 1079. > err = ip_mc_source(add, omode, sk, &mreqs, + 1080. greqs.gsr_interface); + 1081. break; + +net/ipv4/ip_sockglue.c:885: error: UNINITIALIZED_VALUE + The value read from mreq.imr_ifindex was never initialized. + 883. mreq.imr_ifindex = dev->ifindex; + 884. } else + 885. > dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex); + 886. + 887. + +net/ipv4/ip_sockglue.c:902: error: UNINITIALIZED_VALUE + The value read from mreq.imr_ifindex was never initialized. + 900. break; + 901. + 902. > inet->mc_index = mreq.imr_ifindex; + 903. inet->mc_addr = mreq.imr_address.s_addr; + 904. err = 0; + +net/ipv4/ip_sockglue.c:990: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_interface was never initialized. + 988. + 989. mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 990. > mreq.imr_address.s_addr = mreqs.imr_interface; + 991. mreq.imr_ifindex = 0; + 992. err = ip_mc_join_group(sk, &mreq); + +net/ipv4/ip_sockglue.c:989: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_multiaddr was never initialized. + 987. struct ip_mreqn mreq; + 988. + 989. > mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 990. mreq.imr_address.s_addr = mreqs.imr_interface; + 991. mreq.imr_ifindex = 0; + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +lib/iov_iter.c:608: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 606. if (iter_is_iovec(i)) + 607. might_fault(); + 608. > iterate_all_kinds(i, bytes, v, ({ + 609. if (copyin((to += v.iov_len) - v.iov_len, + 610. v.iov_base, v.iov_len)) + +net/sunrpc/clnt.c:606: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 604. err = -ENOMEM; + 605. rcu_read_lock(); + 606. > xprt = xprt_get(rcu_dereference(clnt->cl_xprt)); + 607. xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 608. rcu_read_unlock(); + +net/sunrpc/clnt.c:607: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 605. rcu_read_lock(); + 606. xprt = xprt_get(rcu_dereference(clnt->cl_xprt)); + 607. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 608. rcu_read_unlock(); + 609. if (xprt == NULL || xps == NULL) { + +drivers/ata/libata-scsi.c:639: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 637. scsi_cmd[0] = ATA_16; + 638. + 639. > scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + +drivers/ata/libata-scsi.c:641: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 639. scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. > scsi_cmd[6] = args[3]; + 642. scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + +drivers/ata/libata-scsi.c:642: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + 642. > scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + 644. scsi_cmd[12] = 0xc2; + +drivers/ata/libata-scsi.c:646: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 644. scsi_cmd[12] = 0xc2; + 645. } else { + 646. > scsi_cmd[6] = args[1]; + 647. } + 648. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:648: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 646. scsi_cmd[6] = args[1]; + 647. } + 648. > scsi_cmd[14] = args[0]; + 649. + 650. /* Good values for timeout and retries? Values below + +include/net/sch_generic.h:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. for (i = 0; i < dev->num_tx_queues; i++) { + 602. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + 603. > if (rcu_access_pointer(txq->qdisc) != &noop_qdisc) + 604. return false; + 605. } + +drivers/gpu/drm/i915/intel_cdclk.c:628: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 626. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 627. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 628. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 629. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 630. 50)) { + +drivers/gpu/drm/i915/intel_cdclk.c:628: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 626. val |= (cmd << DSPFREQGUAR_SHIFT_CHV); + 627. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, val); + 628. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DSPFREQ) & + 629. DSPFREQSTAT_MASK_CHV) == (cmd << DSPFREQSTAT_SHIFT_CHV), + 630. 50)) { + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +drivers/gpu/drm/drm_dp_mst_topology.c:620: error: DEAD_STORE + The value written to &idx (type int) is never used. + 618. msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1; + 619. msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7); + 620. > idx++; + 621. return true; + 622. fail_len: + +lib/radix-tree.c:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. struct radix_tree_node **nodep, unsigned long *maxindex) + 602. { + 603. > struct radix_tree_node *node = rcu_dereference_raw(root->rnode); + 604. + 605. *nodep = node; + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +net/ipv4/devinet.c:609: error: DEAD_STORE + The value written to &err (type int) is never used. + 607. struct ifaddrmsg *ifm; + 608. struct in_ifaddr *ifa, **ifap; + 609. > int err = -EINVAL; + 610. + 611. ASSERT_RTNL(); + +net/ipv4/udp.c:608: error: DEAD_STORE + The value written to &code (type int) is never used. + 606. struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2)); + 607. const int type = icmp_hdr(skb)->type; + 608. > const int code = icmp_hdr(skb)->code; + 609. struct sock *sk; + 610. int harderr; + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +net/ipv4/ip_options.c:654: error: UNINITIALIZED_VALUE + The value read from nexthop was never initialized. + 652. if (srrptr <= srrspace) { + 653. opt->srr_is_hit = 1; + 654. > opt->nexthop = nexthop; + 655. opt->is_changed = 1; + 656. } + +crypto/drbg.c:607: error: DEAD_STORE + The value written to &ret (type int) is never used. + 605. int reseed) + 606. { + 607. > int ret = -EFAULT; + 608. int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + +lib/vsprintf.c:624: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 622. rcu_read_lock(); + 623. for (i = 0; i < depth; i++, d = p) { + 624. > p = READ_ONCE(d->d_parent); + 625. array[i] = READ_ONCE(d->d_name.name); + 626. if (p == d) { + +lib/vsprintf.c:625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 623. for (i = 0; i < depth; i++, d = p) { + 624. p = READ_ONCE(d->d_parent); + 625. > array[i] = READ_ONCE(d->d_name.name); + 626. if (p == d) { + 627. if (i) + +lib/vsprintf.c:633: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 631. } + 632. } + 633. > s = array[--i]; + 634. for (n = 0; n != spec.precision; n++, buf++) { + 635. char c = *s++; + +lib/vsprintf.c:640: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 638. break; + 639. c = '/'; + 640. > s = array[--i]; + 641. } + 642. if (buf < end) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +kernel/module.c:614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 612. module_assert_mutex_or_preempt(); + 613. + 614. > list_for_each_entry_rcu(mod, &modules, list) { + 615. if (!even_unformed && mod->state == MODULE_STATE_UNFORMED) + 616. continue; + +drivers/tty/serial/serial_core.c:617: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 615. port = uart_port_lock(state, flags); + 616. ret = uart_circ_chars_pending(&state->xmit); + 617. > uart_port_unlock(port, flags); + 618. return ret; + 619. } + +kernel/sched/core.c:610: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 608. static inline bool got_nohz_idle_kick(void) + 609. { + 610. > int cpu = smp_processor_id(); + 611. + 612. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +kernel/sched/core.c:610: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 608. static inline bool got_nohz_idle_kick(void) + 609. { + 610. > int cpu = smp_processor_id(); + 611. + 612. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +drivers/gpu/drm/i915/i915_gem_request.c:651: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 649. + 650. /* Move the oldest request to the slab-cache (if not in use!) */ + 651. > req = list_first_entry_or_null(&engine->timeline->requests, + 652. typeof(*req), link); + 653. if (req && i915_gem_request_completed(req)) + +drivers/pcmcia/ds.c:614: error: DEAD_STORE + The value written to &ret (type int) is never used. + 612. cistpl_longlink_mfc_t mfc; + 613. unsigned int no_funcs, i, no_chains; + 614. > int ret = -EAGAIN; + 615. + 616. mutex_lock(&s->ops_mutex); + +drivers/pcmcia/ds.c:655: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 653. + 654. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) + 655. > no_funcs = mfc.nfn; + 656. else + 657. no_funcs = 1; + +net/ipv4/route.c:614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 612. struct fib_nh_exception *fnhe, *oldest; + 613. + 614. > oldest = rcu_dereference(hash->chain); + 615. for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe; + 616. fnhe = rcu_dereference(fnhe->fnhe_next)) { + +net/ipv4/route.c:615: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 613. + 614. oldest = rcu_dereference(hash->chain); + 615. > for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe; + 616. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 617. if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp)) + +net/ipv6/mcast.c:619: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 617. + 618. rcu_read_lock(); + 619. > for_each_pmc_rcu(np, mc) { + 620. if (ipv6_addr_equal(&mc->addr, mc_addr)) + 621. break; + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &ret (type int) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +drivers/gpu/drm/i915/i915_pmu.c:635: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 625 could be null and is dereferenced at line 635, column 7. + 633. * bitmask when the last listener on an event goes away. + 634. */ + 635. > if (--engine->pmu.enable_count[sample] == 0) + 636. engine->pmu.enable &= ~BIT(sample); + 637. } + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +net/netfilter/nf_conntrack_core.c:624: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 622. unsigned int sequence; + 623. + 624. > zone = nf_ct_zone(ct); + 625. + 626. local_bh_disable(); + +drivers/tty/pty.c:617: error: DEAD_STORE + The value written to &fd (type int) is never used. + 615. int ptm_open_peer(struct file *master, struct tty_struct *tty, int flags) + 616. { + 617. > int fd = -1; + 618. struct file *filp; + 619. int retval = -EINVAL; + +drivers/tty/pty.c:619: error: DEAD_STORE + The value written to &retval (type int) is never used. + 617. int fd = -1; + 618. struct file *filp; + 619. > int retval = -EINVAL; + 620. struct path path; + 621. + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.act_mask was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_nr was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_size was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.end_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.pid was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.start_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +include/linux/rhashtable.h:628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 626. unsigned int hash; + 627. + 628. > tbl = rht_dereference_rcu(ht->tbl, ht); + 629. restart: + 630. hash = rht_key_hashfn(ht, tbl, key, params); + +include/linux/rhashtable.h:631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 629. restart: + 630. hash = rht_key_hashfn(ht, tbl, key, params); + 631. > rht_for_each_rcu(he, tbl, hash) { + 632. if (params.obj_cmpfn ? + 633. params.obj_cmpfn(&arg, rht_obj(ht, he)) : + +include/linux/rhashtable.h:642: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 640. smp_rmb(); + 641. + 642. > tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 643. if (unlikely(tbl)) + 644. goto restart; + +include/linux/sched/signal.h:622: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 620. unsigned int limit) + 621. { + 622. > return READ_ONCE(tsk->signal->rlim[limit].rlim_cur); + 623. } + 624. + +kernel/trace/trace_events_filter.c:641: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 639. * n_preds, root and filter->preds are protect with preemption disabled. + 640. */ + 641. > root = rcu_dereference_sched(filter->root); + 642. if (!root) + 643. return 1; + +kernel/trace/trace_events_filter.c:645: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 643. return 1; + 644. + 645. > data.preds = preds = rcu_dereference_sched(filter->preds); + 646. ret = walk_pred_tree(preds, root, filter_match_preds_cb, &data); + 647. WARN_ON(ret); + +lib/radix-tree.c:632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 630. maxshift += RADIX_TREE_MAP_SHIFT; + 631. + 632. > entry = rcu_dereference_raw(root->rnode); + 633. if (!entry && (!is_idr(root) || root_tag_get(root, IDR_FREE))) + 634. goto out; + +net/sunrpc/svc_xprt.c:649: error: DEAD_STORE + The value written to &i (type int) is never used. + 647. } + 648. rqstp->rq_page_end = &rqstp->rq_pages[i]; + 649. > rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */ + 650. + 651. /* Make arg->head point to first page and arg->pages point to rest */ + +drivers/gpu/drm/i915/intel_breadcrumbs.c:644: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 642. */ + 643. rcu_read_lock(); + 644. > request = rcu_dereference(b->first_signal); + 645. if (request) + 646. request = i915_gem_request_get_rcu(request); + +drivers/gpu/drm/i915/intel_breadcrumbs.c:671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 669. * the oldest before picking the next one. + 670. */ + 671. > if (request == rcu_access_pointer(b->first_signal)) { + 672. struct rb_node *rb = + 673. rb_next(&request->signaling.node); + +drivers/tty/serial/serial_core.c:644: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 642. if (port->ops->flush_buffer) + 643. port->ops->flush_buffer(port); + 644. > uart_port_unlock(port, flags); + 645. tty_port_tty_wakeup(&state->port); + 646. } + +net/core/sock.c:624: error: DEAD_STORE + The value written to &ret (type int) is never used. + 622. int __user *optlen, int len) + 623. { + 624. > int ret = -ENOPROTOOPT; + 625. #ifdef CONFIG_NETDEVICES + 626. struct net *net = sock_net(sk); + +net/netfilter/nfnetlink_log.c:687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 685. size += nla_total_size(sizeof(u_int32_t)); + 686. if (inst->flags & NFULNL_CFG_F_CONNTRACK) { + 687. > nfnl_ct = rcu_dereference(nfnl_ct_hook); + 688. if (nfnl_ct != NULL) { + 689. ct = nfnl_ct->get_ct(skb, &ctinfo); + +drivers/md/dm-stats.c:655: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 653. + 654. got_precise_time = false; + 655. > list_for_each_entry_rcu(s, &stats->list, list_entry) { + 656. if (s->stat_flags & STAT_PRECISE_TIMESTAMPS && !got_precise_time) { + 657. if (!end) + +net/netlabel/netlabel_kapi.c:624: error: DEAD_STORE + The value written to &iter (type netlbl_lsm_catmap*) is never used. + 622. int netlbl_catmap_walk(struct netlbl_lsm_catmap *catmap, u32 offset) + 623. { + 624. > struct netlbl_lsm_catmap *iter = catmap; + 625. u32 idx; + 626. u32 bit; + +net/ipv4/cipso_ipv4.c:632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 630. + 631. rcu_read_lock(); + 632. > list_for_each_entry_rcu(iter_doi, &cipso_v4_doi_list, list) + 633. if (refcount_read(&iter_doi->refcount) > 0) { + 634. if (doi_cnt++ < *skip_cnt) + +drivers/gpu/drm/i915/intel_guc_submission.c:631: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 629. &data->preempt_ctx_report[engine->guc_id]; + 630. + 631. > WARN_ON(wait_for_atomic(report->report_return_status == + 632. INTEL_GUC_REPORT_STATUS_COMPLETE, + 633. GUC_PREEMPT_POSTPROCESS_DELAY_MS)); + +drivers/gpu/drm/i915/intel_guc_submission.c:631: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 629. &data->preempt_ctx_report[engine->guc_id]; + 630. + 631. > WARN_ON(wait_for_atomic(report->report_return_status == + 632. INTEL_GUC_REPORT_STATUS_COMPLETE, + 633. GUC_PREEMPT_POSTPROCESS_DELAY_MS)); + +net/wireless/util.c:645: error: UNINITIALIZED_VALUE + The value read from eth.h_proto was never initialized. + 643. + 644. skb_copy_bits(skb, offset, ð, sizeof(eth)); + 645. > len = ntohs(eth.h_proto); + 646. subframe_len = sizeof(struct ethhdr) + len; + 647. padding = (4 - subframe_len) & 0x3; + +include/linux/sched/signal.h:628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 626. unsigned int limit) + 627. { + 628. > return READ_ONCE(tsk->signal->rlim[limit].rlim_max); + 629. } + 630. + +kernel/audit.c:641: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 639. + 640. rcu_read_lock(); + 641. > ac = rcu_dereference(auditd_conn); + 642. if (!ac) { + 643. rcu_read_unlock(); + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +net/ipv4/inet_hashtables.c:644: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 642. goto unlock; + 643. + 644. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 645. reuseport_detach_sock(sk); + 646. if (ilb) { + +include/net/sch_generic.h:630: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 628. { + 629. #ifdef CONFIG_NET_SCHED + 630. > struct qdisc_size_table *stab = rcu_dereference_bh(sch->stab); + 631. + 632. if (stab) + +drivers/gpu/drm/drm_dp_mst_topology.c:643: error: DEAD_STORE + The value written to &idx (type int) is never used. + 641. + 642. msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]); + 643. > idx++; + 644. return true; + 645. fail_len: + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +drivers/char/random.c:643: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 641. + 642. retry: + 643. > entropy_count = orig = READ_ONCE(r->entropy_count); + 644. if (nfrac < 0) { + 645. /* Debit */ + +sound/core/info.c:635: error: DEAD_STORE + The value written to &c (type int) is never used. + 633. int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) + 634. { + 635. > int c = -1; + 636. + 637. if (snd_BUG_ON(!buffer || !buffer->buffer)) + +net/ipv4/ipconfig.c:709: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 707. } + 708. + 709. > *e++ = 255; /* End of the list */ + 710. } + 711. + +drivers/usb/core/message.c:658: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 656. break; + 657. } + 658. > return result; + 659. } + 660. EXPORT_SYMBOL_GPL(usb_get_descriptor); + +net/ipv4/igmp.c:681: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 679. + 680. /* change recs */ + 681. > for_each_pmc_rcu(in_dev, pmc) { + 682. spin_lock_bh(&pmc->lock); + 683. if (pmc->sfcount[MCAST_EXCLUDE]) { + +drivers/gpu/drm/drm_ioc32.c:652: error: UNINITIALIZED_VALUE + The value read from info.agp_version_major was never initialized. + 650. return err; + 651. + 652. > i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + +drivers/gpu/drm/drm_ioc32.c:653: error: UNINITIALIZED_VALUE + The value read from info.agp_version_minor was never initialized. + 651. + 652. i32.agp_version_major = info.agp_version_major; + 653. > i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + +drivers/gpu/drm/drm_ioc32.c:655: error: UNINITIALIZED_VALUE + The value read from info.aperture_base was never initialized. + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. > i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + +drivers/gpu/drm/drm_ioc32.c:656: error: UNINITIALIZED_VALUE + The value read from info.aperture_size was never initialized. + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. > i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + +drivers/gpu/drm/drm_ioc32.c:660: error: UNINITIALIZED_VALUE + The value read from info.id_device was never initialized. + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. > i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + 662. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:659: error: UNINITIALIZED_VALUE + The value read from info.id_vendor was never initialized. + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. > i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + +drivers/gpu/drm/drm_ioc32.c:657: error: UNINITIALIZED_VALUE + The value read from info.memory_allowed was never initialized. + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. > i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + +drivers/gpu/drm/drm_ioc32.c:658: error: UNINITIALIZED_VALUE + The value read from info.memory_used was never initialized. + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. > i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + +drivers/gpu/drm/drm_ioc32.c:654: error: UNINITIALIZED_VALUE + The value read from info.mode was never initialized. + 652. i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. > i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + +include/linux/atomic.h:653: error: UNINITIALIZED_VALUE + The value read from dec was never initialized. + 651. c = old; + 652. } + 653. > return dec; + 654. } + 655. #endif + +net/netfilter/nf_conntrack_sip.c:662: error: UNINITIALIZED_VALUE + The value read from end was never initialized. + 660. return 0; + 661. if (endp) + 662. > *endp = end; + 663. return 1; + 664. } + +net/sunrpc/auth_gss/gss_rpc_xdr.c:683: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 681. + 682. /* ctx->ctx_flags */ + 683. > p = xdr_decode_hyper(p, &ctx->ctx_flags); + 684. + 685. /* ctx->locally_initiated */ + +security/keys/keyring.c:706: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 704. * slots 1-15). + 705. */ + 706. > ptr = READ_ONCE(keyring->keys.root); + 707. if (!ptr) + 708. goto not_this_keyring; + +security/keys/keyring.c:719: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 717. goto not_this_keyring; + 718. + 719. > ptr = READ_ONCE(shortcut->next_node); + 720. node = assoc_array_ptr_to_node(ptr); + 721. goto begin_node; + +security/keys/keyring.c:736: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 734. if (assoc_array_ptr_is_shortcut(ptr)) { + 735. shortcut = assoc_array_ptr_to_shortcut(ptr); + 736. > ptr = READ_ONCE(shortcut->next_node); + 737. BUG_ON(!assoc_array_ptr_is_node(ptr)); + 738. } + +security/keys/keyring.c:747: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 745. /* Go through the slots in a node */ + 746. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 747. > ptr = READ_ONCE(node->slots[slot]); + 748. + 749. if (assoc_array_ptr_is_meta(ptr) && node->back_pointer) + +security/keys/keyring.c:785: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 783. * to ascend to the parent and continue processing there. + 784. */ + 785. > ptr = READ_ONCE(node->back_pointer); + 786. slot = node->parent_slot; + 787. + +security/keys/keyring.c:790: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 788. if (ptr && assoc_array_ptr_is_shortcut(ptr)) { + 789. shortcut = assoc_array_ptr_to_shortcut(ptr); + 790. > ptr = READ_ONCE(shortcut->back_pointer); + 791. slot = shortcut->parent_slot; + 792. } + +drivers/gpu/drm/i915/i915_gem_request.h:644: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 642. i915_gem_active_isset(const struct i915_gem_active *active) + 643. { + 644. > return rcu_access_pointer(active->request); + 645. } + 646. + +net/netlabel/netlabel_unlabeled.c:665: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 663. iface = netlbl_unlhsh_search_iface(dev->ifindex); + 664. } else + 665. > iface = rcu_dereference(netlbl_unlhsh_def); + 666. if (iface == NULL) { + 667. ret_val = -ENOENT; + +block/blk-merge.c:651: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 649. int cpu; + 650. + 651. > cpu = part_stat_lock(); + 652. part = req->part; + 653. + +block/blk-merge.c:651: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 649. int cpu; + 650. + 651. > cpu = part_stat_lock(); + 652. part = req->part; + 653. + +kernel/relay.c:685: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 683. } + 684. + 685. > curr_cpu = get_cpu(); + 686. /* + 687. * The CPU hotplug notifier ran before us and created buffers with + +kernel/relay.c:685: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 683. } + 684. + 685. > curr_cpu = get_cpu(); + 686. /* + 687. * The CPU hotplug notifier ran before us and created buffers with + +net/ipv4/route.c:662: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 660. spin_lock_bh(&fnhe_lock); + 661. + 662. > hash = rcu_dereference(nh->nh_exceptions); + 663. if (!hash) { + 664. hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC); + +net/ipv4/route.c:673: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 671. + 672. depth = 0; + 673. > for (fnhe = rcu_dereference(hash->chain); fnhe; + 674. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 675. if (fnhe->fnhe_daddr == daddr) + +net/ipv4/route.c:674: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 672. depth = 0; + 673. for (fnhe = rcu_dereference(hash->chain); fnhe; + 674. > fnhe = rcu_dereference(fnhe->fnhe_next)) { + 675. if (fnhe->fnhe_daddr == daddr) + 676. break; + +net/ipv4/route.c:691: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 689. fnhe->fnhe_expires = max(1UL, expires); + 690. /* Update all cached dsts too */ + 691. > rt = rcu_dereference(fnhe->fnhe_rth_input); + 692. if (rt) + 693. fill_route_from_fnhe(rt, fnhe); + +net/ipv4/route.c:694: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 692. if (rt) + 693. fill_route_from_fnhe(rt, fnhe); + 694. > rt = rcu_dereference(fnhe->fnhe_rth_output); + 695. if (rt) + 696. fill_route_from_fnhe(rt, fnhe); + +net/ipv4/route.c:719: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 717. * applies to them. + 718. */ + 719. > rt = rcu_dereference(nh->nh_rth_input); + 720. if (rt) + 721. rt->dst.obsolete = DST_OBSOLETE_KILL; + +net/ipv4/route.c:726: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 724. struct rtable __rcu **prt; + 725. prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i); + 726. > rt = rcu_dereference(*prt); + 727. if (rt) + 728. rt->dst.obsolete = DST_OBSOLETE_KILL; + +kernel/locking/mutex.c:653: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 651. { + 652. struct ww_mutex *ww = container_of(lock, struct ww_mutex, base); + 653. > struct ww_acquire_ctx *hold_ctx = READ_ONCE(ww->ctx); + 654. struct mutex_waiter *cur; + 655. + +net/sunrpc/rpcb_clnt.c:652: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 650. { + 651. struct rpc_clnt *parent = clnt->cl_parent; + 652. > struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch); + 653. + 654. while (parent != clnt) { + +net/sunrpc/rpcb_clnt.c:655: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 653. + 654. while (parent != clnt) { + 655. > if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps) + 656. break; + 657. if (clnt->cl_autobind) + +drivers/gpu/drm/i915/intel_guc_submission.c:663: error: DEAD_STORE + The value written to &count (type unsigned int) is never used. + 661. rq = port_unpack(&port[n], &count); + 662. if (rq && count == 0) { + 663. > port_set(&port[n], port_pack(rq, ++count)); + 664. + 665. flush_ggtt_writes(rq->ring->vma); + +drivers/gpu/drm/i915/intel_sdvo.c:661: error: UNINITIALIZED_VALUE + The value read from response.input0_trained was never initialized. + 659. return false; + 660. + 661. > *input_1 = response.input0_trained; + 662. *input_2 = response.input1_trained; + 663. return true; + +drivers/gpu/drm/i915/intel_sdvo.c:662: error: UNINITIALIZED_VALUE + The value read from response.input1_trained was never initialized. + 660. + 661. *input_1 = response.input0_trained; + 662. > *input_2 = response.input1_trained; + 663. return true; + 664. } + +net/ipv4/devinet.c:666: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 664. + 665. rcu_read_lock(); + 666. > hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) { + 667. unsigned long age; + 668. + +net/sunrpc/xprtsock.c:746: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 744. } + 745. + 746. > return status; + 747. } + 748. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/time/tick-sched.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static inline bool local_timer_softirq_pending(void) + 654. { + 655. > return local_softirq_pending() & TIMER_SOFTIRQ; + 656. } + 657. + +drivers/iommu/dmar.c:661: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 659. + 660. while (dev) { + 661. > for_each_active_dev_scope(devices, cnt, index, tmp) + 662. if (dev_is_pci(tmp) && dev == to_pci_dev(tmp)) + 663. return 1; + +block/bio.c:699: error: NULL_DEREFERENCE + pointer `bio->bi_io_vec` last assigned on line 684 could be null and is dereferenced at line 699, column 3. + 697. break; + 698. case REQ_OP_WRITE_SAME: + 699. > bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0]; + 700. break; + 701. default: + +net/sunrpc/svcauth_unix.c:662: error: DEAD_STORE + The value written to &cred (type svc_cred*) is never used. + 660. struct ip_map *ipm; + 661. struct group_info *gi; + 662. > struct svc_cred *cred = &rqstp->rq_cred; + 663. struct svc_xprt *xprt = rqstp->rq_xprt; + 664. struct net *net = xprt->xpt_net; + +drivers/gpu/drm/i915/intel_ringbuffer.h:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. { + 659. /* Ensure that the compiler doesn't optimize away the load. */ + 660. > return READ_ONCE(engine->status_page.page_addr[reg]); + 661. } + 662. + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +kernel/softirq.c:661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 659. { + 660. local_irq_disable(); + 661. > if (local_softirq_pending()) { + 662. /* + 663. * We can safely run softirq on inline stack, as we are not deep + +kernel/time/tick-sched.c:661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 659. ktime_t now, int cpu) + 660. { + 661. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 662. u64 basemono, next_tick, next_tmr, next_rcu, delta, expires; + 663. unsigned long seq, basejiff; + +kernel/time/tick-sched.c:661: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 659. ktime_t now, int cpu) + 660. { + 661. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 662. u64 basemono, next_tick, next_tmr, next_rcu, delta, expires; + 663. unsigned long seq, basejiff; + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/linux/netdevice.h:669: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 667. + 668. /* We only give a hint, preemption can change CPU under us */ + 669. > val |= raw_smp_processor_id(); + 670. + 671. if (table->ents[index] != val) + +kernel/exit.c:676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 674. reaper = find_new_reaper(father, reaper); + 675. list_for_each_entry(p, &father->children, sibling) { + 676. > for_each_thread(p, t) { + 677. t->real_parent = reaper; + 678. BUG_ON((!t->ptrace) != (t->parent == father)); + +drivers/base/core.c:671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 669. * never change once they are set, so they don't need special care. + 670. */ + 671. > drv = READ_ONCE(dev->driver); + 672. return drv ? drv->name : + 673. (dev->bus ? dev->bus->name : + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +lib/iov_iter.c:673: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 671. if (unlikely(i->count < bytes)) + 672. return false; + 673. > iterate_all_kinds(i, bytes, v, ({ + 674. if (__copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len, + 675. v.iov_base, v.iov_len)) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +kernel/rcu/tree.c:688: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 686. if (rsp == NULL) + 687. return; + 688. > *flags = READ_ONCE(rsp->gp_flags); + 689. *gpnum = READ_ONCE(rsp->gpnum); + 690. *completed = READ_ONCE(rsp->completed); + +kernel/rcu/tree.c:689: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 687. return; + 688. *flags = READ_ONCE(rsp->gp_flags); + 689. > *gpnum = READ_ONCE(rsp->gpnum); + 690. *completed = READ_ONCE(rsp->completed); + 691. } + +kernel/rcu/tree.c:690: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 688. *flags = READ_ONCE(rsp->gp_flags); + 689. *gpnum = READ_ONCE(rsp->gpnum); + 690. > *completed = READ_ONCE(rsp->completed); + 691. } + 692. EXPORT_SYMBOL_GPL(rcutorture_get_gp_data); + +drivers/md/dm-stats.c:676: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 674. + 675. local_irq_disable(); + 676. > p = &s->stat_percpu[smp_processor_id()][x]; + 677. dm_stat_round(s, shared, p); + 678. local_irq_enable(); + +ipc/sem.c:717: error: DEAD_STORE + The value written to &result (type int) is never used. + 715. curr = &sma->sems[sop->sem_num]; + 716. sem_op = sop->sem_op; + 717. > result = curr->semval; + 718. + 719. if (sop->sem_flg & SEM_UNDO) { + +kernel/cpu.c:674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 672. { + 673. BUG_ON(smpboot_register_percpu_thread(&cpuhp_threads)); + 674. > kthread_unpark(this_cpu_read(cpuhp_state.thread)); + 675. } + 676. + +drivers/iommu/dmar.c:681: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 679. + 680. rcu_read_lock(); + 681. > for_each_drhd_unit(dmaru) { + 682. drhd = container_of(dmaru->hdr, + 683. struct acpi_dmar_hardware_unit, + +kernel/kexec_core.c:759: error: DEAD_STORE + The value written to &addr (type unsigned long) is never used. + 757. continue; + 758. } + 759. > addr = old_addr; + 760. page = old_page; + 761. break; + +drivers/gpu/drm/drm_ioc32.c:685: error: UNINITIALIZED_VALUE + The value read from req32.size was never initialized. + 683. return -EFAULT; + 684. + 685. > request.size = req32.size; + 686. request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:686: error: UNINITIALIZED_VALUE + The value read from req32.type was never initialized. + 684. + 685. request.size = req32.size; + 686. > request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + 688. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +drivers/gpu/drm/drm_ioc32.c:692: error: UNINITIALIZED_VALUE + The value read from request.handle was never initialized. + 690. return err; + 691. + 692. > req32.handle = request.handle; + 693. req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + +drivers/gpu/drm/drm_ioc32.c:693: error: UNINITIALIZED_VALUE + The value read from request.physical was never initialized. + 691. + 692. req32.handle = request.handle; + 693. > req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + 695. drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +net/ipv6/af_inet6.c:700: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 698. + 699. rcu_read_lock(); + 700. > final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), + 701. &final); + 702. rcu_read_unlock(); + +net/ipv4/inet_connection_sock.c:720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 718. } + 719. } + 720. > defer_accept = READ_ONCE(queue->rskq_defer_accept); + 721. if (defer_accept) + 722. max_retries = defer_accept; + +net/ipv6/udp.c:687: error: DEAD_STORE + The value written to &dif (type int) is never used. + 685. unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. > int dif = inet6_iif(skb); + 688. struct hlist_node *node; + 689. struct sk_buff *nskb; + +net/ipv6/udp.c:685: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 683. unsigned short hnum = ntohs(uh->dest); + 684. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 685. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. int dif = inet6_iif(skb); + +net/ipv6/udp.c:697: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 695. start_lookup: + 696. hslot = &udptable->hash2[hash2]; + 697. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 698. } + 699. + +net/ipv6/udp.c:700: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 698. } + 699. + 700. > sk_for_each_entry_offset_rcu(sk, node, &hslot->head, offset) { + 701. if (!__udp_v6_is_mcast_sock(net, sk, uh->dest, daddr, + 702. uh->source, saddr, dif, hnum)) + +drivers/gpu/drm/i915/intel_runtime_pm.c:683: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 682 could be null and is dereferenced at line 683, column 6. + 681. + 682. power_well = lookup_power_well(dev_priv, BXT_DPIO_CMN_A); + 683. > if (power_well->count > 0) + 684. bxt_ddi_phy_verify_state(dev_priv, power_well->bxt.phy); + 685. + +drivers/gpu/drm/i915/intel_runtime_pm.c:687: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 686 could be null and is dereferenced at line 687, column 6. + 685. + 686. power_well = lookup_power_well(dev_priv, BXT_DPIO_CMN_BC); + 687. > if (power_well->count > 0) + 688. bxt_ddi_phy_verify_state(dev_priv, power_well->bxt.phy); + 689. + +lib/decompress_bunzip2.c:686: error: DEAD_STORE + The value written to &i (type int) is never used. + 684. { + 685. struct bunzip_data *bd; + 686. > int i = -1; + 687. unsigned char *inbuf; + 688. + +drivers/pcmcia/ds.c:707: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 705. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 706. &mfc)) + 707. > new_funcs = mfc.nfn; + 708. else + 709. new_funcs = 1; + +net/ipv6/addrconf.c:698: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 696. cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ + 697. net->dev_base_seq; + 698. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 699. if (idx < s_idx) + 700. goto cont; + +drivers/md/dm.c:684: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 682. *srcu_idx = srcu_read_lock(&md->io_barrier); + 683. + 684. > return srcu_dereference(md->map, &md->io_barrier); + 685. } + 686. + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +kernel/module.c:687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 685. preempt_disable(); + 686. + 687. > list_for_each_entry_rcu(mod, &modules, list) { + 688. if (mod->state == MODULE_STATE_UNFORMED) + 689. continue; + +lib/radix-tree.c:686: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 684. + 685. for (;;) { + 686. > struct radix_tree_node *node = rcu_dereference_raw(root->rnode); + 687. struct radix_tree_node *child; + 688. + +lib/radix-tree.c:700: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 698. if (node->count != 1) + 699. break; + 700. > child = rcu_dereference_raw(node->slots[0]); + 701. if (!child) + 702. break; + +drivers/gpu/drm/i915/intel_hdmi.c:692: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 688 could be null and is dereferenced at line 692, column 13. + 690. i915_reg_t reg = TVIDEO_DIP_CTL(intel_crtc->pipe); + 691. u32 val = I915_READ(reg); + 692. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 693. + 694. assert_hdmi_port_disabled(intel_hdmi); + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +drivers/usb/core/message.c:704: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 702. break; + 703. } + 704. > return result; + 705. } + 706. + +kernel/cgroup/cgroup-v1.c:700: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 698 could be null and is dereferenced at line 700, column 7. + 698. for_each_subsys(ss, i) + 699. seq_printf(m, "%s\t%d\t%d\t%d\n", + 700. > ss->legacy_name, ss->root->hierarchy_id, + 701. atomic_read(&ss->root->nr_cgrps), + 702. cgroup_ssid_enabled(i)); + +kernel/cpu.c:703: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 701. WARN_ON(cpu_online(cpu)); + 702. rcu_read_lock(); + 703. > for_each_process(p) { + 704. struct task_struct *t; + 705. + +drivers/iommu/intel-iommu.c:694: error: DEAD_STORE + The value written to &agaw (type int) is never used. + 692. { + 693. unsigned long sagaw; + 694. > int agaw = -1; + 695. + 696. sagaw = cap_sagaw(iommu->cap); + +drivers/md/md.c:695: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 693. struct md_rdev *rdev; + 694. + 695. > rdev_for_each_rcu(rdev, mddev) + 696. if (rdev->desc_nr == nr) + 697. return rdev; + +net/core/net-sysfs.c:705: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 703. + 704. rcu_read_lock(); + 705. > map = rcu_dereference(queue->rps_map); + 706. if (map) + 707. for (i = 0; i < map->len; i++) + +net/ipv4/ip_fragment.c:712: error: UNINITIALIZED_VALUE + The value read from iph.tot_len was never initialized. + 710. return skb; + 711. + 712. > len = ntohs(iph.tot_len); + 713. if (skb->len < netoff + len || len < (iph.ihl * 4)) + 714. return skb; + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +sound/pci/hda/hda_proc.c:699: error: DEAD_STORE + The value written to &curr (type int) is never used. + 697. struct hda_codec *codec, hda_nid_t nid) + 698. { + 699. > int i, curr = -1; + 700. u8 dev_list[AC_MAX_DEV_LIST_LEN]; + 701. int devlist_len; + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +drivers/iommu/dmar.c:711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 709. struct acpi_dmar_pci_path *path; + 710. + 711. > for_each_drhd_unit(dmaru) { + 712. drhd = container_of(dmaru->hdr, + 713. struct acpi_dmar_hardware_unit, + +drivers/iommu/dmar.c:728: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 726. dev_name(&adev->dev), dmaru->reg_base_addr, + 727. scope->bus, path->device, path->function); + 728. > for_each_dev_scope(dmaru->devices, dmaru->devices_cnt, i, tmp) + 729. if (tmp == NULL) { + 730. dmaru->devices[i].bus = scope->bus; + +kernel/sched/core.c:713: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 711. if (ret) + 712. goto out; + 713. > list_for_each_entry_rcu(child, &parent->children, siblings) { + 714. parent = child; + 715. goto down; + +net/ipv4/ping.c:763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 761. + 762. rcu_read_lock(); + 763. > inet_opt = rcu_dereference(inet->inet_opt); + 764. if (inet_opt) { + 765. memcpy(&opt_copy, inet_opt, + +net/ipv4/ping.c:827: error: UNINITIALIZED_VALUE + The value read from user_icmph.code was never initialized. + 825. + 826. pfh.icmph.type = user_icmph.type; /* already checked */ + 827. > pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + 829. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv4/ping.c:826: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 824. lock_sock(sk); + 825. + 826. > pfh.icmph.type = user_icmph.type; /* already checked */ + 827. pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + +net/ipv4/ping.c:848: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 846. kfree(ipc.opt); + 847. if (!err) { + 848. > icmp_out_count(sock_net(sk), user_icmph.type); + 849. return len; + 850. } + +net/ipv6/ndisc.c:720: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 720, column 3. + 718. __func__, target); + 719. } + 720. > ndisc_send_ns(dev, target, target, saddr, 0); + 721. } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) { + 722. neigh_app_ns(neigh); + +net/ipv6/ndisc.c:725: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 725, column 3. + 723. } else { + 724. addrconf_addr_solict_mult(target, &mcaddr); + 725. > ndisc_send_ns(dev, target, &mcaddr, saddr, 0); + 726. } + 727. } + +drivers/md/dm.c:705: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 703. { + 704. rcu_read_lock(); + 705. > return rcu_dereference(md->map); + 706. } + 707. + +net/sunrpc/auth_gss/gss_rpc_xdr.c:711: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 709. if (!p) + 710. return -ENOSPC; + 711. > p = xdr_encode_hyper(p, cb->initiator_addrtype); + 712. + 713. /* cb->initiator_address */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:722: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 720. if (!p) + 721. return -ENOSPC; + 722. > p = xdr_encode_hyper(p, cb->acceptor_addrtype); + 723. + 724. /* cb->acceptor_address */ + +drivers/ata/libata-scsi.c:726: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 724. scsi_cmd[1] = (3 << 1); /* Non-data */ + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. > scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + +drivers/ata/libata-scsi.c:727: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. scsi_cmd[4] = args[1]; + 727. > scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + +drivers/ata/libata-scsi.c:728: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 726. scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. > scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + +drivers/ata/libata-scsi.c:729: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. > scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + +drivers/ata/libata-scsi.c:730: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. > scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:732: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. > scsi_cmd[14] = args[0]; + 733. + 734. /* Good values for timeout and retries? Values below + +net/ipv6/ip6_flowlabel.c:711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 709. + 710. for (state->bucket = 0; state->bucket <= FL_HASH_MASK; ++state->bucket) { + 711. > for_each_fl_rcu(state->bucket, fl) { + 712. if (net_eq(fl->fl_net, net)) + 713. goto out; + +net/netlabel/netlabel_cipso_v4.c:706: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 704. static int netlbl_cipsov4_remove(struct sk_buff *skb, struct genl_info *info) + 705. { + 706. > int ret_val = -EINVAL; + 707. struct netlbl_domhsh_walk_arg cb_arg; + 708. struct netlbl_audit audit_info; + +net/sunrpc/svcsock.c:739: error: DEAD_STORE + The value written to &err (type int) is never used. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:739: error: UNINITIALIZED_VALUE + The value read from level was never initialized. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:739: error: UNINITIALIZED_VALUE + The value read from optname was never initialized. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +kernel/softirq.c:714: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 712. /* Find end, append list for that CPU. */ + 713. if (&per_cpu(tasklet_vec, cpu).head != per_cpu(tasklet_vec, cpu).tail) { + 714. > *__this_cpu_read(tasklet_vec.tail) = per_cpu(tasklet_vec, cpu).head; + 715. this_cpu_write(tasklet_vec.tail, per_cpu(tasklet_vec, cpu).tail); + 716. per_cpu(tasklet_vec, cpu).head = NULL; + +kernel/softirq.c:722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 720. + 721. if (&per_cpu(tasklet_hi_vec, cpu).head != per_cpu(tasklet_hi_vec, cpu).tail) { + 722. > *__this_cpu_read(tasklet_hi_vec.tail) = per_cpu(tasklet_hi_vec, cpu).head; + 723. __this_cpu_write(tasklet_hi_vec.tail, per_cpu(tasklet_hi_vec, cpu).tail); + 724. per_cpu(tasklet_hi_vec, cpu).head = NULL; + +drivers/char/agp/intel-gtt.c:710: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 708. static void i830_chipset_flush(void) + 709. { + 710. > unsigned long timeout = jiffies + msecs_to_jiffies(1000); + 711. + 712. /* Forcibly evict everything from the CPU write buffers. + +net/ipv6/route.c:721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 719. match = NULL; + 720. cont = NULL; + 721. > for (rt = rr_head; rt; rt = rcu_dereference(rt->rt6_next)) { + 722. if (rt->rt6i_metric != metric) { + 723. cont = rt; + +net/ipv6/route.c:731: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 729. + 730. for (rt = leaf; rt && rt != rr_head; + 731. > rt = rcu_dereference(rt->rt6_next)) { + 732. if (rt->rt6i_metric != metric) { + 733. cont = rt; + +net/ipv6/route.c:743: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 741. return match; + 742. + 743. > for (rt = cont; rt; rt = rcu_dereference(rt->rt6_next)) + 744. match = find_match(rt, oif, strict, &mpri, match, do_rr); + 745. + +net/wireless/scan.c:719: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 717. struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); + 718. struct cfg80211_internal_bss *bss, *res = NULL; + 719. > unsigned long now = jiffies; + 720. int bss_privacy; + 721. + +net/wireless/trace.h:710: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 708. ); + 709. + 710. > DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, + 711. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 712. TP_ARGS(wiphy, netdev, mac), + +drivers/md/md.c:718: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 716. struct md_rdev *rdev; + 717. + 718. > rdev_for_each_rcu(rdev, mddev) + 719. if (rdev->bdev->bd_dev == dev) + 720. return rdev; + +net/ipv4/ipconfig.c:742: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 740. *e++ = 150; + 741. + 742. > *e++ = 255; /* End of the list */ + 743. } + 744. + +drivers/gpu/drm/i915/i915_gem_gtt.c:719: error: DEAD_STORE + The value written to &ret (type int) is never used. + 717. { + 718. struct i915_page_directory_pointer *pdp; + 719. > int ret = -ENOMEM; + 720. + 721. WARN_ON(!use_4lvl(vm)); + +arch/x86/events/intel/p4.c:724: error: NULL_DEREFERENCE + pointer `bind` last assigned on line 723 could be null and is dereferenced at line 724, column 9. + 722. config = p4_general_events[hw_event]; + 723. bind = p4_config_get_bind(config); + 724. > esel = P4_OPCODE_ESEL(bind->opcode); + 725. config |= p4_config_pack_cccr(P4_CCCR_ESEL(esel)); + 726. + +drivers/md/dm-stats.c:730: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 728. __dm_stat_init_temporary_percpu_totals(shared, s, x); + 729. local_irq_disable(); + 730. > p = &s->stat_percpu[smp_processor_id()][x]; + 731. p->sectors[READ] -= shared->tmp.sectors[READ]; + 732. p->sectors[WRITE] -= shared->tmp.sectors[WRITE]; + +drivers/md/dm-stats.c:748: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 746. for (i = 0; i < s->n_histogram_entries + 1; i++) { + 747. local_irq_disable(); + 748. > p = &s->stat_percpu[smp_processor_id()][x]; + 749. p->histogram[i] -= shared->tmp.histogram[i]; + 750. local_irq_enable(); + +kernel/rcu/tree.c:725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 723. + 724. lockdep_assert_irqs_disabled(); + 725. > return READ_ONCE(*fp); + 726. } + 727. + +drivers/cpufreq/cpufreq.c:719: error: UNINITIALIZED_VALUE + The value read from new_policy.min was never initialized. + 717. } + 718. + 719. > store_one(scaling_min_freq, min); + 720. store_one(scaling_max_freq, max); + 721. + +kernel/auditsc.c:725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 723. + 724. rcu_read_lock(); + 725. > list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) { + 726. if (audit_filter_rules(tsk, &e->rule, NULL, NULL, + 727. &state, true)) { + +kernel/trace/trace_events_trigger.c:744: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 742. goto out; + 743. assign: + 744. > tmp = rcu_access_pointer(data->filter); + 745. + 746. rcu_assign_pointer(data->filter, filter); + +kernel/trace/trace_events_trigger.c:760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 758. data->filter_str = kstrdup(filter_str, GFP_KERNEL); + 759. if (!data->filter_str) { + 760. > free_event_filter(rcu_access_pointer(data->filter)); + 761. data->filter = NULL; + 762. ret = -ENOMEM; + +drivers/cpufreq/cpufreq.c:720: error: UNINITIALIZED_VALUE + The value read from new_policy.max was never initialized. + 718. + 719. store_one(scaling_min_freq, min); + 720. > store_one(scaling_max_freq, max); + 721. + 722. /** + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +kernel/signal.c:723: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 721. { + 722. const struct cred *cred = current_cred(); + 723. > const struct cred *tcred = __task_cred(t); + 724. + 725. if (uid_eq(cred->euid, tcred->suid) || + +drivers/gpu/drm/drm_ioc32.c:731: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 729. return -EFAULT; + 730. + 731. > request.handle = req32.handle; + 732. request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:732: error: UNINITIALIZED_VALUE + The value read from req32.offset was never initialized. + 730. + 731. request.handle = req32.handle; + 732. > request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + 734. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +net/ipv6/ip6_flowlabel.c:726: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 724. struct net *net = seq_file_net(seq); + 725. + 726. > for_each_fl_continue_rcu(fl) { + 727. if (net_eq(fl->fl_net, net)) + 728. goto out; + +net/ipv6/ip6_flowlabel.c:733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 731. try_again: + 732. if (++state->bucket <= FL_HASH_MASK) { + 733. > for_each_fl_rcu(state->bucket, fl) { + 734. if (net_eq(fl->fl_net, net)) + 735. goto out; + +net/netfilter/nf_conntrack_core.c:746: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 744. return NF_ACCEPT; + 745. + 746. > zone = nf_ct_zone(ct); + 747. local_bh_disable(); + 748. + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +lib/rhashtable.c:737: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 735. + 736. if (!iter->walker.tbl && !iter->end_of_table) { + 737. > iter->walker.tbl = rht_dereference_rcu(ht->tbl, ht); + 738. return -EAGAIN; + 739. } + +include/linux/rhashtable.h:784: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 782. + 783. RCU_INIT_POINTER(list->next, plist); + 784. > head = rht_dereference_bucket(head->next, tbl, hash); + 785. RCU_INIT_POINTER(list->rhead.next, head); + 786. rcu_assign_pointer(*pprev, obj); + +include/linux/rhashtable.h:801: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 799. goto slow_path; + 800. + 801. > head = rht_dereference_bucket(*pprev, tbl, hash); + 802. + 803. RCU_INIT_POINTER(obj->next, head); + +include/linux/rhashtable.h:781: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 779. + 780. list = container_of(obj, struct rhlist_head, rhead); + 781. > plist = container_of(head, struct rhlist_head, rhead); + 782. + 783. RCU_INIT_POINTER(list->next, plist); + +include/linux/rhashtable.h:743: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 741. rcu_read_lock(); + 742. + 743. > tbl = rht_dereference_rcu(ht->tbl, ht); + 744. hash = rht_head_hashfn(ht, tbl, obj, params); + 745. lock = rht_bucket_lock(tbl, hash); + +net/wireless/trace.h:727: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 725. ); + 726. + 727. > DECLARE_EVENT_CLASS(station_del, + 728. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 729. struct station_del_parameters *params), + +drivers/usb/host/ohci-hcd.c:791: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 789. + 790. /* find the last TD processed by the controller. */ + 791. > head = hc32_to_cpu(ohci, READ_ONCE(ed->hwHeadP)) & TD_MASK; + 792. td_start = td; + 793. td_next = list_prepare_entry(td, &ed->td_list, td_list); + +kernel/cgroup/cgroup-v1.c:749: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 747. */ + 748. rcu_read_lock(); + 749. > cgrp = rcu_dereference(*(void __rcu __force **)&kn->priv); + 750. if (!cgrp || cgroup_is_dead(cgrp)) { + 751. rcu_read_unlock(); + +arch/x86/events/amd/ibs.c:738: error: DEAD_STORE + The value written to &attr (type attribute**) is never used. + 736. if (ibs_caps & IBS_CAPS_OPCNT) { + 737. perf_ibs_op.config_mask |= IBS_OP_CNT_CTL; + 738. > *attr++ = &format_attr_cnt_ctl.attr; + 739. } + 740. perf_ibs_pmu_init(&perf_ibs_op, "ibs_op"); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +kernel/rcu/tree.c:745: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 743. if (!rcu_segcblist_restempty(&rdp->cblist, RCU_NEXT_READY_TAIL)) + 744. return true; /* Yes, CPU has newly registered callbacks. */ + 745. > if (rcu_segcblist_future_gp_needed(&rdp->cblist, + 746. READ_ONCE(rsp->completed))) + 747. return true; /* Yes, CBs for future grace period. */ + +kernel/smp.c:739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 737. preempt_disable(); + 738. for_each_online_cpu(cpu) { + 739. > if (cpu == smp_processor_id()) + 740. continue; + 741. + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +drivers/iommu/intel-iommu.c:761: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 759. /* No hardware attached; use lowest common denominator */ + 760. rcu_read_lock(); + 761. > for_each_active_iommu(iommu, drhd) { + 762. if (!ecap_coherent(iommu->ecap)) { + 763. domain->iommu_coherency = 0; + +drivers/pcmcia/ti113x.h:780: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 778. default: + 779. if (operation == HOOK_POWER_PRE) + 780. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + +drivers/pcmcia/ti113x.h:782: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 780. mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + 783. } + 784. + +drivers/pcmcia/ds.c:776: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 774. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 775. &mfc)) + 776. > new_funcs = mfc.nfn; + 777. + 778. if (old_funcs != new_funcs) + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/intel_crt.c:820: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 818. out: + 819. intel_display_power_put(dev_priv, intel_encoder->power_domain); + 820. > return status; + 821. } + 822. + +drivers/video/fbdev/core/fbmem.c:795: error: DEAD_STORE + The value written to &dst (type unsigned char*) is never used. + 793. dst = buffer; + 794. fb_memcpy_fromfb(dst, src, c); + 795. > dst += c; + 796. src += c; + 797. + +sound/core/control.c:759: error: UNINITIALIZED_VALUE + The value read from list.offset was never initialized. + 757. if (copy_from_user(&list, _list, sizeof(list))) + 758. return -EFAULT; + 759. > offset = list.offset; + 760. space = list.space; + 761. + +sound/core/control.c:760: error: UNINITIALIZED_VALUE + The value read from list.space was never initialized. + 758. return -EFAULT; + 759. offset = list.offset; + 760. > space = list.space; + 761. + 762. down_read(&card->controls_rwsem); + +net/ipv4/tcp_metrics.c:762: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 760. + 761. rcu_read_lock(); + 762. > for (col = 0, tm = rcu_dereference(hb->chain); tm; + 763. tm = rcu_dereference(tm->tcpm_next), col++) { + 764. if (!net_eq(tm_net(tm), net)) + +net/ipv4/tcp_metrics.c:763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 761. rcu_read_lock(); + 762. for (col = 0, tm = rcu_dereference(hb->chain); tm; + 763. > tm = rcu_dereference(tm->tcpm_next), col++) { + 764. if (!net_eq(tm_net(tm), net)) + 765. continue; + +net/ipv6/route.c:752: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 750. int oif, int strict) + 751. { + 752. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 753. struct rt6_info *match, *rt0; + 754. bool do_rr = false; + +net/ipv6/route.c:760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 758. return net->ipv6.ip6_null_entry; + 759. + 760. > rt0 = rcu_dereference(fn->rr_ptr); + 761. if (!rt0) + 762. rt0 = leaf; + +net/ipv6/route.c:781: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 779. + 780. if (do_rr) { + 781. > struct rt6_info *next = rcu_dereference(rt0->rt6_next); + 782. + 783. /* no entries matched; do round-robin */ + +scripts/asn1_compiler.c:769: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 769, column 3. + 767. types = type_list = calloc(nr + 1, sizeof(type_list[0])); + 768. if (!type_list) { + 769. > perror(NULL); + 770. exit(1); + 771. } + +scripts/asn1_compiler.c:774: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 774, column 3. + 772. type_index = calloc(nr, sizeof(type_index[0])); + 773. if (!type_index) { + 774. > perror(NULL); + 775. exit(1); + 776. } + +net/ipv6/icmp.c:784: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 782. */ + 783. + 784. > ipprot = rcu_dereference(inet6_protos[nexthdr]); + 785. if (ipprot && ipprot->err_handler) + 786. ipprot->err_handler(skb, NULL, type, code, inner_offset, info); + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +lib/radix-tree.c:764: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 762. if (node->count) { + 763. if (node_to_entry(node) == + 764. > rcu_dereference_raw(root->rnode)) + 765. deleted |= radix_tree_shrink(root, + 766. update_node); + +net/ipv4/icmp.c:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. raw_icmp_error(skb, protocol, info); + 768. + 769. > ipprot = rcu_dereference(inet_protos[protocol]); + 770. if (ipprot && ipprot->err_handler) + 771. ipprot->err_handler(skb, info); + +lib/rhashtable.c:760: error: DEAD_STORE + The value written to &p (type rhash_head*) is never used. + 758. struct rhlist_head *list = iter->list; + 759. struct rhashtable *ht = iter->ht; + 760. > struct rhash_head *p = iter->p; + 761. bool rhlist = ht->rhlist; + 762. + +lib/rhashtable.c:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. int skip = iter->skip; + 768. + 769. > rht_for_each_rcu(p, tbl, iter->slot) { + 770. if (rhlist) { + 771. list = container_of(p, struct rhlist_head, + +lib/rhashtable.c:777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 775. goto next; + 776. skip--; + 777. > list = rcu_dereference(list->next); + 778. } while (list); + 779. + +lib/rhashtable.c:803: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 801. smp_rmb(); + 802. + 803. > iter->walker.tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 804. if (iter->walker.tbl) { + 805. iter->slot = 0; + +drivers/gpu/drm/i915/i915_vma.c:800: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 798. __i915_vma_unpin(vma); + 799. if (ret) + 800. > return ret; + 801. } + 802. GEM_BUG_ON(i915_vma_is_active(vma)); + +drivers/scsi/scsi_transport_spi.c:812: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 810. } + 811. } + 812. > return retval; + 813. } + 814. + +net/sched/cls_api.c:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. reclassify: + 768. #endif + 769. > for (; tp; tp = rcu_dereference_bh(tp->next)) { + 770. int err; + 771. + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +drivers/gpu/drm/i915/i915_gem_userptr.c:821: error: UNINITIALIZED_VALUE + The value read from handle was never initialized. + 819. return ret; + 820. + 821. > args->handle = handle; + 822. return 0; + 823. } + +kernel/auditsc.c:771: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 769. rcu_read_lock(); + 770. if (!list_empty(list)) { + 771. > list_for_each_entry_rcu(e, list, list) { + 772. if (audit_in_mask(&e->rule, ctx->major) && + 773. audit_filter_rules(tsk, &e->rule, ctx, NULL, + +kernel/printk/printk.c:813: error: DEAD_STORE + The value written to &len (type unsigned long) is never used. + 811. facility = LOG_FACILITY(u); + 812. endp++; + 813. > len -= endp - line; + 814. line = endp; + 815. } + +net/core/dev.c:766: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 764. struct hlist_head *head = dev_name_hash(net, name); + 765. + 766. > hlist_for_each_entry_rcu(dev, head, name_hlist) + 767. if (!strncmp(dev->name, name, IFNAMSIZ)) + 768. return dev; + +net/sunrpc/clnt.c:768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 766. + 767. rcu_read_lock(); + 768. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 769. rcu_read_unlock(); + 770. if (xps == NULL) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +arch/x86/events/intel/pt.c:769: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 765 could be null and is dereferenced at line 769, column 9. + 767. + 768. /* offset of the first region in this table from the beginning of buf */ + 769. > base = buf->cur->offset + buf->output_off; + 770. + 771. /* offset of the current output region within this table */ + +arch/x86/events/perf_event.h:767: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 765. u64 enable_mask) + 766. { + 767. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 768. + 769. if (hwc->extra_reg.reg) + +arch/x86/events/perf_event.h:767: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 765. u64 enable_mask) + 766. { + 767. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 768. + 769. if (hwc->extra_reg.reg) + +kernel/rcu/srcutree.c:789: error: DEAD_STORE + The value written to &t (type unsigned long) is never used. + 787. + 788. /* First, see if enough time has passed since the last GP. */ + 789. > t = ktime_get_mono_fast_ns(); + 790. if (exp_holdoff == 0 || + 791. time_in_range_open(t, sp->srcu_last_gp_end, + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +drivers/i2c/busses/i2c-i801.c:813: error: UNINITIALIZED_VALUE + The value read from hostc was never initialized. + 811. && read_write == I2C_SMBUS_WRITE) { + 812. /* restore saved configuration register value */ + 813. > pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc); + 814. } + 815. return result; + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/ipv4/tcp_input.c:793: error: DEAD_STORE + The value written to &rate (type unsigned long long) is never used. + 791. + 792. if (likely(tp->srtt_us)) + 793. > do_div(rate, tp->srtt_us); + 794. + 795. /* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +drivers/iommu/intel-iommu.c:777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 775. + 776. rcu_read_lock(); + 777. > for_each_active_iommu(iommu, drhd) { + 778. if (iommu != skip) { + 779. if (!ecap_sc_support(iommu->ecap)) { + +net/wireless/trace.h:772: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +drivers/usb/core/usb.c:776: error: DEAD_STORE + The value written to &jiffies_expire (type unsigned long) is never used. + 774. const struct usb_interface *iface) + 775. { + 776. > unsigned long jiffies_expire = jiffies + HZ; + 777. + 778. if (udev->state == USB_STATE_NOTATTACHED) + +lib/iov_iter.c:786: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 784. return 0; + 785. } + 786. > iterate_all_kinds(i, bytes, v, + 787. copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len), + 788. memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page, + +net/ipv4/icmp.c:779: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 777. + 778. rcu_read_lock(); + 779. > ok = rcu_dereference(inet_protos[proto])->icmp_strict_tag_validation; + 780. rcu_read_unlock(); + 781. return ok; + +net/wireless/util.c:778: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 776. const struct cfg80211_bss_ies *ies; + 777. + 778. > ies = rcu_dereference(bss->ies); + 779. if (!ies) + 780. return NULL; + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +net/core/net-sysfs.c:782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 780. + 781. rcu_read_lock(); + 782. > flow_table = rcu_dereference(queue->rps_flow_table); + 783. if (flow_table) + 784. val = (unsigned long)flow_table->mask + 1; + +drivers/ata/ahci.c:830: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 828. + 829. DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class); + 830. > return rc; + 831. } + 832. + +net/ipv4/fib_semantics.c:861: error: UNINITIALIZED_VALUE + The value read from res.scope was never initialized. + 859. goto out; + 860. } + 861. > nh->nh_scope = res.scope; + 862. nh->nh_oif = FIB_RES_OIF(res); + 863. nh->nh_dev = dev = FIB_RES_DEV(res); + +kernel/time/timer.c:786: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 784. timer->entry.pprev = NULL; + 785. timer->function = func; + 786. > timer->flags = flags | raw_smp_processor_id(); + 787. lockdep_init_map(&timer->lockdep_map, name, key, 0); + 788. } + +drivers/gpu/drm/i915/intel_lrc.c:836: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 834. + 835. head = execlists->csb_head; + 836. > tail = READ_ONCE(buf[write_idx]); + 837. } + 838. GEM_TRACE("%s cs-irq head=%d [%d], tail=%d [%d]\n", + +drivers/gpu/drm/i915/intel_lrc.c:868: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 866. */ + 867. + 868. > status = READ_ONCE(buf[2 * head]); /* maybe mmio! */ + 869. GEM_TRACE("%s csb[%d]: status=0x%08x:0x%08x, active=0x%x\n", + 870. engine->name, head, + +net/wireless/sme.c:850: error: DEAD_STORE + The value written to &next (type unsigned char*) is never used. + 848. ev->cr.pmkid = next; + 849. memcpy((void *)ev->cr.pmkid, params->pmkid, WLAN_PMKID_LEN); + 850. > next += WLAN_PMKID_LEN; + 851. } + 852. ev->cr.update_erp_next_seq_num = params->update_erp_next_seq_num; + +drivers/ata/libata-scsi.c:789: error: DEAD_STORE + The value written to &rc (type int) is never used. + 787. { + 788. unsigned long val; + 789. > int rc = -EINVAL; + 790. unsigned long flags; + 791. + +drivers/input/serio/i8042.c:787: error: DEAD_STORE + The value written to &retval (type int) is never used. + 785. static int __init i8042_check_aux(void) + 786. { + 787. > int retval = -1; + 788. bool irq_registered = false; + 789. bool aux_loop_broken = false; + +tools/lib/subcmd/parse-options.c:788: error: DEAD_STORE + The value written to &o (type option const *) is never used. + 786. { + 787. int nr_opts = 0, len; + 788. > const struct option *o = opts; + 789. struct option *ordered; + 790. + +drivers/gpu/drm/drm_dp_mst_topology.c:796: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 794. * provided by the wake_up/wait_event pair are enough. + 795. */ + 796. > state = READ_ONCE(txmsg->state); + 797. return (state == DRM_DP_SIDEBAND_TX_RX || + 798. state == DRM_DP_SIDEBAND_TX_TIMEOUT); + +net/ipv4/fib_frontend.c:807: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 805. e = 0; + 806. head = &net->ipv4.fib_table_hash[h]; + 807. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 808. if (e < s_e) + 809. goto next; + +drivers/char/agp/frontend.c:795: error: UNINITIALIZED_VALUE + The value read from mode.agp_mode was never initialized. + 793. return -EFAULT; + 794. + 795. > agp_enable(agp_bridge, mode.agp_mode); + 796. return 0; + 797. } + +drivers/gpu/drm/i915/intel_breadcrumbs.c:800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 798. + 799. if (!RB_EMPTY_NODE(&request->signaling.node)) { + 800. > if (request == rcu_access_pointer(b->first_signal)) { + 801. struct rb_node *rb = + 802. rb_next(&request->signaling.node); + +kernel/trace/trace.c:794: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 792. + 793. /* If this is the temp buffer, we need to commit fully */ + 794. > if (this_cpu_read(trace_buffered_event) == event) { + 795. /* Length is in event->array[0] */ + 796. ring_buffer_write(buffer, event->array[0], &event->array[1]); + +drivers/gpu/drm/i915/intel_runtime_pm.c:814: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 812. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 813. + 814. > if (wait_for(COND, 100)) + 815. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 816. state, + +drivers/gpu/drm/i915/intel_runtime_pm.c:814: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 812. vlv_punit_write(dev_priv, PUNIT_REG_PWRGT_CTRL, ctrl); + 813. + 814. > if (wait_for(COND, 100)) + 815. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 816. state, + +kernel/auditsc.c:800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 798. return 0; + 799. + 800. > list_for_each_entry_rcu(e, list, list) { + 801. if (audit_in_mask(&e->rule, ctx->major) && + 802. audit_filter_rules(tsk, &e->rule, ctx, n, &state, false)) { + +drivers/iommu/intel-iommu.c:802: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 800. /* set iommu_superpage to the smallest common denominator */ + 801. rcu_read_lock(); + 802. > for_each_active_iommu(iommu, drhd) { + 803. if (iommu != skip) { + 804. mask &= cap_super_page_val(iommu->cap); + +sound/pci/hda/hda_controller.c:802: error: DEAD_STORE + The value written to &loopcounter (type unsigned long) is never used. + 800. timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. > for (loopcounter = 0;; loopcounter++) { + 803. spin_lock_irq(&bus->reg_lock); + 804. if (chip->polling_mode || do_poll) + +sound/pci/hda/hda_controller.c:800: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 798. + 799. again: + 800. > timeout = jiffies + msecs_to_jiffies(1000); + 801. + 802. for (loopcounter = 0;; loopcounter++) { + +drivers/md/md.c:814: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 810 could be null and is dereferenced at line 814, column 2. + 812. atomic_inc(&rdev->nr_pending); + 813. + 814. > bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev); + 815. bio->bi_iter.bi_sector = sector; + 816. bio_add_page(bio, page, size, 0); + +net/core/fib_rules.c:816: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 814. + 815. if (rule->action == FR_ACT_GOTO && + 816. > rcu_access_pointer(rule->ctarget) == NULL) + 817. frh->flags |= FIB_RULE_UNRESOLVED; + 818. + +net/wireless/trace.h:793: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +arch/x86/pci/mmconfig-shared.c:804: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 802. + 803. mutex_lock(&pci_mmcfg_lock); + 804. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) + 805. if (cfg->segment == seg && cfg->start_bus == start && + 806. cfg->end_bus == end) { + +drivers/char/agp/frontend.c:812: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 810. return -EFAULT; + 811. + 812. > client = agp_find_client_by_pid(reserve.pid); + 813. + 814. if (reserve.seg_count == 0) { + +drivers/char/agp/frontend.c:816: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 814. if (reserve.seg_count == 0) { + 815. /* remove a client */ + 816. > client_priv = agp_find_private(reserve.pid); + 817. + 818. if (client_priv != NULL) { + +drivers/char/agp/frontend.c:826: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 824. return 0; + 825. } + 826. > return agp_remove_client(reserve.pid); + 827. } else { + 828. struct agp_segment *segment; + +drivers/char/agp/frontend.c:848: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 846. if (client == NULL) { + 847. /* Create the client and add the segment */ + 848. > client = agp_create_client(reserve.pid); + 849. + 850. if (client == NULL) { + +drivers/char/agp/frontend.c:854: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 852. return -ENOMEM; + 853. } + 854. > client_priv = agp_find_private(reserve.pid); + 855. + 856. if (client_priv != NULL) { + +drivers/usb/mon/mon_bin.c:849: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 847. } + 848. nbytes -= step_len; + 849. > buf += step_len; + 850. rp->b_read += step_len; + 851. done += step_len; + +drivers/usb/mon/mon_bin.c:848: error: DEAD_STORE + The value written to &nbytes (type unsigned long) is never used. + 846. return -EFAULT; + 847. } + 848. > nbytes -= step_len; + 849. buf += step_len; + 850. rp->b_read += step_len; + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +drivers/gpu/drm/i915/i915_pmu.c:805: error: DEAD_STORE + The value written to &pmu (type i915_pmu*) is never used. + 803. static int i915_pmu_cpu_online(unsigned int cpu, struct hlist_node *node) + 804. { + 805. > struct i915_pmu *pmu = hlist_entry_safe(node, typeof(*pmu), node); + 806. + 807. GEM_BUG_ON(!pmu->base.event_init); + +kernel/resource.c:824: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 822. } + 823. + 824. > for (next = first; ; next = next->sibling) { + 825. /* Partial overlap? Bad, and unfixable */ + 826. if (next->start < new->start || next->end > new->end) + +kernel/resource.c:836: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 834. new->parent = parent; + 835. new->sibling = next->sibling; + 836. > new->child = first; + 837. + 838. next->sibling = NULL; + +kernel/resource.c:839: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 837. + 838. next->sibling = NULL; + 839. > for (next = first; next; next = next->sibling) + 840. next->parent = new; + 841. + +net/ipv4/ipmr.c:821: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 819. goto out; + 820. + 821. > now = jiffies; + 822. expires = 10*HZ; + 823. + +drivers/base/power/wakeup.c:814: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 812. + 813. srcuidx = srcu_read_lock(&wakeup_srcu); + 814. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) { + 815. if (ws->active) { + 816. pr_debug("active wakeup source: %s\n", ws->name); + +kernel/time/posix-cpu-timers.c:832: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 830. tsk_expires->virt_exp = expires; + 831. + 832. > tsk_expires->sched_exp = check_timers_list(++timers, firing, + 833. tsk->se.sum_exec_runtime); + 834. + +arch/x86/events/intel/pt.c:832: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 832, column 32. + 830. */ + 831. if (!pt_cap_get(PT_CAP_topa_multiple_entries) || + 832. > buf->output_off == sizes(TOPA_ENTRY(buf->cur, buf->cur_idx)->size)) { + 833. perf_aux_output_flag(&pt->handle, + 834. PERF_AUX_FLAG_TRUNCATED); + +arch/x86/events/intel/pt.c:843: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 843, column 52. + 841. * before the output reaches its output region's boundary. + 842. */ + 843. > if (!pt_cap_get(PT_CAP_topa_multiple_entries) && !buf->snapshot && + 844. pt_buffer_region_size(buf) - buf->output_off <= TOPA_PMI_MARGIN) { + 845. void *head = pt_buffer_region(buf); + +net/netfilter/nf_conntrack_netlink.c:817: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 815. struct hlist_nulls_node *n; + 816. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 817. > u_int8_t l3proto = nfmsg->nfgen_family; + 818. struct nf_conn *nf_ct_evict[8]; + 819. int res, i; + +net/netfilter/nf_conntrack_netlink.c:812: error: DEAD_STORE + The value written to &net (type net*) is never used. + 810. ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) + 811. { + 812. > struct net *net = sock_net(skb->sk); + 813. struct nf_conn *ct, *last; + 814. struct nf_conntrack_tuple_hash *h; + +net/wireless/trace.h:810: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 808. ); + 809. + 810. > DECLARE_EVENT_CLASS(mpath_evt, + 811. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 812. u8 *next_hop), + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +lib/radix-tree.c:832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 830. return error; + 831. shift = error; + 832. > child = rcu_dereference_raw(root->rnode); + 833. } + 834. + +kernel/signal.c:830: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 828. siginitset(&flush, sigmask(SIGCONT)); + 829. flush_sigqueue_mask(&flush, &signal->shared_pending); + 830. > for_each_thread(p, t) + 831. flush_sigqueue_mask(&flush, &t->pending); + 832. } else if (sig == SIGCONT) { + +kernel/signal.c:839: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 837. siginitset(&flush, SIG_KERNEL_STOP_MASK); + 838. flush_sigqueue_mask(&flush, &signal->shared_pending); + 839. > for_each_thread(p, t) { + 840. flush_sigqueue_mask(&flush, &t->pending); + 841. task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING); + +net/wireless/scan.c:822: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 820. u32 n_entries = 0; + 821. + 822. > ies = rcu_access_pointer(new->pub.beacon_ies); + 823. if (WARN_ON(!ies)) + 824. return false; + +net/wireless/scan.c:856: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 854. if (bss->pub.scan_width != new->pub.scan_width) + 855. continue; + 856. > if (rcu_access_pointer(bss->pub.beacon_ies)) + 857. continue; + 858. ies = rcu_access_pointer(bss->pub.ies); + +net/wireless/scan.c:858: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 856. if (rcu_access_pointer(bss->pub.beacon_ies)) + 857. continue; + 858. > ies = rcu_access_pointer(bss->pub.ies); + 859. if (!ies) + 860. continue; + +drivers/video/fbdev/core/fbmem.c:873: error: DEAD_STORE + The value written to &src (type unsigned char*) is never used. + 871. fb_memcpy_tofb(dst, src, c); + 872. dst += c; + 873. > src += c; + 874. *ppos += c; + 875. buf += c; + +net/xfrm/xfrm_state.c:826: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 824. struct xfrm_state *x; + 825. + 826. > hlist_for_each_entry_rcu(x, net->xfrm.state_byspi + h, byspi) { + 827. if (x->props.family != family || + 828. x->id.spi != spi || + +drivers/net/ethernet/intel/e1000e/ich8lan.c:891: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 889. + 890. data &= ~I82579_LPI_100_PLL_SHUT; + 891. > ret_val = e1000_write_emi_reg_locked(hw, I82579_LPI_PLL_SHUT, + 892. data); + 893. } + +net/netfilter/nfnetlink_log.c:860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 858. + 859. if ((flags & NFULNL_CFG_F_CONNTRACK) && + 860. > !rcu_access_pointer(nfnl_ct_hook)) { + 861. #ifdef CONFIG_MODULES + 862. nfnl_unlock(NFNL_SUBSYS_ULOG); + +net/netfilter/nfnetlink_log.c:865: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 863. request_module("ip_conntrack_netlink"); + 864. nfnl_lock(NFNL_SUBSYS_ULOG); + 865. > if (rcu_access_pointer(nfnl_ct_hook)) { + 866. ret = -EAGAIN; + 867. goto out_put; + +drivers/gpu/drm/i915/intel_ringbuffer.h:832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 830. * a hint and nothing more. + 831. */ + 832. > return READ_ONCE(engine->timeline->seqno); + 833. } + 834. + +kernel/kprobes.c:838: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 836. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 837. head = &kprobe_table[i]; + 838. > hlist_for_each_entry_rcu(p, head, hlist) + 839. if (!kprobe_disabled(p)) + 840. optimize_kprobe(p); + +net/ipv4/tcp_metrics.c:856: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 854. ret = -ESRCH; + 855. rcu_read_lock(); + 856. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 857. tm = rcu_dereference(tm->tcpm_next)) { + 858. if (addr_same(&tm->tcpm_daddr, &daddr) && + +net/ipv4/tcp_metrics.c:857: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 855. rcu_read_lock(); + 856. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 857. > tm = rcu_dereference(tm->tcpm_next)) { + 858. if (addr_same(&tm->tcpm_daddr, &daddr) && + 859. (!src || addr_same(&tm->tcpm_saddr, &saddr)) && + +drivers/scsi/scsi_sysfs.c:826: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 824. }; + 825. + 826. > sdev_vpd_pg_attr(pg83); + 827. sdev_vpd_pg_attr(pg80); + 828. + +drivers/scsi/scsi_sysfs.c:827: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 825. + 826. sdev_vpd_pg_attr(pg83); + 827. > sdev_vpd_pg_attr(pg80); + 828. + 829. static ssize_t show_inquiry(struct file *filep, struct kobject *kobj, + +lib/rhashtable.c:835: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 833. + 834. if (p) { + 835. > if (!rhlist || !(list = rcu_dereference(list->next))) { + 836. p = rcu_dereference(p->next); + 837. list = container_of(p, struct rhlist_head, rhead); + +lib/rhashtable.c:836: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 834. if (p) { + 835. if (!rhlist || !(list = rcu_dereference(list->next))) { + 836. > p = rcu_dereference(p->next); + 837. list = container_of(p, struct rhlist_head, rhead); + 838. } + +kernel/trace/trace_uprobe.c:840: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 838. + 839. rcu_read_lock(); + 840. > list_for_each_entry_rcu(link, &tu->tp.files, list) + 841. __uprobe_trace_func(tu, 0, regs, ucb, dsize, link->file); + 842. rcu_read_unlock(); + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/core/dev.c:840: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 838. struct hlist_head *head = dev_index_hash(net, ifindex); + 839. + 840. > hlist_for_each_entry_rcu(dev, head, index_hlist) + 841. if (dev->ifindex == ifindex) + 842. return dev; + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +drivers/md/md.c:846: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 842 could be null and is dereferenced at line 846, column 3. + 844. + 845. if (metadata_op && rdev->meta_bdev) + 846. > bio_set_dev(bio, rdev->meta_bdev); + 847. else + 848. bio_set_dev(bio, rdev->bdev); + +drivers/md/md.c:848: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 842 could be null and is dereferenced at line 848, column 3. + 846. bio_set_dev(bio, rdev->meta_bdev); + 847. else + 848. > bio_set_dev(bio, rdev->bdev); + 849. bio_set_op_attrs(bio, op, op_flags); + 850. if (metadata_op) + +net/netfilter/nf_conntrack_core.c:851: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 849. struct nf_conn *ct; + 850. + 851. > zone = nf_ct_zone(ignored_conntrack); + 852. + 853. rcu_read_lock(); + +net/netfilter/nf_conntrack_core.c:858: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 856. hash = __hash_conntrack(net, tuple, hsize); + 857. + 858. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[hash], hnnode) { + 859. ct = nf_ct_tuplehash_to_ctrack(h); + 860. + +scripts/asn1_compiler.c:843: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 843, column 3. + 841. struct element *e = calloc(1, sizeof(*e)); + 842. if (!e) { + 843. > perror(NULL); + 844. exit(1); + 845. } + +net/netfilter/nf_conntrack_sip.c:913: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 911. + 912. if (direct_rtp) { + 913. > hooks = rcu_dereference(nf_nat_sip_hooks); + 914. if (hooks && + 915. !hooks->sdp_port(skb, protoff, dataoff, dptr, datalen, + +net/netfilter/nf_conntrack_sip.c:935: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 933. IPPROTO_UDP, NULL, &rtcp_port); + 934. + 935. > hooks = rcu_dereference(nf_nat_sip_hooks); + 936. if (hooks && ct->status & IPS_NAT_MASK && !direct_rtp) + 937. ret = hooks->sdp_media(skb, protoff, dataoff, dptr, + +kernel/time/time.c:854: error: UNINITIALIZED_VALUE + The value read from kts.tv_nsec was never initialized. + 852. + 853. ts->tv_sec = kts.tv_sec; + 854. > ts->tv_nsec = kts.tv_nsec; + 855. + 856. return 0; + +kernel/time/time.c:853: error: UNINITIALIZED_VALUE + The value read from kts.tv_sec was never initialized. + 851. return -EFAULT; + 852. + 853. > ts->tv_sec = kts.tv_sec; + 854. ts->tv_nsec = kts.tv_nsec; + 855. + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/xfrm/xfrm_state.c:851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 849. struct xfrm_state *x; + 850. + 851. > hlist_for_each_entry_rcu(x, net->xfrm.state_bysrc + h, bysrc) { + 852. if (x->props.family != family || + 853. x->id.proto != proto || + +net/ipv4/udp.c:946: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 944. + 945. rcu_read_lock(); + 946. > inet_opt = rcu_dereference(inet->inet_opt); + 947. if (inet_opt) { + 948. memcpy(&opt_copy, inet_opt, + +net/sunrpc/rpcb_clnt.c:858: error: NULL_DEREFERENCE + pointer `p` last assigned on line 858 could be null and is dereferenced at line 858, column 2. + 856. + 857. p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2); + 858. > *p++ = cpu_to_be32(rpcb->r_prog); + 859. *p++ = cpu_to_be32(rpcb->r_vers); + 860. *p++ = cpu_to_be32(rpcb->r_prot); + +kernel/trace/trace_uprobe.c:854: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 852. + 853. rcu_read_lock(); + 854. > list_for_each_entry_rcu(link, &tu->tp.files, list) + 855. __uprobe_trace_func(tu, func, regs, ucb, dsize, link->file); + 856. rcu_read_unlock(); + +drivers/pci/pci-sysfs.c:915: error: DEAD_STORE + The value written to &off (type long long) is never used. + 913. pci_user_read_config_byte(dev, off, &val); + 914. data[off - init_off] = val; + 915. > off++; + 916. --size; + 917. } + +drivers/pci/pci-sysfs.c:916: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 914. data[off - init_off] = val; + 915. off++; + 916. > --size; + 917. } + 918. + +kernel/kprobes.c:865: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 863. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 864. head = &kprobe_table[i]; + 865. > hlist_for_each_entry_rcu(p, head, hlist) { + 866. if (!kprobe_disabled(p)) + 867. unoptimize_kprobe(p, false); + +drivers/char/agp/generic.c:867: error: DEAD_STORE + The value written to &size (type int) is never used. + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + 867. > size = page_order = num_entries = 0; + 868. + 869. if (bridge->driver->size_type != FIXED_APER_SIZE) { + +drivers/char/agp/generic.c:873: error: DEAD_STORE + The value written to &size (type int) is never used. + 871. switch (bridge->driver->size_type) { + 872. case U8_APER_SIZE: + 873. > size = A_SIZE_8(temp)->size; + 874. page_order = + 875. A_SIZE_8(temp)->page_order; + +drivers/char/agp/generic.c:880: error: DEAD_STORE + The value written to &size (type int) is never used. + 878. break; + 879. case U16_APER_SIZE: + 880. > size = A_SIZE_16(temp)->size; + 881. page_order = A_SIZE_16(temp)->page_order; + 882. num_entries = A_SIZE_16(temp)->num_entries; + +drivers/char/agp/generic.c:885: error: DEAD_STORE + The value written to &size (type int) is never used. + 883. break; + 884. case U32_APER_SIZE: + 885. > size = A_SIZE_32(temp)->size; + 886. page_order = A_SIZE_32(temp)->page_order; + 887. num_entries = A_SIZE_32(temp)->num_entries; + +drivers/char/agp/generic.c:893: error: DEAD_STORE + The value written to &size (type int) is never used. + 891. case LVL2_APER_SIZE: + 892. default: + 893. > size = page_order = num_entries = 0; + 894. break; + 895. } + +drivers/char/agp/generic.c:923: error: DEAD_STORE + The value written to &size (type int) is never used. + 921. } while (!table && (i < bridge->driver->num_aperture_sizes)); + 922. } else { + 923. > size = ((struct aper_size_info_fixed *) temp)->size; + 924. page_order = ((struct aper_size_info_fixed *) temp)->page_order; + 925. num_entries = ((struct aper_size_info_fixed *) temp)->num_entries; + +net/wireless/trace.h:849: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +block/blk-mq.c:867: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 865. while (true) { + 866. start = read_seqcount_begin(&rq->gstate_seq); + 867. > gstate = READ_ONCE(rq->gstate); + 868. deadline = blk_rq_deadline(rq); + 869. if (!read_seqcount_retry(&rq->gstate_seq, start)) + +block/blk-mq.c:881: error: UNINITIALIZED_VALUE + The value read from deadline was never initialized. + 879. hctx->nr_expired++; + 880. } else if (!data->next_set || time_after(data->next, deadline)) { + 881. > data->next = deadline; + 882. data->next_set = 1; + 883. } + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +kernel/time/tick-sched.c:884: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 882. return false; + 883. + 884. > if (unlikely(local_softirq_pending() && cpu_online(cpu))) { + 885. static int ratelimit; + 886. + +kernel/time/tick-sched.c:888: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 886. + 887. if (ratelimit < 10 && + 888. > (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +net/ipv4/ip_output.c:1095: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1093. cork->length -= length; + 1094. IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS); + 1095. > return err; + 1096. } + 1097. + +drivers/usb/host/ehci-hub.c:1108: error: DEAD_STORE + The value written to &temp1 (type unsigned int) is never used. + 1106. // status may be from integrated TT + 1107. if (ehci->has_hostpc) { + 1108. > temp1 = ehci_readl(ehci, hostpc_reg); + 1109. status |= ehci_port_speed(ehci, temp1); + 1110. } else + +drivers/iommu/intel-iommu.c:893: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 891. + 892. rcu_read_lock(); + 893. > for_each_active_iommu(iommu, drhd) { + 894. if (pdev && segment != drhd->segment) + 895. continue; + +drivers/iommu/intel-iommu.c:897: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 895. continue; + 896. + 897. > for_each_active_dev_scope(drhd->devices, + 898. drhd->devices_cnt, i, tmp) { + 899. if (tmp == dev) { + +kernel/sys.c:866: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 864. + 865. rcu_read_lock(); + 866. > pid = task_tgid_vnr(rcu_dereference(current->real_parent)); + 867. rcu_read_unlock(); + 868. + +drivers/usb/class/usblp.c:899: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 897. set_current_state(TASK_RUNNING); + 898. remove_wait_queue(&usblp->wwait, &waita); + 899. > return rc; + 900. } + 901. + +net/core/fib_rules.c:873: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 871. + 872. rcu_read_lock(); + 873. > list_for_each_entry_rcu(rule, &ops->rules_list, list) { + 874. if (idx < cb->args[1]) + 875. goto skip; + +net/ipv6/ip6_fib.c:1053: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1051. iter->rt6i_node = NULL; + 1052. fib6_purge_rt(iter, fn, info->nl_net); + 1053. > if (rcu_access_pointer(fn->rr_ptr) == iter) + 1054. fn->rr_ptr = NULL; + 1055. rt6_release(iter); + +net/ipv6/ip6_fib.c:1069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1067. iter->rt6i_node = NULL; + 1068. fib6_purge_rt(iter, fn, info->nl_net); + 1069. > if (rcu_access_pointer(fn->rr_ptr) == iter) + 1070. fn->rr_ptr = NULL; + 1071. rt6_release(iter); + +net/sunrpc/clnt.c:884: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 882. rpc_free_iostats(clnt->cl_metrics); + 883. clnt->cl_metrics = NULL; + 884. > xprt_put(rcu_dereference_raw(clnt->cl_xprt)); + 885. xprt_iter_destroy(&clnt->cl_xpi); + 886. rpciod_down(); + +lib/radix-tree.c:877: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 875. + 876. for (;;) { + 877. > void *entry = rcu_dereference_raw(child->slots[offset]); + 878. if (radix_tree_is_internal_node(entry) && + 879. !is_sibling_entry(child, entry)) { + +drivers/gpu/drm/drm_ioc32.c:892: error: UNINITIALIZED_VALUE + The value read from req64.fb_id was never initialized. + 890. return err; + 891. + 892. > if (put_user(req64.fb_id, &argp->fb_id)) + 893. return -EFAULT; + 894. + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +net/ipv4/route.c:887: error: DEAD_STORE + The value written to &log_martians (type int) is never used. + 885. return; + 886. } + 887. > log_martians = IN_DEV_LOG_MARTIANS(in_dev); + 888. vif = l3mdev_master_ifindex_rcu(rt->dst.dev); + 889. rcu_read_unlock(); + +kernel/sched/topology.c:903: error: NULL_DEREFERENCE + pointer `last` last assigned on line 876 could be null and is dereferenced at line 903, column 2. + 901. last = sg; + 902. } + 903. > last->next = first; + 904. sd->groups = first; + 905. + +net/wireless/trace.h:873: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +net/ipv6/udp.c:888: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 886. struct sock *sk; + 887. + 888. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 889. if (sk->sk_state == TCP_ESTABLISHED && + 890. INET6_MATCH(sk, net, rmt_addr, loc_addr, ports, dif, sdif)) + +kernel/workqueue.c:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. + 893. /* this can only happen on the local cpu */ + 894. > if (WARN_ON_ONCE(pool->cpu != raw_smp_processor_id())) + 895. return NULL; + 896. + +kernel/sched/sched.h:881: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 879. static inline u64 __rq_clock_broken(struct rq *rq) + 880. { + 881. > return READ_ONCE(rq->clock); + 882. } + 883. + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +kernel/time/timer.c:893: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 891. return; + 892. + 893. > jnow = READ_ONCE(jiffies); + 894. base->must_forward_clk = base->is_idle; + 895. if ((long)(jnow - base->clk) < 2) + +net/ipv6/route.c:887: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 885. if (fn->fn_flags & RTN_TL_ROOT) + 886. return NULL; + 887. > pn = rcu_dereference(fn->parent); + 888. sn = FIB6_SUBTREE(pn); + 889. if (sn && sn != fn) + +drivers/gpu/drm/i915/intel_breadcrumbs.c:888: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 886. WARN_ON(READ_ONCE(b->irq_wait)); + 887. WARN_ON(!RB_EMPTY_ROOT(&b->waiters)); + 888. > WARN_ON(rcu_access_pointer(b->first_signal)); + 889. WARN_ON(!RB_EMPTY_ROOT(&b->signals)); + 890. + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +net/wireless/scan.c:900: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 898. spin_lock_bh(&rdev->bss_lock); + 899. + 900. > if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) { + 901. spin_unlock_bh(&rdev->bss_lock); + 902. return NULL; + +net/wireless/scan.c:909: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 907. if (found) { + 908. /* Update IEs */ + 909. > if (rcu_access_pointer(tmp->pub.proberesp_ies)) { + 910. const struct cfg80211_bss_ies *old; + 911. + +net/wireless/scan.c:912: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 910. const struct cfg80211_bss_ies *old; + 911. + 912. > old = rcu_access_pointer(found->pub.proberesp_ies); + 913. + 914. rcu_assign_pointer(found->pub.proberesp_ies, + +net/wireless/scan.c:922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 920. kfree_rcu((struct cfg80211_bss_ies *)old, + 921. rcu_head); + 922. > } else if (rcu_access_pointer(tmp->pub.beacon_ies)) { + 923. const struct cfg80211_bss_ies *old; + 924. struct cfg80211_internal_bss *bss; + +net/wireless/scan.c:940: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 938. */ + 939. + 940. > f = rcu_access_pointer(tmp->pub.beacon_ies); + 941. kfree_rcu((struct cfg80211_bss_ies *)f, + 942. rcu_head); + +net/wireless/scan.c:946: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 944. } + 945. + 946. > old = rcu_access_pointer(found->pub.beacon_ies); + 947. + 948. rcu_assign_pointer(found->pub.beacon_ies, + +net/wireless/scan.c:952: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 950. + 951. /* Override IEs if they were from a beacon before */ + 952. > if (old == rcu_access_pointer(found->pub.ies)) + 953. rcu_assign_pointer(found->pub.ies, + 954. tmp->pub.beacon_ies); + +net/wireless/scan.c:961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 959. const struct cfg80211_bss_ies *ies; + 960. + 961. > ies = rcu_access_pointer(bss->pub.beacon_ies); + 962. WARN_ON(ies != old); + 963. + +net/wireless/scan.c:1001: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 999. GFP_ATOMIC); + 1000. if (!new) { + 1001. > ies = (void *)rcu_dereference(tmp->pub.beacon_ies); + 1002. if (ies) + 1003. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:1004: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1002. if (ies) + 1003. kfree_rcu(ies, rcu_head); + 1004. > ies = (void *)rcu_dereference(tmp->pub.proberesp_ies); + 1005. if (ies) + 1006. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:1013: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1011. INIT_LIST_HEAD(&new->hidden_list); + 1012. + 1013. > if (rcu_access_pointer(tmp->pub.proberesp_ies)) { + 1014. hidden = rb_find_bss(rdev, tmp, BSS_CMP_HIDE_ZLEN); + 1015. if (!hidden) + +net/sunrpc/cache.c:894: error: DEAD_STORE + The value written to &ret (type long) is never used. + 892. struct page *page; + 893. char *kaddr; + 894. > ssize_t ret = -ENOMEM; + 895. + 896. if (count >= PAGE_SIZE) + +kernel/cgroup/cgroup-v1.c:897: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 895 could be null and is dereferenced at line 897, column 25. + 895. for_each_subsys(ss, ssid) + 896. if (root->subsys_mask & (1 << ssid)) + 897. > seq_show_option(seq, ss->legacy_name, NULL); + 898. if (root->flags & CGRP_ROOT_NOPREFIX) + 899. seq_puts(seq, ",noprefix"); + +net/netfilter/nf_conntrack_core.c:899: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 897. struct nf_conn *tmp; + 898. + 899. > hlist_nulls_for_each_entry_rcu(h, n, head, hnnode) { + 900. tmp = nf_ct_tuplehash_to_ctrack(h); + 901. + +net/core/fib_rules.c:911: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 909. + 910. rcu_read_lock(); + 911. > list_for_each_entry_rcu(ops, &net->rules_ops, list) { + 912. if (idx < cb->args[0] || !try_module_get(ops->owner)) + 913. goto skip; + +drivers/net/ethernet/intel/e1000e/82571.c:919: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 917. } else { + 918. data &= ~IGP02E1000_PM_D0_LPLU; + 919. > ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data); + 920. /* LPLU and SmartSpeed are mutually exclusive. LPLU is used + 921. * during Dx states where the power conservation is most + +kernel/trace/ring_buffer.c:907: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 905. val &= ~RB_FLAG_MASK; + 906. + 907. > ret = cmpxchg((unsigned long *)&list->next, + 908. val | old_flag, val | new_flag); + 909. + +net/wireless/trace.h:894: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +drivers/gpu/drm/i915/intel_breadcrumbs.c:909: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 907. } + 908. + 909. > if (rcu_access_pointer(b->first_signal)) { + 910. wake_up_process(b->signaler); + 911. busy = true; + +drivers/hid/hid-ntrig.c:956: error: DEAD_STORE + The value written to &ret (type int) is never used. + 954. ntrig_report_version(hdev); + 955. + 956. > ret = sysfs_create_group(&hdev->dev.kobj, + 957. &ntrig_attribute_group); + 958. + +net/ipv4/igmp.c:910: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 908. + 909. rcu_read_lock(); + 910. > for_each_pmc_rcu(in_dev, im) { + 911. if (im->multiaddr == group) { + 912. igmp_stop_timer(im); + +net/ipv6/udp.c:926: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 924. skb->sk = sk; + 925. skb->destructor = sock_efree; + 926. > dst = READ_ONCE(sk->sk_rx_dst); + 927. + 928. if (dst) + +net/ipv4/tcp_output.c:933: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 931. + 932. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 933. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 934. if (nval != oval) + 935. continue; + +net/ipv4/tcp_output.c:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. goto out; + 924. + 925. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 926. struct tsq_tasklet *tsq; + 927. bool empty; + +drivers/gpu/drm/drm_plane.c:915: error: DEAD_STORE + The value written to &ret (type int) is never used. + 913. u32 target_vblank = page_flip->sequence; + 914. struct drm_modeset_acquire_ctx ctx; + 915. > int ret = -EINVAL; + 916. + 917. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +net/core/neighbour.c:917: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 915. state = neigh->nud_state; + 916. now = jiffies; + 917. > next = now + HZ; + 918. + 919. if (!(state & NUD_IN_TIMER)) + +net/core/neighbour.c:926: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 924. neigh->confirmed + neigh->parms->reachable_time)) { + 925. neigh_dbg(2, "neigh %p is still alive\n", neigh); + 926. > next = neigh->confirmed + neigh->parms->reachable_time; + 927. } else if (time_before_eq(now, + 928. neigh->used + + +net/core/neighbour.c:934: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 932. neigh->updated = jiffies; + 933. neigh_suspect(neigh); + 934. > next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); + 935. } else { + 936. neigh_dbg(2, "neigh %p is suspected\n", neigh); + +net/core/neighbour.c:951: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 949. neigh_connect(neigh); + 950. notify = 1; + 951. > next = neigh->confirmed + neigh->parms->reachable_time; + 952. } else { + 953. neigh_dbg(2, "neigh %p is probed\n", neigh); + +net/core/neighbour.c:958: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 956. atomic_set(&neigh->probes, 0); + 957. notify = 1; + 958. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 959. } + 960. } else { + +net/core/neighbour.c:962: error: DEAD_STORE + The value written to &next (type unsigned long) is never used. + 960. } else { + 961. /* NUD_PROBE|NUD_INCOMPLETE */ + 962. > next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); + 963. } + 964. + +net/ipv4/tcp_ipv4.c:920: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 918. + 919. /* caller either holds rcu_read_lock() or socket lock */ + 920. > md5sig = rcu_dereference_check(tp->md5sig_info, + 921. lockdep_sock_is_held(sk)); + 922. if (!md5sig) + +net/ipv4/tcp_ipv4.c:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. return NULL; + 924. + 925. > hlist_for_each_entry_rcu(key, &md5sig->head, node) { + 926. if (key->family != family) + 927. continue; + +net/sunrpc/rpcb_clnt.c:920: error: NULL_DEREFERENCE + pointer `p` last assigned on line 919 could be null and is dereferenced by call to `xdr_encode_opaque()` at line 920, column 2. + 918. len = maxstrlen; + 919. p = xdr_reserve_space(xdr, 4 + len); + 920. > xdr_encode_opaque(p, string, len); + 921. } + 922. + +net/netfilter/x_tables.c:929: error: UNINITIALIZED_VALUE + The value read from compat_tmp.num_counters was never initialized. + 927. + 928. memcpy(info->name, compat_tmp.name, sizeof(info->name) - 1); + 929. > info->num_counters = compat_tmp.num_counters; + 930. user += sizeof(compat_tmp); + 931. } else + +include/net/sock.h:913: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 911. static inline void sk_incoming_cpu_update(struct sock *sk) + 912. { + 913. > int cpu = raw_smp_processor_id(); + 914. + 915. if (unlikely(sk->sk_incoming_cpu != cpu)) + +include/net/sock.h:913: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 911. static inline void sk_incoming_cpu_update(struct sock *sk) + 912. { + 913. > int cpu = raw_smp_processor_id(); + 914. + 915. if (unlikely(sk->sk_incoming_cpu != cpu)) + +kernel/time/posix-cpu-timers.c:947: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 945. prof_expires = check_timers_list(timers, firing, ptime); + 946. virt_expires = check_timers_list(++timers, firing, utime); + 947. > sched_expires = check_timers_list(++timers, firing, sum_sched_runtime); + 948. + 949. /* + +drivers/usb/early/ehci-dbgp.c:954: error: DEAD_STORE + The value written to &ret (type int) is never used. + 952. } + 953. if (chunk > 0) { + 954. > ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, + 955. dbgp_endpoint_out, buf, chunk); + 956. } + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +net/core/ethtool.c:926: error: UNINITIALIZED_VALUE + The value read from info.sset_mask was never initialized. + 924. + 925. /* store copy of mask, because we zero struct later on */ + 926. > sset_mask = info.sset_mask; + 927. if (!sset_mask) + 928. return 0; + +drivers/char/agp/frontend.c:924: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 922. return -EFAULT; + 923. + 924. > memory = agp_find_mem_by_key(bind_info.key); + 925. + 926. if (memory == NULL) + +drivers/char/agp/frontend.c:929: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 927. return -EINVAL; + 928. + 929. > return agp_bind_memory(memory, bind_info.pg_start); + 930. } + 931. + +net/ipv6/route.c:928: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 926. fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); + 927. restart: + 928. > rt = rcu_dereference(fn->leaf); + 929. if (!rt) { + 930. rt = net->ipv6.ip6_null_entry; + +kernel/cgroup/cgroup-v1.c:922: error: DEAD_STORE + The value written to &mask (type unsigned short) is never used. + 920. char *token, *o = data; + 921. bool all_ss = false, one_ss = false; + 922. > u16 mask = U16_MAX; + 923. struct cgroup_subsys *ss; + 924. int nr_opts = 0; + +net/wireless/trace.h:918: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +include/net/sock.h:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. + 924. rcu_read_lock(); + 925. > sock_flow_table = rcu_dereference(rps_sock_flow_table); + 926. rps_record_sock_flow(sock_flow_table, hash); + 927. rcu_read_unlock(); + +drivers/gpu/drm/i915/intel_ringbuffer.h:923: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 921. static inline bool intel_engine_has_waiter(const struct intel_engine_cs *engine) + 922. { + 923. > return READ_ONCE(engine->breadcrumbs.irq_wait); + 924. } + 925. + +kernel/time/timer.c:934: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 932. * and spin_lock(). + 933. */ + 934. > tf = READ_ONCE(timer->flags); + 935. + 936. if (!(tf & TIMER_MIGRATING)) { + +net/ipv4/igmp.c:1008: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1006. */ + 1007. rcu_read_lock(); + 1008. > for_each_pmc_rcu(in_dev, im) { + 1009. int changed; + 1010. + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +net/ipv4/ipconfig.c:982: error: DEAD_STORE + The value written to &h (type iphdr*) is never used. + 980. + 981. b = (struct bootp_pkt *)skb_network_header(skb); + 982. > h = &b->iph; + 983. + 984. /* One reply at a time, please. */ + +net/sunrpc/rpcb_clnt.c:936: error: NULL_DEREFERENCE + pointer `p` last assigned on line 936 could be null and is dereferenced at line 936, column 2. + 934. + 935. p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2); + 936. > *p++ = cpu_to_be32(rpcb->r_prog); + 937. *p = cpu_to_be32(rpcb->r_vers); + 938. + +drivers/pci/pci-sysfs.c:976: error: DEAD_STORE + The value written to &off (type long long) is never used. + 974. if (size) { + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. > off++; + 977. --size; + 978. } + +drivers/pci/pci-sysfs.c:977: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. off++; + 977. > --size; + 978. } + 979. + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +drivers/i2c/i2c-core-base.c:949: error: DEAD_STORE + The value written to &blank (type char*) is never used. + 947. + 948. /* Parse remaining parameters, reject extra parameters */ + 949. > res = sscanf(++blank, "%hi%c", &info.addr, &end); + 950. if (res < 1) { + 951. dev_err(dev, "%s: Can't parse I2C address\n", "new_device"); + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/iommu/iommu.c:945: error: UNINITIALIZED_VALUE + The value read from data.group was never initialized. + 943. */ + 944. if (pci_for_each_dma_alias(pdev, get_pci_alias_or_group, &data)) + 945. > return data.group; + 946. + 947. pdev = data.pdev; + +drivers/iommu/iommu.c:947: error: UNINITIALIZED_VALUE + The value read from data.pdev was never initialized. + 945. return data.group; + 946. + 947. > pdev = data.pdev; + 948. + 949. /* + +drivers/usb/class/usblp.c:951: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 949. set_current_state(TASK_RUNNING); + 950. remove_wait_queue(&usblp->rwait, &waita); + 951. > return rc; + 952. } + 953. + +net/xfrm/xfrm_state.c:953: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 951. rcu_read_lock(); + 952. h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, encap_family); + 953. > hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h, bydst) { + 954. if (x->props.family == encap_family && + 955. x->props.reqid == tmpl->reqid && + +net/xfrm/xfrm_state.c:969: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 967. + 968. h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, encap_family); + 969. > hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h_wildcard, bydst) { + 970. if (x->props.family == encap_family && + 971. x->props.reqid == tmpl->reqid && + +drivers/char/agp/frontend.c:941: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 939. return -EFAULT; + 940. + 941. > memory = agp_find_mem_by_key(unbind.key); + 942. + 943. if (memory == NULL) + +drivers/gpu/drm/i915/intel_dpio_phy.c:943: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 940 could be null and is dereferenced at line 943, column 6. + 941. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 942. + 943. > if (dport->release_cl2_override) { + 944. chv_phy_powergate_ch(dev_priv, DPIO_PHY0, DPIO_CH1, false); + 945. dport->release_cl2_override = false; + +drivers/net/ethernet/broadcom/tg3.c:955: error: DEAD_STORE + The value written to &apedata (type unsigned int) is never used. + 953. APE_HOST_SEG_LEN_MAGIC); + 954. apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT); + 955. > tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata); + 956. tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID, + 957. APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM)); + +net/ipv4/fib_trie.c:948: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 946. do { + 947. pn = n; + 948. > n = get_child_rcu(n, index); + 949. + 950. if (!n) + +net/core/dev.c:951: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 949. struct net_device *dev; + 950. + 951. > for_each_netdev_rcu(net, dev) + 952. if (dev->type == type && + 953. !memcmp(dev->dev_addr, ha, dev->addr_len)) + +net/ipv4/devinet.c:958: error: DEAD_STORE + The value written to &ret (type int) is never used. + 956. struct net_device *dev; + 957. char *colon; + 958. > int ret = -EFAULT; + 959. int tryaddrmatch = 0; + 960. + +net/ipv4/tcp_ipv4.c:960: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 958. + 959. /* caller either holds rcu_read_lock() or socket lock */ + 960. > md5sig = rcu_dereference_check(tp->md5sig_info, + 961. lockdep_sock_is_held(sk)); + 962. if (!md5sig) + +net/ipv4/tcp_ipv4.c:968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 966. size = sizeof(struct in6_addr); + 967. #endif + 968. > hlist_for_each_entry_rcu(key, &md5sig->head, node) { + 969. if (key->family != family) + 970. continue; + +drivers/usb/core/hub.c:959: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 958 could be null and is dereferenced at line 959, column 9. + 957. return -EINVAL; + 958. hub = usb_hub_to_struct_hub(udev->parent); + 959. > intf = to_usb_interface(hub->intfdev); + 960. + 961. usb_autopm_get_interface(intf); + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +net/netlabel/netlabel_domainhash.c:965: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 963. rcu_read_lock(); + 964. for (iter_bkt = *skip_bkt; + 965. > iter_bkt < rcu_dereference(netlbl_domhsh)->size; + 966. iter_bkt++, chain_cnt = 0) { + 967. iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + +net/netlabel/netlabel_domainhash.c:967: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 965. iter_bkt < rcu_dereference(netlbl_domhsh)->size; + 966. iter_bkt++, chain_cnt = 0) { + 967. > iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + 968. list_for_each_entry_rcu(iter_entry, iter_list, list) + 969. if (iter_entry->valid) { + +net/netlabel/netlabel_domainhash.c:968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 966. iter_bkt++, chain_cnt = 0) { + 967. iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + 968. > list_for_each_entry_rcu(iter_entry, iter_list, list) + 969. if (iter_entry->valid) { + 970. if (chain_cnt++ < *skip_chain) + +net/ipv4/tcp_output.c:968: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 966. + 967. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 968. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 969. if (nval != oval) + 970. continue; + +net/ipv4/tcp_output.c:960: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 958. unsigned long nval, oval; + 959. + 960. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 961. struct tsq_tasklet *tsq; + 962. bool empty; + +net/wireless/trace.h:956: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/ipv4/netfilter/ip_tables.c:984: error: DEAD_STORE + The value written to &ret (type int) is never used. + 982. + 983. if (compat) { + 984. > ret = compat_table_info(private, &tmp); + 985. xt_compat_flush_offsets(AF_INET); + 986. private = &tmp; + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +net/netfilter/nfnetlink_log.c:976: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 974. + 975. if (!hlist_empty(head)) + 976. > return rcu_dereference_bh(hlist_first_rcu(head)); + 977. } + 978. return NULL; + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/usb/core/sysfs.c:977: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 975. + 976. intf = to_usb_interface(dev); + 977. > string = READ_ONCE(intf->cur_altsetting->string); + 978. if (!string) + 979. return 0; + +net/core/skbuff.c:1000: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 998. uarg->len++; + 999. uarg->bytelen = bytelen; + 1000. > atomic_set(&sk->sk_zckey, ++next); + 1001. sock_zerocopy_get(uarg); + 1002. return uarg; + +net/core/dev.c:978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 976. + 977. rcu_read_lock(); + 978. > for_each_netdev_rcu(net, dev) + 979. if (dev->type == type) { + 980. dev_hold(dev); + +net/wireless/trace.h:973: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +net/ipv6/netfilter/ip6_tables.c:1001: error: DEAD_STORE + The value written to &ret (type int) is never used. + 999. + 1000. if (compat) { + 1001. > ret = compat_table_info(private, &tmp); + 1002. xt_compat_flush_offsets(AF_INET6); + 1003. private = &tmp; + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +net/netfilter/nf_conntrack_sip.c:996: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 994. int ret = NF_ACCEPT; + 995. + 996. > hooks = rcu_dereference(nf_nat_sip_hooks); + 997. + 998. /* Find beginning of session description */ + +net/netfilter/nf_conntrack_sip.c:1079: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1077. + 1078. /* Update session connection and owner addresses */ + 1079. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1080. if (hooks && ct->status & IPS_NAT_MASK) + 1081. ret = hooks->sdp_session(skb, protoff, dataoff, + +ipc/msg.c:1099: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1097. * signal) it will either see the message and continue ... + 1098. */ + 1099. > msg = READ_ONCE(msr_d.r_msg); + 1100. if (msg != ERR_PTR(-EAGAIN)) + 1101. goto out_unlock1; + +net/netfilter/nfnetlink_log.c:984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 982. struct hlist_node *h) + 983. { + 984. > h = rcu_dereference_bh(hlist_next_rcu(h)); + 985. while (!h) { + 986. struct nfnl_log_net *log; + +net/netfilter/nfnetlink_log.c:994: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 992. log = nfnl_log_pernet(net); + 993. head = &log->instance_table[st->bucket]; + 994. > h = rcu_dereference_bh(hlist_first_rcu(head)); + 995. } + 996. return h; + +drivers/gpu/drm/i915/intel_dpio_phy.c:990: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 989 could be null and is dereferenced by call to `vlv_dport_to_channel()` at line 990, column 27. + 988. struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc); + 989. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 990. > enum dpio_channel port = vlv_dport_to_channel(dport); + 991. enum pipe pipe = intel_crtc->pipe; + 992. + +drivers/usb/core/sysfs.c:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. intf = to_usb_interface(dev); + 992. udev = interface_to_usbdev(intf); + 993. > alt = READ_ONCE(intf->cur_altsetting); + 994. + 995. return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" + +drivers/usb/mon/mon_bin.c:1067: error: UNINITIALIZED_VALUE + The value read from getb.alloc was never initialized. + 1065. if (getb.alloc > 0x10000000) /* Want to cast to u32 */ + 1066. return -EINVAL; + 1067. > ret = mon_bin_get_event(file, rp, getb.hdr, + 1068. (cmd == MON_IOCX_GET)? PKT_SZ_API0: PKT_SZ_API1, + 1069. getb.data, (unsigned int)getb.alloc); + +drivers/usb/mon/mon_bin.c:1090: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch was never initialized. + 1088. return -EFAULT; + 1089. } + 1090. > ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch); + 1091. if (ret < 0) + 1092. return ret; + +drivers/usb/mon/mon_bin.c:1084: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush was never initialized. + 1082. + 1083. if (mfetch.nflush) { + 1084. > ret = mon_bin_flush(rp, mfetch.nflush); + 1085. if (ret < 0) + 1086. return ret; + +drivers/md/dm.c:996: error: DEAD_STORE + The value written to &offset (type unsigned long) is never used. + 994. offset = dm_target_offset(ti, sector); + 995. if (unlikely(ti->max_io_len & (ti->max_io_len - 1))) + 996. > max_len = sector_div(offset, ti->max_io_len); + 997. else + 998. max_len = offset & (ti->max_io_len - 1); + +drivers/cdrom/cdrom.c:1025: error: UNINITIALIZED_VALUE + The value read from entry.cdte_ctrl was never initialized. + 1023. tracks->audio++; + 1024. } + 1025. > cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n", + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + +drivers/cdrom/cdrom.c:1009: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk0 was never initialized. + 1007. /* check what type of tracks are on this disc */ + 1008. entry.cdte_format = CDROM_MSF; + 1009. > for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) { + 1010. entry.cdte_track = i; + 1011. if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) { + +drivers/cdrom/cdrom.c:1028: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk1 was never initialized. + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + 1028. > cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n", + 1029. header.cdth_trk1, tracks->audio, tracks->data, + 1030. tracks->cdi, tracks->xa); + +kernel/trace/ring_buffer.c:1000: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 998. val |= RB_PAGE_HEAD; + 999. + 1000. > ret = cmpxchg(ptr, val, (unsigned long)&new->list); + 1001. + 1002. return ret == val; + +kernel/relay.c:996: error: DEAD_STORE + The value written to &consumed (type unsigned long) is never used. + 994. size_t n_subbufs = buf->chan->n_subbufs; + 995. size_t produced = buf->subbufs_produced; + 996. > size_t consumed = buf->subbufs_consumed; + 997. + 998. relay_file_read_consume(buf, read_pos, 0); + +kernel/trace/trace_events.c:995: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 993. { + 994. struct trace_array *tr = m->private; + 995. > struct trace_pid_list *pid_list = rcu_dereference_sched(tr->filtered_pids); + 996. + 997. return trace_pid_next(pid_list, v, pos); + +net/ipv4/tcp_output.c:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. static bool tcp_needs_internal_pacing(const struct sock *sk) + 992. { + 993. > return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED; + 994. } + 995. + +net/netfilter/nf_conntrack_core.c:1005: error: DEAD_STORE + The value written to &nf_conntrack_max95 (type unsigned int) is never used. + 1003. i = gc_work->last_bucket; + 1004. if (gc_work->early_drop) + 1005. > nf_conntrack_max95 = nf_conntrack_max / 100u * 95u; + 1006. + 1007. do { + +net/netfilter/nf_conntrack_core.c:1021: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1019. i = 0; + 1020. + 1021. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[i], hnnode) { + 1022. struct net *net; + 1023. + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +net/wireless/trace.h:993: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +security/selinux/ss/policydb.c:1006: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1004. + 1005. rc = -EINVAL; + 1006. > items = le32_to_cpu(buf[0]); + 1007. if (items > ARRAY_SIZE(buf)) { + 1008. printk(KERN_ERR "SELinux: mls: range overflow\n"); + +security/selinux/ss/policydb.c:1018: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1016. } + 1017. + 1018. > r->level[0].sens = le32_to_cpu(buf[0]); + 1019. if (items > 1) + 1020. r->level[1].sens = le32_to_cpu(buf[1]); + +security/selinux/ss/policydb.c:1020: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1018. r->level[0].sens = le32_to_cpu(buf[0]); + 1019. if (items > 1) + 1020. > r->level[1].sens = le32_to_cpu(buf[1]); + 1021. else + 1022. r->level[1].sens = r->level[0].sens; + +kernel/trace/trace_events.c:1015: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1013. rcu_read_lock_sched(); + 1014. + 1015. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 1016. + 1017. if (!pid_list) + +net/ipv6/ipv6_sockglue.c:1289: error: UNINITIALIZED_VALUE + The value read from freq.flr_flags was never initialized. + 1287. + 1288. len = sizeof(freq); + 1289. > flags = freq.flr_flags; + 1290. + 1291. memset(&freq, 0, sizeof(freq)); + +security/selinux/avc.c:1022: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1020. node = avc_lookup(ssid, tsid, tclass); + 1021. if (unlikely(!node)) { + 1022. > node = avc_compute_av(ssid, tsid, tclass, &avd, xp_node); + 1023. } else { + 1024. memcpy(&avd, &node->ae.avd, sizeof(avd)); + +security/selinux/avc.c:1049: error: UNINITIALIZED_VALUE + The value read from avd.seqno was never initialized. + 1047. &local_xpd); + 1048. rcu_read_lock(); + 1049. > avc_update_node(AVC_CALLBACK_ADD_XPERMS, requested, driver, xperm, + 1050. ssid, tsid, tclass, avd.seqno, &local_xpd, 0); + 1051. } else { + +drivers/video/fbdev/core/fbmon.c:1074: error: UNINITIALIZED_VALUE + The value read from svd[_] was never initialized. + 1072. + 1073. for (i = specs->modedb_len + num; i < specs->modedb_len + num + svd_n; i++) { + 1074. > int idx = svd[i - specs->modedb_len - num]; + 1075. if (!idx || idx >= ARRAY_SIZE(cea_modes)) { + 1076. pr_warn("Reserved SVD code %d\n", idx); + +drivers/pci/pci.c:1028: error: DEAD_STORE + The value written to &i (type int) is never used. + 1026. pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]); + 1027. pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]); + 1028. > pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]); + 1029. + 1030. return 0; + +arch/x86/events/core.c:1013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1011. + 1012. hwc->idx = cpuc->assign[i]; + 1013. > hwc->last_cpu = smp_processor_id(); + 1014. hwc->last_tag = ++cpuc->tags[i]; + 1015. + +arch/x86/events/core.c:1013: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1011. + 1012. hwc->idx = cpuc->assign[i]; + 1013. > hwc->last_cpu = smp_processor_id(); + 1014. hwc->last_tag = ++cpuc->tags[i]; + 1015. + +net/wireless/trace.h:1012: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +drivers/gpu/drm/i915/i915_gem_gtt.c:1066: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1064. kunmap_atomic(vaddr); + 1065. + 1066. > return ret; + 1067. } + 1068. + +kernel/fork.c:1023: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1021. * this mm -- see comment above for justification. + 1022. */ + 1023. > old_exe_file = rcu_dereference_raw(mm->exe_file); + 1024. + 1025. if (new_exe_file) + +kernel/trace/trace_kprobe.c:1022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1020. struct event_file_link *link; + 1021. + 1022. > list_for_each_entry_rcu(link, &tk->tp.files, list) + 1023. __kprobe_trace_func(tk, regs, link->file); + 1024. } + +drivers/gpu/drm/i915/intel_display.c:1022: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 1020. static void wait_for_pipe_scanline_moving(struct intel_crtc *crtc, bool state) + 1021. { + 1022. > struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 1023. enum pipe pipe = crtc->pipe; + 1024. + +drivers/gpu/drm/i915/intel_display.c:1026: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1024. + 1025. /* Wait for the display line to settle/start moving */ + 1026. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1027. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1028. pipe_name(pipe), onoff(state)); + +drivers/gpu/drm/i915/intel_display.c:1026: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1024. + 1025. /* Wait for the display line to settle/start moving */ + 1026. > if (wait_for(pipe_scanline_is_moving(dev_priv, pipe) == state, 100)) + 1027. DRM_ERROR("pipe %c scanline %s wait timed out\n", + 1028. pipe_name(pipe), onoff(state)); + +arch/x86/events/intel/ds.c:1067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1065. if (!kernel_ip(ip)) { + 1066. int bytes; + 1067. > u8 *buf = this_cpu_read(insn_buffer); + 1068. + 1069. /* 'size' must fit our buffer, see above */ + +arch/x86/events/intel/ds.c:1067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1065. if (!kernel_ip(ip)) { + 1066. int bytes; + 1067. > u8 *buf = this_cpu_read(insn_buffer); + 1068. + 1069. /* 'size' must fit our buffer, see above */ + +net/ipv4/ping.c:1027: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1025. struct sock *sk; + 1026. struct ping_iter_state *state = seq->private; + 1027. > struct net *net = seq_file_net(seq); + 1028. + 1029. for (state->bucket = start; state->bucket < PING_HTABLE_SIZE; + +net/xfrm/xfrm_user.c:1026: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1024. u32 pid, unsigned int group) + 1025. { + 1026. > struct sock *nlsk = rcu_dereference(net->xfrm.nlsk); + 1027. + 1028. if (nlsk) + +drivers/gpu/drm/i915/intel_dp.c:1130: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1128. + 1129. if ((status & DP_AUX_CH_CTL_DONE) == 0) { + 1130. > DRM_ERROR("dp_aux_ch not done status 0x%08x\n", status); + 1131. ret = -EBUSY; + 1132. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1140: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1138. */ + 1139. if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) { + 1140. > DRM_ERROR("dp_aux_ch receive error status 0x%08x\n", status); + 1141. ret = -EIO; + 1142. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1148: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1146. * "normal" -- don't fill the kernel log with these */ + 1147. if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) { + 1148. > DRM_DEBUG_KMS("dp_aux_ch timeout status 0x%08x\n", status); + 1149. ret = -ETIMEDOUT; + 1150. goto out; + +drivers/nvmem/core.c:1045: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1043. + 1044. /* setup the first byte with lsb bits from nvmem */ + 1045. > rc = nvmem_reg_read(nvmem, cell->offset, &v, 1); + 1046. *b++ |= GENMASK(bit_offset - 1, 0) & v; + 1047. + +drivers/nvmem/core.c:1062: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1060. if ((nbits + bit_offset) % BITS_PER_BYTE) { + 1061. /* setup the last byte with msb bits from nvmem */ + 1062. > rc = nvmem_reg_read(nvmem, + 1063. cell->offset + cell->bytes - 1, &v, 1); + 1064. *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v; + +lib/vsprintf.c:1059: error: UNINITIALIZED_VALUE + The value read from zerolength[_] was never initialized. + 1057. for (i = 0; i < range; i++) { + 1058. if (zerolength[i] > longest) { + 1059. > longest = zerolength[i]; + 1060. colonpos = i; + 1061. } + +include/linux/rhashtable.h:1065: error: DEAD_STORE + The value written to &list (type rhlist_head*) is never used. + 1063. continue; + 1064. + 1065. > list = rht_dereference_bucket(list->next, tbl, hash); + 1066. RCU_INIT_POINTER(*lpprev, list); + 1067. err = 0; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1067: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1065. if ((hw->mac_type == e1000_82545_rev_3) || + 1066. (hw->mac_type == e1000_82546_rev_3)) { + 1067. > ret_val = + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1070: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + 1070. > ret_val = + 1071. e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); + 1072. } + +arch/x86/events/core.c:1035: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1033. { + 1034. return hwc->idx == cpuc->assign[i] && + 1035. > hwc->last_cpu == smp_processor_id() && + 1036. hwc->last_tag == cpuc->tags[i]; + 1037. } + +drivers/pci/pci.c:1050: error: DEAD_STORE + The value written to &i (type int) is never used. + 1048. pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]); + 1049. pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]); + 1050. > pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]); + 1051. } + 1052. + +drivers/base/power/wakeup.c:1046: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1044. + 1045. srcuidx = srcu_read_lock(&wakeup_srcu); + 1046. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 1047. print_wakeup_source_stats(m, ws); + 1048. srcu_read_unlock(&wakeup_srcu, srcuidx); + +drivers/gpu/drm/i915/intel_dpio_phy.c:1050: error: DEAD_STORE + The value written to &val (type unsigned int) is never used. + 1048. + 1049. /* Enable clock channels for this port */ + 1050. > val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(port)); + 1051. val = 0; + 1052. if (pipe) + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1040 could be null and is dereferenced at line 1043, column 17. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 1039 could be null and is dereferenced at line 1043, column 2. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +kernel/fork.c:1043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1041. + 1042. rcu_read_lock(); + 1043. > exe_file = rcu_dereference(mm->exe_file); + 1044. if (exe_file && !get_file_rcu(exe_file)) + 1045. exe_file = NULL; + +net/ipv6/tcp_ipv6.c:1072: error: DEAD_STORE + The value written to &newinet (type inet_sock*) is never used. + 1070. inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; + 1071. + 1072. > newinet = inet_sk(newsk); + 1073. newnp = inet6_sk(newsk); + 1074. newtp = tcp_sk(newsk); + +net/ipv6/tcp_ipv6.c:1179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1177. opt = ireq->ipv6_opt; + 1178. if (!opt) + 1179. > opt = rcu_dereference(np->opt); + 1180. if (opt) { + 1181. opt = ipv6_dup_options(newsk, opt); + +net/wireless/trace.h:1042: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/ipv6/route.c:1061: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1060 could be null and is dereferenced by call to `dev_net()` at line 1061, column 23. + 1059. rcu_read_lock(); + 1060. dev = ip6_rt_get_dev_rcu(ort); + 1061. > rt = __ip6_dst_alloc(dev_net(dev), dev, 0); + 1062. rcu_read_unlock(); + 1063. if (!rt) + +net/ipv4/inet_connection_sock.c:1058: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1056. + 1057. rcu_read_lock(); + 1058. > inet_opt = rcu_dereference(inet->inet_opt); + 1059. if (inet_opt && inet_opt->opt.srr) + 1060. daddr = inet_opt->opt.faddr; + +kernel/exit.c:1055: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1053. int state, status; + 1054. pid_t pid = task_pid_vnr(p); + 1055. > uid_t uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1056. struct waitid_info *infop; + 1057. + +drivers/gpu/drm/i915/i915_gem_request.c:1067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1065. * stop busywaiting, see busywait_stop(). + 1066. */ + 1067. > *cpu = get_cpu(); + 1068. t = local_clock() >> 10; + 1069. put_cpu(); + +drivers/gpu/drm/i915/i915_gem_request.c:1067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1065. * stop busywaiting, see busywait_stop(). + 1066. */ + 1067. > *cpu = get_cpu(); + 1068. t = local_clock() >> 10; + 1069. put_cpu(); + +security/selinux/ss/policydb.c:1066: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1064. goto out; + 1065. } + 1066. > c->user = le32_to_cpu(buf[0]); + 1067. c->role = le32_to_cpu(buf[1]); + 1068. c->type = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1067: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1065. } + 1066. c->user = le32_to_cpu(buf[0]); + 1067. > c->role = le32_to_cpu(buf[1]); + 1068. c->type = le32_to_cpu(buf[2]); + 1069. if (p->policyvers >= POLICYDB_VERSION_MLS) { + +security/selinux/ss/policydb.c:1068: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1066. c->user = le32_to_cpu(buf[0]); + 1067. c->role = le32_to_cpu(buf[1]); + 1068. > c->type = le32_to_cpu(buf[2]); + 1069. if (p->policyvers >= POLICYDB_VERSION_MLS) { + 1070. rc = mls_read_range_helper(&c->range, fp); + +kernel/time/tick-sched.c:1071: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1069. + 1070. if (ts->idle_active) + 1071. > tick_nohz_stop_idle(ts, now); + 1072. + 1073. if (ts->tick_stopped) { + +kernel/time/tick-sched.c:1074: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1072. + 1073. if (ts->tick_stopped) { + 1074. > tick_nohz_restart_sched_tick(ts, now); + 1075. tick_nohz_account_idle_ticks(ts); + 1076. } + +drivers/dma-buf/dma-buf.c:1097: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1095. seq = read_seqcount_begin(&robj->seq); + 1096. rcu_read_lock(); + 1097. > fobj = rcu_dereference(robj->fence); + 1098. shared_count = fobj ? fobj->shared_count : 0; + 1099. fence = rcu_dereference(robj->fence_excl); + +drivers/dma-buf/dma-buf.c:1099: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1097. fobj = rcu_dereference(robj->fence); + 1098. shared_count = fobj ? fobj->shared_count : 0; + 1099. > fence = rcu_dereference(robj->fence_excl); + 1100. if (!read_seqcount_retry(&robj->seq, seq)) + 1101. break; + +drivers/dma-buf/dma-buf.c:1111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1109. dma_fence_is_signaled(fence) ? "" : "un"); + 1110. for (i = 0; i < shared_count; i++) { + 1111. > fence = rcu_dereference(fobj->shared[i]); + 1112. if (!dma_fence_get_rcu(fence)) + 1113. continue; + +drivers/gpu/drm/i915/i915_gem.c:1113: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1111. * page_length = bytes to copy for this page + 1112. */ + 1113. > u32 page_base = node.start; + 1114. unsigned page_offset = offset_in_page(offset); + 1115. unsigned page_length = PAGE_SIZE - page_offset; + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/input/evdev.c:1140: error: UNINITIALIZED_VALUE + The value read from mask.codes_ptr was never initialized. + 1138. return -EFAULT; + 1139. + 1140. > codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + +drivers/input/evdev.c:1152: error: UNINITIALIZED_VALUE + The value read from mask.codes_ptr was never initialized. + 1150. return -EFAULT; + 1151. + 1152. > codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + +drivers/input/evdev.c:1141: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1139. + 1140. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. > return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + 1143. compat_mode); + +drivers/input/evdev.c:1153: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1151. + 1152. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. > return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + 1155. compat_mode); + +drivers/input/evdev.c:1141: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1139. + 1140. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. > return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + 1143. compat_mode); + +drivers/input/evdev.c:1153: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1151. + 1152. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. > return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + 1155. compat_mode); + +kernel/trace/trace_kprobe.c:1072: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1070. struct event_file_link *link; + 1071. + 1072. > list_for_each_entry_rcu(link, &tk->tp.files, list) + 1073. __kretprobe_trace_func(tk, ri, regs, link->file); + 1074. } + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.data was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1094: error: UNINITIALIZED_VALUE + The value read from ctrl.timeout was never initialized. + 1092. goto done; + 1093. } + 1094. > tmo = ctrl.timeout; + 1095. snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1082: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1080. if (ret) + 1081. return ret; + 1082. > wLength = ctrl.wLength; /* To suppress 64k PAGE_SIZE warning */ + 1083. if (wLength > PAGE_SIZE) + 1084. return -EINVAL; + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1107: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1105. } + 1106. pipe = usb_rcvctrlpipe(dev, 0); + 1107. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, NULL, 0); + 1108. + 1109. usb_unlock_device(dev); + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1124: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1122. } else { + 1123. if (ctrl.wLength) { + 1124. > if (copy_from_user(tbuf, ctrl.data, ctrl.wLength)) { + 1125. ret = -EFAULT; + 1126. goto done; + +drivers/usb/core/devio.c:1130: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1128. } + 1129. pipe = usb_sndctrlpipe(dev, 0); + 1130. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, + 1131. tbuf, ctrl.wLength); + 1132. + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +kernel/sched/sched.h:1073: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1071. struct sched_domain *sd, *hsd = NULL; + 1072. + 1073. > for_each_domain(cpu, sd) { + 1074. if (!(sd->flags & flag)) + 1075. break; + +net/ipv4/tcp_ipv4.c:1099: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 1097. return -EINVAL; + 1098. + 1099. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr, + 1100. AF_INET, prefixlen, cmd.tcpm_key, cmd.tcpm_keylen, + 1101. GFP_KERNEL); + +net/ipv4/tcp_ipv4.c:1087: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 1085. if (optname == TCP_MD5SIG_EXT && + 1086. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 1087. > prefixlen = cmd.tcpm_prefixlen; + 1088. if (prefixlen > 32) + 1089. return -EINVAL; + +net/wireless/trace.h:1069: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +drivers/gpu/drm/drm_dp_mst_topology.c:1079: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1077. case DP_PEER_DEVICE_SST_SINK: + 1078. /* add i2c over sideband */ + 1079. > ret = drm_dp_mst_register_i2c_bus(&port->aux); + 1080. break; + 1081. case DP_PEER_DEVICE_MST_BRANCHING: + +drivers/md/dm-raid1.c:1142: error: DEAD_STORE + The value written to &argv (type char**) is never used. + 1140. goto err_destroy_wq; + 1141. + 1142. > argv += args_used; + 1143. argc -= args_used; + 1144. + +kernel/kprobes.c:1075: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1073. struct kprobe *kp; + 1074. + 1075. > list_for_each_entry_rcu(kp, &p->list, list) { + 1076. if (kp->pre_handler && likely(!kprobe_disabled(kp))) { + 1077. set_kprobe_instance(kp); + +net/ipv4/cipso_ipv4.c:1105: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 1103. + 1104. for (iter = 0; array_cnt > 0;) { + 1105. > *((__be16 *)&net_cat[iter]) = htons(array[--array_cnt]); + 1106. iter += 2; + 1107. array_cnt--; + +net/ipv4/cipso_ipv4.c:1109: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 1107. array_cnt--; + 1108. if (array[array_cnt] != 0) { + 1109. > *((__be16 *)&net_cat[iter]) = htons(array[array_cnt]); + 1110. iter += 2; + 1111. } + +net/sunrpc/svc.c:1083: error: DEAD_STORE + The value written to &error (type int) is never used. + 1081. */ + 1082. if (error == -EPROTONOSUPPORT) + 1083. > error = rpcb_register(net, program, version, 0, 0); + 1084. + 1085. dprintk("svc: %s(%sv%u), error %d\n", + +drivers/tty/vt/vt_ioctl.c:1091: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 1089. op->width = 8; + 1090. op->height = cfdarg.charheight; + 1091. > op->charcount = cfdarg.charcount; + 1092. op->data = compat_ptr(cfdarg.chardata); + 1093. return con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:1099: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 1097. op->width = 8; + 1098. op->height = cfdarg.charheight; + 1099. > op->charcount = cfdarg.charcount; + 1100. op->data = compat_ptr(cfdarg.chardata); + 1101. i = con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:1092: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1090. op->height = cfdarg.charheight; + 1091. op->charcount = cfdarg.charcount; + 1092. > op->data = compat_ptr(cfdarg.chardata); + 1093. return con_font_op(vc_cons[fg_console].d, op); + 1094. case GIO_FONTX: + +drivers/tty/vt/vt_ioctl.c:1100: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1098. op->height = cfdarg.charheight; + 1099. op->charcount = cfdarg.charcount; + 1100. > op->data = compat_ptr(cfdarg.chardata); + 1101. i = con_font_op(vc_cons[fg_console].d, op); + 1102. if (i) + +drivers/tty/vt/vt_ioctl.c:1090: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 1088. op->flags = KD_FONT_FLAG_OLD; + 1089. op->width = 8; + 1090. > op->height = cfdarg.charheight; + 1091. op->charcount = cfdarg.charcount; + 1092. op->data = compat_ptr(cfdarg.chardata); + +drivers/tty/vt/vt_ioctl.c:1098: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 1096. op->flags = KD_FONT_FLAG_OLD; + 1097. op->width = 8; + 1098. > op->height = cfdarg.charheight; + 1099. op->charcount = cfdarg.charcount; + 1100. op->data = compat_ptr(cfdarg.chardata); + +drivers/iommu/intel-iommu.c:1078: error: DEAD_STORE + The value written to &large_page (type unsigned int) is never used. + 1076. unsigned long last_pfn) + 1077. { + 1078. > unsigned int large_page = 1; + 1079. struct dma_pte *first_pte, *pte; + 1080. + +drivers/pci/pci.c:1087: error: DEAD_STORE + The value written to &i (type int) is never used. + 1085. cap = (u16 *)&save_state->cap.data[0]; + 1086. + 1087. > pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]); + 1088. } + 1089. + +drivers/gpu/drm/i915/intel_dsi.c:1152: error: DEAD_STORE + The value written to &vbp (type unsigned short) is never used. + 1150. vfp = I915_READ(MIPI_VFP_COUNT(port)); + 1151. vsync = I915_READ(MIPI_VSYNC_PADDING_COUNT(port)); + 1152. > vbp = I915_READ(MIPI_VBP_COUNT(port)); + 1153. + 1154. adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp; + +block/elevator.c:1091: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `elevator_switch()` at line 1091, column 10. + 1089. */ + 1090. if (q->mq_ops && !strncmp(name, "none", 4)) + 1091. > return elevator_switch(q, NULL); + 1092. + 1093. strlcpy(elevator_name, name, sizeof(elevator_name)); + +net/xfrm/xfrm_policy.c:1103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1101. priority = ~0U; + 1102. ret = NULL; + 1103. > hlist_for_each_entry_rcu(pol, chain, bydst) { + 1104. err = xfrm_policy_match(pol, fl, type, family, dir); + 1105. if (err) { + +net/xfrm/xfrm_policy.c:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. } + 1118. chain = &net->xfrm.policy_inexact[dir]; + 1119. > hlist_for_each_entry_rcu(pol, chain, bydst) { + 1120. if ((pol->priority >= priority) && ret) + 1121. break; + +net/netlink/genetlink.c:1087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1085. int err; + 1086. + 1087. > for_each_net_rcu(net) { + 1088. if (prev) { + 1089. tmp = skb_clone(skb, flags); + +kernel/sched/sched.h:1086: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1084. struct sched_domain *sd; + 1085. + 1086. > for_each_domain(cpu, sd) { + 1087. if (sd->flags & flag) + 1088. break; + +kernel/irq/irqdomain.c:1090: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1089 could be null and is dereferenced at line 1090, column 9. + 1088. for (i = 0; i < nr_irqs; i++) { + 1089. irq_data = irq_get_irq_data(virq + i); + 1090. > tmp = irq_data->parent_data; + 1091. irq_data->parent_data = NULL; + 1092. irq_data->domain = NULL; + +security/commoncap.c:1090: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1088. + 1089. rcu_read_lock(); + 1090. > is_subset = cap_issubset(__task_cred(p)->cap_permitted, + 1091. current_cred()->cap_permitted); + 1092. if (!is_subset && !ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) + +security/commoncap.c:1092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1090. is_subset = cap_issubset(__task_cred(p)->cap_permitted, + 1091. current_cred()->cap_permitted); + 1092. > if (!is_subset && !ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) + 1093. ret = -EPERM; + 1094. rcu_read_unlock(); + +kernel/kprobes.c:1092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1090. struct kprobe *kp; + 1091. + 1092. > list_for_each_entry_rcu(kp, &p->list, list) { + 1093. if (kp->post_handler && likely(!kprobe_disabled(kp))) { + 1094. set_kprobe_instance(kp); + +net/netfilter/nf_conntrack_sip.c:1099: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1094 could be null and is dereferenced at line 1099, column 11. + 1097. (code >= 200 && code <= 299)) + 1098. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1099. > else if (ct_sip_info->invite_cseq == cseq) + 1100. flush_expectations(ct, true); + 1101. return NF_ACCEPT; + +net/wireless/trace.h:1087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/ipv6/route.c:1095: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1094 could be null and is dereferenced by call to `dev_net()` at line 1095, column 28. + 1093. rcu_read_lock(); + 1094. dev = ip6_rt_get_dev_rcu(rt); + 1095. > pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags); + 1096. rcu_read_unlock(); + 1097. if (!pcpu_rt) + +drivers/video/fbdev/core/fbmem.c:1188: error: UNINITIALIZED_VALUE + The value read from con2fb.framebuffer was never initialized. + 1186. return -EINVAL; + 1187. if (!registered_fb[con2fb.framebuffer]) + 1188. > request_module("fb%d", con2fb.framebuffer); + 1189. if (!registered_fb[con2fb.framebuffer]) { + 1190. ret = -EINVAL; + +drivers/gpu/drm/drm_dp_mst_topology.c:1102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1100. if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) { + 1101. if (mstb->port_parent) { + 1102. > ret = drm_dp_send_dpcd_write( + 1103. mstb->mgr, + 1104. mstb->port_parent, + +drivers/gpu/drm/drm_dp_mst_topology.c:1110: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1108. } else { + 1109. + 1110. > ret = drm_dp_dpcd_write( + 1111. mstb->mgr->aux, + 1112. DP_GUID, + +kernel/rcu/srcutree.c:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. * by the prior grace period. + 1109. */ + 1110. > idx = rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq)); /* ^^^ */ + 1111. if (idx == SRCU_STATE_IDLE) { + 1112. spin_lock_irq_rcu_node(sp); + +kernel/rcu/srcutree.c:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. return; + 1118. } + 1119. > idx = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 1120. if (idx == SRCU_STATE_IDLE) + 1121. srcu_gp_start(sp); + +kernel/rcu/srcutree.c:1129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1127. } + 1128. + 1129. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN1) { + 1130. idx = 1 ^ (sp->srcu_idx & 1); + 1131. if (!try_check_zero(sp, idx, 1)) { + +kernel/rcu/srcutree.c:1139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1137. } + 1138. + 1139. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN2) { + 1140. + 1141. /* + +net/ipv4/ipmr.c:1107: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1107, column 5. + 1105. + 1106. if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) { + 1107. > nlh->nlmsg_len = skb_tail_pointer(skb) - + 1108. (u8 *)nlh; + 1109. } else { + +net/ipv4/ipmr.c:1110: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1110, column 5. + 1108. (u8 *)nlh; + 1109. } else { + 1110. > nlh->nlmsg_type = NLMSG_ERROR; + 1111. nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr)); + 1112. skb_trim(skb, nlh->nlmsg_len); + +security/selinux/avc.c:1110: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1108. node = avc_lookup(ssid, tsid, tclass); + 1109. if (unlikely(!node)) + 1110. > node = avc_compute_av(ssid, tsid, tclass, avd, &xp_node); + 1111. else + 1112. memcpy(avd, &node->ae.avd, sizeof(*avd)); + +drivers/input/mouse/alps.c:1113: error: DEAD_STORE + The value written to &z (type int) is never used. + 1111. y = (packet[3] & 0x07) | (packet[4] & 0xb8) | + 1112. ((packet[3] & 0x20) << 1); + 1113. > z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1); + 1114. + 1115. left = (packet[1] & 0x01); + +drivers/gpu/drm/i915/intel_ddi.c:1102: error: DEAD_STORE + The value written to &refclk (type int) is never used. + 1100. i915_reg_t reg) + 1101. { + 1102. > int refclk = LC_FREQ; + 1103. int n, p, r; + 1104. u32 wrpll; + +net/core/sock.c:1376: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1374. #ifdef CONFIG_NET_RX_BUSY_POLL + 1375. case SO_INCOMING_NAPI_ID: + 1376. > v.val = READ_ONCE(sk->sk_napi_id); + 1377. + 1378. /* aggregate non-NAPI IDs down to 0 */ + +include/linux/rhashtable.h:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. rcu_read_lock(); + 1109. + 1110. > tbl = rht_dereference_rcu(ht->tbl, ht); + 1111. + 1112. /* Because we have already taken (and released) the bucket + +include/linux/rhashtable.h:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. while ((err = __rhashtable_remove_fast_one(ht, tbl, obj, params, + 1118. rhlist)) && + 1119. > (tbl = rht_dereference_rcu(tbl->future_tbl, ht))) + 1120. ; + 1121. + +kernel/irq/irqdomain.c:1112: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1111 could be null and is dereferenced at line 1112, column 3. + 1110. for (i = 0; i < nr_irqs; i++) { + 1111. irq_data = irq_get_irq_data(virq + i); + 1112. > irq_data->domain = domain; + 1113. + 1114. for (parent = domain->parent; parent; parent = parent->parent) { + +kernel/kprobes.c:1105: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1103. int trapnr) + 1104. { + 1105. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1106. + 1107. /* + +kernel/kprobes.c:1105: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1103. int trapnr) + 1104. { + 1105. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1106. + 1107. /* + +drivers/char/random.c:1113: error: DEAD_STORE + The value written to &idx (type unsigned int) is never used. + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + 1113. > ptr += idx++; + 1114. WRITE_ONCE(f->reg_idx, idx); + 1115. return *ptr; + +drivers/char/random.c:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. if (regs == NULL) + 1109. return 0; + 1110. > idx = READ_ONCE(f->reg_idx); + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + +net/wireless/trace.h:1103: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +scripts/kconfig/confdata.c:1114: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1109 could be null and is dereferenced at line 1114, column 2. + 1112. * Set all non-assinged choice values to no + 1113. */ + 1114. > expr_list_for_each_sym(prop->expr, e, sym) { + 1115. if (!sym_has_value(sym)) + 1116. sym->def[S_DEF_USER].tri = no; + +net/netfilter/nf_conntrack_sip.c:1116: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1111 could be null and is dereferenced at line 1116, column 11. + 1114. (code >= 200 && code <= 299)) + 1115. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1116. > else if (ct_sip_info->invite_cseq == cseq) + 1117. flush_expectations(ct, true); + 1118. return NF_ACCEPT; + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +net/ipv4/netfilter/ip_tables.c:1135: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1133. tmp.name[sizeof(tmp.name)-1] = 0; + 1134. + 1135. > newinfo = xt_alloc_table_info(tmp.size); + 1136. if (!newinfo) + 1137. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1140: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1138. + 1139. loc_cpu_entry = newinfo->entries; + 1140. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1141. tmp.size) != 0) { + 1142. ret = -EFAULT; + +security/selinux/ss/policydb.c:1133: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1131. goto bad; + 1132. + 1133. > len = le32_to_cpu(buf[0]); + 1134. perdatum->value = le32_to_cpu(buf[1]); + 1135. + +security/selinux/ss/policydb.c:1134: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1132. + 1133. len = le32_to_cpu(buf[0]); + 1134. > perdatum->value = le32_to_cpu(buf[1]); + 1135. + 1136. rc = str_read(&key, GFP_KERNEL, fp, len); + +arch/x86/events/core.c:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. left = x86_pmu.limit_period(event, left); + 1156. + 1157. > per_cpu(pmc_prev_left[idx], smp_processor_id()) = left; + 1158. + 1159. if (!(hwc->flags & PERF_X86_EVENT_AUTO_RELOAD) || + +kernel/kprobes.c:1121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1119. static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs) + 1120. { + 1121. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1122. int ret = 0; + 1123. + +kernel/kprobes.c:1121: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1119. static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs) + 1120. { + 1121. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1122. int ret = 0; + 1123. + +net/ipv6/route.c:1133: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1131. dst_hold(&pcpu_rt->dst); + 1132. p = this_cpu_ptr(rt->rt6i_pcpu); + 1133. > prev = cmpxchg(p, NULL, pcpu_rt); + 1134. BUG_ON(prev); + 1135. + +security/keys/keyctl.c:1138: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `keyctl_instantiate_key_common()` at line 1138, column 9. + 1136. } + 1137. + 1138. > return keyctl_instantiate_key_common(id, NULL, ringid); + 1139. } + 1140. + +net/netfilter/nf_conntrack_sip.c:1133: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1128 could be null and is dereferenced at line 1133, column 11. + 1131. (code >= 200 && code <= 299)) + 1132. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1133. > else if (ct_sip_info->invite_cseq == cseq) + 1134. flush_expectations(ct, true); + 1135. return NF_ACCEPT; + +drivers/pci/msi.c:1129: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1129, column 9. + 1127. int minvec, int maxvec) + 1128. { + 1129. > return __pci_enable_msix_range(dev, entries, minvec, maxvec, NULL); + 1130. } + 1131. EXPORT_SYMBOL(pci_enable_msix_range); + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.alloc32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1146: error: UNINITIALIZED_VALUE + The value read from getb.data32 was never initialized. + 1144. ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. > compat_ptr(getb.data32), getb.alloc32); + 1147. if (ret < 0) + 1148. return ret; + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.hdr32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +drivers/usb/mon/mon_bin.c:1163: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush32 was never initialized. + 1161. + 1162. if (mfetch.nflush32) { + 1163. > ret = mon_bin_flush(rp, mfetch.nflush32); + 1164. if (ret < 0) + 1165. return ret; + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.offvec32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +net/wireless/trace.h:1127: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/ipv4/ipmr.c:1184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1182. + 1183. rcu_read_lock(); + 1184. > mroute_sk = rcu_dereference(mrt->mroute_sk); + 1185. if (!mroute_sk) { + 1186. rcu_read_unlock(); + +net/ipv6/ip6_fib.c:1135: error: DEAD_STORE + The value written to &err (type int) is never used. + 1133. struct fib6_table *table = rt->rt6i_table; + 1134. struct fib6_node *fn, *pn = NULL; + 1135. > int err = -ENOMEM; + 1136. int allow_create = 1; + 1137. int replace_required = 0; + +net/ipv6/ip6_fib.c:1164: error: DEAD_STORE + The value written to &pn (type fib6_node*) is never used. + 1162. } + 1163. + 1164. > pn = fn; + 1165. + 1166. #ifdef CONFIG_IPV6_SUBTREES + +net/ipv6/ip6_fib.c:1291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1289. (!(fn->fn_flags & (RTN_RTINFO|RTN_ROOT)) || + 1290. (fn->fn_flags & RTN_TL_ROOT && + 1291. > !rcu_access_pointer(fn->leaf)))) + 1292. fib6_repair_tree(info->nl_net, table, fn); + 1293. /* Always release dst as dst->__refcnt is guaranteed + +net/ipv6/netfilter/ip6_tables.c:1153: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1151. tmp.name[sizeof(tmp.name)-1] = 0; + 1152. + 1153. > newinfo = xt_alloc_table_info(tmp.size); + 1154. if (!newinfo) + 1155. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1158: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1156. + 1157. loc_cpu_entry = newinfo->entries; + 1158. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1159. tmp.size) != 0) { + 1160. ret = -EFAULT; + +kernel/kprobes.c:1140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1138. p->nmissed++; + 1139. } else { + 1140. > list_for_each_entry_rcu(kp, &p->list, list) + 1141. kp->nmissed++; + 1142. } + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_tv.c:1194: error: DEAD_STORE + The value written to &type (type int) is never used. + 1192. intel_wait_for_vblank(dev_priv, intel_crtc->pipe); + 1193. + 1194. > type = -1; + 1195. tv_dac = I915_READ(TV_DAC); + 1196. DRM_DEBUG_KMS("TV detected: %x, %x\n", tv_ctl, tv_dac); + +lib/rhashtable.c:1148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1146. union nested_table *ntbl; + 1147. + 1148. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1149. ntbl = rht_dereference_bucket_rcu(ntbl[index].table, tbl, hash); + 1150. subhash >>= tbl->nest; + +lib/rhashtable.c:1149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1147. + 1148. ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1149. > ntbl = rht_dereference_bucket_rcu(ntbl[index].table, tbl, hash); + 1150. subhash >>= tbl->nest; + 1151. + +lib/rhashtable.c:1154: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1152. while (ntbl && size > (1 << shift)) { + 1153. index = subhash & ((1 << shift) - 1); + 1154. > ntbl = rht_dereference_bucket_rcu(ntbl[index].table, + 1155. tbl, hash); + 1156. size >>= shift; + +kernel/audit.c:1404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1402. unsigned int t; + 1403. + 1404. > t = READ_ONCE(current->signal->audit_tty); + 1405. s.enabled = t & AUDIT_TTY_ENABLE; + 1406. s.log_passwd = !!(t & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1423. + 1424. if (err) + 1425. > t = READ_ONCE(current->signal->audit_tty); + 1426. else { + 1427. t = s.enabled | (-s.log_passwd & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1255: error: UNINITIALIZED_VALUE + The value read from s.backlog_limit was never initialized. + 1253. } + 1254. if (s.mask & AUDIT_STATUS_BACKLOG_LIMIT) { + 1255. > err = audit_set_backlog_limit(s.backlog_limit); + 1256. if (err < 0) + 1257. return err; + +kernel/audit.c:1264: error: UNINITIALIZED_VALUE + The value read from s.backlog_wait_time was never initialized. + 1262. if (s.backlog_wait_time > 10*AUDIT_BACKLOG_WAIT_TIME) + 1263. return -EINVAL; + 1264. > err = audit_set_backlog_wait_time(s.backlog_wait_time); + 1265. if (err < 0) + 1266. return err; + +kernel/audit.c:1180: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1178. memcpy(&s, data, min_t(size_t, sizeof(s), nlmsg_len(nlh))); + 1179. if (s.mask & AUDIT_STATUS_ENABLED) { + 1180. > err = audit_set_enabled(s.enabled); + 1181. if (err < 0) + 1182. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1185: error: UNINITIALIZED_VALUE + The value read from s.failure was never initialized. + 1183. } + 1184. if (s.mask & AUDIT_STATUS_FAILURE) { + 1185. > err = audit_set_failure(s.failure); + 1186. if (err < 0) + 1187. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.log_passwd was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1196: error: UNINITIALIZED_VALUE + The value read from s.pid was never initialized. + 1194. * run auditd from the initial pid namespace, but + 1195. * something to keep in mind if this changes */ + 1196. > pid_t new_pid = s.pid; + 1197. pid_t auditd_pid; + 1198. struct pid *req_pid = task_tgid(current); + +kernel/audit.c:1250: error: UNINITIALIZED_VALUE + The value read from s.rate_limit was never initialized. + 1248. } + 1249. if (s.mask & AUDIT_STATUS_RATE_LIMIT) { + 1250. > err = audit_set_rate_limit(s.rate_limit); + 1251. if (err < 0) + 1252. return err; + +kernel/audit.c:1351: error: UNINITIALIZED_VALUE + The value read from sizes[_] was never initialized. + 1349. bufp += 2 * sizeof(u32); + 1350. msglen -= 2 * sizeof(u32); + 1351. > old = audit_unpack_string(&bufp, &msglen, sizes[0]); + 1352. if (IS_ERR(old)) { + 1353. err = PTR_ERR(old); + +kernel/audit.c:1356: error: UNINITIALIZED_VALUE + The value read from sizes[_] was never initialized. + 1354. break; + 1355. } + 1356. > new = audit_unpack_string(&bufp, &msglen, sizes[1]); + 1357. if (IS_ERR(new)) { + 1358. err = PTR_ERR(new); + +net/netfilter/nf_conntrack_sip.c:1151: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1145 could be null and is dereferenced at line 1151, column 3. + 1149. ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1150. if (ret == NF_ACCEPT) + 1151. > ct_sip_info->invite_cseq = cseq; + 1152. return ret; + 1153. } + +drivers/tty/vt/vt_ioctl.c:1155: error: UNINITIALIZED_VALUE + The value read from tmp.entries was never initialized. + 1153. if (copy_from_user(&tmp, user_ud, sizeof tmp)) + 1154. return -EFAULT; + 1155. > tmp_entries = compat_ptr(tmp.entries); + 1156. switch (cmd) { + 1157. case PIO_UNIMAP: + +drivers/tty/vt/vt_ioctl.c:1160: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1158. if (!perm) + 1159. return -EPERM; + 1160. > return con_set_unimap(vc, tmp.entry_ct, tmp_entries); + 1161. case GIO_UNIMAP: + 1162. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:1164: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1162. if (!perm && fg_console != vc->vc_num) + 1163. return -EPERM; + 1164. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries); + 1165. } + 1166. return 0; + +kernel/cgroup/cpuset.c:1165: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 1156 could be null and is dereferenced at line 1165, column 16. + 1163. */ + 1164. if (is_in_v2_mode() && nodes_empty(*new_mems)) + 1165. > *new_mems = parent->effective_mems; + 1166. + 1167. /* Skip the whole subtree if the nodemask remains the same. */ + +kernel/rcu/tree.c:1151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1149. static int rcu_is_cpu_rrupt_from_idle(void) + 1150. { + 1151. > return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 0 && + 1152. __this_cpu_read(rcu_dynticks.dynticks_nmi_nesting) <= 1; + 1153. } + +kernel/rcu/tree.c:1152: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1150. { + 1151. return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 0 && + 1152. > __this_cpu_read(rcu_dynticks.dynticks_nmi_nesting) <= 1; + 1153. } + 1154. + +net/sunrpc/svc.c:1163: error: DEAD_STORE + The value written to &rpc_stat (type unsigned int) is never used. + 1161. __be32 *reply_statp; + 1162. + 1163. > rpc_stat = rpc_success; + 1164. + 1165. if (argv->iov_len < 6*4) + +security/selinux/ss/policydb.c:1166: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1164. goto bad; + 1165. + 1166. > len = le32_to_cpu(buf[0]); + 1167. comdatum->value = le32_to_cpu(buf[1]); + 1168. + +security/selinux/ss/policydb.c:1167: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1165. + 1166. len = le32_to_cpu(buf[0]); + 1167. > comdatum->value = le32_to_cpu(buf[1]); + 1168. + 1169. rc = symtab_init(&comdatum->permissions, PERM_SYMTAB_SIZE); + +security/selinux/ss/policydb.c:1172: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1170. if (rc) + 1171. goto bad; + 1172. > comdatum->permissions.nprim = le32_to_cpu(buf[2]); + 1173. nel = le32_to_cpu(buf[3]); + 1174. + +security/selinux/ss/policydb.c:1173: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1171. goto bad; + 1172. comdatum->permissions.nprim = le32_to_cpu(buf[2]); + 1173. > nel = le32_to_cpu(buf[3]); + 1174. + 1175. rc = str_read(&key, GFP_KERNEL, fp, len); + +crypto/drbg.c:1153: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1151. static inline int drbg_alloc_state(struct drbg_state *drbg) + 1152. { + 1153. > int ret = -ENOMEM; + 1154. unsigned int sb_size = 0; + 1155. + +drivers/pci/msi.c:1167: error: NULL_DEREFERENCE + pointer `affd` last assigned on line 1163 could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1167, column 10. + 1165. + 1166. if (flags & PCI_IRQ_MSIX) { + 1167. > vecs = __pci_enable_msix_range(dev, NULL, min_vecs, max_vecs, + 1168. affd); + 1169. if (vecs > 0) + +scripts/asn1_compiler.c:1207: error: UNINITIALIZED_VALUE + The value read from children was never initialized. + 1205. + 1206. *_cursor = cursor; + 1207. > return children; + 1208. + 1209. overrun_error: + +drivers/usb/core/devio.c:1190: error: UNINITIALIZED_VALUE + The value read from bulk.data was never initialized. + 1188. tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. > if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + 1191. ret = -EINVAL; + 1192. goto done; + +drivers/usb/core/devio.c:1165: error: UNINITIALIZED_VALUE + The value read from bulk.ep was never initialized. + 1163. if (copy_from_user(&bulk, arg, sizeof(bulk))) + 1164. return -EFAULT; + 1165. > ret = findintfep(ps->dev, bulk.ep); + 1166. if (ret < 0) + 1167. return ret; + +drivers/usb/core/devio.c:1177: error: UNINITIALIZED_VALUE + The value read from bulk.len was never initialized. + 1175. if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN))) + 1176. return -EINVAL; + 1177. > len1 = bulk.len; + 1178. if (len1 >= (INT_MAX - sizeof(struct urb))) + 1179. return -EINVAL; + +drivers/usb/core/devio.c:1188: error: UNINITIALIZED_VALUE + The value read from bulk.timeout was never initialized. + 1186. goto done; + 1187. } + 1188. > tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + +net/wireless/trace.h:1157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/sunrpc/auth_gss/svcauth_gss.c:1167: error: DEAD_STORE + The value written to &status (type int) is never used. + 1165. struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. > int status = -EINVAL; + 1168. + 1169. memset(&rsci, 0, sizeof(rsci)); + +net/sunrpc/auth_gss/svcauth_gss.c:1205: error: DEAD_STORE + The value written to &status (type int) is never used. + 1203. rsci.cred.cr_gss_mech = gm; + 1204. + 1205. > status = -EINVAL; + 1206. /* mech-specific data: */ + 1207. status = gss_import_sec_context(ud->out_handle.data, + +net/core/rtnetlink.c:1265: error: UNINITIALIZED_VALUE + The value read from vf_stats.broadcast was never initialized. + 1263. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1264. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1265. > nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1266. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1267. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + +net/core/rtnetlink.c:1267: error: UNINITIALIZED_VALUE + The value read from vf_stats.multicast was never initialized. + 1265. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1266. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1267. > nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + 1268. vf_stats.multicast, IFLA_VF_STATS_PAD) || + 1269. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + +net/core/rtnetlink.c:1261: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_bytes was never initialized. + 1259. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1260. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1261. > nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1262. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1263. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + +net/core/rtnetlink.c:1269: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_dropped was never initialized. + 1267. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + 1268. vf_stats.multicast, IFLA_VF_STATS_PAD) || + 1269. > nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + 1270. vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || + 1271. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, + +net/core/rtnetlink.c:1257: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_packets was never initialized. + 1255. if (!vfstats) + 1256. goto nla_put_vf_failure; + 1257. > if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1258. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1259. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + +net/core/rtnetlink.c:1263: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_bytes was never initialized. + 1261. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1262. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1263. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1264. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1265. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + +net/core/rtnetlink.c:1271: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_dropped was never initialized. + 1269. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + 1270. vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || + 1271. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, + 1272. vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) { + 1273. nla_nest_cancel(skb, vfstats); + +net/core/rtnetlink.c:1259: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_packets was never initialized. + 1257. if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1258. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1259. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1260. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1261. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + +net/sched/act_api.c:1168: error: DEAD_STORE + The value written to &t (type tcamsg*) is never used. + 1166. struct tc_action_ops *a_o; + 1167. int ret = 0; + 1168. > struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1169. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1170. struct nlattr *count_attr = NULL; + +net/xfrm/xfrm_policy.c:1168: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1166. rcu_read_lock(); + 1167. again: + 1168. > pol = rcu_dereference(sk->sk_policy[dir]); + 1169. if (pol != NULL) { + 1170. bool match; + +net/ipv6/ip6_output.c:1217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1215. v6_cork->tclass = ipc6->tclass; + 1216. if (rt->dst.flags & DST_XFRM_TUNNEL) + 1217. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1218. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1219. else + +net/ipv6/ip6_output.c:1220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1218. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1219. else + 1220. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1221. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(xfrm_dst_path(&rt->dst)); + 1222. if (np->frag_size < mtu) { + +lib/rhashtable.c:1179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1177. unsigned int nhash; + 1178. + 1179. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1180. hash >>= tbl->nest; + 1181. nhash = index; + +drivers/usb/host/uhci-q.c:1182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1180. int len; + 1181. + 1182. > ctrlstat = td_status(uhci, td); + 1183. status = uhci_status_bits(ctrlstat); + 1184. if (status & TD_CTRL_ACTIVE) + +net/netfilter/nf_conntrack_sip.c:1265: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1178 could be null and is dereferenced at line 1265, column 3. + 1263. store_cseq: + 1264. if (ret == NF_ACCEPT) + 1265. > ct_sip_info->register_cseq = cseq; + 1266. return ret; + 1267. } + +net/netfilter/nf_conntrack_sip.c:1250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1248. exp->flags = NF_CT_EXPECT_PERMANENT | NF_CT_EXPECT_INACTIVE; + 1249. + 1250. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1251. if (hooks && ct->status & IPS_NAT_MASK) + 1252. ret = hooks->expect(skb, protoff, dataoff, dptr, datalen, + +net/sunrpc/clnt.c:1180: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1178. + 1179. rcu_read_lock(); + 1180. > xprt = rcu_dereference(clnt->cl_xprt); + 1181. + 1182. bytes = xprt->addrlen; + +drivers/tty/serial/serial_core.c:1224: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1222. uart_port_deref(uport); + 1223. + 1224. > return ret; + 1225. } + 1226. + +net/netlabel/netlabel_unlabeled.c:1196: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1194. rcu_read_lock(); + 1195. for (iter_bkt = skip_bkt; + 1196. > iter_bkt < rcu_dereference(netlbl_unlhsh)->size; + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + +net/netlabel/netlabel_unlabeled.c:1198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1196. iter_bkt < rcu_dereference(netlbl_unlhsh)->size; + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. > iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + 1199. list_for_each_entry_rcu(iface, iter_list, list) { + 1200. if (!iface->valid || + +net/netlabel/netlabel_unlabeled.c:1199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + 1199. > list_for_each_entry_rcu(iface, iter_list, list) { + 1200. if (!iface->valid || + 1201. iter_chain++ < skip_chain) + +net/wireless/trace.h:1178: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +drivers/net/ethernet/broadcom/tg3.c:1213: error: DEAD_STORE + The value written to &frame_val (type unsigned int) is never used. + 1211. if ((frame_val & MI_COM_BUSY) == 0) { + 1212. udelay(5); + 1213. > frame_val = tr32(MAC_MI_COM); + 1214. break; + 1215. } + +lib/radix-tree.c:1185: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1183. radix_tree_update_node_t update_node) + 1184. { + 1185. > void *old = rcu_dereference_raw(*slot); + 1186. int exceptional = !!radix_tree_exceptional_entry(item) - + 1187. !!radix_tree_exceptional_entry(old); + +net/ipv4/tcp.c:1426: error: UNINITIALIZED_VALUE + The value read from size_goal was never initialized. + 1424. if (copied) { + 1425. tcp_tx_timestamp(sk, sockc.tsflags); + 1426. > tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1427. } + 1428. out_nopush: + +net/ipv4/tcp.c:1425: error: UNINITIALIZED_VALUE + The value read from sockc.tsflags was never initialized. + 1423. out: + 1424. if (copied) { + 1425. > tcp_tx_timestamp(sk, sockc.tsflags); + 1426. tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1427. } + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1226: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1224. *batch++ = lower_32_bits(addr); + 1225. *batch++ = upper_32_bits(addr); + 1226. > *batch++ = upper_32_bits(target_offset); + 1227. } else { + 1228. *batch++ = (MI_STORE_DWORD_IMM_GEN4 | (1 << 21)) + 1; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1232: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1230. *batch++ = upper_32_bits(addr); + 1231. *batch++ = lower_32_bits(target_offset); + 1232. > *batch++ = upper_32_bits(target_offset); + 1233. } + 1234. } else if (gen >= 6) { + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1238: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1236. *batch++ = 0; + 1237. *batch++ = addr; + 1238. > *batch++ = target_offset; + 1239. } else if (gen >= 4) { + 1240. *batch++ = MI_STORE_DWORD_IMM_GEN4 | MI_USE_GGTT; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1243: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1241. *batch++ = 0; + 1242. *batch++ = addr; + 1243. > *batch++ = target_offset; + 1244. } else { + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1247: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + 1246. *batch++ = addr; + 1247. > *batch++ = target_offset; + 1248. } + 1249. + +arch/x86/events/core.c:1187: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1185. void x86_pmu_enable_event(struct perf_event *event) + 1186. { + 1187. > if (__this_cpu_read(cpu_hw_events.enabled)) + 1188. __x86_pmu_enable_event(&event->hw, + 1189. ARCH_PERFMON_EVENTSEL_ENABLE); + +net/sunrpc/auth_gss/auth_gss.c:1194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1192. { + 1193. struct gss_auth *gss_auth; + 1194. > struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch); + 1195. + 1196. while (clnt != clnt->cl_parent) { + +net/sunrpc/auth_gss/auth_gss.c:1199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1197. struct rpc_clnt *parent = clnt->cl_parent; + 1198. /* Find the original parent for this transport */ + 1199. > if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps) + 1200. break; + 1201. clnt = parent; + +arch/x86/pci/irq.c:1197: error: DEAD_STORE + The value written to &msg (type char*) is never used. + 1195. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin); + 1196. if (pin && !pcibios_lookup_irq(dev, 1)) { + 1197. > char *msg = ""; + 1198. + 1199. if (!io_apic_assign_pci_irqs && dev->irq) + +kernel/relay.c:1203: error: DEAD_STORE + The value written to &pos (type unsigned long long) is never used. + 1201. uint64_t pos = (uint64_t) *ppos; + 1202. uint32_t alloc_size = (uint32_t) rbuf->chan->alloc_size; + 1203. > size_t read_start = (size_t) do_div(pos, alloc_size); + 1204. size_t read_subbuf = read_start / subbuf_size; + 1205. size_t padding = rbuf->padding[read_subbuf]; + +net/ipv4/af_inet.c:1208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1206. /* Reroute. */ + 1207. rcu_read_lock(); + 1208. > inet_opt = rcu_dereference(inet->inet_opt); + 1209. daddr = inet->inet_daddr; + 1210. if (inet_opt && inet_opt->opt.srr) + +drivers/gpu/drm/i915/intel_lrc.c:1197: error: DEAD_STORE + The value written to &ce (type intel_context*) is never used. + 1195. { + 1196. struct intel_engine_cs *engine = request->engine; + 1197. > struct intel_context *ce = &request->ctx->engine[engine->id]; + 1198. int ret; + 1199. + +net/netfilter/nf_conntrack_netlink.c:1251: error: DEAD_STORE + The value written to &err (type int) is never used. + 1249. ct = nf_ct_tuplehash_to_ctrack(h); + 1250. + 1251. > err = -ENOMEM; + 1252. skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); + 1253. if (skb2 == NULL) { + +net/netfilter/nf_conntrack_core.c:1249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1247. + 1248. if (timeout_ext) + 1249. > nf_ct_timeout_ext_add(ct, rcu_dereference(timeout_ext->timeout), + 1250. GFP_ATOMIC); + 1251. + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +net/rfkill/core.c:1230: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1228. if (rfkill->type == ev.type || + 1229. ev.type == RFKILL_TYPE_ALL) + 1230. > rfkill_set_block(rfkill, ev.soft); + 1231. ret = 0; + 1232. break; + +net/rfkill/core.c:1238: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1236. (rfkill->type == ev.type || + 1237. ev.type == RFKILL_TYPE_ALL)) + 1238. > rfkill_set_block(rfkill, ev.soft); + 1239. ret = 0; + 1240. break; + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.type was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +drivers/iommu/intel-iommu.c:1244: error: DEAD_STORE + The value written to &last_pte (type dma_pte*) is never used. + 1242. if (first_pte) + 1243. domain_flush_cache(domain, first_pte, + 1244. > (void *)++last_pte - (void *)first_pte); + 1245. + 1246. return freelist; + +security/selinux/ss/policydb.c:1213: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1211. if (rc < 0) + 1212. return -EINVAL; + 1213. > t->flags = le32_to_cpu(buf[0]); + 1214. + 1215. return 0; + +net/sunrpc/clnt.c:1206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1204. struct rpc_xprt *xprt; + 1205. + 1206. > xprt = rcu_dereference(clnt->cl_xprt); + 1207. + 1208. if (xprt->address_strings[format] != NULL) + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +net/wireless/trace.h:1206: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/ipv6/calipso.c:1216: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1212 could be null and is dereferenced at line 1216, column 6. + 1214. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1215. + 1216. > if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt) + 1217. old = req_inet->ipv6_opt->hopopt; + 1218. else + +drivers/base/power/main.c:1218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1216. idx = device_links_read_lock(); + 1217. + 1218. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1219. link->supplier->power.must_resume = true; + 1220. + +net/core/net-sysfs.c:1230: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1228. + 1229. rcu_read_lock(); + 1230. > dev_maps = rcu_dereference(dev->xps_maps); + 1231. if (dev_maps) { + 1232. for_each_possible_cpu(cpu) { + +net/core/net-sysfs.c:1236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1234. struct xps_map *map; + 1235. + 1236. > map = rcu_dereference(dev_maps->cpu_map[tci]); + 1237. if (!map) + 1238. continue; + +kernel/exit.c:1241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1239. *p_code = 0; + 1240. + 1241. > uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1242. unlock_sig: + 1243. spin_unlock_irq(&p->sighand->siglock); + +net/ipv6/addrconf.c:1260: error: UNINITIALIZED_VALUE + The value read from expires was never initialized. + 1258. + 1259. if (action != CLEANUP_PREFIX_RT_NOP) { + 1260. > cleanup_prefix_route(ifp, expires, + 1261. action == CLEANUP_PREFIX_RT_DEL); + 1262. } + +net/socket.c:1265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1263. * Otherwise module support will break! + 1264. */ + 1265. > if (rcu_access_pointer(net_families[family]) == NULL) + 1266. request_module("net-pf-%d", family); + 1267. #endif + +net/socket.c:1270: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1268. + 1269. rcu_read_lock(); + 1270. > pf = rcu_dereference(net_families[family]); + 1271. err = -EAFNOSUPPORT; + 1272. if (!pf) + +security/selinux/ss/policydb.c:1243: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1241. if (rc) + 1242. return rc; + 1243. > c->permissions = le32_to_cpu(buf[0]); + 1244. nexpr = le32_to_cpu(buf[1]); + 1245. le = NULL; + +security/selinux/ss/policydb.c:1244: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1242. return rc; + 1243. c->permissions = le32_to_cpu(buf[0]); + 1244. > nexpr = le32_to_cpu(buf[1]); + 1245. le = NULL; + 1246. depth = -1; + +security/selinux/ss/policydb.c:1260: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1258. if (rc) + 1259. return rc; + 1260. > e->expr_type = le32_to_cpu(buf[0]); + 1261. e->attr = le32_to_cpu(buf[1]); + 1262. e->op = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1261: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1259. return rc; + 1260. e->expr_type = le32_to_cpu(buf[0]); + 1261. > e->attr = le32_to_cpu(buf[1]); + 1262. e->op = le32_to_cpu(buf[2]); + 1263. + +security/selinux/ss/policydb.c:1262: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1260. e->expr_type = le32_to_cpu(buf[0]); + 1261. e->attr = le32_to_cpu(buf[1]); + 1262. > e->op = le32_to_cpu(buf[2]); + 1263. + 1264. switch (e->expr_type) { + +kernel/time/tick-sched.c:1238: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1236. u64 offset = ktime_to_ns(tick_period) >> 1; + 1237. do_div(offset, num_possible_cpus()); + 1238. > offset *= smp_processor_id(); + 1239. hrtimer_add_expires_ns(&ts->sched_timer, offset); + 1240. } + +net/ipv4/igmp.c:1237: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1235. /* clear dead sources, too */ + 1236. rcu_read_lock(); + 1237. > for_each_pmc_rcu(in_dev, pmc) { + 1238. struct ip_sf_list *psf, *psf_next; + 1239. + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1241: error: DEAD_STORE + The value written to &ctrl_reg (type unsigned int) is never used. + 1239. } + 1240. + 1241. > ctrl_reg = er32(CTRL); + 1242. + 1243. /* force 1000, set loopback */ + +net/wireless/trace.h:1224: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +include/linux/sched.h:1231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1229. rcu_read_lock(); + 1230. if (pid_alive(tsk)) + 1231. > pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns); + 1232. rcu_read_unlock(); + 1233. + +kernel/events/uprobes.c:1234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1232. + 1233. /* Pairs with xol_add_vma() smp_store_release() */ + 1234. > area = READ_ONCE(mm->uprobes_state.xol_area); /* ^^^ */ + 1235. return area; + 1236. } + +net/core/ethtool.c:1250: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1248. if (copy_from_user(&rxfh, useraddr, sizeof(rxfh))) + 1249. return -EFAULT; + 1250. > user_indir_size = rxfh.indir_size; + 1251. user_key_size = rxfh.key_size; + 1252. + +net/core/ethtool.c:1251: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1249. return -EFAULT; + 1250. user_indir_size = rxfh.indir_size; + 1251. > user_key_size = rxfh.key_size; + 1252. + 1253. /* Check that reserved fields are 0 for now */ + +drivers/net/ethernet/intel/e1000e/netdev.c:1230: error: DEAD_STORE + The value written to &hw (type e1000_hw*) is never used. + 1228. struct e1000_adapter *adapter = tx_ring->adapter; + 1229. struct net_device *netdev = adapter->netdev; + 1230. > struct e1000_hw *hw = &adapter->hw; + 1231. struct e1000_tx_desc *tx_desc, *eop_desc; + 1232. struct e1000_buffer *buffer_info; + +drivers/scsi/scsi_transport_spi.c:1235: error: DEAD_STORE + The value written to &msg (type unsigned char*) is never used. + 1233. if (cmd->flags & SCMD_TAGGED) { + 1234. *msg++ = SIMPLE_QUEUE_TAG; + 1235. > *msg++ = cmd->request->tag; + 1236. return 2; + 1237. } + +drivers/tty/serial/serial_core.c:1257: error: UNINITIALIZED_VALUE + The value read from cnow.brk was never initialized. + 1255. icount->overrun = cnow.overrun; + 1256. icount->parity = cnow.parity; + 1257. > icount->brk = cnow.brk; + 1258. icount->buf_overrun = cnow.buf_overrun; + 1259. + +drivers/tty/serial/serial_core.c:1258: error: UNINITIALIZED_VALUE + The value read from cnow.buf_overrun was never initialized. + 1256. icount->parity = cnow.parity; + 1257. icount->brk = cnow.brk; + 1258. > icount->buf_overrun = cnow.buf_overrun; + 1259. + 1260. return 0; + +drivers/tty/serial/serial_core.c:1248: error: UNINITIALIZED_VALUE + The value read from cnow.cts was never initialized. + 1246. uart_port_deref(uport); + 1247. + 1248. > icount->cts = cnow.cts; + 1249. icount->dsr = cnow.dsr; + 1250. icount->rng = cnow.rng; + +drivers/tty/serial/serial_core.c:1251: error: UNINITIALIZED_VALUE + The value read from cnow.dcd was never initialized. + 1249. icount->dsr = cnow.dsr; + 1250. icount->rng = cnow.rng; + 1251. > icount->dcd = cnow.dcd; + 1252. icount->rx = cnow.rx; + 1253. icount->tx = cnow.tx; + +drivers/tty/serial/serial_core.c:1249: error: UNINITIALIZED_VALUE + The value read from cnow.dsr was never initialized. + 1247. + 1248. icount->cts = cnow.cts; + 1249. > icount->dsr = cnow.dsr; + 1250. icount->rng = cnow.rng; + 1251. icount->dcd = cnow.dcd; + +drivers/tty/serial/serial_core.c:1254: error: UNINITIALIZED_VALUE + The value read from cnow.frame was never initialized. + 1252. icount->rx = cnow.rx; + 1253. icount->tx = cnow.tx; + 1254. > icount->frame = cnow.frame; + 1255. icount->overrun = cnow.overrun; + 1256. icount->parity = cnow.parity; + +drivers/tty/serial/serial_core.c:1255: error: UNINITIALIZED_VALUE + The value read from cnow.overrun was never initialized. + 1253. icount->tx = cnow.tx; + 1254. icount->frame = cnow.frame; + 1255. > icount->overrun = cnow.overrun; + 1256. icount->parity = cnow.parity; + 1257. icount->brk = cnow.brk; + +drivers/tty/serial/serial_core.c:1256: error: UNINITIALIZED_VALUE + The value read from cnow.parity was never initialized. + 1254. icount->frame = cnow.frame; + 1255. icount->overrun = cnow.overrun; + 1256. > icount->parity = cnow.parity; + 1257. icount->brk = cnow.brk; + 1258. icount->buf_overrun = cnow.buf_overrun; + +drivers/tty/serial/serial_core.c:1250: error: UNINITIALIZED_VALUE + The value read from cnow.rng was never initialized. + 1248. icount->cts = cnow.cts; + 1249. icount->dsr = cnow.dsr; + 1250. > icount->rng = cnow.rng; + 1251. icount->dcd = cnow.dcd; + 1252. icount->rx = cnow.rx; + +drivers/tty/serial/serial_core.c:1252: error: UNINITIALIZED_VALUE + The value read from cnow.rx was never initialized. + 1250. icount->rng = cnow.rng; + 1251. icount->dcd = cnow.dcd; + 1252. > icount->rx = cnow.rx; + 1253. icount->tx = cnow.tx; + 1254. icount->frame = cnow.frame; + +drivers/tty/serial/serial_core.c:1253: error: UNINITIALIZED_VALUE + The value read from cnow.tx was never initialized. + 1251. icount->dcd = cnow.dcd; + 1252. icount->rx = cnow.rx; + 1253. > icount->tx = cnow.tx; + 1254. icount->frame = cnow.frame; + 1255. icount->overrun = cnow.overrun; + +net/ipv4/devinet.c:1279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1277. in dev_base list. + 1278. */ + 1279. > for_each_netdev_rcu(net, dev) { + 1280. if (l3mdev_master_ifindex_rcu(dev) != master_idx) + 1281. continue; + +drivers/gpu/drm/i915/i915_debugfs.c:1307: error: UNINITIALIZED_VALUE + The value read from acthd[_] was never initialized. + 1305. spin_unlock_irq(&b->rb_lock); + 1306. + 1307. > seq_printf(m, "\tACTHD = 0x%08llx [current 0x%08llx]\n", + 1308. (long long)engine->hangcheck.acthd, + 1309. (long long)acthd[id]); + +drivers/gpu/drm/i915/i915_debugfs.c:1288: error: UNINITIALIZED_VALUE + The value read from seqno[_] was never initialized. + 1286. + 1287. seq_printf(m, "%s:\n", engine->name); + 1288. > seq_printf(m, "\tseqno = %x [current %x, last %x], inflight %d\n", + 1289. engine->hangcheck.seqno, seqno[id], + 1290. intel_engine_last_submit(engine), + +net/ipv6/ip6_output.c:1541: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1539. cork->length -= length; + 1540. IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS); + 1541. > return err; + 1542. } + 1543. + +net/ipv6/route.c:1252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1250. *bucket += hval; + 1251. + 1252. > hlist_for_each_entry_rcu(rt6_ex, &(*bucket)->chain, hlist) { + 1253. struct rt6_info *rt6 = rt6_ex->rt6i; + 1254. bool matched = ipv6_addr_equal(daddr, &rt6->rt6i_dst.addr); + +drivers/ata/libahci.c:1258: error: DEAD_STORE + The value written to &tmp (type unsigned int) is never used. + 1256. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1257. writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL); + 1258. > tmp = readl(mmio + HOST_CTL); + 1259. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1260. } + +kernel/signal.c:1254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1252. local_irq_save(*flags); + 1253. rcu_read_lock(); + 1254. > sighand = rcu_dereference(tsk->sighand); + 1255. if (unlikely(sighand == NULL)) { + 1256. rcu_read_unlock(); + +kernel/signal.c:1281: error: UNINITIALIZED_VALUE + The value read from sighand was never initialized. + 1279. } + 1280. + 1281. > return sighand; + 1282. } + 1283. + +drivers/gpu/drm/i915/i915_gem.c:1316: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1314. * page_length = bytes to copy for this page + 1315. */ + 1316. > u32 page_base = node.start; + 1317. unsigned int page_offset = offset_in_page(offset); + 1318. unsigned int page_length = PAGE_SIZE - page_offset; + +net/wireless/trace.h:1245: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +kernel/events/core.c:1257: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1255. again: + 1256. rcu_read_lock(); + 1257. > ctx = READ_ONCE(event->ctx); + 1258. if (!atomic_inc_not_zero(&ctx->refcount)) { + 1259. rcu_read_unlock(); + +net/ipv6/calipso.c:1257: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1252 could be null and is dereferenced at line 1257, column 7. + 1255. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1256. + 1257. > if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt) + 1258. return; + 1259. + +include/linux/sched.h:1253: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1251. static inline unsigned int task_state_index(struct task_struct *tsk) + 1252. { + 1253. > unsigned int tsk_state = READ_ONCE(tsk->state); + 1254. unsigned int state = (tsk_state | tsk->exit_state) & TASK_REPORT; + 1255. + +net/core/filter.c:1263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1261. if (err) + 1262. return err; + 1263. > } else if (!rcu_access_pointer(sk->sk_reuseport_cb)) { + 1264. /* The socket wasn't bound with SO_REUSEPORT */ + 1265. return -EINVAL; + +net/ipv4/af_inet.c:1303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1301. } + 1302. + 1303. > ops = rcu_dereference(inet_offloads[proto]); + 1304. if (likely(ops && ops->callbacks.gso_segment)) + 1305. segs = ops->callbacks.gso_segment(skb, features); + +drivers/char/random.c:1267: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1265. /* Can we pull enough? */ + 1266. retry: + 1267. > entropy_count = orig = READ_ONCE(r->entropy_count); + 1268. ibytes = nbytes; + 1269. /* never pull more than available */ + +net/netlabel/netlabel_unlabeled.c:1274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1272. + 1273. rcu_read_lock(); + 1274. > iface = rcu_dereference(netlbl_unlhsh_def); + 1275. if (iface == NULL || !iface->valid) + 1276. goto unlabel_staticlistdef_return; + +kernel/trace/trace.h:1263: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1261. struct ring_buffer_event *event) + 1262. { + 1263. > if (this_cpu_read(trace_buffered_event) == event) { + 1264. /* Simply release the temp buffer */ + 1265. this_cpu_dec(trace_buffered_event_cnt); + +scripts/kconfig/symbol.c:1273: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1272 could be null and is dereferenced at line 1273, column 2. + 1271. + 1272. prop = sym_get_choice_prop(choice); + 1273. > expr_list_for_each_sym(prop->expr, e, sym) + 1274. sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); + 1275. + +drivers/gpu/drm/i915/intel_tv.c:1302: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 1300. + 1301. if (status == connector_status_connected) { + 1302. > intel_tv->type = type; + 1303. intel_tv_find_better_format(connector); + 1304. } + +net/ipv4/tcp_ipv4.c:1273: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1271. { + 1272. struct inet_request_sock *ireq = inet_rsk(req); + 1273. > struct net *net = sock_net(sk_listener); + 1274. + 1275. sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr); + +net/netfilter/nf_conntrack_sip.c:1293: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1276 could be null and is dereferenced at line 1293, column 6. + 1291. * request and compare it here. + 1292. */ + 1293. > if (ct_sip_info->register_cseq != cseq) + 1294. return NF_ACCEPT; + 1295. + +net/ipv6/addrconf.c:1327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1325. * idev->desync_factor if it's larger + 1326. */ + 1327. > cnf_temp_preferred_lft = READ_ONCE(idev->cnf.temp_prefered_lft); + 1328. max_desync_factor = min_t(__u32, + 1329. idev->cnf.max_desync_factor, + +kernel/time/hrtimer.c:1277: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1275. + 1276. do { + 1277. > base = READ_ONCE(timer->base); + 1278. seq = raw_read_seqcount_begin(&base->seq); + 1279. + +net/ipv4/route.c:1289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1287. return mtu; + 1288. + 1289. > mtu = READ_ONCE(dst->dev->mtu); + 1290. + 1291. if (unlikely(ip_mtu_locked(dst))) { + +net/wireless/trace.h:1280: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +block/bio.c:1312: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1310. + 1311. if (unlikely(offs & queue_dma_alignment(q))) { + 1312. > ret = -EINVAL; + 1313. j = 0; + 1314. } else { + +kernel/exit.c:1302: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1300. if (!unlikely(wo->wo_flags & WNOWAIT)) + 1301. p->signal->flags &= ~SIGNAL_STOP_CONTINUED; + 1302. > uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1303. spin_unlock_irq(&p->sighand->siglock); + 1304. + +drivers/usb/core/devio.c:1291: error: UNINITIALIZED_VALUE + The value read from gd.interface was never initialized. + 1289. if (copy_from_user(&gd, arg, sizeof(gd))) + 1290. return -EFAULT; + 1291. > intf = usb_ifnum_to_if(ps->dev, gd.interface); + 1292. if (!intf || !intf->dev.driver) + 1293. ret = -ENODATA; + +drivers/dma/dmaengine.c:1287: error: DEAD_STORE + The value written to &dma_sync_wait_timeout (type unsigned long) is never used. + 1285. dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx) + 1286. { + 1287. > unsigned long dma_sync_wait_timeout = jiffies + msecs_to_jiffies(5000); + 1288. + 1289. if (!tx) + +net/netfilter/nf_conntrack_netlink.c:1293: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 1291. struct hlist_nulls_node *n; + 1292. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 1293. > u_int8_t l3proto = nfmsg->nfgen_family; + 1294. int res; + 1295. int cpu; + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +net/sunrpc/auth_gss/svcauth_gss.c:1298: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1296. + 1297. WARN_ON_ONCE(type != 0 && type != 1); + 1298. > ret = cmpxchg(&sn->use_gss_proxy, -1, type); + 1299. if (ret != -1 && ret != type) + 1300. return -EBUSY; + +drivers/net/ethernet/marvell/sky2.c:1312: error: UNINITIALIZED_VALUE + The value read from rss_key[_] was never initialized. + 1310. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 1311. for (i = 0; i < nkeys; i++) + 1312. > sky2_write32(hw, SK_REG(sky2->port, RSS_KEY + i * 4), + 1313. rss_key[i]); + 1314. + +kernel/cgroup/cgroup-v1.c:1311: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 1310 could be null and is dereferenced at line 1311, column 22. + 1309. + 1310. for_each_subsys(ss, i) { + 1311. > if (strcmp(token, ss->name) && + 1312. strcmp(token, ss->legacy_name)) + 1313. continue; + +net/ipv4/fib_trie.c:1314: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1312. cindex = 0; + 1313. + 1314. > n = get_child_rcu(pn, cindex); + 1315. if (!n) + 1316. return -EAGAIN; + +net/ipv4/fib_trie.c:1355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1353. } + 1354. + 1355. > n = get_child_rcu(n, index); + 1356. if (unlikely(!n)) + 1357. goto backtrace; + +net/ipv4/fib_trie.c:1381: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1379. */ + 1380. + 1381. > while ((n = rcu_dereference(*cptr)) == NULL) { + 1382. backtrace: + 1383. #ifdef CONFIG_IP_FIB_TRIE_STATS + +net/ipv4/fib_trie.c:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. #endif + 1404. /* Get Child's index */ + 1405. > pn = node_parent_rcu(pn); + 1406. cindex = get_index(pkey, pn); + 1407. } + +net/ipv4/fib_trie.c:1422: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1420. + 1421. /* Step 3: Process the leaf, if that fails fall back to backtracing */ + 1422. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) { + 1423. struct fib_info *fi = fa->fa_info; + 1424. int nhsel, err; + +net/core/ethtool.c:1355: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1353. rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE) { + 1354. indir = (u32 *)rss_config; + 1355. > ret = ethtool_copy_validate_indir(indir, + 1356. useraddr + rss_cfg_offset, + 1357. &rx_rings, + +net/core/ethtool.c:1369: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1367. if (rxfh.key_size) { + 1368. hkey = rss_config + indir_bytes; + 1369. > if (copy_from_user(hkey, + 1370. useraddr + rss_cfg_offset + indir_bytes, + 1371. rxfh.key_size)) { + +net/core/dev.c:1304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1302. + 1303. rcu_read_lock(); + 1304. > alias = rcu_dereference(dev->ifalias); + 1305. if (alias) + 1306. ret = snprintf(name, len, "%s", alias->ifalias); + +net/wireless/trace.h:1298: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +scripts/kconfig/symbol.c:1318: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1317 could be null and is dereferenced by call to `prop_get_symbol()` at line 1318, column 25. + 1316. dep_stack_insert(&stack, sym); + 1317. prop = sym_get_choice_prop(sym); + 1318. > sym2 = sym_check_deps(prop_get_symbol(prop)); + 1319. dep_stack_remove(); + 1320. } else if (sym_is_choice(sym)) { + +net/ipv4/route.c:1303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1301. static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr) + 1302. { + 1303. > struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions); + 1304. struct fib_nh_exception *fnhe; + 1305. u32 hval; + +net/ipv4/route.c:1312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1310. hval = fnhe_hashfun(daddr); + 1311. + 1312. > for (fnhe = rcu_dereference(hash[hval].chain); fnhe; + 1313. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 1314. if (fnhe->fnhe_daddr == daddr) + +net/ipv4/route.c:1313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1311. + 1312. for (fnhe = rcu_dereference(hash[hval].chain); fnhe; + 1313. > fnhe = rcu_dereference(fnhe->fnhe_next)) { + 1314. if (fnhe->fnhe_daddr == daddr) + 1315. return fnhe; + +drivers/base/regmap/regmap.c:1313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1311. kfree(map->work_buf); + 1312. while (!list_empty(&map->async_free)) { + 1313. > async = list_first_entry_or_null(&map->async_free, + 1314. struct regmap_async, + 1315. list); + +block/blk-mq.c:1326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1324. * handle dispatched requests to this hctx + 1325. */ + 1326. > if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + +block/blk-mq.c:1329: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + 1329. > raw_smp_processor_id(), + 1330. cpumask_empty(hctx->cpumask) ? "inactive": "active"); + 1331. dump_stack(); + +block/blk-mq.c:1326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1324. * handle dispatched requests to this hctx + 1325. */ + 1326. > if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + +block/blk-mq.c:1328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1326. if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. > printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + 1329. raw_smp_processor_id(), + 1330. cpumask_empty(hctx->cpumask) ? "inactive": "active"); + +kernel/signal.c:1313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1311. success = 0; + 1312. retval = -ESRCH; + 1313. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 1314. int err = group_send_sig_info(sig, info, p); + 1315. success |= !err; + +lib/vsprintf.c:1316: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 1314. bool uc = false; + 1315. + 1316. > switch (*(++fmt)) { + 1317. case 'L': + 1318. uc = true; /* fall-through */ + +drivers/usb/host/ehci-hub.c:1313: error: DEAD_STORE + The value written to &portnum (type int) is never used. + 1311. if (ehci_is_TDI(ehci)) + 1312. return; + 1313. > set_owner(ehci, --portnum, PORT_OWNER); + 1314. } + 1315. + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +net/ipv6/ip6_fib.c:1330: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1328. dir = addr_bit_set(args->addr, fn->fn_bit); + 1329. + 1330. > next = dir ? rcu_dereference(fn->right) : + 1331. rcu_dereference(fn->left); + 1332. + +net/ipv6/ip6_fib.c:1331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1329. + 1330. next = dir ? rcu_dereference(fn->right) : + 1331. > rcu_dereference(fn->left); + 1332. + 1333. if (next) { + +net/ipv6/ip6_fib.c:1344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1342. + 1343. if (subtree || fn->fn_flags & RTN_RTINFO) { + 1344. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 1345. struct rt6key *key; + 1346. + +net/ipv6/ip6_fib.c:1370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1368. break; + 1369. + 1370. > fn = rcu_dereference(fn->parent); + 1371. } + 1372. + +kernel/rcu/tree.c:1321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1319. WRITE_ONCE(rsp->jiffies_stall, j + j1); + 1320. rsp->jiffies_resched = j + j1 / 2; + 1321. > rsp->n_force_qs_gpstart = READ_ONCE(rsp->n_force_qs); + 1322. } + 1323. + +block/genhd.c:1332: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1330. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1331. while ((hd = disk_part_iter_next(&piter))) { + 1332. > cpu = part_stat_lock(); + 1333. part_round_stats(gp->queue, cpu, hd); + 1334. part_stat_unlock(); + +block/genhd.c:1332: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1330. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1331. while ((hd = disk_part_iter_next(&piter))) { + 1332. > cpu = part_stat_lock(); + 1333. part_round_stats(gp->queue, cpu, hd); + 1334. part_stat_unlock(); + +security/selinux/ss/policydb.c:1331: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1329. goto bad; + 1330. + 1331. > len = le32_to_cpu(buf[0]); + 1332. len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1332: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1330. + 1331. len = le32_to_cpu(buf[0]); + 1332. > len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + 1334. + +security/selinux/ss/policydb.c:1333: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1331. len = le32_to_cpu(buf[0]); + 1332. len2 = le32_to_cpu(buf[1]); + 1333. > cladatum->value = le32_to_cpu(buf[2]); + 1334. + 1335. rc = symtab_init(&cladatum->permissions, PERM_SYMTAB_SIZE); + +security/selinux/ss/policydb.c:1338: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1336. if (rc) + 1337. goto bad; + 1338. > cladatum->permissions.nprim = le32_to_cpu(buf[3]); + 1339. nel = le32_to_cpu(buf[4]); + 1340. + +security/selinux/ss/policydb.c:1339: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1337. goto bad; + 1338. cladatum->permissions.nprim = le32_to_cpu(buf[3]); + 1339. > nel = le32_to_cpu(buf[4]); + 1340. + 1341. ncons = le32_to_cpu(buf[5]); + +security/selinux/ss/policydb.c:1341: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1339. nel = le32_to_cpu(buf[4]); + 1340. + 1341. > ncons = le32_to_cpu(buf[5]); + 1342. + 1343. rc = str_read(&key, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:1374: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1372. if (rc) + 1373. goto bad; + 1374. > ncons = le32_to_cpu(buf[0]); + 1375. rc = read_cons_helper(p, &cladatum->validatetrans, + 1376. ncons, 1, fp); + +security/selinux/ss/policydb.c:1386: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1384. goto bad; + 1385. + 1386. > cladatum->default_user = le32_to_cpu(buf[0]); + 1387. cladatum->default_role = le32_to_cpu(buf[1]); + 1388. cladatum->default_range = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1387: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1385. + 1386. cladatum->default_user = le32_to_cpu(buf[0]); + 1387. > cladatum->default_role = le32_to_cpu(buf[1]); + 1388. cladatum->default_range = le32_to_cpu(buf[2]); + 1389. } + +security/selinux/ss/policydb.c:1388: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1386. cladatum->default_user = le32_to_cpu(buf[0]); + 1387. cladatum->default_role = le32_to_cpu(buf[1]); + 1388. > cladatum->default_range = le32_to_cpu(buf[2]); + 1389. } + 1390. + +security/selinux/ss/policydb.c:1395: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1393. if (rc) + 1394. goto bad; + 1395. > cladatum->default_type = le32_to_cpu(buf[0]); + 1396. } + 1397. + +kernel/auditfilter.c:1325: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1323. if (list_empty(&audit_filter_list[listtype])) + 1324. goto unlock_and_return; + 1325. > list_for_each_entry_rcu(e, &audit_filter_list[listtype], list) { + 1326. int i, result = 0; + 1327. + +net/ipv4/route.c:1336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1334. else + 1335. porig = &fnhe->fnhe_rth_output; + 1336. > orig = rcu_dereference(*porig); + 1337. + 1338. if (fnhe->fnhe_genid != genid) { + +net/wireless/trace.h:1321: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/xfrm/xfrm_policy.c:1332: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1330. rcu_read_lock(); + 1331. for (i = 0; i < 2; i++) { + 1332. > p = rcu_dereference(osk->sk_policy[i]); + 1333. if (p) { + 1334. np = clone_policy(p, i); + +net/ipv4/tcp_ipv4.c:1365: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1363. newsk->sk_bound_dev_if = ireq->ir_iif; + 1364. newinet->inet_saddr = ireq->ir_loc_addr; + 1365. > inet_opt = rcu_dereference(ireq->ireq_opt); + 1366. RCU_INIT_POINTER(newinet->inet_opt, inet_opt); + 1367. newinet->mc_index = inet_iif(skb); + +ipc/sem.c:1361: error: DEAD_STORE + The value written to &err (type int) is never used. + 1359. goto out_rcu_wakeup; + 1360. + 1361. > err = -EACCES; + 1362. switch (cmd) { + 1363. case GETALL: + +kernel/exit.c:1342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1340. * can't confuse the checks below. + 1341. */ + 1342. > int exit_state = READ_ONCE(p->exit_state); + 1343. int ret; + 1344. + +kernel/sched/core.c:1425: error: UNINITIALIZED_VALUE + The value read from ncsw was never initialized. + 1423. } + 1424. + 1425. > return ncsw; + 1426. } + 1427. + +kernel/rcu/tree.c:1343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1341. + 1342. j = jiffies; + 1343. > gpa = READ_ONCE(rsp->gp_activity); + 1344. if (j - gpa > 2 * HZ) { + 1345. pr_err("%s kthread starved for %ld jiffies! g%lu c%lu f%#x %s(%d) ->state=%#lx ->cpu=%d\n", + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +arch/x86/events/intel/p4.c:1347: error: DEAD_STORE + The value written to &high (type unsigned int) is never used. + 1345. BUILD_BUG_ON(ARCH_P4_MAX_CCCR > INTEL_PMC_MAX_GENERIC); + 1346. + 1347. > rdmsr(MSR_IA32_MISC_ENABLE, low, high); + 1348. if (!(low & (1 << 7))) { + 1349. pr_cont("unsupported Netburst CPU model %d ", + +net/sunrpc/clnt.c:1349: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1347. + 1348. rcu_read_lock(); + 1349. > xprt = rcu_dereference(clnt->cl_xprt); + 1350. salen = xprt->addrlen; + 1351. memcpy(sap, &xprt->addr, salen); + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.altsetting was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +drivers/usb/core/devio.c:1349: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1347. if (copy_from_user(&setintf, arg, sizeof(setintf))) + 1348. return -EFAULT; + 1349. > ret = checkintf(ps, setintf.interface); + 1350. if (ret) + 1351. return ret; + +drivers/usb/core/devio.c:1353: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1351. return ret; + 1352. + 1353. > destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. return usb_set_interface(ps->dev, setintf.interface, + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +net/ipv4/devinet.c:1352: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1350. + 1351. rcu_read_lock(); + 1352. > for_each_netdev_rcu(net, dev) { + 1353. in_dev = __in_dev_get_rcu(dev); + 1354. if (in_dev) { + +net/wireless/trace.h:1343: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +kernel/sys.c:1356: error: UNINITIALIZED_VALUE + The value read from r32.rlim_cur was never initialized. + 1354. r.rlim_cur = RLIM_INFINITY; + 1355. else + 1356. > r.rlim_cur = r32.rlim_cur; + 1357. if (r32.rlim_max == COMPAT_RLIM_INFINITY) + 1358. r.rlim_max = RLIM_INFINITY; + +kernel/sys.c:1360: error: UNINITIALIZED_VALUE + The value read from r32.rlim_max was never initialized. + 1358. r.rlim_max = RLIM_INFINITY; + 1359. else + 1360. > r.rlim_max = r32.rlim_max; + 1361. return do_prlimit(current, resource, &r, NULL); + 1362. } + +net/ipv4/tcp_input.c:1473: error: DEAD_STORE + The value written to &pcount (type int) is never used. + 1471. len = skb->len; + 1472. if (skb_shift(prev, skb, len)) { + 1473. > pcount += tcp_skb_pcount(skb); + 1474. tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb), + 1475. len, mss, 0); + +net/ipv4/af_inet.c:1374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1372. + 1373. rcu_read_lock(); + 1374. > ops = rcu_dereference(inet_offloads[proto]); + 1375. if (!ops || !ops->callbacks.gro_receive) + 1376. goto out_unlock; + +net/packet/af_packet.c:1355: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1353. unsigned int num) + 1354. { + 1355. > return smp_processor_id() % num; + 1356. } + 1357. + +kernel/signal.c:1355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1353. struct task_struct *target) + 1354. { + 1355. > const struct cred *pcred = __task_cred(target); + 1356. if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) && + 1357. !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid)) + +kernel/events/core.c:1370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1368. local_irq_save(*flags); + 1369. rcu_read_lock(); + 1370. > ctx = rcu_dereference(task->perf_event_ctxp[ctxn]); + 1371. if (ctx) { + 1372. /* + +kernel/events/core.c:1383: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1381. */ + 1382. raw_spin_lock(&ctx->lock); + 1383. > if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) { + 1384. raw_spin_unlock(&ctx->lock); + 1385. rcu_read_unlock(); + +drivers/cpufreq/intel_pstate.c:1361: error: DEAD_STORE + The value written to &pstate (type int) is never used. + 1359. + 1360. update_turbo_state(); + 1361. > pstate = intel_pstate_get_base_pstate(cpu); + 1362. pstate = max(cpu->pstate.min_pstate, cpu->max_perf_ratio); + 1363. intel_pstate_set_pstate(cpu, pstate); + +net/netlink/af_netlink.c:1364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1362. + 1363. rcu_read_lock(); + 1364. > listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners); + 1365. + 1366. if (listeners && group - 1 < nl_table[sk->sk_protocol].groups) + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +net/sunrpc/clnt.c:1371: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1369. + 1370. rcu_read_lock(); + 1371. > xprt = rcu_dereference(clnt->cl_xprt); + 1372. if (xprt->ops->set_buffer_size) + 1373. xprt->ops->set_buffer_size(xprt, sndsize, rcvsize); + +net/sunrpc/auth_gss/auth_gss.c:1376: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1374. + 1375. rcu_read_lock(); + 1376. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1377. if (!ctx) + 1378. goto out; + +net/sunrpc/auth_gss/auth_gss.c:1392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1390. + 1391. rcu_read_lock(); + 1392. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1393. + 1394. /* did the ctx disappear or was it replaced by one with no acceptor? */ + +net/wireless/trace.h:1366: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/ipv4/route.c:1383: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1381. */ + 1382. dst_hold(&rt->dst); + 1383. > prev = cmpxchg(p, orig, rt); + 1384. if (prev == orig) { + 1385. if (orig) { + +drivers/usb/host/uhci-q.c:1385: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1383. uhci_remove_tds_from_frame(uhci, qh->iso_frame); + 1384. + 1385. > ctrlstat = td_status(uhci, td); + 1386. if (ctrlstat & TD_CTRL_ACTIVE) { + 1387. status = -EXDEV; /* TD was added too late? */ + +ipc/mqueue.c:1391: error: UNINITIALIZED_VALUE + The value read from v.mq_curmsgs was never initialized. + 1389. attr->mq_maxmsg = v.mq_maxmsg; + 1390. attr->mq_msgsize = v.mq_msgsize; + 1391. > attr->mq_curmsgs = v.mq_curmsgs; + 1392. return 0; + 1393. } + +ipc/mqueue.c:1388: error: UNINITIALIZED_VALUE + The value read from v.mq_flags was never initialized. + 1386. + 1387. memset(attr, 0, sizeof(*attr)); + 1388. > attr->mq_flags = v.mq_flags; + 1389. attr->mq_maxmsg = v.mq_maxmsg; + 1390. attr->mq_msgsize = v.mq_msgsize; + +ipc/mqueue.c:1389: error: UNINITIALIZED_VALUE + The value read from v.mq_maxmsg was never initialized. + 1387. memset(attr, 0, sizeof(*attr)); + 1388. attr->mq_flags = v.mq_flags; + 1389. > attr->mq_maxmsg = v.mq_maxmsg; + 1390. attr->mq_msgsize = v.mq_msgsize; + 1391. attr->mq_curmsgs = v.mq_curmsgs; + +ipc/mqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from v.mq_msgsize was never initialized. + 1388. attr->mq_flags = v.mq_flags; + 1389. attr->mq_maxmsg = v.mq_maxmsg; + 1390. > attr->mq_msgsize = v.mq_msgsize; + 1391. attr->mq_curmsgs = v.mq_curmsgs; + 1392. return 0; + +kernel/sched/rt.c:1394: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1392. + 1393. rcu_read_lock(); + 1394. > curr = READ_ONCE(rq->curr); /* unlocked access */ + 1395. + 1396. /* + +net/sunrpc/clnt.c:1388: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1386. + 1387. rcu_read_lock(); + 1388. > ret = rcu_dereference(clnt->cl_xprt)->xprt_net; + 1389. rcu_read_unlock(); + 1390. return ret; + +net/core/net-sysfs.c:1405: error: DEAD_STORE + The value written to &txq (type int) is never used. + 1403. if (error) + 1404. goto error; + 1405. > txq = real_tx; + 1406. + 1407. return 0; + +net/wireless/trace.h:1384: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +kernel/rcu/tree.c:1391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1389. if (!rcu_kick_kthreads) + 1390. return; + 1391. > j = READ_ONCE(rsp->jiffies_kick_kthreads); + 1392. if (time_after(jiffies, j) && rsp->gp_kthread && + 1393. (rcu_gp_in_progress(rsp) || READ_ONCE(rsp->gp_flags))) { + +arch/x86/events/intel/ds.c:1485: error: UNINITIALIZED_VALUE + The value read from counts[_] was never initialized. + 1483. + 1484. if (counts[bit]) { + 1485. > __intel_pmu_pebs_event(event, iregs, base, + 1486. top, bit, counts[bit]); + 1487. } + +arch/x86/events/intel/ds.c:1478: error: UNINITIALIZED_VALUE + The value read from error[_] was never initialized. + 1476. /* log dropped samples number */ + 1477. if (error[bit]) { + 1478. > perf_log_lost_samples(event, error[bit]); + 1479. + 1480. if (perf_event_account_interrupt(event)) + +drivers/gpu/drm/i915/intel_overlay.c:1429: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1427. if (IS_ERR(vma)) { + 1428. DRM_ERROR("failed to pin overlay register bo\n"); + 1429. > ret = PTR_ERR(vma); + 1430. goto out_free_bo; + 1431. } + +net/ipv6/route.c:1397: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1395. struct rt6_info *res = NULL; + 1396. + 1397. > bucket = rcu_dereference(rt->rt6i_exception_bucket); + 1398. + 1399. #ifdef CONFIG_IPV6_SUBTREES + +drivers/md/dm.c:1399: error: NULL_DEREFERENCE + pointer `tio` last assigned on line 1398 could be null and is dereferenced at line 1399, column 2. + 1397. + 1398. tio = alloc_tio(ci, ti, 0, GFP_NOIO); + 1399. > tio->len_ptr = len; + 1400. r = clone_bio(tio, bio, sector, *len); + 1401. if (r < 0) { + +scripts/kconfig/symbol.c:1403: error: NULL_DEREFERENCE + pointer `sym2` last assigned on line 1402 could be null and is dereferenced at line 1403, column 14. + 1401. for_all_properties(sym, prop, P_ENV) { + 1402. sym2 = prop_get_symbol(prop); + 1403. > if (strcmp(sym2->name, env)) + 1404. menu_warn(current_entry, "redefining environment symbol from %s", + 1405. sym2->name); + +net/ipv6/udp.c:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. if (static_key_false(&udpv6_encap_needed) && up->encap_type) { + 1404. void (*encap_destroy)(struct sock *sk); + 1405. > encap_destroy = READ_ONCE(up->encap_destroy); + 1406. if (encap_destroy) + 1407. encap_destroy(sk); + +block/blk-mq.c:1409: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1407. + 1408. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1409. > int cpu = get_cpu(); + 1410. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1411. __blk_mq_run_hw_queue(hctx); + +block/blk-mq.c:1409: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1407. + 1408. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1409. > int cpu = get_cpu(); + 1410. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1411. __blk_mq_run_hw_queue(hctx); + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1449: error: DEAD_STORE + The value written to &l (type int) is never used. + 1447. if (!ret_val) + 1448. good_cnt++; + 1449. > if (unlikely(++l == rxdr->count)) + 1450. l = 0; + 1451. /* time + 20 msecs (200 msecs on 2.4) is more than + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1435: error: DEAD_STORE + The value written to &time (type unsigned long) is never used. + 1433. E1000_WRITE_FLUSH(); + 1434. msleep(200); + 1435. > time = jiffies; /* set the start time for the receive */ + 1436. good_cnt = 0; + 1437. do { /* receive the sent packets */ + +net/netfilter/nf_conntrack_netlink.c:1407: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1405. int err; + 1406. + 1407. > parse_nat_setup = rcu_dereference(nfnetlink_parse_nat_setup_hook); + 1408. if (!parse_nat_setup) { + 1409. #ifdef CONFIG_MODULES + +net/netfilter/nf_conntrack_sip.c:1423: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1405 could be null and is dereferenced at line 1423, column 3. + 1421. port != ct->tuplehash[dir].tuple.src.u.udp.port && + 1422. nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3)) + 1423. > ct_sip_info->forced_dport = port; + 1424. + 1425. for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) { + +drivers/md/dm-raid1.c:1422: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1420. (unsigned long long)ms->nr_regions, buffer); + 1421. + 1422. > sz += log->type->status(log, type, result+sz, maxlen-sz); + 1423. + 1424. break; + +drivers/md/dm-raid1.c:1441: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1439. DMEMIT(" handle_errors"); + 1440. if (keep_log(ms)) + 1441. > DMEMIT(" keep_log"); + 1442. } + 1443. + +drivers/gpu/drm/i915/intel_runtime_pm.c:1425: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1423. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1424. + 1425. > if (wait_for(COND, 100)) + 1426. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1427. state, + +drivers/gpu/drm/i915/intel_runtime_pm.c:1425: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1423. vlv_punit_write(dev_priv, PUNIT_REG_DSPFREQ, ctrl); + 1424. + 1425. > if (wait_for(COND, 100)) + 1426. DRM_ERROR("timeout setting power well state %08x (%08x)\n", + 1427. state, + +net/sunrpc/clnt.c:1408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1406. + 1407. rcu_read_lock(); + 1408. > ret = rcu_dereference(clnt->cl_xprt)->max_payload; + 1409. rcu_read_unlock(); + 1410. return ret; + +drivers/gpu/drm/i915/i915_debugfs.c:1415: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1413. + 1414. for_each_fw_domain(fw_domain, i915, tmp) + 1415. > seq_printf(m, "%s.wake_count = %u\n", + 1416. intel_uncore_forcewake_domain_to_str(fw_domain->id), + 1417. READ_ONCE(fw_domain->wake_count)); + +drivers/gpu/vga/vgaarb.c:1468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1466. + 1467. if (!vga_default_device()) { + 1468. > vgadev = list_first_entry_or_null(&vga_list, + 1469. struct vga_device, list); + 1470. if (vgadev) { + +net/wireless/trace.h:1405: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +kernel/fork.c:1411: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1409. unsigned long cpu_limit; + 1410. + 1411. > cpu_limit = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); + 1412. if (cpu_limit != RLIM_INFINITY) { + 1413. sig->cputime_expires.prof_exp = cpu_limit * NSEC_PER_SEC; + +kernel/rcu/tree.c:1474: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1472. } else { + 1473. j = jiffies; + 1474. > gpa = READ_ONCE(rsp->gp_activity); + 1475. pr_err("All QSes seen, last %s kthread activity %ld (%ld-%ld), jiffies_till_next_fqs=%ld, root ->qsmask %#lx\n", + 1476. rsp->name, j - gpa, j, gpa, + +kernel/rcu/tree.c:1460: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1458. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1459. cpu)->cblist); + 1460. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1461. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1462. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +kernel/rcu/tree.c:1460: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1458. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1459. cpu)->cblist); + 1460. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1461. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1462. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +kernel/signal.c:1430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1428. struct task_struct * p; + 1429. + 1430. > for_each_process(p) { + 1431. if (task_pid_vnr(p) > 1 && + 1432. !same_thread_group(p, current)) { + +security/selinux/ss/policydb.c:1427: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1425. goto bad; + 1426. + 1427. > len = le32_to_cpu(buf[0]); + 1428. role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +security/selinux/ss/policydb.c:1428: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1426. + 1427. len = le32_to_cpu(buf[0]); + 1428. > role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1430. role->bounds = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1430: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1428. role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1430. > role->bounds = le32_to_cpu(buf[2]); + 1431. + 1432. rc = str_read(&key, GFP_KERNEL, fp, len); + +net/packet/af_packet.c:1419: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1417. + 1418. rcu_read_lock(); + 1419. > prog = rcu_dereference(f->bpf_prog); + 1420. if (prog) + 1421. ret = bpf_prog_run_clear_cb(prog, skb) % num; + +drivers/net/ethernet/broadcom/tg3.c:1421: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 1420 could be null and is dereferenced at line 1421, column 10. + 1419. + 1420. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 1421. > switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) { + 1422. case PHY_ID_BCM50610: + 1423. case PHY_ID_BCM50610M: + +net/ipv6/ip6_fib.c:1425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1423. + 1424. for (fn = root; fn ; ) { + 1425. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 1426. struct rt6key *key; + 1427. + +net/ipv6/ip6_fib.c:1455: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1453. */ + 1454. if (addr_bit_set(addr, fn->fn_bit)) + 1455. > fn = rcu_dereference(fn->right); + 1456. else + 1457. fn = rcu_dereference(fn->left); + +net/ipv6/ip6_fib.c:1457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1455. fn = rcu_dereference(fn->right); + 1456. else + 1457. > fn = rcu_dereference(fn->left); + 1458. } + 1459. out: + +net/ipv6/route.c:1430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1428. return -EINVAL; + 1429. + 1430. > if (!rcu_access_pointer(from->rt6i_exception_bucket)) + 1431. return -ENOENT; + 1432. + +net/sunrpc/clnt.c:1424: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1422. + 1423. rcu_read_lock(); + 1424. > xprt = rcu_dereference(clnt->cl_xprt); + 1425. ret = xprt->ops->bc_maxpayload(xprt); + 1426. rcu_read_unlock(); + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1431: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1429. return -EFAULT; + 1430. + 1431. > if (tmp.oldlenp && get_user(oldlen, tmp.oldlenp)) + 1432. return -EFAULT; + 1433. + +kernel/sysctl_binary.c:1442: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1440. } + 1441. + 1442. > if (tmp.oldlenp && put_user(oldlen, tmp.oldlenp)) + 1443. return -EFAULT; + 1444. + +drivers/gpu/drm/i915/intel_tv.c:1432: error: NULL_DEREFERENCE + pointer `old_state` last assigned on line 1429 could be null and is dereferenced at line 1432, column 6. + 1430. new_crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc); + 1431. + 1432. > if (old_state->tv.mode != new_state->tv.mode || + 1433. old_state->tv.margins.left != new_state->tv.margins.left || + 1434. old_state->tv.margins.right != new_state->tv.margins.right || + +net/wireless/trace.h:1421: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/sunrpc/auth_gss/auth_gss.c:1430: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 1428. struct gss_cred *gss_cred = container_of(rc, struct gss_cred, gc_base); + 1429. struct gss_cl_ctx *ctx; + 1430. > unsigned long timeout = jiffies + (gss_key_expire_timeo * HZ); + 1431. int ret = 0; + 1432. + +net/sunrpc/auth_gss/auth_gss.c:1434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1432. + 1433. rcu_read_lock(); + 1434. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1435. if (!ctx || time_after(timeout, ctx->gc_expiry)) + 1436. ret = -EACCES; + +drivers/block/loop.c:1442: error: UNINITIALIZED_VALUE + The value read from info.lo_device was never initialized. + 1440. memset(info64, 0, sizeof(*info64)); + 1441. info64->lo_number = info.lo_number; + 1442. > info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + +drivers/block/loop.c:1448: error: UNINITIALIZED_VALUE + The value read from info.lo_encrypt_key_size was never initialized. + 1446. info64->lo_sizelimit = 0; + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. > info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. info64->lo_flags = info.lo_flags; + 1450. info64->lo_init[0] = info.lo_init[0]; + +drivers/block/loop.c:1447: error: UNINITIALIZED_VALUE + The value read from info.lo_encrypt_type was never initialized. + 1445. info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + 1447. > info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. info64->lo_flags = info.lo_flags; + +drivers/block/loop.c:1449: error: UNINITIALIZED_VALUE + The value read from info.lo_flags was never initialized. + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. > info64->lo_flags = info.lo_flags; + 1450. info64->lo_init[0] = info.lo_init[0]; + 1451. info64->lo_init[1] = info.lo_init[1]; + +drivers/block/loop.c:1443: error: UNINITIALIZED_VALUE + The value read from info.lo_inode was never initialized. + 1441. info64->lo_number = info.lo_number; + 1442. info64->lo_device = info.lo_device; + 1443. > info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + 1445. info64->lo_offset = info.lo_offset; + +drivers/block/loop.c:1441: error: UNINITIALIZED_VALUE + The value read from info.lo_number was never initialized. + 1439. + 1440. memset(info64, 0, sizeof(*info64)); + 1441. > info64->lo_number = info.lo_number; + 1442. info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + +drivers/block/loop.c:1445: error: UNINITIALIZED_VALUE + The value read from info.lo_offset was never initialized. + 1443. info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + 1445. > info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + +drivers/block/loop.c:1444: error: UNINITIALIZED_VALUE + The value read from info.lo_rdevice was never initialized. + 1442. info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + 1444. > info64->lo_rdevice = info.lo_rdevice; + 1445. info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + +net/packet/af_packet.c:1436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1434. { + 1435. struct packet_fanout *f = pt->af_packet_priv; + 1436. > unsigned int num = READ_ONCE(f->num_members); + 1437. struct net *net = read_pnet(&f->net); + 1438. struct packet_sock *po; + +net/sunrpc/clnt.c:1440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1438. if (clnt->cl_autobind) { + 1439. rcu_read_lock(); + 1440. > xprt_clear_bound(rcu_dereference(clnt->cl_xprt)); + 1441. rcu_read_unlock(); + 1442. } + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +drivers/base/regmap/regmap.c:1533: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1531. + 1532. spin_lock_irqsave(&map->async_lock, flags); + 1533. > async = list_first_entry_or_null(&map->async_free, + 1534. struct regmap_async, + 1535. list); + +kernel/sched/core.c:1447: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1445. preempt_disable(); + 1446. cpu = task_cpu(p); + 1447. > if ((cpu != smp_processor_id()) && task_curr(p)) + 1448. smp_send_reschedule(cpu); + 1449. preempt_enable(); + +net/wireless/trace.h:1441: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/sunrpc/auth_gss/auth_gss.c:1453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1451. /* Don't match with creds that have expired. */ + 1452. rcu_read_lock(); + 1453. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1454. if (!ctx || time_after(jiffies, ctx->gc_expiry)) { + 1455. rcu_read_unlock(); + +net/ipv4/ipmr.c:1467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1465. } + 1466. if (optname != MRT_INIT) { + 1467. > if (sk != rcu_access_pointer(mrt->mroute_sk) && + 1468. !ns_capable(net->user_ns, CAP_NET_ADMIN)) { + 1469. ret = -EACCES; + +net/ipv4/ipmr.c:1496: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1494. break; + 1495. case MRT_DONE: + 1496. > if (sk != rcu_access_pointer(mrt->mroute_sk)) { + 1497. ret = -EACCES; + 1498. } else { + +net/ipv4/ipmr.c:1542: error: UNINITIALIZED_VALUE + The value read from mfc.mfcc_parent was never initialized. + 1540. } + 1541. if (parent == 0) + 1542. > parent = mfc.mfcc_parent; + 1543. if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY) + 1544. ret = ipmr_mfc_delete(mrt, &mfc, parent); + +net/ipv4/ipmr.c:1521: error: UNINITIALIZED_VALUE + The value read from vif.vifc_vifi was never initialized. + 1519. sk == rtnl_dereference(mrt->mroute_sk)); + 1520. } else { + 1521. > ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL); + 1522. } + 1523. break; + +net/ipv4/devinet.c:1466: error: DEAD_STORE + The value written to &in_dev (type in_device*) is never used. + 1464. /* Re-enabling IP */ + 1465. if (inetdev_valid_mtu(dev->mtu)) + 1466. > in_dev = inetdev_init(dev); + 1467. } + 1468. goto out; + +drivers/gpu/drm/drm_vblank.c:1550: error: DEAD_STORE + The value written to &end (type unsigned long) is never used. + 1548. DRM_DEBUG("waiting on vblank count %llu, crtc %u\n", + 1549. req_seq, pipe); + 1550. > DRM_WAIT_ON(ret, vblank->queue, 3 * HZ, + 1551. vblank_passed(drm_vblank_count(dev, pipe), + 1552. req_seq) || + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +drivers/gpu/drm/i915/i915_debugfs.c:1463: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1461. int count = 0; + 1462. + 1463. > forcewake_count = READ_ONCE(dev_priv->uncore.fw_domain[FW_DOMAIN_ID_RENDER].wake_count); + 1464. if (forcewake_count) { + 1465. seq_puts(m, "RC information inaccurate because somebody " + +net/netfilter/nf_conntrack_sip.c:1468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1466. + 1467. if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) { + 1468. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1469. if (hooks && !hooks->msg(skb, protoff, dataoff, + 1470. dptr, datalen)) { + +kernel/kprobes.c:1467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1465. + 1466. if (p != ap) { + 1467. > list_for_each_entry_rcu(list_p, &ap->list, list) + 1468. if (list_p == p) + 1469. /* kprobe p is a valid probe */ + +kernel/trace/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1459. static inline void *event_file_data(struct file *filp) + 1460. { + 1461. > return READ_ONCE(file_inode(filp)->i_private); + 1462. } + 1463. + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.name was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1480: error: UNINITIALIZED_VALUE + The value read from tmp.newval was never initialized. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. > compat_ptr(tmp.newval), tmp.newlen); + 1481. + 1482. if (result >= 0) { + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1474: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1472. return -EFAULT; + 1473. + 1474. > compat_oldlenp = compat_ptr(tmp.oldlenp); + 1475. if (compat_oldlenp && get_user(oldlen, compat_oldlenp)) + 1476. return -EFAULT; + +kernel/sysctl_binary.c:1479: error: UNINITIALIZED_VALUE + The value read from tmp.oldval was never initialized. + 1477. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. > compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + 1481. + +net/wireless/trace.h:1461: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +drivers/net/ethernet/intel/e100.c:1472: error: DEAD_STORE + The value written to &stat (type unsigned short) is never used. + 1470. nic->mii.phy_id = (addr == 0) ? 1 : (addr == 1) ? 0 : addr; + 1471. bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR); + 1472. > stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1473. stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1474. if (!((bmcr == 0xFFFF) || ((stat == 0) && (bmcr == 0)))) + +kernel/trace/trace_events_trigger.c:1472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1470. int ret = 0; + 1471. + 1472. > list_for_each_entry_rcu(test, &file->triggers, list) { + 1473. test_enable_data = test->private_data; + 1474. if (test_enable_data && + +net/ipv6/route.c:1475: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1473. + 1474. rcu_read_lock(); + 1475. > bucket = rcu_dereference(from->rt6i_exception_bucket); + 1476. + 1477. #ifdef CONFIG_IPV6_SUBTREES + +net/netlabel/netlabel_unlabeled.c:1472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1470. iface = netlbl_unlhsh_search_iface(skb->skb_iif); + 1471. if (iface == NULL) + 1472. > iface = rcu_dereference(netlbl_unlhsh_def); + 1473. if (iface == NULL || !iface->valid) + 1474. goto unlabel_getattr_nolabel; + +security/selinux/ss/policydb.c:1483: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1481. goto bad; + 1482. + 1483. > len = le32_to_cpu(buf[0]); + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + +security/selinux/ss/policydb.c:1484: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1482. + 1483. len = le32_to_cpu(buf[0]); + 1484. > typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + 1486. u32 prop = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1486: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + 1486. > u32 prop = le32_to_cpu(buf[2]); + 1487. + 1488. if (prop & TYPEDATUM_PROPERTY_PRIMARY) + +security/selinux/ss/policydb.c:1493: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1491. typdatum->attribute = 1; + 1492. + 1493. > typdatum->bounds = le32_to_cpu(buf[3]); + 1494. } else { + 1495. typdatum->primary = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1495: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1493. typdatum->bounds = le32_to_cpu(buf[3]); + 1494. } else { + 1495. > typdatum->primary = le32_to_cpu(buf[2]); + 1496. } + 1497. + +net/core/rtnetlink.c:1481: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1479. return -EMSGSIZE; + 1480. + 1481. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 1482. struct nlattr *af; + 1483. int err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1496: error: DEAD_STORE + The value written to &c (type char) is never used. + 1494. end = addr + size; + 1495. for (; addr < end; addr += PAGE_SIZE) { + 1496. > int err = __get_user(c, addr); + 1497. if (err) + 1498. return err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1500: error: DEAD_STORE + The value written to &c (type char) is never used. + 1498. return err; + 1499. } + 1500. > return __get_user(c, end - 1); + 1501. } + 1502. + +net/netfilter/nf_conntrack_sip.c:1555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1553. const struct nf_nat_sip_hooks *hooks; + 1554. + 1555. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1556. if (hooks) + 1557. hooks->seq_adjust(skb, protoff, tdiff); + +drivers/cpufreq/intel_pstate.c:1485: error: DEAD_STORE + The value written to &max_pstate (type int) is never used. + 1483. static int intel_pstate_prepare_request(struct cpudata *cpu, int pstate) + 1484. { + 1485. > int max_pstate = intel_pstate_get_base_pstate(cpu); + 1486. int min_pstate; + 1487. + +sound/core/control.c:1511: error: UNINITIALIZED_VALUE + The value read from header.length was never initialized. + 1509. if (header.length < sizeof(unsigned int) * 2) + 1510. return -EINVAL; + 1511. > container_size = header.length; + 1512. container = buf->tlv; + 1513. + +sound/core/control.c:1514: error: UNINITIALIZED_VALUE + The value read from header.numid was never initialized. + 1512. container = buf->tlv; + 1513. + 1514. > kctl = snd_ctl_find_numid(file->card, header.numid); + 1515. if (kctl == NULL) + 1516. return -ENOENT; + +kernel/rcu/tree.c:1512: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1510. print_cpu_stall_info_begin(); + 1511. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1512. > print_cpu_stall_info(rsp, smp_processor_id()); + 1513. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1514. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1541: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1539. * switches for an entirely unreasonable amount of time. + 1540. */ + 1541. > resched_cpu(smp_processor_id()); + 1542. } + 1543. + +kernel/rcu/tree.c:1512: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1510. print_cpu_stall_info_begin(); + 1511. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1512. > print_cpu_stall_info(rsp, smp_processor_id()); + 1513. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1514. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1541: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1539. * switches for an entirely unreasonable amount of time. + 1540. */ + 1541. > resched_cpu(smp_processor_id()); + 1542. } + 1543. + +net/core/net-sysfs.c:1501: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1499. * device is dead and about to be freed. + 1500. */ + 1501. > kfree(rcu_access_pointer(dev->ifalias)); + 1502. netdev_freemem(dev); + 1503. } + +security/keys/keyctl.c:1540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1538. * there's no point */ + 1539. mycred = current_cred(); + 1540. > pcred = __task_cred(parent); + 1541. if (mycred == pcred || + 1542. mycred->session_keyring == pcred->session_keyring) { + +net/ipv4/netfilter/ip_tables.c:1516: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1514. tmp.name[sizeof(tmp.name)-1] = 0; + 1515. + 1516. > newinfo = xt_alloc_table_info(tmp.size); + 1517. if (!newinfo) + 1518. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1521: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1519. + 1520. loc_cpu_entry = newinfo->entries; + 1521. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1522. tmp.size) != 0) { + 1523. ret = -EFAULT; + +kernel/cgroup/cpuset.c:1503: error: DEAD_STORE + The value written to &cs (type cpuset*) is never used. + 1501. + 1502. cgroup_taskset_first(tset, &css); + 1503. > cs = css_cs(css); + 1504. + 1505. mutex_lock(&cpuset_mutex); + +kernel/trace/trace_events_trigger.c:1512: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1510. bool unregistered = false; + 1511. + 1512. > list_for_each_entry_rcu(data, &file->triggers, list) { + 1513. enable_data = data->private_data; + 1514. if (enable_data && + +net/ipv6/netfilter/ip6_tables.c:1526: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1524. tmp.name[sizeof(tmp.name)-1] = 0; + 1525. + 1526. > newinfo = xt_alloc_table_info(tmp.size); + 1527. if (!newinfo) + 1528. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1531: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1529. + 1530. loc_cpu_entry = newinfo->entries; + 1531. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1532. tmp.size) != 0) { + 1533. ret = -EFAULT; + +net/wireless/trace.h:1506: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +kernel/trace/ring_buffer.c:1549: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1547. first_page->prev = prev_page; + 1548. + 1549. > r = cmpxchg(&prev_page->next, head_page_with_bit, first_page); + 1550. + 1551. if (r == head_page_with_bit) { + +drivers/hid/hid-sony.c:1645: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1643. err_stop: + 1644. kfree(buf); + 1645. > return ret; + 1646. } + 1647. + +net/ipv4/ip_output.c:1518: error: DEAD_STORE + The value written to &rt (type rtable*) is never used. + 1516. struct ipcm_cookie ipc; + 1517. struct flowi4 fl4; + 1518. > struct rtable *rt = skb_rtable(skb); + 1519. struct net *net = sock_net(sk); + 1520. struct sk_buff *nskb; + +net/netfilter/nf_conntrack_netlink.c:1532: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1530. if (help) { + 1531. rcu_read_lock(); + 1532. > helper = rcu_dereference(help->helper); + 1533. if (helper && !strcmp(helper->name, helpname)) + 1534. err = 0; + +net/ipv4/tcp_ipv4.c:1541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1539. skb->destructor = sock_edemux; + 1540. if (sk_fullsock(sk)) { + 1541. > struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst); + 1542. + 1543. if (dst) + +security/selinux/ss/policydb.c:1528: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1526. return rc; + 1527. } + 1528. > lp->sens = le32_to_cpu(buf[0]); + 1529. + 1530. rc = ebitmap_read(&lp->cat, fp); + +kernel/time/timer.c:1521: error: DEAD_STORE + The value written to &base (type timer_base*) is never used. + 1519. u64 get_next_timer_interrupt(unsigned long basej, u64 basem) + 1520. { + 1521. > struct timer_base *base = this_cpu_ptr(&timer_bases[BASE_STD]); + 1522. u64 expires = KTIME_MAX; + 1523. unsigned long nextevt; + +kernel/time/timer.c:1530: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1528. * Possible pending timers will be migrated later to an active cpu. + 1529. */ + 1530. > if (cpu_is_offline(smp_processor_id())) + 1531. return expires; + 1532. + +kernel/time/timer.c:1530: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1528. * Possible pending timers will be migrated later to an active cpu. + 1529. */ + 1530. > if (cpu_is_offline(smp_processor_id())) + 1531. return expires; + 1532. + +net/ipv4/af_inet.c:1538: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1536. + 1537. rcu_read_lock(); + 1538. > ops = rcu_dereference(inet_offloads[proto]); + 1539. if (WARN_ON(!ops || !ops->callbacks.gro_complete)) + 1540. goto out_unlock; + +net/wireless/trace.h:1524: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +drivers/pci/setup-bus.c:1532: error: DEAD_STORE + The value written to &idx (type int) is never used. + 1530. unsigned old_flags = 0; + 1531. struct resource *b_res; + 1532. > int idx = 1; + 1533. + 1534. b_res = &dev->resource[PCI_BRIDGE_RESOURCES]; + +kernel/events/uprobes.c:1532: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1530. + 1531. /* Pairs with xol_add_vma() smp_store_release() */ + 1532. > area = READ_ONCE(current->mm->uprobes_state.xol_area); /* ^^^ */ + 1533. if (area) + 1534. trampoline_vaddr = area->vaddr; + +drivers/cpufreq/intel_pstate.c:1534: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1532. + 1533. /* Don't allow remote callbacks */ + 1534. > if (smp_processor_id() != cpu->cpu) + 1535. return; + 1536. + +net/core/ethtool.c:1560: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1558. return -ENOMEM; + 1559. + 1560. > bytes_remaining = eeprom.len; + 1561. while (bytes_remaining > 0) { + 1562. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +security/selinux/ss/policydb.c:1557: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1555. goto bad; + 1556. + 1557. > len = le32_to_cpu(buf[0]); + 1558. usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +security/selinux/ss/policydb.c:1558: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1556. + 1557. len = le32_to_cpu(buf[0]); + 1558. > usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1560. usrdatum->bounds = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1560: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1558. usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1560. > usrdatum->bounds = le32_to_cpu(buf[2]); + 1561. + 1562. rc = str_read(&key, GFP_KERNEL, fp, len); + +kernel/sys.c:1548: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1546. return 0; + 1547. + 1548. > tcred = __task_cred(task); + 1549. id_match = (uid_eq(cred->uid, tcred->euid) && + 1550. uid_eq(cred->uid, tcred->suid) && + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +kernel/rcu/tree.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. * and rsp->gp_start suffice to forestall false positives. + 1575. */ + 1576. > gpnum = READ_ONCE(rsp->gpnum); + 1577. smp_rmb(); /* Pick up ->gpnum first... */ + 1578. js = READ_ONCE(rsp->jiffies_stall); + +kernel/rcu/tree.c:1578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1576. gpnum = READ_ONCE(rsp->gpnum); + 1577. smp_rmb(); /* Pick up ->gpnum first... */ + 1578. > js = READ_ONCE(rsp->jiffies_stall); + 1579. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1580. gps = READ_ONCE(rsp->gp_start); + +kernel/rcu/tree.c:1580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1578. js = READ_ONCE(rsp->jiffies_stall); + 1579. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1580. > gps = READ_ONCE(rsp->gp_start); + 1581. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1582. completed = READ_ONCE(rsp->completed); + +kernel/rcu/tree.c:1582: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1580. gps = READ_ONCE(rsp->gp_start); + 1581. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1582. > completed = READ_ONCE(rsp->completed); + 1583. if (ULONG_CMP_GE(completed, gpnum) || + 1584. ULONG_CMP_LT(j, js) || + +drivers/base/power/runtime.c:1552: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1550. idx = device_links_read_lock(); + 1551. + 1552. > list_for_each_entry_rcu(link, &dev->links.consumers, s_node) { + 1553. if (link->flags & DL_FLAG_STATELESS) + 1554. continue; + +net/wireless/trace.h:1545: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/xfrm/xfrm_policy.c:1638: error: NULL_DEREFERENCE + pointer `xdst_prev` last assigned on line 1559 could be null and is dereferenced by call to `xfrm_dst_set_child()` at line 1638, column 2. + 1636. } + 1637. + 1638. > xfrm_dst_set_child(xdst_prev, dst); + 1639. xdst0->path = dst; + 1640. + +net/wireless/util.c:1579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1577. if (params->radar_detect) { + 1578. rcu_read_lock(); + 1579. > regdom = rcu_dereference(cfg80211_regdomain); + 1580. if (regdom) + 1581. region = regdom->dfs_region; + +arch/x86/events/intel/ds.c:1554: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1552. void perf_restore_debug_store(void) + 1553. { + 1554. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 1555. + 1556. if (!x86_pmu.bts && !x86_pmu.pebs) + +arch/x86/events/intel/ds.c:1554: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1552. void perf_restore_debug_store(void) + 1553. { + 1554. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 1555. + 1556. if (!x86_pmu.bts && !x86_pmu.pebs) + +net/core/sock.c:1565: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1563. sk->sk_destruct(sk); + 1564. + 1565. > filter = rcu_dereference_check(sk->sk_filter, + 1566. refcount_read(&sk->sk_wmem_alloc) == 0); + 1567. if (filter) { + +net/core/sock.c:1571: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1569. RCU_INIT_POINTER(sk->sk_filter, NULL); + 1570. } + 1571. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1572. reuseport_detach_sock(sk); + 1573. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +net/wireless/trace.h:1564: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +include/linux/blkdev.h:1571: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1569. { + 1570. unsigned int granularity = max(lim->physical_block_size, lim->io_min); + 1571. > unsigned int alignment = sector_div(sector, granularity >> 9) << 9; + 1572. + 1573. return (granularity + lim->alignment_offset - alignment) % granularity; + +net/ipv6/route.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. int i; + 1575. + 1576. > if (!rcu_access_pointer(rt->rt6i_exception_bucket)) + 1577. return; + 1578. + +drivers/base/power/runtime.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. idx = device_links_read_lock(); + 1575. + 1576. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1577. if (link->flags & DL_FLAG_PM_RUNTIME) + 1578. pm_runtime_get_sync(link->supplier); + +kernel/sched/deadline.c:1586: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1584. + 1585. rcu_read_lock(); + 1586. > curr = READ_ONCE(rq->curr); /* unlocked access */ + 1587. + 1588. /* + +net/core/net-sysfs.c:1596: error: DEAD_STORE + The value written to &groups (type attribute_group const **) is never used. + 1594. #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211) + 1595. if (ndev->ieee80211_ptr) + 1596. > *groups++ = &wireless_group; + 1597. #if IS_ENABLED(CONFIG_WIRELESS_EXT) + 1598. else if (ndev->wireless_handlers) + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +net/ipv4/fib_semantics.c:1594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1592. u8 last_tos = 0; + 1593. + 1594. > hlist_for_each_entry_rcu(fa, fa_head, fa_list) { + 1595. struct fib_info *next_fi = fa->fa_info; + 1596. + +drivers/gpu/drm/i915/intel_engine_cs.c:1601: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1599. * are truly idle. + 1600. */ + 1601. > if (wait_for(intel_engine_is_idle(engine), 10)) { + 1602. struct drm_printer p = drm_debug_printer(__func__); + 1603. + +drivers/gpu/drm/i915/intel_engine_cs.c:1601: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1599. * are truly idle. + 1600. */ + 1601. > if (wait_for(intel_engine_is_idle(engine), 10)) { + 1602. struct drm_printer p = drm_debug_printer(__func__); + 1603. + +drivers/base/power/runtime.c:1594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1592. idx = device_links_read_lock(); + 1593. + 1594. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1595. if (link->flags & DL_FLAG_PM_RUNTIME) + 1596. pm_runtime_put(link->supplier); + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +net/wireless/trace.h:1587: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1585. ); + 1586. + 1587. > DECLARE_EVENT_CLASS(tx_rx_evt, + 1588. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1589. TP_ARGS(wiphy, rx, tx), + +security/selinux/ss/policydb.c:1604: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1602. goto bad; + 1603. + 1604. > len = le32_to_cpu(buf[0]); + 1605. levdatum->isalias = le32_to_cpu(buf[1]); + 1606. + +security/selinux/ss/policydb.c:1605: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1603. + 1604. len = le32_to_cpu(buf[0]); + 1605. > levdatum->isalias = le32_to_cpu(buf[1]); + 1606. + 1607. rc = str_read(&key, GFP_ATOMIC, fp, len); + +net/ipv4/fib_trie.c:1607: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1605. + 1606. /* descend into the next child */ + 1607. > n = get_child_rcu(pn, cindex++); + 1608. if (!n) + 1609. break; + +net/ipv4/fib_trie.c:1622: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1620. t_key pkey = pn->key; + 1621. + 1622. > pn = node_parent_rcu(pn); + 1623. cindex = get_index(pkey, pn) + 1; + 1624. continue; + +net/ipv4/fib_trie.c:1628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1626. + 1627. /* grab the next available node */ + 1628. > n = get_child_rcu(pn, cindex++); + 1629. if (!n) + 1630. continue; + +drivers/gpu/drm/drm_dp_mst_topology.c:1605: error: DEAD_STORE + The value written to &len (type int) is never used. + 1603. + 1604. txmsg->dst = mstb; + 1605. > len = build_link_address(txmsg); + 1606. + 1607. mstb->link_address_sent = true; + +net/ipv6/addrconf.c:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx]; + 1603. + 1604. > list_for_each_entry_rcu(score->ifa, &idev->addr_list, if_list) { + 1605. int i; + 1606. + +net/sunrpc/auth_gss/svcauth_gss.c:1616: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1614. BUG_ON(integ_len % 4); + 1615. *p++ = htonl(integ_len); + 1616. > *p++ = htonl(gc->gc_seq); + 1617. if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset, integ_len)) { + 1618. WARN_ON_ONCE(1); + +include/linux/blkdev.h:1611: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1609. + 1610. /* Offset of the partition start in 'granularity' sectors */ + 1611. > offset = sector_div(sector, granularity); + 1612. + 1613. /* And why do we do this modulus *again* in blkdev_issue_discard()? */ + +net/core/ethtool.c:1625: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1623. return -ENOMEM; + 1624. + 1625. > bytes_remaining = eeprom.len; + 1626. while (bytes_remaining > 0) { + 1627. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +kernel/printk/printk.c:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. + 1603. raw_spin_lock(&console_owner_lock); + 1604. > waiter = READ_ONCE(console_waiter); + 1605. console_owner = NULL; + 1606. raw_spin_unlock(&console_owner_lock); + +net/ipv6/tcp_ipv6.c:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. skb->destructor = sock_edemux; + 1630. if (sk_fullsock(sk)) { + 1631. > struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst); + 1632. + 1633. if (dst) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +drivers/scsi/scsi_transport_spi.c:1625: error: DEAD_STORE + The value written to &error (type int) is never used. + 1623. if (error) + 1624. return error; + 1625. > error = anon_transport_class_register(&spi_device_class); + 1626. return transport_class_register(&spi_host_class); + 1627. } + +drivers/scsi/sd.c:1636: error: UNINITIALIZED_VALUE + The value read from res was never initialized. + 1634. + 1635. if (res) { + 1636. > sd_print_result(sdkp, "Synchronize Cache(10) failed", res); + 1637. + 1638. if (driver_byte(res) & DRIVER_SENSE) + +kernel/cgroup/cpuset.c:1614: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1609 could be null and is dereferenced by call to `is_cpuset_online()` at line 1614, column 7. + 1612. + 1613. mutex_lock(&cpuset_mutex); + 1614. > if (!is_cpuset_online(cs)) { + 1615. retval = -ENODEV; + 1616. goto out_unlock; + +net/wireless/trace.h:1609: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1607. ); + 1608. + 1609. > DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, + 1610. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1611. TP_ARGS(wiphy, netdev, id), + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from fault_reason was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from guest_addr was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from source_id was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/clk/clk.c:1635: error: DEAD_STORE + The value written to &best_parent_rate (type unsigned long) is never used. + 1633. parent = old_parent = core->parent; + 1634. if (parent) + 1635. > best_parent_rate = parent->rate; + 1636. + 1637. clk_core_get_boundaries(core, &min_rate, &max_rate); + +drivers/gpu/drm/i915/intel_cdclk.c:1628: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1626. + 1627. /* Timeout 200us */ + 1628. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1629. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1630. + +drivers/gpu/drm/i915/intel_cdclk.c:1628: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1626. + 1627. /* Timeout 200us */ + 1628. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) == 0, 1)) + 1629. DRM_ERROR("timout waiting for CDCLK PLL unlock\n"); + 1630. + +kernel/sched/core.c:1640: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1638. __schedstat_inc(p->se.statistics.nr_wakeups_remote); + 1639. rcu_read_lock(); + 1640. > for_each_domain(rq->cpu, sd) { + 1641. if (cpumask_test_cpu(cpu, sched_domain_span(sd))) { + 1642. __schedstat_inc(sd->ttwu_wake_remote); + +kernel/sched/rt.c:1660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1658. + 1659. rcu_read_lock(); + 1660. > for_each_domain(cpu, sd) { + 1661. if (sd->flags & SD_WAKE_AFFINE) { + 1662. int best_cpu; + +kernel/sched/rt.c:1628: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1626. struct sched_domain *sd; + 1627. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1628. > int this_cpu = smp_processor_id(); + 1629. int cpu = task_cpu(task); + 1630. + +kernel/sched/rt.c:1628: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1626. struct sched_domain *sd; + 1627. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1628. > int this_cpu = smp_processor_id(); + 1629. int cpu = task_cpu(task); + 1630. + +net/unix/af_unix.c:1707: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 1705. goto out_free; + 1706. + 1707. > other = unix_find_other(net, sunaddr, namelen, sk->sk_type, + 1708. hash, &err); + 1709. if (other == NULL) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +kernel/kprobes.c:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. struct kprobe *kp; + 1630. + 1631. > list_for_each_entry_rcu(kp, &ap->list, list) + 1632. if (!kprobe_disabled(kp)) + 1633. /* + +drivers/scsi/scsi_lib.c:1631: error: DEAD_STORE + The value written to &wait_for (type unsigned long) is never used. + 1629. { + 1630. struct scsi_cmnd *cmd = blk_mq_rq_to_pdu(rq); + 1631. > unsigned long wait_for = (cmd->allowed + 1) * rq->timeout; + 1632. int disposition; + 1633. + +security/selinux/ss/policydb.c:1645: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1643. goto bad; + 1644. + 1645. > len = le32_to_cpu(buf[0]); + 1646. catdatum->value = le32_to_cpu(buf[1]); + 1647. catdatum->isalias = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1646: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1644. + 1645. len = le32_to_cpu(buf[0]); + 1646. > catdatum->value = le32_to_cpu(buf[1]); + 1647. catdatum->isalias = le32_to_cpu(buf[2]); + 1648. + +security/selinux/ss/policydb.c:1647: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1645. len = le32_to_cpu(buf[0]); + 1646. catdatum->value = le32_to_cpu(buf[1]); + 1647. > catdatum->isalias = le32_to_cpu(buf[2]); + 1648. + 1649. rc = str_read(&key, GFP_ATOMIC, fp, len); + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/ipv4/devinet.c:1654: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1652. cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ + 1653. net->dev_base_seq; + 1654. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 1655. if (idx < s_idx) + 1656. goto cont; + +drivers/gpu/drm/i915/intel_cdclk.c:1646: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1644. + 1645. /* Timeout 200us */ + 1646. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1647. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1648. + +drivers/gpu/drm/i915/intel_cdclk.c:1646: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1644. + 1645. /* Timeout 200us */ + 1646. > if (wait_for((I915_READ(BXT_DE_PLL_ENABLE) & BXT_DE_PLL_LOCK) != 0, 1)) + 1647. DRM_ERROR("timout waiting for CDCLK PLL lock\n"); + 1648. + +kernel/printk/printk.c:1649: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1647. + 1648. raw_spin_lock(&console_owner_lock); + 1649. > owner = READ_ONCE(console_owner); + 1650. waiter = READ_ONCE(console_waiter); + 1651. if (!waiter && owner && owner != current) { + +kernel/printk/printk.c:1650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1648. raw_spin_lock(&console_owner_lock); + 1649. owner = READ_ONCE(console_owner); + 1650. > waiter = READ_ONCE(console_waiter); + 1651. if (!waiter && owner && owner != current) { + 1652. WRITE_ONCE(console_waiter, true); + +net/wireless/trace.h:1636: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +drivers/cdrom/cdrom.c:1764: error: UNINITIALIZED_VALUE + The value read from rpc_state.region_mask was never initialized. + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. > ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + 1766. break; + +drivers/cdrom/cdrom.c:1765: error: UNINITIALIZED_VALUE + The value read from rpc_state.rpc_scheme was never initialized. + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. > ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + 1766. break; + 1767. + +drivers/cdrom/cdrom.c:1761: error: UNINITIALIZED_VALUE + The value read from rpc_state.type_code was never initialized. + 1759. return ret; + 1760. + 1761. > ai->lrpcs.type = rpc_state.type_code; + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + +drivers/cdrom/cdrom.c:1763: error: UNINITIALIZED_VALUE + The value read from rpc_state.ucca was never initialized. + 1761. ai->lrpcs.type = rpc_state.type_code; + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. > ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + +drivers/cdrom/cdrom.c:1762: error: UNINITIALIZED_VALUE + The value read from rpc_state.vra was never initialized. + 1760. + 1761. ai->lrpcs.type = rpc_state.type_code; + 1762. > ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + +drivers/hid/usbhid/hid-core.c:1641: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1639. static int __init hid_init(void) + 1640. { + 1641. > int retval = -ENOMEM; + 1642. + 1643. retval = hid_quirks_init(quirks_param, BUS_USB, MAX_USBHID_BOOT_QUIRKS); + +drivers/hid/hid-core.c:1698: error: DEAD_STORE + The value written to &len (type int) is never used. + 1696. ((struct hiddev *)hdev->hiddev)->minor); + 1697. if (hdev->claimed & HID_CLAIMED_HIDRAW) + 1698. > len += sprintf(buf + len, "%shidraw%d", len ? "," : "", + 1699. ((struct hidraw *)hdev->hidraw)->minor); + 1700. + +drivers/net/ethernet/intel/e1000e/ethtool.c:1690: error: DEAD_STORE + The value written to &time (type unsigned long) is never used. + 1688. e1e_flush(); + 1689. msleep(200); + 1690. > time = jiffies; /* set the start time for the receive */ + 1691. good_cnt = 0; + 1692. /* receive the sent packets */ + +net/sunrpc/auth_gss/svcauth_gss.c:1661: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1659. len = p++; + 1660. offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base; + 1661. > *p++ = htonl(gc->gc_seq); + 1662. inpages = resbuf->pages; + 1663. /* XXX: Would be better to write some xdr helper functions for + +drivers/gpu/drm/drm_dp_mst_topology.c:1659: error: DEAD_STORE + The value written to &len (type int) is never used. + 1657. + 1658. txmsg->dst = mstb; + 1659. > len = build_enum_path_resources(txmsg, port->port_num); + 1660. + 1661. drm_dp_queue_down_tx(mgr, txmsg); + +net/ipv6/route.c:1656: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1654. int i; + 1655. + 1656. > if (!rcu_access_pointer(rt->rt6i_exception_bucket)) + 1657. return; + 1658. + +net/core/sock.c:1696: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1694. + 1695. rcu_read_lock(); + 1696. > filter = rcu_dereference(sk->sk_filter); + 1697. if (filter != NULL) + 1698. /* though it's an empty new sock, the charging may fail + +net/core/sock.c:1722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1720. newsk->sk_err_soft = 0; + 1721. newsk->sk_priority = 0; + 1722. > newsk->sk_incoming_cpu = raw_smp_processor_id(); + 1723. atomic64_set(&newsk->sk_cookie, 0); + 1724. if (likely(newsk->sk_net_refcnt)) + +kernel/cgroup/cpuset.c:1661: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1656 could be null and is dereferenced by call to `is_cpuset_online()` at line 1661, column 7. + 1659. + 1660. mutex_lock(&cpuset_mutex); + 1661. > if (!is_cpuset_online(cs)) + 1662. goto out_unlock; + 1663. + +net/ipv6/ip6_fib.c:1679: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1677. + 1678. /* Reset round-robin state, if necessary */ + 1679. > if (rcu_access_pointer(fn->rr_ptr) == rt) + 1680. fn->rr_ptr = NULL; + 1681. + +net/ipv6/ip6_fib.c:1711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1709. * 2. For other nodes, expunge its radix tree node. + 1710. */ + 1711. > if (!rcu_access_pointer(fn->leaf)) { + 1712. if (!(fn->fn_flags & RTN_TL_ROOT)) { + 1713. fn->fn_flags &= ~RTN_RTINFO; + +net/sunrpc/xprtsock.c:1670: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1668. return; + 1669. rcu_read_lock(); + 1670. > wq = rcu_dereference(sk->sk_wq); + 1671. if (!wq || test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags) == 0) + 1672. goto out; + +drivers/tty/n_tty.c:1688: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1686. * read_tail (so this producer will not overwrite unread data) + 1687. */ + 1688. > size_t tail = smp_load_acquire(&ldata->read_tail); + 1689. + 1690. room = N_TTY_BUF_SIZE - (ldata->read_head - tail); + +drivers/tty/n_tty.c:1718: error: UNINITIALIZED_VALUE + The value read from room was never initialized. + 1716. } + 1717. + 1718. > tty->receive_room = room; + 1719. + 1720. /* Unthrottle if handling overflow on pty */ + +drivers/net/ethernet/broadcom/tg3.c:1699: error: DEAD_STORE + The value written to &data (type unsigned int*) is never used. + 1697. else + 1698. val = 0; + 1699. > *data++ = val; + 1700. } + 1701. + +drivers/usb/host/uhci-q.c:1693: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1691. urbp = list_entry(qh->queue.next, struct urb_priv, node); + 1692. td = list_entry(urbp->td_list.next, struct uhci_td, list); + 1693. > status = td_status(uhci, td); + 1694. if (!(status & TD_CTRL_ACTIVE)) { + 1695. + +block/bio.c:1674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1672. unsigned long sectors, struct hd_struct *part) + 1673. { + 1674. > int cpu = part_stat_lock(); + 1675. + 1676. part_round_stats(q, cpu, part); + +block/bio.c:1674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1672. unsigned long sectors, struct hd_struct *part) + 1673. { + 1674. > int cpu = part_stat_lock(); + 1675. + 1676. part_round_stats(q, cpu, part); + +net/wireless/trace.h:1675: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +drivers/base/power/main.c:1692: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1690. idx = device_links_read_lock(); + 1691. + 1692. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) { + 1693. spin_lock_irq(&link->supplier->power.lock); + 1694. link->supplier->power.direct_complete = false; + +drivers/gpu/drm/i915/intel_hdmi.c:1688: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1683 could be null and is dereferenced at line 1688, column 2. + 1686. intel_hdmi_prepare(encoder, pipe_config); + 1687. + 1688. > intel_dig_port->set_infoframes(&encoder->base, + 1689. pipe_config->has_infoframe, + 1690. pipe_config, conn_state); + +drivers/md/dm-ioctl.c:1689: error: UNINITIALIZED_VALUE + The value read from version[_] was never initialized. + 1687. if ((DM_VERSION_MAJOR != version[0]) || + 1688. (DM_VERSION_MINOR < version[1])) { + 1689. > DMWARN("ioctl interface mismatch: " + 1690. "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)", + 1691. DM_VERSION_MAJOR, DM_VERSION_MINOR, + +kernel/kprobes.c:1712: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1710. ap->break_handler = NULL; + 1711. if (p->post_handler && !kprobe_gone(p)) { + 1712. > list_for_each_entry_rcu(list_p, &ap->list, list) { + 1713. if ((list_p != p) && (list_p->post_handler)) + 1714. goto noclean; + +block/bio.c:1689: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1687. { + 1688. unsigned long duration = jiffies - start_time; + 1689. > int cpu = part_stat_lock(); + 1690. + 1691. part_stat_add(cpu, part, ticks[rw], duration); + +block/bio.c:1689: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1687. { + 1688. unsigned long duration = jiffies - start_time; + 1689. > int cpu = part_stat_lock(); + 1690. + 1691. part_stat_add(cpu, part, ticks[rw], duration); + +net/ipv4/route.c:1738: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1736. if (do_cache) { + 1737. if (fnhe) { + 1738. > rth = rcu_dereference(fnhe->fnhe_rth_input); + 1739. if (rth && rth->dst.expires && + 1740. time_after(jiffies, rth->dst.expires)) { + +net/ipv4/route.c:1748: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1746. } + 1747. + 1748. > rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input); + 1749. + 1750. rt_cache: + +net/ipv6/addrconf.c:1763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1761. } + 1762. + 1763. > for_each_netdev_rcu(net, dev) { + 1764. /* only consider addresses on devices in the + 1765. * same L3 domain + +net/wireless/trace.h:1692: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +drivers/gpu/drm/i915/intel_hdmi.c:1706: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1697 could be null and is dereferenced at line 1706, column 2. + 1704. 0x2b247878); + 1705. + 1706. > dport->set_infoframes(&encoder->base, + 1707. pipe_config->has_infoframe, + 1708. pipe_config, conn_state); + +net/ipv4/netfilter/ip_tables.c:1731: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1729. target = 0; + 1730. + 1731. > try_then_request_module(xt_find_revision(AF_INET, rev.name, + 1732. rev.revision, + 1733. target, &ret), + +include/net/sock.h:1698: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1696. { + 1697. BUILD_BUG_ON(offsetof(struct socket_wq, wait) != 0); + 1698. > return &rcu_dereference_raw(sk->sk_wq)->wait; + 1699. } + 1700. /* Detach socket from process context. + +kernel/printk/printk.c:1712: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1710. if (!con->write) + 1711. continue; + 1712. > if (!cpu_online(smp_processor_id()) && + 1713. !(con->flags & CON_ANYTIME)) + 1714. continue; + +kernel/printk/printk.c:1712: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1710. if (!con->write) + 1711. continue; + 1712. > if (!cpu_online(smp_processor_id()) && + 1713. !(con->flags & CON_ANYTIME)) + 1714. continue; + +net/ipv4/udp.c:1711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1709. + 1710. spin_lock_bh(&hslot->lock); + 1711. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1712. reuseport_detach_sock(sk); + 1713. if (sk_del_node_init_rcu(sk)) { + +drivers/gpu/drm/drm_atomic_helper.c:1705: error: DEAD_STORE + The value written to &completed (type _Bool) is never used. + 1703. { + 1704. struct drm_crtc_commit *commit, *stall_commit = NULL; + 1705. > bool completed = true; + 1706. int i; + 1707. long ret = 0; + +net/core/filter.c:1707: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1705. int ret; + 1706. + 1707. > if (unlikely(__this_cpu_read(xmit_recursion) > XMIT_RECURSION_LIMIT)) { + 1708. net_crit_ratelimited("bpf: recursion limit reached on datapath, buggy bpf program?\n"); + 1709. kfree_skb(skb); + +net/ipv6/netfilter/ip6_tables.c:1741: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1739. target = 0; + 1740. + 1741. > try_then_request_module(xt_find_revision(AF_INET6, rev.name, + 1742. rev.revision, + 1743. target, &ret), + +net/ipv6/mcast.c:1720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1718. return skb; + 1719. + 1720. > mtu = READ_ONCE(dev->mtu); + 1721. if (mtu < IPV6_MIN_MTU) + 1722. return skb; + +net/ipv4/fib_trie.c:1728: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1726. struct key_vector *local_l = NULL, *local_tp; + 1727. + 1728. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1729. struct fib_alias *new_fa; + 1730. + +net/sunrpc/auth_gss/svcauth_gss.c:1716: error: DEAD_STORE + The value written to &stat (type int) is never used. + 1714. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1715. struct xdr_buf *resbuf = &rqstp->rq_res; + 1716. > int stat = -EINVAL; + 1717. struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id); + 1718. + +drivers/gpu/drm/drm_dp_mst_topology.c:1747: error: DEAD_STORE + The value written to &len (type int) is never used. + 1745. + 1746. txmsg->dst = mstb; + 1747. > len = build_allocate_payload(txmsg, port_num, + 1748. id, + 1749. pbn, port->num_sdp_streams, sinks); + +kernel/rcu/tree_plugin.h:1715: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1713. { + 1714. rdp->ticks_this_gp = 0; + 1715. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1716. } + 1717. + +kernel/rcu/tree_plugin.h:1715: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1713. { + 1714. rdp->ticks_this_gp = 0; + 1715. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1716. } + 1717. + +lib/radix-tree.c:1768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1766. else + 1767. while (++offset < RADIX_TREE_MAP_SIZE) { + 1768. > void *slot = rcu_dereference_raw( + 1769. node->slots[offset]); + 1770. if (is_sibling_entry(node, slot)) + +lib/radix-tree.c:1782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1780. if (offset == RADIX_TREE_MAP_SIZE) + 1781. goto restart; + 1782. > child = rcu_dereference_raw(node->slots[offset]); + 1783. } + 1784. + +drivers/iommu/dmar.c:1722: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1720. * Enable fault control interrupt. + 1721. */ + 1722. > for_each_iommu(iommu, drhd) { + 1723. u32 fault_status; + 1724. int ret = dmar_set_interrupt(iommu); + +net/ipv4/devinet.c:1720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1718. u32 ext_filter_mask) + 1719. { + 1720. > struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 1721. + 1722. if (!in_dev) + +net/xfrm/xfrm_policy.c:1729: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1727. struct xfrm_dst *old; + 1728. + 1729. > old = this_cpu_read(xfrm_last_dst); + 1730. if (old && !xfrm_bundle_ok(old)) + 1731. xfrm_last_dst_update(NULL, old); + +net/xfrm/xfrm_policy.c:1729: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1727. struct xfrm_dst *old; + 1728. + 1729. > old = this_cpu_read(xfrm_last_dst); + 1730. if (old && !xfrm_bundle_ok(old)) + 1731. xfrm_last_dst_update(NULL, old); + +net/ipv4/devinet.c:1731: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1729. u32 ext_filter_mask) + 1730. { + 1731. > struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 1732. struct nlattr *nla; + 1733. int i; + +net/ipv4/udp.c:1742: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1740. + 1741. if (hslot2 != nhslot2 || + 1742. > rcu_access_pointer(sk->sk_reuseport_cb)) { + 1743. hslot = udp_hashslot(udptable, sock_net(sk), + 1744. udp_sk(sk)->udp_port_hash); + +net/ipv4/udp.c:1747: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1745. /* we must lock primary chain too */ + 1746. spin_lock_bh(&hslot->lock); + 1747. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1748. reuseport_detach_sock(sk); + 1749. + +kernel/signal.c:1773: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1771. rcu_read_lock(); + 1772. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); + 1773. > info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), + 1774. task_uid(tsk)); + 1775. rcu_read_unlock(); + +kernel/signal.c:1774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1772. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); + 1773. info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), + 1774. > task_uid(tsk)); + 1775. rcu_read_unlock(); + 1776. + +net/wireless/trace.h:1732: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +net/xfrm/xfrm_policy.c:1756: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1754. old = per_cpu(xfrm_last_dst, cpu); + 1755. if (old && !xfrm_bundle_ok(old)) { + 1756. > if (smp_processor_id() == cpu) { + 1757. __xfrm_pcpu_work_fn(); + 1758. continue; + +sound/core/timer.c:1835: error: UNINITIALIZED_VALUE + The value read from params.filter was never initialized. + 1833. } + 1834. } + 1835. > tu->filter = params.filter; + 1836. tu->ticks = params.ticks; + 1837. spin_unlock_irq(&tu->qlock); + +sound/core/timer.c:1812: error: UNINITIALIZED_VALUE + The value read from params.queue_size was never initialized. + 1810. if (params.queue_size > 0 && + 1811. (unsigned int)tu->queue_size != params.queue_size) { + 1812. > err = realloc_user_queue(tu, params.queue_size); + 1813. if (err < 0) + 1814. goto _end; + +sound/core/timer.c:1836: error: UNINITIALIZED_VALUE + The value read from params.ticks was never initialized. + 1834. } + 1835. tu->filter = params.filter; + 1836. > tu->ticks = params.ticks; + 1837. spin_unlock_irq(&tu->qlock); + 1838. err = 0; + +net/wireless/trace.h:1752: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1750. ); + 1751. + 1752. > DECLARE_EVENT_CLASS(rdev_pmksa, + 1753. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1754. struct cfg80211_pmksa *pmksa), + +drivers/gpu/drm/i915/intel_ddi.c:1760: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 1756 could be null and is dereferenced at line 1760, column 10. + 1758. + 1759. if (intel_ddi_get_hw_state(encoder, &pipe)) + 1760. > return BIT_ULL(dig_port->ddi_io_power_domain); + 1761. + 1762. return 0; + +include/net/sock.h:1757: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1755. __sk_dst_get(struct sock *sk) + 1756. { + 1757. > return rcu_dereference_check(sk->sk_dst_cache, + 1758. lockdep_sock_is_held(sk)); + 1759. } + +kernel/workqueue.c:1758: error: DEAD_STORE + The value written to &id (type int) is never used. + 1756. { + 1757. struct worker *worker = NULL; + 1758. > int id = -1; + 1759. char id_buf[16]; + 1760. + +ipc/sem.c:1761: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1759. struct sem_undo *un; + 1760. + 1761. > list_for_each_entry_rcu(un, &ulp->list_proc, list_proc) { + 1762. if (un->semid == semid) + 1763. return un; + +drivers/block/loop.c:1783: error: DEAD_STORE + The value written to &err (type int) is never used. + 1781. i = err; + 1782. + 1783. > err = -ENOMEM; + 1784. lo->tag_set.ops = &loop_mq_ops; + 1785. lo->tag_set.nr_hw_queues = 1; + +include/net/sock.h:1767: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1765. + 1766. rcu_read_lock(); + 1767. > dst = rcu_dereference(sk->sk_dst_cache); + 1768. if (dst && !atomic_inc_not_zero(&dst->__refcnt)) + 1769. dst = NULL; + +drivers/gpu/drm/i915/intel_hdmi.c:1777: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1767 could be null and is dereferenced at line 1777, column 2. + 1775. chv_set_phy_signal_level(encoder, 128, 102, false); + 1776. + 1777. > dport->set_infoframes(&encoder->base, + 1778. pipe_config->has_infoframe, + 1779. pipe_config, conn_state); + +drivers/gpu/drm/drm_dp_mst_topology.c:1784: error: DEAD_STORE + The value written to &len (type int) is never used. + 1782. + 1783. txmsg->dst = port->parent; + 1784. > len = build_power_updown_phy(txmsg, port->port_num, power_up); + 1785. drm_dp_queue_down_tx(mgr, txmsg); + 1786. + +net/wireless/trace.h:1770: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +include/net/xfrm.h:1780: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1778. + 1779. rcu_read_lock(); + 1780. > nlsk = rcu_dereference(net->xfrm.nlsk); + 1781. if (nlsk) + 1782. ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS); + +kernel/cgroup/cgroup.c:1800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1798. */ + 1799. read_lock(&tasklist_lock); + 1800. > do_each_thread(g, p) { + 1801. WARN_ON_ONCE(!list_empty(&p->cg_list) || + 1802. task_css_set(p) != &init_css_set); + +drivers/gpu/drm/drm_fb_helper.c:1862: error: UNINITIALIZED_VALUE + The value read from sizes.surface_height was never initialized. + 1860. + 1861. sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1862. > sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1863. + 1864. for (j = 0; j < mode_set->num_connectors; j++) { + +drivers/gpu/drm/drm_fb_helper.c:1861: error: UNINITIALIZED_VALUE + The value read from sizes.surface_width was never initialized. + 1859. gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size; + 1860. + 1861. > sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1862. sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1863. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +include/net/xfrm.h:1793: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1791. + 1792. rcu_read_lock(); + 1793. > nlsk = rcu_dereference(net->xfrm.nlsk); + 1794. if (nlsk) + 1795. ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE); + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +kernel/events/core.c:1802: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1800. event_filter_match(struct perf_event *event) + 1801. { + 1802. > return (event->cpu == -1 || event->cpu == smp_processor_id()) && + 1803. perf_cgroup_match(event) && pmu_filter_match(event); + 1804. } + +net/wireless/trace.h:1800: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +kernel/cgroup/cpuset.c:1817: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1813 could be null and is dereferenced at line 1817, column 10. + 1815. switch (type) { + 1816. case FILE_SCHED_RELAX_DOMAIN_LEVEL: + 1817. > return cs->relax_domain_level; + 1818. default: + 1819. BUG(); + +drivers/usb/core/hub.c:1831: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1817 could be null and is dereferenced at line 1831, column 9. + 1829. info->nports = hdev->maxchild; + 1830. for (i = 0; i < info->nports; i++) { + 1831. > if (hub->ports[i]->child == NULL) + 1832. info->port[i] = 0; + 1833. else + +net/xfrm/xfrm_policy.c:1840: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1838. } + 1839. + 1840. > xdst = this_cpu_read(xfrm_last_dst); + 1841. if (xdst && + 1842. xdst->u.dst.dev == dst_orig->dev && + +net/xfrm/xfrm_policy.c:1840: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1838. } + 1839. + 1840. > xdst = this_cpu_read(xfrm_last_dst); + 1841. if (xdst && + 1842. xdst->u.dst.dev == dst_orig->dev && + +kernel/sched/core.c:1828: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1826. rcu_read_lock(); + 1827. + 1828. > if (!is_idle_task(rcu_dereference(rq->curr))) + 1829. goto out; + 1830. + +net/core/ethtool.c:1830: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1828. return -EFAULT; + 1829. + 1830. > ret = __ethtool_get_sset_count(dev, gstrings.string_set); + 1831. if (ret < 0) + 1832. return ret; + +net/core/ethtool.c:1842: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1840. return -ENOMEM; + 1841. + 1842. > __ethtool_get_strings(dev, gstrings.string_set, data); + 1843. + 1844. ret = -EFAULT; + +net/ipv4/udp.c:1848: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1846. + 1847. /* if we're overly short, let UDP handle it */ + 1848. > encap_rcv = READ_ONCE(up->encap_rcv); + 1849. if (encap_rcv) { + 1850. int ret; + +net/ipv4/udp.c:1903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1901. + 1902. prefetch(&sk->sk_rmem_alloc); + 1903. > if (rcu_access_pointer(sk->sk_filter) && + 1904. udp_lib_checksum_complete(skb)) + 1905. goto csum_error; + +net/wireless/trace.h:1821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.keycode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +drivers/tty/vt/keyboard.c:1834: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1832. switch (cmd) { + 1833. case KDGETKEYCODE: + 1834. > kc = getkeycode(tmp.scancode); + 1835. if (kc >= 0) + 1836. kc = put_user(kc, &user_kbkc->keycode); + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +lib/radix-tree.c:1836: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1834. + 1835. radix_tree_for_each_slot(slot, root, &iter, first_index) { + 1836. > results[ret] = rcu_dereference_raw(*slot); + 1837. if (!results[ret]) + 1838. continue; + +net/ipv6/addrconf.c:1830: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1828. + 1829. rcu_read_lock(); + 1830. > list_for_each_entry_rcu(ifp, &idev->addr_list, if_list) + 1831. cnt++; + 1832. rcu_read_unlock(); + +net/ipv4/cipso_ipv4.c:1830: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1828. const struct netlbl_lsm_secattr *secattr) + 1829. { + 1830. > int ret_val = -EPERM; + 1831. unsigned char *buf = NULL; + 1832. u32 buf_len; + +drivers/usb/host/ehci-sched.c:1888: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 1886. + 1887. /* give urb back to the driver; completion often (re)submits */ + 1888. > dev = urb->dev; + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + +kernel/sys.c:1835: error: DEAD_STORE + The value written to &mm (type mm_struct*) is never used. + 1833. { + 1834. unsigned long mmap_max_addr = TASK_SIZE; + 1835. > struct mm_struct *mm = current->mm; + 1836. int error = -EINVAL, i; + 1837. + +drivers/i2c/i2c-core-base.c:1855: error: DEAD_STORE + The value written to &orig_jiffies (type unsigned long) is never used. + 1853. + 1854. /* Retry automatically on arbitration loss */ + 1855. > orig_jiffies = jiffies; + 1856. for (ret = 0, try = 0; try <= adap->retries; try++) { + 1857. ret = adap->algo->master_xfer(adap, msgs, num); + +drivers/iommu/dmar.c:1836: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1834. dmar_res_handler_t handler, void *arg) + 1835. { + 1836. > int ret = -ENODEV; + 1837. union acpi_object *obj; + 1838. struct acpi_dmar_header *start; + +kernel/signal.c:1860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1858. rcu_read_lock(); + 1859. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); + 1860. > info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); + 1861. rcu_read_unlock(); + 1862. + +kernel/signal.c:1860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1858. rcu_read_lock(); + 1859. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); + 1860. > info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); + 1861. rcu_read_unlock(); + 1862. + +net/core/neighbour.c:1874: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1872. + 1873. rcu_read_lock_bh(); + 1874. > nht = rcu_dereference_bh(tbl->nht); + 1875. ndc.ndtc_hash_rnd = nht->hash_rnd[0]; + 1876. ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1); + +drivers/cdrom/cdrom.c:1856: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1854. return ret; + 1855. + 1856. > s->copyright.cpst = buf[4]; + 1857. s->copyright.rmi = buf[5]; + 1858. + +drivers/cdrom/cdrom.c:1857: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1855. + 1856. s->copyright.cpst = buf[4]; + 1857. > s->copyright.rmi = buf[5]; + 1858. + 1859. return 0; + +net/wireless/trace.h:1838: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +security/selinux/ss/policydb.c:1853: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1851. return rc; + 1852. + 1853. > nel = le32_to_cpu(buf[0]); + 1854. for (i = 0; i < nel; i++) { + 1855. rc = -ENOMEM; + +security/selinux/ss/policydb.c:1864: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1862. goto out; + 1863. + 1864. > rt->source_type = le32_to_cpu(buf[0]); + 1865. rt->target_type = le32_to_cpu(buf[1]); + 1866. if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) { + +security/selinux/ss/policydb.c:1865: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1863. + 1864. rt->source_type = le32_to_cpu(buf[0]); + 1865. > rt->target_type = le32_to_cpu(buf[1]); + 1866. if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) { + 1867. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:1870: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1868. if (rc) + 1869. goto out; + 1870. > rt->target_class = le32_to_cpu(buf[0]); + 1871. } else + 1872. rt->target_class = p->process_class; + +net/sunrpc/xprtsock.c:1850: error: DEAD_STORE + The value written to &port (type unsigned short) is never used. + 1848. if (port <= xprt_min_resvport || port > xprt_max_resvport) + 1849. return xprt_max_resvport; + 1850. > return --port; + 1851. } + 1852. static int xs_bind(struct sock_xprt *transport, struct socket *sock) + +net/ipv6/addrconf.c:1852: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1850. + 1851. rcu_read_lock(); + 1852. > hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { + 1853. if (!net_eq(dev_net(ifp->idev->dev), net)) + 1854. continue; + +drivers/iommu/intel-iommu.c:1850: error: DEAD_STORE + The value written to &count (type int) is never used. + 1848. struct intel_iommu *iommu) + 1849. { + 1850. > int num, count = INT_MAX; + 1851. + 1852. assert_spin_locked(&device_domain_lock); + +net/ipv4/af_inet.c:1854: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1852. struct inet_protosw *q; + 1853. struct list_head *r; + 1854. > int rc = -EINVAL; + 1855. + 1856. sock_skb_cb_check_size(sizeof(struct inet_skb_parm)); + +kernel/sched/core.c:1857: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1855. + 1856. #if defined(CONFIG_SMP) + 1857. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1858. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1859. ttwu_queue_remote(p, cpu, wake_flags); + +kernel/sched/core.c:1857: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1855. + 1856. #if defined(CONFIG_SMP) + 1857. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1858. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1859. ttwu_queue_remote(p, cpu, wake_flags); + +kernel/time/hrtimer.c:1853: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1851. void __init hrtimers_init(void) + 1852. { + 1853. > hrtimers_prepare_cpu(smp_processor_id()); + 1854. open_softirq(HRTIMER_SOFTIRQ, hrtimer_run_softirq); + 1855. } + +kernel/time/hrtimer.c:1853: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1851. void __init hrtimers_init(void) + 1852. { + 1853. > hrtimers_prepare_cpu(smp_processor_id()); + 1854. open_softirq(HRTIMER_SOFTIRQ, hrtimer_run_softirq); + 1855. } + +drivers/usb/core/hub.c:1865: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1855 could be null and is dereferenced at line 1865, column 15. + 1863. * will always have maxchild equal to 0. + 1864. */ + 1865. > *ppowner = &(hub->ports[port1 - 1]->port_owner); + 1866. return 0; + 1867. } + +kernel/sched/deadline.c:1895: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1893. + 1894. rcu_read_lock(); + 1895. > for_each_domain(cpu, sd) { + 1896. if (sd->flags & SD_WAKE_AFFINE) { + 1897. int best_cpu; + +kernel/sched/deadline.c:1856: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1854. struct sched_domain *sd; + 1855. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1856. > int this_cpu = smp_processor_id(); + 1857. int cpu = task_cpu(task); + 1858. + +kernel/sched/deadline.c:1856: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1854. struct sched_domain *sd; + 1855. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1856. > int this_cpu = smp_processor_id(); + 1857. int cpu = task_cpu(task); + 1858. + +net/wireless/trace.h:1855: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +security/selinux/ss/services.c:1914: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1912. + 1913. /* Convert the user. */ + 1914. > rc = -EINVAL; + 1915. usrdatum = hashtab_search(args->newp->p_users.table, + 1916. sym_name(args->oldp, SYM_USERS, c->user - 1)); + +security/selinux/ss/services.c:1922: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1920. + 1921. /* Convert the role. */ + 1922. > rc = -EINVAL; + 1923. role = hashtab_search(args->newp->p_roles.table, + 1924. sym_name(args->oldp, SYM_ROLES, c->role - 1)); + +security/selinux/ss/services.c:1930: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1928. + 1929. /* Convert the type. */ + 1930. > rc = -EINVAL; + 1931. typdatum = hashtab_search(args->newp->p_types.table, + 1932. sym_name(args->oldp, SYM_TYPES, c->type - 1)); + +security/selinux/ss/services.c:1960: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1958. while (oc && oc->sid[0] != SECINITSID_UNLABELED) + 1959. oc = oc->next; + 1960. > rc = -EINVAL; + 1961. if (!oc) { + 1962. printk(KERN_ERR "SELinux: unable to look up" + +kernel/auditsc.c:1881: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1879. rcu_read_lock(); + 1880. if (!list_empty(list)) { + 1881. > list_for_each_entry_rcu(e, list, list) { + 1882. for (i = 0; i < e->rule.field_count; i++) { + 1883. struct audit_field *f = &e->rule.fields[i]; + +drivers/gpu/drm/drm_dp_mst_topology.c:1909: error: UNINITIALIZED_VALUE + The value read from req_payload.payload_state was never initialized. + 1907. mgr->payloads[i].start_slot = 0; + 1908. } + 1909. > mgr->payloads[i].payload_state = req_payload.payload_state; + 1910. } + 1911. cur_slots += req_payload.num_slots; + +net/ipv4/igmp.c:1876: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1874. return -ENODEV; + 1875. rcu_read_lock(); + 1876. > for_each_pmc_rcu(in_dev, pmc) { + 1877. if (*pmca == pmc->multiaddr) + 1878. break; + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/rcu/tree.c:1903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1901. need_gp = !!(rnp->qsmask & rdp->grpmask); + 1902. rdp->cpu_no_qs.b.norm = need_gp; + 1903. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 1904. rdp->core_needs_qs = need_gp; + 1905. zero_cpu_stall_ticks(rdp); + +kernel/rcu/tree.c:1903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1901. need_gp = !!(rnp->qsmask & rdp->grpmask); + 1902. rdp->cpu_no_qs.b.norm = need_gp; + 1903. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 1904. rdp->core_needs_qs = need_gp; + 1905. zero_cpu_stall_ticks(rdp); + +ipc/sem.c:1874: error: DEAD_STORE + The value written to &error (type int) is never used. + 1872. unsigned nsops, const struct timespec64 *timeout) + 1873. { + 1874. > int error = -EINVAL; + 1875. struct sem_array *sma; + 1876. struct sembuf fast_sops[SEMOPM_FAST]; + +ipc/sem.c:2078: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2076. * window between wake_q_add() and wake_up_q(). + 2077. */ + 2078. > error = READ_ONCE(queue.status); + 2079. if (error != -EINTR) { + 2080. /* + +ipc/sem.c:2096: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2094. goto out_unlock_free; + 2095. + 2096. > error = READ_ONCE(queue.status); + 2097. + 2098. /* + +kernel/trace/ring_buffer.c:2000: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1998. struct buffer_page *buffer_tail_page; + 1999. + 2000. > buffer_tail_page = READ_ONCE(cpu_buffer->tail_page); + 2001. /* + 2002. * If the tail had moved passed next, then we need + +net/ipv6/addrconf.c:1889: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1887. idev = __in6_dev_get(dev); + 1888. if (idev) { + 1889. > list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) { + 1890. ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len); + 1891. if (ret) + +drivers/iommu/dmar.c:1895: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1893. */ + 1894. if (!dmaru->include_all && dmaru->devices && dmaru->devices_cnt) { + 1895. > for_each_active_dev_scope(dmaru->devices, + 1896. dmaru->devices_cnt, i, dev) + 1897. return -EBUSY; + +drivers/gpu/drm/i915/intel_uncore.c:1921: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1919. intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL); + 1920. + 1921. > return ret; + 1922. } + 1923. + +net/wireless/trace.h:1885: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +crypto/drbg.c:1904: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1902. struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. > int rc = -EFAULT; + 1905. bool pr = false; + 1906. int coreref = 0; + +crypto/drbg.c:1903: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1901. unsigned char buf[OUTBUFLEN]; + 1902. struct drbg_state *drbg = NULL; + 1903. > int ret = -EFAULT; + 1904. int rc = -EFAULT; + 1905. bool pr = false; + +block/blk-core.c:1992: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1990. + 1991. if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) + 1992. > req->cpu = raw_smp_processor_id(); + 1993. + 1994. plug = current->plug; + +block/blk-core.c:1992: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1990. + 1991. if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) + 1992. > req->cpu = raw_smp_processor_id(); + 1993. + 1994. plug = current->plug; + +net/ipv6/ip6_fib.c:1924: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1922. if (res) { + 1923. #if RT6_DEBUG >= 2 + 1924. > pr_debug("%s: del failed: rt=%p@%p err=%d\n", + 1925. __func__, rt, + 1926. rcu_access_pointer(rt->rt6i_node), + +net/core/dev.c:1908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1906. struct packet_type *ptype, *pt_prev = *pt; + 1907. + 1908. > list_for_each_entry_rcu(ptype, ptype_list, list) { + 1909. if (ptype->type != type) + 1910. continue; + +drivers/cpufreq/cpufreq.c:1906: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1904. unsigned int intermediate_freq = 0; + 1905. unsigned int newfreq = policy->freq_table[index].frequency; + 1906. > int retval = -EINVAL; + 1907. bool notify; + 1908. + +net/ipv6/addrconf.c:1911: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1909. idev = __in6_dev_get(dev); + 1910. if (idev) { + 1911. > list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) { + 1912. onlink = ipv6_prefix_equal(addr, &ifa->addr, + 1913. ifa->prefix_len); + +drivers/usb/core/hub.c:1908: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1904 could be null and is dereferenced at line 1908, column 7. + 1906. + 1907. for (n = 0; n < hdev->maxchild; n++) { + 1908. > if (hub->ports[n]->port_owner == owner) + 1909. hub->ports[n]->port_owner = NULL; + 1910. } + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +lib/radix-tree.c:1919: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1917. + 1918. radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) { + 1919. > results[ret] = rcu_dereference_raw(*slot); + 1920. if (!results[ret]) + 1921. continue; + +net/ipv4/route.c:2022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2020. if (res->fi) { + 2021. if (!itag) { + 2022. > rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input); + 2023. if (rt_cache_valid(rth)) { + 2024. skb_dst_set_noref(skb, &rth->dst); + +net/xfrm/xfrm_state.c:1912: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1910. + 1911. rcu_read_lock(); + 1912. > list_for_each_entry_rcu(km, &xfrm_km_list, list) + 1913. if (km->notify_policy) + 1914. km->notify_policy(xp, dir, c); + +net/wireless/trace.h:1908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +security/selinux/ss/policydb.c:1925: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1923. if (rc) + 1924. return rc; + 1925. > nel = le32_to_cpu(buf[0]); + 1926. + 1927. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:1945: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1943. if (rc) + 1944. goto out; + 1945. > len = le32_to_cpu(buf[0]); + 1946. + 1947. /* path component string */ + +security/selinux/ss/policydb.c:1958: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1956. goto out; + 1957. + 1958. > ft->stype = le32_to_cpu(buf[0]); + 1959. ft->ttype = le32_to_cpu(buf[1]); + 1960. ft->tclass = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1959: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1957. + 1958. ft->stype = le32_to_cpu(buf[0]); + 1959. > ft->ttype = le32_to_cpu(buf[1]); + 1960. ft->tclass = le32_to_cpu(buf[2]); + 1961. + +security/selinux/ss/policydb.c:1960: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1958. ft->stype = le32_to_cpu(buf[0]); + 1959. ft->ttype = le32_to_cpu(buf[1]); + 1960. > ft->tclass = le32_to_cpu(buf[2]); + 1961. + 1962. otype->otype = le32_to_cpu(buf[3]); + +security/selinux/ss/policydb.c:1962: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1960. ft->tclass = le32_to_cpu(buf[2]); + 1961. + 1962. > otype->otype = le32_to_cpu(buf[3]); + 1963. + 1964. rc = ebitmap_set_bit(&p->filename_trans_ttypes, ft->ttype, 1); + +net/ipv4/cipso_ipv4.c:1915: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1913. const struct netlbl_lsm_secattr *secattr) + 1914. { + 1915. > int ret_val = -EPERM; + 1916. unsigned char *buf = NULL; + 1917. u32 buf_len; + +kernel/sched/rt.c:1948: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1946. * Matches WMB in rt_set_overload(). + 1947. */ + 1948. > next = atomic_read_acquire(&rd->rto_loop_next); + 1949. + 1950. if (rd->rto_loop == next) + +net/ipv4/fib_trie.c:1917: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1915. struct fib_alias *fa; + 1916. + 1917. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1918. struct fib_info *fi = fa->fa_info; + 1919. + +drivers/usb/core/hub.c:1922: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1921 could be null and is dereferenced at line 1922, column 11. + 1920. return false; + 1921. hub = usb_hub_to_struct_hub(udev->parent); + 1922. > return !!hub->ports[udev->portnum - 1]->port_owner; + 1923. } + 1924. + +arch/x86/events/core.c:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. * transaction. See x86_pmu_add() and x86_pmu_*_txn(). + 1933. */ + 1934. > __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + +arch/x86/events/core.c:1935: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1933. */ + 1934. __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. > __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + 1937. } + +net/xfrm/xfrm_state.c:1922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1920. struct xfrm_mgr *km; + 1921. rcu_read_lock(); + 1922. > list_for_each_entry_rcu(km, &xfrm_km_list, list) + 1923. if (km->notify) + 1924. km->notify(x, c); + +net/socket.c:1930: error: UNINITIALIZED_VALUE + The value read from msg.msg_control was never initialized. + 1928. return -EFAULT; + 1929. + 1930. > kmsg->msg_control = (void __force *)msg.msg_control; + 1931. kmsg->msg_controllen = msg.msg_controllen; + 1932. kmsg->msg_flags = msg.msg_flags; + +net/socket.c:1931: error: UNINITIALIZED_VALUE + The value read from msg.msg_controllen was never initialized. + 1929. + 1930. kmsg->msg_control = (void __force *)msg.msg_control; + 1931. > kmsg->msg_controllen = msg.msg_controllen; + 1932. kmsg->msg_flags = msg.msg_flags; + 1933. + +net/socket.c:1932: error: UNINITIALIZED_VALUE + The value read from msg.msg_flags was never initialized. + 1930. kmsg->msg_control = (void __force *)msg.msg_control; + 1931. kmsg->msg_controllen = msg.msg_controllen; + 1932. > kmsg->msg_flags = msg.msg_flags; + 1933. + 1934. kmsg->msg_namelen = msg.msg_namelen; + +net/socket.c:1965: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 1963. kmsg->msg_iocb = NULL; + 1964. + 1965. > return import_iovec(save_addr ? READ : WRITE, + 1966. msg.msg_iov, msg.msg_iovlen, + 1967. UIO_FASTIOV, iov, &kmsg->msg_iter); + +net/socket.c:1945: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 1943. + 1944. if (save_addr) + 1945. > *save_addr = msg.msg_name; + 1946. + 1947. if (msg.msg_name && kmsg->msg_namelen) { + +net/socket.c:1934: error: UNINITIALIZED_VALUE + The value read from msg.msg_namelen was never initialized. + 1932. kmsg->msg_flags = msg.msg_flags; + 1933. + 1934. > kmsg->msg_namelen = msg.msg_namelen; + 1935. if (!msg.msg_name) + 1936. kmsg->msg_namelen = 0; + +net/ipv6/addrconf.c:1930: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1928. + 1929. rcu_read_lock(); + 1930. > hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { + 1931. if (!net_eq(dev_net(ifp->idev->dev), net)) + 1932. continue; + +drivers/usb/core/hub.c:1931: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1927 could be null and is dereferenced at line 1931, column 7. + 1929. + 1930. for (i = 0; i < udev->maxchild; ++i) { + 1931. > if (hub->ports[i]->child) + 1932. recursively_mark_NOTATTACHED(hub->ports[i]->child); + 1933. } + +net/ipv4/tcp_output.c:1966: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1964. goto send_now; + 1965. + 1966. > win_divisor = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_tso_win_divisor); + 1967. if (win_divisor) { + 1968. u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache); + +drivers/video/fbdev/core/fbmem.c:1934: error: DEAD_STORE + The value written to &err (type int) is never used. + 1932. struct fb_modelist *modelist; + 1933. struct fb_videomode *m, mode; + 1934. > int err = 1; + 1935. + 1936. list_for_each_safe(pos, n, &info->modelist) { + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/core/dev.c:1945: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1943. rcu_read_lock(); + 1944. again: + 1945. > list_for_each_entry_rcu(ptype, ptype_list, list) { + 1946. /* Never send packets back to the socket + 1947. * they originated from - MvS (miquels@drinkel.ow.org) + +drivers/tty/n_tty.c:1947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1945. size_t n; + 1946. bool is_eof; + 1947. > size_t head = smp_load_acquire(&ldata->commit_head); + 1948. size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + 1949. + +net/wireless/trace.h:1939: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +drivers/input/mouse/alps.c:1948: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1946. { + 1947. u16 reg_val = 0x181; + 1948. > int ret = -1; + 1949. + 1950. /* enter monitor mode, to write the register */ + +net/ipv4/udp.c:1956: error: DEAD_STORE + The value written to &dif (type int) is never used. + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. > int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + +net/ipv4/udp.c:1955: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1953. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + +net/ipv4/udp.c:1967: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1965. start_lookup: + 1966. hslot = &udptable->hash2[hash2]; + 1967. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 1968. } + 1969. + +net/ipv4/udp.c:1957: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. > int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + 1959. struct sk_buff *nskb; + +net/ipv4/udp.c:1970: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1968. } + 1969. + 1970. > sk_for_each_entry_offset_rcu(sk, node, &hslot->head, offset) { + 1971. if (!__udp_is_mcast_sock(net, sk, uh->dest, daddr, + 1972. uh->source, saddr, dif, sdif, hnum)) + +net/xfrm/xfrm_state.c:1952: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1950. + 1951. rcu_read_lock(); + 1952. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 1953. acqret = km->acquire(x, t, pol); + 1954. if (!acqret) + +net/ipv4/fib_trie.c:1959: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1957. struct fib_table *tb; + 1958. + 1959. > hlist_for_each_entry_rcu(tb, head, tb_hlist) + 1960. fib_table_notify(net, tb, nb); + 1961. } + +net/sunrpc/auth_gss/auth_gss.c:1965: error: DEAD_STORE + The value written to &status (type int) is never used. + 1963. struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; + 1964. int savedlen = head->iov_len; + 1965. > int status = -EIO; + 1966. + 1967. if (ctx->gc_proc != RPC_GSS_PROC_DATA) + +drivers/input/input.c:1967: error: UNINITIALIZED_VALUE + The value read from mt_slots was never initialized. + 1965. mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum - + 1966. dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1, + 1967. > mt_slots = clamp(mt_slots, 2, 32); + 1968. } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) { + 1969. mt_slots = 2; + +net/wireless/trace.h:1961: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +drivers/usb/core/devio.c:1969: error: UNINITIALIZED_VALUE + The value read from ds.context was never initialized. + 1967. return -EFAULT; + 1968. ps->discsignr = ds.signr; + 1969. > ps->disccontext = compat_ptr(ds.context); + 1970. return 0; + 1971. } + +drivers/usb/core/devio.c:1968: error: UNINITIALIZED_VALUE + The value read from ds.signr was never initialized. + 1966. if (copy_from_user(&ds, arg, sizeof(ds))) + 1967. return -EFAULT; + 1968. > ps->discsignr = ds.signr; + 1969. ps->disccontext = compat_ptr(ds.context); + 1970. return 0; + +net/xfrm/xfrm_state.c:1968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1966. + 1967. rcu_read_lock(); + 1968. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 1969. if (km->new_mapping) + 1970. err = km->new_mapping(x, ipaddr, sport); + +kernel/cgroup/cpuset.c:1974: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1973 could be null and is dereferenced by call to `parent_cs()` at line 1974, column 26. + 1972. { + 1973. struct cpuset *cs = css_cs(css); + 1974. > struct cpuset *parent = parent_cs(cs); + 1975. struct cpuset *tmp_cs; + 1976. struct cgroup_subsys_state *pos_css; + +net/ipv6/ip6_fib.c:1983: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1981. for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { + 1982. head = &net->ipv6.fib_table_hash[h]; + 1983. > hlist_for_each_entry_rcu(table, head, tb6_hlist) { + 1984. spin_lock_bh(&table->tb6_lock); + 1985. fib6_clean_tree(net, &table->tb6_root, + +drivers/usb/core/devio.c:1985: error: UNINITIALIZED_VALUE + The value read from urb32.actual_length was never initialized. + 1983. kurb->buffer = compat_ptr(urb32.buffer); + 1984. kurb->buffer_length = urb32.buffer_length; + 1985. > kurb->actual_length = urb32.actual_length; + 1986. kurb->start_frame = urb32.start_frame; + 1987. kurb->number_of_packets = urb32.number_of_packets; + +drivers/usb/core/devio.c:1983: error: UNINITIALIZED_VALUE + The value read from urb32.buffer was never initialized. + 1981. kurb->status = urb32.status; + 1982. kurb->flags = urb32.flags; + 1983. > kurb->buffer = compat_ptr(urb32.buffer); + 1984. kurb->buffer_length = urb32.buffer_length; + 1985. kurb->actual_length = urb32.actual_length; + +drivers/usb/core/devio.c:1984: error: UNINITIALIZED_VALUE + The value read from urb32.buffer_length was never initialized. + 1982. kurb->flags = urb32.flags; + 1983. kurb->buffer = compat_ptr(urb32.buffer); + 1984. > kurb->buffer_length = urb32.buffer_length; + 1985. kurb->actual_length = urb32.actual_length; + 1986. kurb->start_frame = urb32.start_frame; + +drivers/usb/core/devio.c:1980: error: UNINITIALIZED_VALUE + The value read from urb32.endpoint was never initialized. + 1978. return -EFAULT; + 1979. kurb->type = urb32.type; + 1980. > kurb->endpoint = urb32.endpoint; + 1981. kurb->status = urb32.status; + 1982. kurb->flags = urb32.flags; + +drivers/usb/core/devio.c:1988: error: UNINITIALIZED_VALUE + The value read from urb32.error_count was never initialized. + 1986. kurb->start_frame = urb32.start_frame; + 1987. kurb->number_of_packets = urb32.number_of_packets; + 1988. > kurb->error_count = urb32.error_count; + 1989. kurb->signr = urb32.signr; + 1990. kurb->usercontext = compat_ptr(urb32.usercontext); + +drivers/usb/core/devio.c:1982: error: UNINITIALIZED_VALUE + The value read from urb32.flags was never initialized. + 1980. kurb->endpoint = urb32.endpoint; + 1981. kurb->status = urb32.status; + 1982. > kurb->flags = urb32.flags; + 1983. kurb->buffer = compat_ptr(urb32.buffer); + 1984. kurb->buffer_length = urb32.buffer_length; + +drivers/usb/core/devio.c:1987: error: UNINITIALIZED_VALUE + The value read from urb32.number_of_packets was never initialized. + 1985. kurb->actual_length = urb32.actual_length; + 1986. kurb->start_frame = urb32.start_frame; + 1987. > kurb->number_of_packets = urb32.number_of_packets; + 1988. kurb->error_count = urb32.error_count; + 1989. kurb->signr = urb32.signr; + +drivers/usb/core/devio.c:1989: error: UNINITIALIZED_VALUE + The value read from urb32.signr was never initialized. + 1987. kurb->number_of_packets = urb32.number_of_packets; + 1988. kurb->error_count = urb32.error_count; + 1989. > kurb->signr = urb32.signr; + 1990. kurb->usercontext = compat_ptr(urb32.usercontext); + 1991. return 0; + +drivers/usb/core/devio.c:1986: error: UNINITIALIZED_VALUE + The value read from urb32.start_frame was never initialized. + 1984. kurb->buffer_length = urb32.buffer_length; + 1985. kurb->actual_length = urb32.actual_length; + 1986. > kurb->start_frame = urb32.start_frame; + 1987. kurb->number_of_packets = urb32.number_of_packets; + 1988. kurb->error_count = urb32.error_count; + +drivers/usb/core/devio.c:1981: error: UNINITIALIZED_VALUE + The value read from urb32.status was never initialized. + 1979. kurb->type = urb32.type; + 1980. kurb->endpoint = urb32.endpoint; + 1981. > kurb->status = urb32.status; + 1982. kurb->flags = urb32.flags; + 1983. kurb->buffer = compat_ptr(urb32.buffer); + +drivers/usb/core/devio.c:1979: error: UNINITIALIZED_VALUE + The value read from urb32.type was never initialized. + 1977. if (copy_from_user(&urb32, uurb, sizeof(*uurb))) + 1978. return -EFAULT; + 1979. > kurb->type = urb32.type; + 1980. kurb->endpoint = urb32.endpoint; + 1981. kurb->status = urb32.status; + +drivers/usb/core/devio.c:1990: error: UNINITIALIZED_VALUE + The value read from urb32.usercontext was never initialized. + 1988. kurb->error_count = urb32.error_count; + 1989. kurb->signr = urb32.signr; + 1990. > kurb->usercontext = compat_ptr(urb32.usercontext); + 1991. return 0; + 1992. } + +net/ipv4/devinet.c:1993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1991. cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ + 1992. net->dev_base_seq; + 1993. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 1994. if (idx < s_idx) + 1995. goto cont; + +kernel/sched/core.c:2054: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2052. * their previous state and preserve Program Order. + 2053. */ + 2054. > smp_cond_load_acquire(&p->on_cpu, !VAL); + 2055. + 2056. p->sched_contributes_to_load = !!task_contributes_to_load(p); + +kernel/module.c:1989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1987. + 1988. mutex_lock(&module_mutex); + 1989. > list_for_each_entry_rcu(mod, &modules, list) { + 1990. if (mod->state == MODULE_STATE_UNFORMED) + 1991. continue; + +net/ipv4/fib_trie.c:1992: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1990. + 1991. /* rcu_read_lock is hold by caller */ + 1992. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1993. int err; + 1994. + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +lib/radix-tree.c:1989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1987. struct radix_tree_node *node, void __rcu **slot) + 1988. { + 1989. > void *old = rcu_dereference_raw(*slot); + 1990. int exceptional = radix_tree_exceptional_entry(old) ? -1 : 0; + 1991. unsigned offset = get_slot_offset(node, slot); + +lib/vsprintf.c:2056: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2054. /* it's the next argument */ + 2055. spec->type = FORMAT_TYPE_WIDTH; + 2056. > return ++fmt - start; + 2057. } + 2058. + +lib/vsprintf.c:2071: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2069. /* it's the next argument */ + 2070. spec->type = FORMAT_TYPE_PRECISION; + 2071. > return ++fmt - start; + 2072. } + 2073. } + +lib/vsprintf.c:2097: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2095. case 'c': + 2096. spec->type = FORMAT_TYPE_CHAR; + 2097. > return ++fmt - start; + 2098. + 2099. case 's': + +lib/vsprintf.c:2101: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2099. case 's': + 2100. spec->type = FORMAT_TYPE_STR; + 2101. > return ++fmt - start; + 2102. + 2103. case 'p': + +lib/vsprintf.c:2105: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2103. case 'p': + 2104. spec->type = FORMAT_TYPE_PTR; + 2105. > return ++fmt - start; + 2106. + 2107. case '%': + +lib/vsprintf.c:2109: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2107. case '%': + 2108. spec->type = FORMAT_TYPE_PERCENT_CHAR; + 2109. > return ++fmt - start; + 2110. + 2111. /* integer number formats - set up the flags and "break" */ + +lib/vsprintf.c:2163: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2161. } + 2162. + 2163. > return ++fmt - start; + 2164. } + 2165. + +net/wireless/trace.h:1990: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +security/selinux/ss/policydb.c:2005: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2003. if (rc) + 2004. return rc; + 2005. > nel = le32_to_cpu(buf[0]); + 2006. + 2007. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2011: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2009. if (rc) + 2010. goto out; + 2011. > len = le32_to_cpu(buf[0]); + 2012. + 2013. rc = -ENOMEM; + +security/selinux/ss/policydb.c:2045: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2043. goto out; + 2044. + 2045. > nel2 = le32_to_cpu(buf[0]); + 2046. for (j = 0; j < nel2; j++) { + 2047. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:2050: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2048. if (rc) + 2049. goto out; + 2050. > len = le32_to_cpu(buf[0]); + 2051. + 2052. rc = -ENOMEM; + +security/selinux/ss/policydb.c:2065: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2063. goto out; + 2064. + 2065. > newc->v.sclass = le32_to_cpu(buf[0]); + 2066. rc = context_read_and_validate(&newc->context[0], p, fp); + 2067. if (rc) + +drivers/tty/n_tty.c:2007: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2005. return 0; + 2006. + 2007. > n = min(*nr + 1, smp_load_acquire(&ldata->canon_head) - ldata->read_tail); + 2008. + 2009. tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + +drivers/cpufreq/cpufreq.c:2002: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2000. unsigned int relation) + 2001. { + 2002. > int ret = -EINVAL; + 2003. + 2004. down_write(&policy->rwsem); + +drivers/gpu/drm/drm_dp_mst_topology.c:2019: error: DEAD_STORE + The value written to &len (type int) is never used. + 2017. } + 2018. + 2019. > len = build_dpcd_write(txmsg, port->port_num, offset, size, bytes); + 2020. txmsg->dst = mstb; + 2021. + +kernel/module.c:2008: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2006. + 2007. mutex_lock(&module_mutex); + 2008. > list_for_each_entry_rcu(mod, &modules, list) { + 2009. /* + 2010. * Ignore going modules since it's possible that ro + +net/ipv4/tcp_ipv4.c:2005: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2003. { + 2004. struct tcp_iter_state *st = seq->private; + 2005. > struct net *net = seq_file_net(seq); + 2006. void *rc = NULL; + 2007. + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +drivers/net/ethernet/broadcom/tg3.c:2023: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2014 could be null and is dereferenced at line 2023, column 6. + 2021. oldflowctrl = tp->link_config.active_flowctrl; + 2022. + 2023. > if (phydev->link) { + 2024. lcl_adv = 0; + 2025. rmt_adv = 0; + +net/packet/af_packet.c:2016: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2014. + 2015. rcu_read_lock(); + 2016. > filter = rcu_dereference(sk->sk_filter); + 2017. if (filter != NULL) + 2018. res = bpf_prog_run_clear_cb(filter->prog, skb); + +kernel/cgroup/cgroup.c:2022: error: NULL_DEREFERENCE + pointer `ns` last assigned on line 2015 could be null and is dereferenced at line 2022, column 18. + 2020. + 2021. /* Check if the caller has permission to mount. */ + 2022. > if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN)) { + 2023. put_cgroup_ns(ns); + 2024. return ERR_PTR(-EPERM); + +net/wireless/trace.h:2011: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +kernel/workqueue.c:2034: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2032. #endif + 2033. /* ensure we're on the correct CPU */ + 2034. > WARN_ON_ONCE(!(pool->flags & POOL_DISASSOCIATED) && + 2035. raw_smp_processor_id() != pool->cpu); + 2036. + +kernel/auditsc.c:2028: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2026. return; + 2027. + 2028. > uid = from_kuid(&init_user_ns, task_uid(current)); + 2029. oldloginuid = from_kuid(&init_user_ns, koldloginuid); + 2030. loginuid = from_kuid(&init_user_ns, kloginuid), + +net/xfrm/xfrm_state.c:2022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2020. + 2021. rcu_read_lock(); + 2022. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2023. if (km->report) { + 2024. ret = km->report(net, proto, sel, addr); + +kernel/trace/trace.c:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. if (atomic_read(&trace_record_taskinfo_disabled) || !tracing_is_on()) + 2028. return true; + 2029. > if (!__this_cpu_read(trace_taskinfo_save)) + 2030. return true; + 2031. return false; + +kernel/cpu.c:2027: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2025. void __init boot_cpu_state_init(void) + 2026. { + 2027. > per_cpu_ptr(&cpuhp_state, smp_processor_id())->state = CPUHP_ONLINE; + 2028. } + +net/wireless/trace.h:2029: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/ipv6/route.c:2045: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2043. + 2044. rcu_read_lock(); + 2045. > fn = rcu_dereference(rt->rt6i_node); + 2046. if (fn && (rt->rt6i_flags & RTF_DEFAULT)) + 2047. fn->fn_sernum = -1; + +net/ipv4/tcp_output.c:2036: error: NULL_DEREFERENCE + pointer `skb` last assigned on line 2035 could be null and is dereferenced at line 2036, column 2. + 2034. + 2035. skb = tcp_send_head(sk); + 2036. > tcp_for_write_queue_from_safe(skb, next, sk) { + 2037. if (len <= skb->len) + 2038. break; + +net/ipv4/tcp_ipv4.c:2038: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2036. struct hlist_nulls_node *node; + 2037. struct tcp_iter_state *st = seq->private; + 2038. > struct net *net = seq_file_net(seq); + 2039. + 2040. ++st->num; + +net/xfrm/xfrm_state.c:2040: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2038. + 2039. rcu_read_lock(); + 2040. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2041. if (km->is_alive && km->is_alive(c)) { + 2042. is_alive = true; + +net/ipv4/igmp.c:2048: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2046. return -ENODEV; + 2047. rcu_read_lock(); + 2048. > for_each_pmc_rcu(in_dev, pmc) { + 2049. if (*pmca == pmc->multiaddr) + 2050. break; + +net/sunrpc/xprtsock.c:2042: error: DEAD_STORE + The value written to &status (type int) is never used. + 2040. struct rpc_xprt *xprt = &transport->xprt; + 2041. struct socket *sock; + 2042. > int status = -EIO; + 2043. + 2044. status = __sock_create(xprt->xprt_net, AF_LOCAL, + +net/ipv4/devinet.c:2052: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2050. + 2051. rcu_read_lock(); + 2052. > for_each_netdev_rcu(net, dev) { + 2053. struct in_device *in_dev; + 2054. + +net/wireless/trace.h:2047: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/xfrm/xfrm_state.c:2080: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2078. err = -EINVAL; + 2079. rcu_read_lock(); + 2080. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2081. pol = km->compile_policy(sk, optname, data, + 2082. optlen, &err); + +drivers/md/md.c:2062: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2060. + 2061. rcu_read_lock(); + 2062. > rdev_for_each_rcu(rdev, mddev1) { + 2063. if (test_bit(Faulty, &rdev->flags) || + 2064. test_bit(Journal, &rdev->flags) || + +drivers/md/md.c:2067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2065. rdev->raid_disk == -1) + 2066. continue; + 2067. > rdev_for_each_rcu(rdev2, mddev2) { + 2068. if (test_bit(Faulty, &rdev2->flags) || + 2069. test_bit(Journal, &rdev2->flags) || + +drivers/scsi/sd.c:2139: error: DEAD_STORE + The value written to &spintime_expire (type unsigned long) is never used. + 2137. SD_TIMEOUT, SD_MAX_RETRIES, + 2138. NULL); + 2139. > spintime_expire = jiffies + 100 * HZ; + 2140. spintime = 1; + 2141. } + +drivers/scsi/sd.c:2155: error: DEAD_STORE + The value written to &spintime_expire (type unsigned long) is never used. + 2153. sshdr.asc == 0x28) { + 2154. if (!spintime) { + 2155. > spintime_expire = jiffies + 5 * HZ; + 2156. spintime = 1; + 2157. } + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2115: error: UNINITIALIZED_VALUE + The value read from fence.flags was never initialized. + 2113. ~__I915_EXEC_FENCE_UNKNOWN_FLAGS); + 2114. + 2115. > fences[n] = ptr_pack_bits(syncobj, fence.flags, 2); + 2116. } + 2117. + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2105: error: UNINITIALIZED_VALUE + The value read from fence.handle was never initialized. + 2103. } + 2104. + 2105. > syncobj = drm_syncobj_find(file, fence.handle); + 2106. if (!syncobj) { + 2107. DRM_DEBUG("Invalid syncobj handle provided\n"); + +kernel/rcu/tree.c:2067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2065. + 2066. /* Someone like call_rcu() requested a force-quiescent-state scan. */ + 2067. > *gfp = READ_ONCE(rsp->gp_flags); + 2068. if (*gfp & RCU_GP_FLAG_FQS) + 2069. return true; + +net/ipv6/route.c:2066: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2064. return !(rt->rt6i_flags & RTF_CACHE) && + 2065. (rt->rt6i_flags & RTF_PCPU || + 2066. > rcu_access_pointer(rt->rt6i_node)); + 2067. } + 2068. + +net/wireless/trace.h:2067: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/xfrm/xfrm_user.c:2084: error: DEAD_STORE + The value written to &err (type int) is never used. + 2082. struct xfrm_userpolicy_info *p = &up->pol; + 2083. u8 type = XFRM_POLICY_TYPE_MAIN; + 2084. > int err = -ENOENT; + 2085. struct xfrm_mark m; + 2086. u32 mark = xfrm_mark_get(attrs, &m); + +drivers/usb/core/devio.c:2084: error: UNINITIALIZED_VALUE + The value read from ds.context was never initialized. + 2082. return -EFAULT; + 2083. ps->discsignr = ds.signr; + 2084. > ps->disccontext = ds.context; + 2085. return 0; + 2086. } + +drivers/usb/core/devio.c:2083: error: UNINITIALIZED_VALUE + The value read from ds.signr was never initialized. + 2081. if (copy_from_user(&ds, arg, sizeof(ds))) + 2082. return -EFAULT; + 2083. > ps->discsignr = ds.signr; + 2084. ps->disccontext = ds.context; + 2085. return 0; + +drivers/hid/hid-sony.c:2126: error: DEAD_STORE + The value written to &offset (type int) is never used. + 2124. /* If both delay values are zero the DualShock 4 disables blinking. */ + 2125. buf[offset++] = sc->led_delay_on[3]; + 2126. > buf[offset++] = sc->led_delay_off[3]; + 2127. + 2128. if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2088: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 2087 could be null and is dereferenced at line 2088, column 8. + 2086. + 2087. power_well = lookup_power_well(dev_priv, power_well_id); + 2088. > ret = power_well->ops->is_enabled(dev_priv, power_well); + 2089. + 2090. return ret; + +drivers/usb/core/hub.c:2088: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2083 could be null and is dereferenced at line 2088, column 7. + 2086. /* Free up all the children before we remove this device */ + 2087. for (i = 0; i < udev->maxchild; i++) { + 2088. > if (hub->ports[i]->child) + 2089. usb_disconnect(&hub->ports[i]->child); + 2090. } + +net/wireless/trace.h:2087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +drivers/net/ethernet/broadcom/tg3.c:2106: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2103 could be null and is dereferenced by call to `phydev_name()` at line 2106, column 32. + 2104. + 2105. /* Attach the MAC to the PHY. */ + 2106. > phydev = phy_connect(tp->dev, phydev_name(phydev), + 2107. tg3_adjust_link, phydev->interface); + 2108. if (IS_ERR(phydev)) { + +arch/x86/events/intel/core.c:2100: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2098. + 2099. if (unlikely(hwc->idx == INTEL_PMC_IDX_FIXED_BTS)) { + 2100. > if (!__this_cpu_read(cpu_hw_events.enabled)) + 2101. return; + 2102. + +kernel/kprobes.c:2105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2103. * chained probes and mark them GONE. + 2104. */ + 2105. > list_for_each_entry_rcu(kp, &p->list, list) + 2106. kp->flags |= KPROBE_FLAG_GONE; + 2107. p->post_handler = NULL; + +kernel/sched/core.c:2133: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2131. + 2132. ttwu_do_wakeup(rq, p, 0, rf); + 2133. > ttwu_stat(p, smp_processor_id(), 0); + 2134. out: + 2135. raw_spin_unlock(&p->pi_lock); + +kernel/sched/core.c:2133: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2131. + 2132. ttwu_do_wakeup(rq, p, 0, rf); + 2133. > ttwu_stat(p, smp_processor_id(), 0); + 2134. out: + 2135. raw_spin_unlock(&p->pi_lock); + +kernel/sched/sched.h:2106: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2104. struct update_util_data *data; + 2105. + 2106. > data = rcu_dereference_sched(*per_cpu_ptr(&cpufreq_update_util_data, + 2107. cpu_of(rq))); + 2108. if (data) + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +security/selinux/ss/policydb.c:2118: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2116. if (rc) + 2117. goto out; + 2118. > nel = le32_to_cpu(buf[0]); + 2119. + 2120. l = NULL; + +security/selinux/ss/policydb.c:2138: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2136. goto out; + 2137. + 2138. > c->sid[0] = le32_to_cpu(buf[0]); + 2139. rc = context_read_and_validate(&c->context[0], p, fp); + 2140. if (rc) + +security/selinux/ss/policydb.c:2148: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2146. if (rc) + 2147. goto out; + 2148. > len = le32_to_cpu(buf[0]); + 2149. + 2150. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:2165: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2163. if (rc) + 2164. goto out; + 2165. > c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. c->u.port.high_port = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:2166: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2164. goto out; + 2165. c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. > c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. c->u.port.high_port = le32_to_cpu(buf[2]); + 2168. rc = context_read_and_validate(&c->context[0], p, fp); + +security/selinux/ss/policydb.c:2167: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2165. c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. > c->u.port.high_port = le32_to_cpu(buf[2]); + 2168. rc = context_read_and_validate(&c->context[0], p, fp); + 2169. if (rc) + +security/selinux/ss/policydb.c:2188: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2186. + 2187. rc = -EINVAL; + 2188. > c->v.behavior = le32_to_cpu(buf[0]); + 2189. /* Determined at runtime, not in policy DB. */ + 2190. if (c->v.behavior == SECURITY_FS_USE_MNTPOINT) + +security/selinux/ss/policydb.c:2195: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2193. goto out; + 2194. + 2195. > len = le32_to_cpu(buf[1]); + 2196. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + 2197. if (rc) + +security/selinux/ss/policydb.c:2245: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2243. if (rc) + 2244. goto out; + 2245. > len = le32_to_cpu(buf[0]); + 2246. + 2247. rc = str_read(&c->u.ibendport.dev_name, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:2256: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2254. } + 2255. + 2256. > c->u.ibendport.port = le32_to_cpu(buf[1]); + 2257. + 2258. rc = context_read_and_validate(&c->context[0], + +security/selinux/ss/policydb.c:2176: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2174. if (rc) + 2175. goto out; + 2176. > c->u.node.addr = nodebuf[0]; /* network order */ + 2177. c->u.node.mask = nodebuf[1]; /* network order */ + 2178. rc = context_read_and_validate(&c->context[0], p, fp); + +security/selinux/ss/policydb.c:2177: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2175. goto out; + 2176. c->u.node.addr = nodebuf[0]; /* network order */ + 2177. > c->u.node.mask = nodebuf[1]; /* network order */ + 2178. rc = context_read_and_validate(&c->context[0], p, fp); + 2179. if (rc) + +security/selinux/ss/policydb.c:2211: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2209. goto out; + 2210. for (k = 0; k < 4; k++) + 2211. > c->u.node6.addr[k] = nodebuf[k]; + 2212. for (k = 0; k < 4; k++) + 2213. c->u.node6.mask[k] = nodebuf[k+4]; + +security/selinux/ss/policydb.c:2213: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2211. c->u.node6.addr[k] = nodebuf[k]; + 2212. for (k = 0; k < 4; k++) + 2213. > c->u.node6.mask[k] = nodebuf[k+4]; + 2214. rc = context_read_and_validate(&c->context[0], p, fp); + 2215. if (rc) + +security/selinux/ss/policydb.c:2232: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2230. } + 2231. + 2232. > c->u.ibpkey.low_pkey = le32_to_cpu(nodebuf[2]); + 2233. c->u.ibpkey.high_pkey = le32_to_cpu(nodebuf[3]); + 2234. + +security/selinux/ss/policydb.c:2233: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2231. + 2232. c->u.ibpkey.low_pkey = le32_to_cpu(nodebuf[2]); + 2233. > c->u.ibpkey.high_pkey = le32_to_cpu(nodebuf[3]); + 2234. + 2235. rc = context_read_and_validate(&c->context[0], + +include/net/sock.h:2110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2108. if (sock_flag(sk, SOCK_FASYNC)) { + 2109. rcu_read_lock(); + 2110. > sock_wake_async(rcu_dereference(sk->sk_wq), how, band); + 2111. rcu_read_unlock(); + 2112. } + +kernel/rcu/tree.c:2170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2168. if (needgp || cpu_needs_another_gp(rsp, rdp)) { + 2169. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2170. > trace_rcu_grace_period(rsp->name, + 2171. READ_ONCE(rsp->gpnum), + 2172. TPS("newreq")); + +drivers/tty/n_tty.c:2168: error: DEAD_STORE + The value written to &nr (type unsigned long) is never used. + 2166. } + 2167. b++; + 2168. > nr--; + 2169. break; + 2170. } + +sound/core/pcm_lib.c:2208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2206. } + 2207. frames = size > avail ? avail : size; + 2208. > appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 2209. appl_ofs = appl_ptr % runtime->buffer_size; + 2210. cont = runtime->buffer_size - appl_ofs; + +net/core/ethtool.c:2135: error: UNINITIALIZED_VALUE + The value read from dump.len was never initialized. + 2133. return ret; + 2134. + 2135. > len = min(tmp.len, dump.len); + 2136. if (!len) + 2137. return -EFAULT; + +net/ipv4/fib_trie.c:2126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2124. while (!IS_TRIE(pn)) { + 2125. while (cindex < child_length(pn)) { + 2126. > struct key_vector *n = get_child_rcu(pn, cindex++); + 2127. + 2128. if (!n) + +net/ipv4/fib_trie.c:2146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2144. /* Current node exhausted, pop back up */ + 2145. pkey = pn->key; + 2146. > pn = node_parent_rcu(pn); + 2147. cindex = get_index(pkey, pn) + 1; + 2148. --iter->depth; + +lib/radix-tree.c:2131: error: UNINITIALIZED_VALUE + The value read from pco_ret__ was never initialized. + 2129. if (!bitmap) + 2130. return 0; + 2131. > if (this_cpu_cmpxchg(ida_bitmap, NULL, bitmap)) + 2132. kfree(bitmap); + 2133. } + +lib/radix-tree.c:2127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2125. preempt_enable(); + 2126. + 2127. > if (!this_cpu_read(ida_bitmap)) { + 2128. struct ida_bitmap *bitmap = kzalloc(sizeof(*bitmap), gfp); + 2129. if (!bitmap) + +net/ipv4/route.c:2154: error: NULL_DEREFERENCE + pointer `in_dev` last assigned on line 2132 could be null and is dereferenced at line 2154, column 8. + 2152. || + 2153. (!ipv4_is_local_multicast(daddr) && + 2154. > IN_DEV_MFORWARD(in_dev)) + 2155. #endif + 2156. ) { + +kernel/irq/manage.c:2154: error: MEMORY_LEAK + `chip` is not reachable after line 2154, column 3. + 2152. + 2153. if (data) + 2154. > err = chip->irq_get_irqchip_state(data, which, state); + 2155. + 2156. irq_put_desc_busunlock(desc, flags); + +arch/x86/events/core.c:2130: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2128. static void refresh_pce(void *ignored) + 2129. { + 2130. > load_mm_cr4(this_cpu_read(cpu_tlbstate.loaded_mm)); + 2131. } + 2132. + +net/ipv4/cipso_ipv4.c:2138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2136. + 2137. rcu_read_lock(); + 2138. > opt = rcu_dereference(inet_sk(sk)->inet_opt); + 2139. if (opt && opt->opt.cipso) + 2140. res = cipso_v4_getattr(opt->opt.__data + + +net/xfrm/xfrm_state.c:2147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2145. spin_lock_bh(&xfrm_state_afinfo_lock); + 2146. if (likely(xfrm_state_afinfo[afinfo->family] != NULL)) { + 2147. > if (rcu_access_pointer(xfrm_state_afinfo[family]) != afinfo) + 2148. err = -EINVAL; + 2149. else + +drivers/md/md.c:2148: error: DEAD_STORE + The value written to &bi_rdev (type blk_integrity*) is never used. + 2146. return 0; + 2147. + 2148. > bi_rdev = bdev_get_integrity(rdev->bdev); + 2149. bi_mddev = blk_get_integrity(mddev->gendisk); + 2150. + +lib/radix-tree.c:2160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2158. return ERR_PTR(error); + 2159. shift = error; + 2160. > child = rcu_dereference_raw(root->rnode); + 2161. } + 2162. + +lib/radix-tree.c:2193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2191. shift = node->shift; + 2192. } + 2193. > child = rcu_dereference_raw(node->slots[offset]); + 2194. } + 2195. slot = &node->slots[offset]; + +net/wireless/trace.h:2139: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/ipv4/ipmr.c:2186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2184. struct sock *mroute_sk; + 2185. + 2186. > mroute_sk = rcu_dereference(mrt->mroute_sk); + 2187. if (mroute_sk) { + 2188. nf_reset(skb); + +drivers/net/ethernet/broadcom/tg3.c:2154: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced at line 2154, column 3. + 2152. if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) { + 2153. tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER; + 2154. > phydev->speed = tp->link_config.speed; + 2155. phydev->duplex = tp->link_config.duplex; + 2156. phydev->autoneg = tp->link_config.autoneg; + +drivers/net/ethernet/broadcom/tg3.c:2160: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced by call to `phy_start()` at line 2160, column 2. + 2158. } + 2159. + 2160. > phy_start(phydev); + 2161. + 2162. phy_start_aneg(phydev); + +drivers/tty/serial/serial_core.c:2155: error: NULL_DEREFERENCE + pointer `tty_dev` last assigned on line 2154 could be null and is dereferenced by call to `device_may_wakeup()` at line 2155, column 27. + 2153. + 2154. tty_dev = device_find_child(uport->dev, &match, serial_match_port); + 2155. > if (!uport->suspended && device_may_wakeup(tty_dev)) { + 2156. if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) + 2157. disable_irq_wake(uport->irq); + +arch/x86/events/intel/core.c:2157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2155. static void intel_pmu_reset(void) + 2156. { + 2157. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 2158. unsigned long flags; + 2159. int idx; + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +arch/x86/events/intel/core.c:2157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2155. static void intel_pmu_reset(void) + 2156. { + 2157. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 2158. unsigned long flags; + 2159. int idx; + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +net/wireless/trace.h:2157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/ipv4/fib_trie.c:2167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2165. + 2166. pn = t->kv; + 2167. > n = rcu_dereference(pn->tnode[0]); + 2168. if (!n) + 2169. return NULL; + +net/xfrm/xfrm_state.c:2163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2161. return NULL; + 2162. + 2163. > return rcu_dereference(xfrm_state_afinfo[family]); + 2164. } + 2165. + +net/ipv4/udp.c:2179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2177. + 2178. result = NULL; + 2179. > sk_for_each_rcu(sk, &hslot->head) { + 2180. if (__udp_is_mcast_sock(net, sk, loc_port, loc_addr, + 2181. rmt_port, rmt_addr, dif, sdif, hnum)) { + +block/blk-mq.c:2172: error: NULL_DEREFERENCE + pointer `hctx` last assigned on line 2171 could be null and is dereferenced at line 2172, column 25. + 2170. + 2171. hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead); + 2172. > ctx = __blk_mq_get_ctx(hctx->queue, cpu); + 2173. + 2174. spin_lock(&ctx->lock); + +kernel/trace/trace.c:2189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2187. + 2188. preempt_disable(); + 2189. > if (cpu == smp_processor_id() && + 2190. this_cpu_read(trace_buffered_event) != + 2191. per_cpu(trace_buffered_event, cpu)) + +kernel/trace/trace.c:2190: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2188. preempt_disable(); + 2189. if (cpu == smp_processor_id() && + 2190. > this_cpu_read(trace_buffered_event) != + 2191. per_cpu(trace_buffered_event, cpu)) + 2192. WARN_ON_ONCE(1); + +net/ipv6/route.c:2188: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2186. fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); + 2187. restart: + 2188. > for_each_fib6_node_rt_rcu(fn) { + 2189. if (rt->rt6i_nh_flags & RTNH_F_DEAD) + 2190. continue; + +net/xfrm/xfrm_state.c:2172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2170. return NULL; + 2171. rcu_read_lock(); + 2172. > afinfo = rcu_dereference(xfrm_state_afinfo[family]); + 2173. if (unlikely(!afinfo)) + 2174. rcu_read_unlock(); + +net/ipv4/route.c:2239: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2237. if (fnhe) { + 2238. prth = &fnhe->fnhe_rth_output; + 2239. > rth = rcu_dereference(*prth); + 2240. if (rth && rth->dst.expires && + 2241. time_after(jiffies, rth->dst.expires)) { + +net/ipv4/route.c:2257: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2255. } + 2256. prth = raw_cpu_ptr(nh->nh_pcpu_rth_output); + 2257. > rth = rcu_dereference(*prth); + 2258. + 2259. rt_cache: + +net/xfrm/xfrm_user.c:2214: error: DEAD_STORE + The value written to &err (type int) is never used. + 2212. t->ealgos = ua->ealgos; + 2213. t->calgos = ua->calgos; + 2214. > err = km_query(x, t, xp); + 2215. + 2216. } + +kernel/irq/manage.c:2200: error: MEMORY_LEAK + `chip` is not reachable after line 2200, column 3. + 2198. + 2199. if (data) + 2200. > err = chip->irq_set_irqchip_state(data, which, val); + 2201. + 2202. irq_put_desc_busunlock(desc, flags); + +net/wireless/trace.h:2175: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +kernel/rcu/tree.c:2230: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2228. TPS("fqswait")); + 2229. rsp->gp_state = RCU_GP_WAIT_FQS; + 2230. > ret = swait_event_idle_timeout(rsp->gp_wq, + 2231. rcu_gp_fqs_check_wake(rsp, &gf), j); + 2232. rsp->gp_state = RCU_GP_DOING_FQS; + +kernel/rcu/tree.c:2194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2192. /* Handle grace-period start. */ + 2193. for (;;) { + 2194. > trace_rcu_grace_period(rsp->name, + 2195. READ_ONCE(rsp->gpnum), + 2196. TPS("reqwait")); + +kernel/rcu/tree.c:2207: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2205. WRITE_ONCE(rsp->gp_activity, jiffies); + 2206. WARN_ON(signal_pending(current)); + 2207. > trace_rcu_grace_period(rsp->name, + 2208. READ_ONCE(rsp->gpnum), + 2209. TPS("reqwaitsig")); + +kernel/rcu/tree.c:2226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2224. jiffies + 3 * j); + 2225. } + 2226. > trace_rcu_grace_period(rsp->name, + 2227. READ_ONCE(rsp->gpnum), + 2228. TPS("fqswait")); + +kernel/rcu/tree.c:2241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2239. if (ULONG_CMP_GE(jiffies, rsp->jiffies_force_qs) || + 2240. (gf & RCU_GP_FLAG_FQS)) { + 2241. > trace_rcu_grace_period(rsp->name, + 2242. READ_ONCE(rsp->gpnum), + 2243. TPS("fqsstart")); + +kernel/rcu/tree.c:2246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2244. rcu_gp_fqs(rsp, first_gp_fqs); + 2245. first_gp_fqs = false; + 2246. > trace_rcu_grace_period(rsp->name, + 2247. READ_ONCE(rsp->gpnum), + 2248. TPS("fqsend")); + +kernel/rcu/tree.c:2265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2263. WRITE_ONCE(rsp->gp_activity, jiffies); + 2264. WARN_ON(signal_pending(current)); + 2265. > trace_rcu_grace_period(rsp->name, + 2266. READ_ONCE(rsp->gpnum), + 2267. TPS("fqswaitsig")); + +net/core/dev.c:2231: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2229. for (i = tc, tci = cpu * num_tc; dev_maps && i--; tci++) { + 2230. /* fill in the new device map from the old device map */ + 2231. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2232. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2233. } + +net/core/dev.c:2258: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2256. } else if (dev_maps) { + 2257. /* fill in the new device map from the old device map */ + 2258. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2259. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2260. } + +net/core/dev.c:2265: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2263. for (i = num_tc - tc, tci++; dev_maps && --i; tci++) { + 2264. /* fill in the new device map from the old device map */ + 2265. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2266. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2267. } + +net/ipv4/fib_trie.c:2201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2199. s->maxdepth = iter.depth; + 2200. + 2201. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) + 2202. ++s->prefixes; + 2203. } else { + +drivers/net/ethernet/intel/e1000/e1000_main.c:2206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2204. struct e1000_rx_ring *ring = &adapter->rx_ring[0]; + 2205. e1000_configure_rx(adapter); + 2206. > adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); + 2207. } + 2208. } + +ipc/sem.c:2210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2208. + 2209. rcu_read_lock(); + 2210. > un = list_entry_rcu(ulp->list_proc.next, + 2211. struct sem_undo, list_proc); + 2212. if (&un->list_proc == &ulp->list_proc) { + +net/xfrm/xfrm_state.c:2195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2193. int xfrm_state_mtu(struct xfrm_state *x, int mtu) + 2194. { + 2195. > const struct xfrm_type *type = READ_ONCE(x->type); + 2196. + 2197. if (x->km.state == XFRM_STATE_VALID && + +net/ipv4/udp.c:2208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2206. struct sock *sk; + 2207. + 2208. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 2209. if (INET_MATCH(sk, net, acookie, rmt_addr, + 2210. loc_addr, ports, dif, sdif)) + +kernel/fork.c:2206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2204. leader = top = top->group_leader; + 2205. down: + 2206. > for_each_thread(leader, parent) { + 2207. list_for_each_entry(child, &parent->children, sibling) { + 2208. res = visitor(child, data); + +block/cfq-iosched.c:2213: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced at line 2213, column 12. + 2211. if (cfq_class_idle(cfqq)) { + 2212. rb_key = CFQ_IDLE_DELAY; + 2213. > parent = st->rb_rightmost; + 2214. if (parent && parent != &cfqq->rb_node) { + 2215. __cfqq = rb_entry(parent, struct cfq_queue, rb_node); + +block/cfq-iosched.c:2231: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced by call to `cfq_rb_first()` at line 2231, column 12. + 2229. } else { + 2230. rb_key = -NSEC_PER_SEC; + 2231. > __cfqq = cfq_rb_first(st); + 2232. rb_key += __cfqq ? __cfqq->rb_key : now; + 2233. } + +net/wireless/trace.h:2200: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +drivers/usb/core/devio.c:2210: error: UNINITIALIZED_VALUE + The value read from ioc32.data was never initialized. + 2208. ctrl.ifno = ioc32.ifno; + 2209. ctrl.ioctl_code = ioc32.ioctl_code; + 2210. > ctrl.data = compat_ptr(ioc32.data); + 2211. return proc_ioctl(ps, &ctrl); + 2212. } + +drivers/usb/core/devio.c:2208: error: UNINITIALIZED_VALUE + The value read from ioc32.ifno was never initialized. + 2206. if (copy_from_user(&ioc32, compat_ptr(arg), sizeof(ioc32))) + 2207. return -EFAULT; + 2208. > ctrl.ifno = ioc32.ifno; + 2209. ctrl.ioctl_code = ioc32.ioctl_code; + 2210. ctrl.data = compat_ptr(ioc32.data); + +drivers/usb/core/devio.c:2209: error: UNINITIALIZED_VALUE + The value read from ioc32.ioctl_code was never initialized. + 2207. return -EFAULT; + 2208. ctrl.ifno = ioc32.ifno; + 2209. > ctrl.ioctl_code = ioc32.ioctl_code; + 2210. ctrl.data = compat_ptr(ioc32.data); + 2211. return proc_ioctl(ps, &ctrl); + +kernel/trace/trace_events.c:2237: error: UNINITIALIZED_VALUE + The value read from last_i was never initialized. + 2235. * system. + 2236. */ + 2237. > for (i = last_i; i < len; i++) { + 2238. if (call->class->system == map[i]->system) { + 2239. /* Save the first system if need be */ + +kernel/kprobes.c:2238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2236. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 2237. head = &kprobe_table[i]; + 2238. > hlist_for_each_entry_rcu(p, head, hlist) + 2239. if (within_module_init((unsigned long)p->addr, mod) || + 2240. (checkcore && + +net/ipv4/udp.c:2261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2259. skb->sk = sk; + 2260. skb->destructor = sock_efree; + 2261. > dst = READ_ONCE(sk->sk_rx_dst); + 2262. + 2263. if (dst) + +net/wireless/trace.h:2220: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +kernel/futex.c:2233: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2231. * optimizing lock_ptr out of the logic below. + 2232. */ + 2233. > lock_ptr = READ_ONCE(q->lock_ptr); + 2234. if (lock_ptr != NULL) { + 2235. spin_lock(lock_ptr); + +lib/radix-tree.c:2223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2221. void idr_destroy(struct idr *idr) + 2222. { + 2223. > struct radix_tree_node *node = rcu_dereference_raw(idr->idr_rt.rnode); + 2224. if (radix_tree_is_internal_node(node)) + 2225. radix_tree_free_nodes(node); + +drivers/usb/host/ehci-sched.c:2270: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 2268. + 2269. /* give urb back to the driver; completion often (re)submits */ + 2270. > dev = urb->dev; + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + +drivers/iommu/intel-iommu.c:2293: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2291. * touches the iova range + 2292. */ + 2293. > tmp = cmpxchg64_local(&pte->val, 0ULL, pteval); + 2294. if (tmp) { + 2295. static int dumps = 5; + +kernel/signal.c:2279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2277. info->si_pid = task_pid_vnr(current->parent); + 2278. info->si_uid = from_kuid_munged(current_user_ns(), + 2279. > task_uid(current->parent)); + 2280. rcu_read_unlock(); + 2281. } + +net/wireless/trace.h:2244: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/unix/af_unix.c:2365: error: DEAD_STORE + The value written to &sunaddr (type sockaddr_un*) is never used. + 2363. /* Copy address just once */ + 2364. if (state->msg && state->msg->msg_name) { + 2365. > DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + +drivers/gpu/drm/drm_dp_mst_topology.c:2276: error: DEAD_STORE + The value written to &origlen (type int) is never used. + 2274. replylen = msg->curchunk_len + msg->curchunk_hdrlen; + 2275. + 2276. > origlen = replylen; + 2277. replylen -= len; + 2278. curreply = len; + +drivers/usb/core/devio.c:2264: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2262. return -EFAULT; + 2263. + 2264. > intf = usb_ifnum_to_if(ps->dev, dc.interface); + 2265. if (!intf) + 2266. return -EINVAL; + +drivers/usb/core/devio.c:2288: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2286. } + 2287. + 2288. > return claimintf(ps, dc.interface); + 2289. } + 2290. + +kernel/auditsc.c:2265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2263. context->target_pid = task_tgid_nr(t); + 2264. context->target_auid = audit_get_loginuid(t); + 2265. > context->target_uid = task_uid(t); + 2266. context->target_sessionid = audit_get_sessionid(t); + 2267. security_task_getsecid(t, &context->target_sid); + +kernel/trace/trace.c:2274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2272. if ((trace_file->flags & + 2273. (EVENT_FILE_FL_SOFT_DISABLED | EVENT_FILE_FL_FILTERED)) && + 2274. > (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. val = this_cpu_inc_return(trace_buffered_event_cnt); + +kernel/trace/trace.c:2276: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2274. (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. > val = this_cpu_inc_return(trace_buffered_event_cnt); + 2277. if (val == 1) { + 2278. trace_event_setup(entry, type, flags, pc); + +kernel/trace/trace.c:2274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2272. if ((trace_file->flags & + 2273. (EVENT_FILE_FL_SOFT_DISABLED | EVENT_FILE_FL_FILTERED)) && + 2274. > (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. val = this_cpu_inc_return(trace_buffered_event_cnt); + +net/wireless/trace.h:2262: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +kernel/printk/printk.c:2271: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2269. static inline int can_use_console(void) + 2270. { + 2271. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2272. } + 2273. + +kernel/printk/printk.c:2271: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2269. static inline int can_use_console(void) + 2270. { + 2271. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2272. } + 2273. + +drivers/input/input.c:2278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2276. rcu_read_lock(); + 2277. + 2278. > list_for_each_entry_rcu(handle, &handler->h_list, h_node) { + 2279. retval = fn(handle, data); + 2280. if (retval) + +net/ipv6/ip6_fib.c:2278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2276. if (tbl) { + 2277. h = (tbl->tb6_id & (FIB6_TABLE_HASHSZ - 1)) + 1; + 2278. > node = rcu_dereference_bh(hlist_next_rcu(&tbl->tb6_hlist)); + 2279. } else { + 2280. h = 0; + +net/ipv6/ip6_fib.c:2285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2283. + 2284. while (!node && h < FIB6_TABLE_HASHSZ) { + 2285. > node = rcu_dereference_bh( + 2286. hlist_first_rcu(&net->ipv6.fib_table_hash[h++])); + 2287. } + +security/selinux/ss/policydb.c:2447: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2445. goto bad; + 2446. + 2447. > rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + +security/selinux/ss/policydb.c:2298: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2296. rc = -EINVAL; + 2297. if (le32_to_cpu(buf[0]) != POLICYDB_MAGIC) { + 2298. > printk(KERN_ERR "SELinux: policydb magic number 0x%x does " + 2299. "not match expected magic number 0x%x\n", + 2300. le32_to_cpu(buf[0]), POLICYDB_MAGIC); + +security/selinux/ss/policydb.c:2305: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2303. + 2304. rc = -EINVAL; + 2305. > len = le32_to_cpu(buf[1]); + 2306. if (len != strlen(POLICYDB_STRING)) { + 2307. printk(KERN_ERR "SELinux: policydb string length %d does not " + +security/selinux/ss/policydb.c:2346: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2344. + 2345. rc = -EINVAL; + 2346. > p->policyvers = le32_to_cpu(buf[0]); + 2347. if (p->policyvers < POLICYDB_VERSION_MIN || + 2348. p->policyvers > POLICYDB_VERSION_MAX) { + +security/selinux/ss/policydb.c:2349: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2347. if (p->policyvers < POLICYDB_VERSION_MIN || + 2348. p->policyvers > POLICYDB_VERSION_MAX) { + 2349. > printk(KERN_ERR "SELinux: policydb version %d does not match " + 2350. "my version range %d-%d\n", + 2351. le32_to_cpu(buf[0]), POLICYDB_VERSION_MIN, POLICYDB_VERSION_MAX); + +security/selinux/ss/policydb.c:2392: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2390. if (le32_to_cpu(buf[2]) != info->sym_num || + 2391. le32_to_cpu(buf[3]) != info->ocon_num) { + 2392. > printk(KERN_ERR "SELinux: policydb table sizes (%d,%d) do " + 2393. "not match mine (%d,%d)\n", le32_to_cpu(buf[2]), + 2394. le32_to_cpu(buf[3]), + +security/selinux/ss/policydb.c:2403: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2401. if (rc) + 2402. goto bad; + 2403. > nprim = le32_to_cpu(buf[0]); + 2404. nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + +security/selinux/ss/policydb.c:2404: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2402. goto bad; + 2403. nprim = le32_to_cpu(buf[0]); + 2404. > nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + 2406. rc = read_f[i](p, p->symtab[i].table, fp); + +security/selinux/ss/policydb.c:2432: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2430. if (rc) + 2431. goto bad; + 2432. > nel = le32_to_cpu(buf[0]); + 2433. ltr = NULL; + 2434. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2448: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2446. + 2447. rc = -EINVAL; + 2448. > tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + 2450. tr->new_role = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:2449: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2447. rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. > tr->type = le32_to_cpu(buf[1]); + 2450. tr->new_role = le32_to_cpu(buf[2]); + 2451. if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) { + +security/selinux/ss/policydb.c:2450: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + 2450. > tr->new_role = le32_to_cpu(buf[2]); + 2451. if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) { + 2452. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:2455: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2453. if (rc) + 2454. goto bad; + 2455. > tr->tclass = le32_to_cpu(buf[0]); + 2456. } else + 2457. tr->tclass = p->process_class; + +security/selinux/ss/policydb.c:2471: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2469. if (rc) + 2470. goto bad; + 2471. > nel = le32_to_cpu(buf[0]); + 2472. lra = NULL; + 2473. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2487: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2485. + 2486. rc = -EINVAL; + 2487. > ra->role = le32_to_cpu(buf[0]); + 2488. ra->new_role = le32_to_cpu(buf[1]); + 2489. if (!policydb_role_isvalid(p, ra->role) || + +security/selinux/ss/policydb.c:2488: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2486. rc = -EINVAL; + 2487. ra->role = le32_to_cpu(buf[0]); + 2488. > ra->new_role = le32_to_cpu(buf[1]); + 2489. if (!policydb_role_isvalid(p, ra->role) || + 2490. !policydb_role_isvalid(p, ra->new_role)) + +kernel/sysctl.c:2325: error: DEAD_STORE + The value written to &left (type unsigned long) is never used. + 2323. + 2324. if (!err && left) + 2325. > left -= proc_skip_spaces(&p); + 2326. + 2327. out_free: + +kernel/auditsc.c:2284: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2282. struct task_struct *tsk = current; + 2283. struct audit_context *ctx = tsk->audit_context; + 2284. > kuid_t uid = current_uid(), t_uid = task_uid(t); + 2285. + 2286. if (auditd_test_task(t) && + +drivers/cdrom/cdrom.c:2302: error: UNINITIALIZED_VALUE + The value read from ms_info.addr_format was never initialized. + 2300. return -EFAULT; + 2301. + 2302. > requested_format = ms_info.addr_format; + 2303. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2304. return -EINVAL; + +kernel/printk/printk.c:2428: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 2426. retry = console_seq != log_next_seq; + 2427. raw_spin_unlock(&logbuf_lock); + 2428. > printk_safe_exit_irqrestore(flags); + 2429. + 2430. if (retry && console_trylock()) + +include/linux/pci.h:2314: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2312. + 2313. if (idx > 0) { + 2314. > envp[idx++] = NULL; + 2315. kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp); + 2316. } + +net/ipv4/udp.c:2298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2296. if (static_key_false(&udp_encap_needed) && up->encap_type) { + 2297. void (*encap_destroy)(struct sock *sk); + 2298. > encap_destroy = READ_ONCE(up->encap_destroy); + 2299. if (encap_destroy) + 2300. encap_destroy(sk); + +kernel/signal.c:2474: error: UNINITIALIZED_VALUE + The value read from signr was never initialized. + 2472. spin_unlock_irq(&sighand->siglock); + 2473. + 2474. > ksig->sig = signr; + 2475. return ksig->sig > 0; + 2476. } + +drivers/gpu/drm/i915/intel_ddi.c:2303: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2298 could be null and is dereferenced at line 2303, column 2. + 2301. intel_disable_ddi_buf(encoder); + 2302. + 2303. > dig_port->set_infoframes(&encoder->base, false, + 2304. old_crtc_state, old_conn_state); + 2305. + +kernel/rcu/tree.c:2310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2308. } + 2309. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2310. > trace_rcu_grace_period(rsp->name, READ_ONCE(rsp->gpnum), + 2311. TPS("newreq")); + 2312. + +net/ipv4/fib_trie.c:2311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2309. struct fib_table *tb; + 2310. + 2311. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2312. struct trie *t = (struct trie *) tb->tb_data; + 2313. struct trie_stat stat; + +drivers/gpu/drm/drm_dp_mst_topology.c:2314: error: DEAD_STORE + The value written to &slot (type int) is never used. + 2312. struct drm_dp_sideband_msg_tx *txmsg; + 2313. struct drm_dp_mst_branch *mstb; + 2314. > int slot = -1; + 2315. mstb = drm_dp_get_mst_branch_device(mgr, + 2316. mgr->down_rep_recv.initial_hdr.lct, + +net/wireless/trace.h:2301: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/ipv4/ipmr.c:2343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2341. nla_nest_end(skb, mp_attr); + 2342. + 2343. > lastuse = READ_ONCE(c->mfc_un.res.lastuse); + 2344. lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0; + 2345. + +net/ipv6/ip6_fib.c:2312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2310. goto iter_table; + 2311. + 2312. > n = rcu_dereference_bh(((struct rt6_info *)v)->rt6_next); + 2313. if (n) { + 2314. ++*pos; + +kernel/trace/ring_buffer.c:2338: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2336. old_index += write_mask; + 2337. new_index += write_mask; + 2338. > index = local_cmpxchg(&bpage->write, old_index, new_index); + 2339. if (index == old_index) { + 2340. /* update counters */ + +kernel/trace/ring_buffer.c:2324: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2322. addr &= PAGE_MASK; + 2323. + 2324. > bpage = READ_ONCE(cpu_buffer->tail_page); + 2325. + 2326. if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) { + +net/core/neighbour.c:2337: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2335. + 2336. rcu_read_lock_bh(); + 2337. > nht = rcu_dereference_bh(tbl->nht); + 2338. + 2339. for (h = s_h; h < (1 << nht->hash_shift); h++) { + +net/core/neighbour.c:2342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2340. if (h > s_h) + 2341. s_idx = 0; + 2342. > for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; + 2343. n != NULL; + 2344. n = rcu_dereference_bh(n->next)) { + +net/core/neighbour.c:2344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2342. for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; + 2343. n != NULL; + 2344. > n = rcu_dereference_bh(n->next)) { + 2345. if (idx < s_idx || !net_eq(dev_net(n->dev), net)) + 2346. goto next; + +net/sunrpc/clnt.c:2375: error: DEAD_STORE + The value written to &len (type int) is never used. + 2373. goto out_err; + 2374. } + 2375. > if (--len < 0) + 2376. goto out_overflow; + 2377. switch ((n = ntohl(*p++))) { + +net/sunrpc/clnt.c:2377: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 2375. if (--len < 0) + 2376. goto out_overflow; + 2377. > switch ((n = ntohl(*p++))) { + 2378. case RPC_AUTH_REJECTEDCRED: + 2379. case RPC_AUTH_REJECTEDVERF: + +net/ipv6/addrconf.c:2345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2343. goto out; + 2344. + 2345. > for_each_fib6_node_rt_rcu(fn) { + 2346. if (rt->dst.dev->ifindex != dev->ifindex) + 2347. continue; + +net/wireless/trace.h:2326: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/ipv4/route.c:2337: error: DEAD_STORE + The value written to &err (type int) is never used. + 2335. unsigned int flags = 0; + 2336. struct rtable *rth; + 2337. > int err = -ENETUNREACH; + 2338. + 2339. if (fl4->saddr) { + +net/xfrm/xfrm_policy.c:2349: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2347. for (; idx < sp->len; idx++) { + 2348. if (xfrm_state_ok(tmpl, sp->xvec[idx], family)) + 2349. > return ++idx; + 2350. if (sp->xvec[idx]->props.mode != XFRM_MODE_TRANSPORT) { + 2351. if (start == -1) + +net/wireless/trace.h:2338: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2336. ); + 2337. + 2338. > DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, + 2339. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2340. TP_ARGS(netdev, macaddr), + +kernel/sched/core.c:2344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2342. { + 2343. unsigned long flags; + 2344. > int cpu = get_cpu(); + 2345. + 2346. __sched_fork(clone_flags, p); + +kernel/sched/core.c:2344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2342. { + 2343. unsigned long flags; + 2344. > int cpu = get_cpu(); + 2345. + 2346. __sched_fork(clone_flags, p); + +drivers/usb/core/hub.c:2360: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2354 could be null and is dereferenced at line 2360, column 10. + 2358. * use that to determine whether it's removable. + 2359. */ + 2360. > switch (hub->ports[udev->portnum - 1]->connect_type) { + 2361. case USB_PORT_CONNECT_TYPE_HOT_PLUG: + 2362. udev->removable = USB_DEVICE_REMOVABLE; + +net/ipv4/fib_trie.c:2354: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2352. struct fib_table *tb; + 2353. + 2354. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2355. struct key_vector *n; + 2356. + +kernel/events/core.c:2355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2353. int cpu) + 2354. { + 2355. > struct task_struct *task = READ_ONCE(ctx->task); + 2356. + 2357. lockdep_assert_held(&ctx->mutex); + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2358: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2356. ); + 2357. + 2358. > DECLARE_EVENT_CLASS(netdev_evt_only, + 2359. TP_PROTO(struct net_device *netdev), + 2360. TP_ARGS(netdev), + +arch/x86/events/core.c:2375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2373. + 2374. /* IRQs are off, so this synchronizes with smp_store_release */ + 2375. > ldt = READ_ONCE(current->active_mm->context.ldt); + 2376. if (!ldt || idx >= ldt->nr_entries) + 2377. return 0; + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +kernel/kprobes.c:2383: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2381. head = &kprobe_table[i]; + 2382. preempt_disable(); + 2383. > hlist_for_each_entry_rcu(p, head, hlist) { + 2384. sym = kallsyms_lookup((unsigned long)p->addr, NULL, + 2385. &offset, &modname, namebuf); + +kernel/kprobes.c:2387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2385. &offset, &modname, namebuf); + 2386. if (kprobe_aggrprobe(p)) { + 2387. > list_for_each_entry_rcu(kp, &p->list, list) + 2388. report_probe(pi, kp, sym, offset, modname, p); + 2389. } else + +net/wireless/trace.h:2375: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/ipv4/fib_trie.c:2394: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2392. /* walk rest of this hash chain */ + 2393. h = tb->tb_id & (FIB_TABLE_HASHSZ - 1); + 2394. > while ((tb_node = rcu_dereference(hlist_next_rcu(&tb->tb_hlist)))) { + 2395. tb = hlist_entry(tb_node, struct fib_table, tb_hlist); + 2396. n = fib_trie_get_first(iter, (struct trie *) tb->tb_data); + +net/ipv4/fib_trie.c:2404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2402. while (++h < FIB_TABLE_HASHSZ) { + 2403. struct hlist_head *head = &net->ipv4.fib_table_hash[h]; + 2404. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2405. n = fib_trie_get_first(iter, (struct trie *) tb->tb_data); + 2406. if (n) + +drivers/gpu/drm/i915/i915_drv.c:2388: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/i915_drv.c:2388: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/i915_drv.c:2388: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/intel_ddi.c:2408: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2396 could be null and is dereferenced at line 2408, column 2. + 2406. * enabling the port. + 2407. */ + 2408. > I915_WRITE(DDI_BUF_CTL(port), + 2409. dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE); + 2410. + +net/wireless/trace.h:2392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2390. ); + 2391. + 2392. > DECLARE_EVENT_CLASS(netdev_frame_event, + 2393. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2394. TP_ARGS(netdev, buf, len), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2407: error: DEAD_STORE + The value written to &ctrl (type unsigned int) is never used. + 2405. u16 phy_data; + 2406. + 2407. > ctrl = er32(CTRL); + 2408. status = er32(STATUS); + 2409. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2468: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 2466. hw->forced_speed_duplex == e1000_10_half)) { + 2467. ew32(IMC, 0xffffffff); + 2468. > ret_val = + 2469. e1000_polarity_reversal_workaround(hw); + 2470. icr = er32(ICR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2416: error: DEAD_STORE + The value written to &rxcw (type unsigned int) is never used. + 2414. if ((hw->media_type == e1000_media_type_fiber) || + 2415. (hw->media_type == e1000_media_type_internal_serdes)) { + 2416. > rxcw = er32(RXCW); + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2419: error: DEAD_STORE + The value written to &signal (type unsigned int) is never used. + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + 2419. > signal = + 2420. (hw->mac_type > + 2421. e1000_82544) ? E1000_CTRL_SWDPIN1 : 0; + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/sunrpc/xprtsock.c:2419: error: DEAD_STORE + The value written to &status (type int) is never used. + 2417. struct socket *sock = transport->sock; + 2418. struct rpc_xprt *xprt = &transport->xprt; + 2419. > int status = -EIO; + 2420. + 2421. if (!sock) { + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +include/linux/netdevice.h:2424: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2422. + 2423. net = dev_net(dev); + 2424. > lh = rcu_dereference(list_next_rcu(&dev->dev_list)); + 2425. return lh == &net->dev_base_head ? NULL : net_device_entry(lh); + 2426. } + +net/wireless/trace.h:2418: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +drivers/md/md.c:2453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2451. if (ret == 0) + 2452. md_cluster_ops->metadata_update_cancel(mddev); + 2453. > bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2454. BIT(MD_SB_CHANGE_DEVS) | + 2455. BIT(MD_SB_CHANGE_CLEAN)); + +drivers/md/md.c:2602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2600. + 2601. if (mddev->in_sync != sync_req || + 2602. > !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2603. BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN))) + 2604. /* have to write it out again */ + +net/wireless/trace.h:2434: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2432. ); + 2433. + 2434. > DECLARE_EVENT_CLASS(netdev_mac_evt, + 2435. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2436. TP_ARGS(netdev, mac), + +kernel/trace/trace.c:2448: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2446. preempt_disable_notrace(); + 2447. + 2448. > export = rcu_dereference_raw_notrace(ftrace_exports_list); + 2449. while (export) { + 2450. trace_process_export(export, event); + +kernel/trace/trace.c:2451: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2449. while (export) { + 2450. trace_process_export(export, event); + 2451. > export = rcu_dereference_raw_notrace(export->next); + 2452. } + 2453. + +drivers/net/ethernet/intel/e1000/e1000_main.c:2461: error: DEAD_STORE + The value written to &txb2b (type _Bool) is never used. + 2459. if (!netif_carrier_ok(netdev)) { + 2460. u32 ctrl; + 2461. > bool txb2b = true; + 2462. /* update snapshot of PHY registers on LSC */ + 2463. e1000_get_speed_and_duplex(hw, + +drivers/net/ethernet/intel/e1000/e1000_main.c:2535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2533. + 2534. if (!netif_carrier_ok(netdev)) { + 2535. > if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { + 2536. /* We've lost link, so the controller stops DMA, + 2537. * but we've got queued Tx work that's never going + +net/core/neighbour.c:2453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2451. + 2452. rcu_read_lock_bh(); + 2453. > nht = rcu_dereference_bh(tbl->nht); + 2454. + 2455. read_lock(&tbl->lock); /* avoid resizes */ + +net/core/neighbour.c:2459: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2457. struct neighbour *n; + 2458. + 2459. > for (n = rcu_dereference_bh(nht->hash_buckets[chain]); + 2460. n != NULL; + 2461. n = rcu_dereference_bh(n->next)) + +net/core/neighbour.c:2461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2459. for (n = rcu_dereference_bh(nht->hash_buckets[chain]); + 2460. n != NULL; + 2461. > n = rcu_dereference_bh(n->next)) + 2462. cb(n, cookie); + 2463. } + +net/wireless/reg.c:2457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2455. rcu_read_lock(); + 2456. + 2457. > cfg80211_regd = rcu_dereference(cfg80211_regdomain); + 2458. wiphy1_regd = rcu_dereference(wiphy1->regd); + 2459. if (!wiphy1_regd) + +net/wireless/reg.c:2458: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2456. + 2457. cfg80211_regd = rcu_dereference(cfg80211_regdomain); + 2458. > wiphy1_regd = rcu_dereference(wiphy1->regd); + 2459. if (!wiphy1_regd) + 2460. wiphy1_regd = cfg80211_regd; + +net/wireless/reg.c:2462: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2460. wiphy1_regd = cfg80211_regd; + 2461. + 2462. > wiphy2_regd = rcu_dereference(wiphy2->regd); + 2463. if (!wiphy2_regd) + 2464. wiphy2_regd = cfg80211_regd; + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +kernel/kprobes.c:2478: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2476. head = &kprobe_table[i]; + 2477. /* Arm all kprobes on a best-effort basis */ + 2478. > hlist_for_each_entry_rcu(p, head, hlist) { + 2479. if (!kprobe_disabled(p)) { + 2480. err = arm_kprobe(p); + +net/wireless/trace.h:2459: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +drivers/net/ethernet/intel/e100.c:2464: error: DEAD_STORE + The value written to &nic (type nic*) is never used. + 2462. static int e100_get_regs_len(struct net_device *netdev) + 2463. { + 2464. > struct nic *nic = netdev_priv(netdev); + 2465. return 1 + E100_PHY_REGS + sizeof(nic->mem->dump_buf); + 2466. } + +net/ipv4/fib_trie.c:2472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2470. struct key_vector *n = v; + 2471. + 2472. > if (IS_TRIE(node_parent_rcu(n))) + 2473. fib_table_print(seq, iter->tb); + 2474. + +net/ipv4/fib_trie.c:2490: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2488. seq_printf(seq, " |-- %pI4\n", &val); + 2489. + 2490. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) { + 2491. char buf1[32], buf2[32]; + 2492. + +net/ipv4/tcp.c:2502: error: UNINITIALIZED_VALUE + The value read from opt.max_window was never initialized. + 2500. tp->snd_wl1 = opt.snd_wl1; + 2501. tp->snd_wnd = opt.snd_wnd; + 2502. > tp->max_window = opt.max_window; + 2503. + 2504. tp->rcv_wnd = opt.rcv_wnd; + +net/ipv4/tcp.c:2504: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wnd was never initialized. + 2502. tp->max_window = opt.max_window; + 2503. + 2504. > tp->rcv_wnd = opt.rcv_wnd; + 2505. tp->rcv_wup = opt.rcv_wup; + 2506. + +net/ipv4/tcp.c:2497: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wup was never initialized. + 2495. return -EINVAL; + 2496. + 2497. > if (after(opt.rcv_wup, tp->rcv_nxt)) + 2498. return -EINVAL; + 2499. + +net/ipv4/tcp.c:2505: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wup was never initialized. + 2503. + 2504. tp->rcv_wnd = opt.rcv_wnd; + 2505. > tp->rcv_wup = opt.rcv_wup; + 2506. + 2507. return 0; + +net/ipv4/tcp.c:2494: error: UNINITIALIZED_VALUE + The value read from opt.snd_wl1 was never initialized. + 2492. return -EINVAL; + 2493. + 2494. > if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd)) + 2495. return -EINVAL; + 2496. + +net/ipv4/tcp.c:2500: error: UNINITIALIZED_VALUE + The value read from opt.snd_wl1 was never initialized. + 2498. return -EINVAL; + 2499. + 2500. > tp->snd_wl1 = opt.snd_wl1; + 2501. tp->snd_wnd = opt.snd_wnd; + 2502. tp->max_window = opt.max_window; + +net/ipv4/tcp.c:2501: error: UNINITIALIZED_VALUE + The value read from opt.snd_wnd was never initialized. + 2499. + 2500. tp->snd_wl1 = opt.snd_wl1; + 2501. > tp->snd_wnd = opt.snd_wnd; + 2502. tp->max_window = opt.max_window; + 2503. + +kernel/rcu/tree.c:2499: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2497. */ + 2498. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */ + 2499. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 2500. raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + 2501. return; + +kernel/rcu/tree.c:2499: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2497. */ + 2498. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */ + 2499. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 2500. raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + 2501. return; + +net/wireless/trace.h:2483: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +include/linux/netdevice.h:2487: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2485. static inline int dev_recursion_level(void) + 2486. { + 2487. > return this_cpu_read(xmit_recursion); + 2488. } + 2489. + +include/linux/netdevice.h:2487: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2485. static inline int dev_recursion_level(void) + 2486. { + 2487. > return this_cpu_read(xmit_recursion); + 2488. } + 2489. + +net/core/dev.c:2502: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2500. rcu_read_lock(); + 2501. if (!(txq->state & QUEUE_STATE_ANY_XOFF)) { + 2502. > struct Qdisc *q = rcu_dereference(txq->qdisc); + 2503. + 2504. __netif_schedule(q); + +kernel/kprobes.c:2521: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2519. head = &kprobe_table[i]; + 2520. /* Disarm all kprobes on a best-effort basis */ + 2521. > hlist_for_each_entry_rcu(p, head, hlist) { + 2522. if (!arch_trampoline_kprobe(p) && !kprobe_disabled(p)) { + 2523. err = disarm_kprobe(p, false); + +net/wireless/trace.h:2505: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/core/dev.c:2516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2514. + 2515. rcu_read_lock(); + 2516. > q = rcu_dereference(dev_queue->qdisc); + 2517. __netif_schedule(q); + 2518. rcu_read_unlock(); + +net/ipv4/tcp.c:2525: error: UNINITIALIZED_VALUE + The value read from opt.opt_val was never initialized. + 2523. switch (opt.opt_code) { + 2524. case TCPOPT_MSS: + 2525. > tp->rx_opt.mss_clamp = opt.opt_val; + 2526. tcp_mtup_init(sk); + 2527. break; + +net/core/dev.c:2538: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2536. get_kfree_skb_cb(skb)->reason = reason; + 2537. local_irq_save(flags); + 2538. > skb->next = __this_cpu_read(softnet_data.completion_queue); + 2539. __this_cpu_write(softnet_data.completion_queue, skb); + 2540. raise_softirq_irqoff(NET_TX_SOFTIRQ); + +net/core/dev.c:2538: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2536. get_kfree_skb_cb(skb)->reason = reason; + 2537. local_irq_save(flags); + 2538. > skb->next = __this_cpu_read(softnet_data.completion_queue); + 2539. __this_cpu_write(softnet_data.completion_queue, skb); + 2540. raise_softirq_irqoff(NET_TX_SOFTIRQ); + +net/wireless/trace.h:2523: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +drivers/base/regmap/regmap.c:2574: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2572. map->unlock(map->lock_arg); + 2573. + 2574. > return ret; + 2575. } + 2576. EXPORT_SYMBOL_GPL(regmap_raw_read); + +drivers/iommu/intel-iommu.c:2542: error: DEAD_STORE + The value written to &req_id (type unsigned short) is never used. + 2540. return NULL; + 2541. + 2542. > req_id = ((u16)bus << 8) | devfn; + 2543. + 2544. if (dev_is_pci(dev)) { + +kernel/events/core.c:2549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2547. * so we need to check again lest we try to stop another CPU's event. + 2548. */ + 2549. > if (READ_ONCE(event->oncpu) != smp_processor_id()) + 2550. return -EAGAIN; + 2551. + +net/netlink/af_netlink.c:2565: error: UNINITIALIZED_VALUE + The value read from nlk was never initialized. + 2563. } while (sock_net(&nlk->sk) != seq_file_net(seq)); + 2564. + 2565. > return nlk; + 2566. } + 2567. + +drivers/gpu/drm/i915/intel_ddi.c:2585: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 2583 could be null and is dereferenced at line 2585, column 7. + 2583. intel_dig_port = enc_to_dig_port(&encoder->base); + 2584. + 2585. > if (intel_dig_port->infoframe_enabled(&encoder->base, pipe_config)) + 2586. pipe_config->has_infoframe = true; + 2587. + +net/netfilter/nf_conntrack_netlink.c:2593: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2591. struct nf_conntrack_helper *helper; + 2592. + 2593. > helper = rcu_dereference(help->helper); + 2594. if (helper && + 2595. nla_put_string(skb, CTA_EXPECT_HELP_NAME, helper->name)) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/core/neighbour.c:2550: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2548. struct neigh_hash_table *nht = state->nht; + 2549. struct neighbour *n = NULL; + 2550. > int bucket = state->bucket; + 2551. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + +net/core/neighbour.c:2554: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + 2553. for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) { + 2554. > n = rcu_dereference_bh(nht->hash_buckets[bucket]); + 2555. + 2556. while (n) { + +net/core/neighbour.c:2572: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2570. break; + 2571. next: + 2572. > n = rcu_dereference_bh(n->next); + 2573. } + 2574. + +net/wireless/trace.h:2546: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +kernel/workqueue.c:2560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2558. } + 2559. + 2560. > for_each_pwq(pwq, wq) { + 2561. struct worker_pool *pool = pwq->pool; + 2562. + +drivers/net/ethernet/broadcom/tg3.c:2613: error: UNINITIALIZED_VALUE + The value read from phy9_orig was never initialized. + 2611. tg3_phy_toggle_auxctl_smdsp(tp, false); + 2612. + 2613. > tg3_writephy(tp, MII_CTRL1000, phy9_orig); + 2614. + 2615. err = tg3_readphy(tp, MII_TG3_EXT_CTRL, ®32); + +net/wireless/trace.h:2563: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +kernel/events/core.c:2589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2587. * fall through with ret==-ENXIO. + 2588. */ + 2589. > ret = cpu_function_call(READ_ONCE(event->oncpu), + 2590. __perf_event_stop, &sd); + 2591. } while (ret == -EAGAIN); + +kernel/trace/trace.c:2603: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2601. preempt_disable_notrace(); + 2602. + 2603. > use_stack = __this_cpu_inc_return(ftrace_stack_reserve); + 2604. /* + 2605. * We don't need any atomic variables, just a barrier. + +drivers/iommu/amd_iommu.c:2581: error: DEAD_STORE + The value written to &npages (type int) is never used. + 2579. struct dma_ops_domain *dma_dom; + 2580. unsigned long startaddr; + 2581. > int npages = 2; + 2582. + 2583. domain = get_domain(dev); + +net/ipv4/ipmr.c:2592: error: DEAD_STORE + The value written to &rtm (type rtmsg*) is never used. + 2590. goto errout; + 2591. + 2592. > rtm = nlmsg_data(nlh); + 2593. + 2594. src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0; + +net/wireless/trace.h:2580: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/core/neighbour.c:2596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2594. return n; + 2595. } + 2596. > n = rcu_dereference_bh(n->next); + 2597. + 2598. while (1) { + +net/core/neighbour.c:2614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2612. break; + 2613. next: + 2614. > n = rcu_dereference_bh(n->next); + 2615. } + 2616. + +net/core/neighbour.c:2623: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2621. break; + 2622. + 2623. > n = rcu_dereference_bh(nht->hash_buckets[state->bucket]); + 2624. } + 2625. + +net/ipv4/igmp.c:2600: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2598. + 2599. rcu_read_lock(); + 2600. > for_each_pmc_rcu(inet, pmc) { + 2601. if (pmc->multi.imr_multiaddr.s_addr == loc_addr && + 2602. (pmc->multi.imr_ifindex == dif || + +net/ipv4/igmp.c:2609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2607. if (!pmc) + 2608. goto unlock; + 2609. > psl = rcu_dereference(pmc->sflist); + 2610. ret = (pmc->sfmode == MCAST_EXCLUDE); + 2611. if (!psl) + +net/socket.c:2592: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2590. bool sock_is_registered(int family) + 2591. { + 2592. > return family < NPROTO && rcu_access_pointer(net_families[family]); + 2593. } + 2594. + +drivers/iommu/amd_iommu.c:2601: error: DEAD_STORE + The value written to &dma_mask (type unsigned long long) is never used. + 2599. unsigned long attrs) + 2600. { + 2601. > u64 dma_mask = dev->coherent_dma_mask; + 2602. struct protection_domain *domain; + 2603. struct dma_ops_domain *dma_dom; + +net/wireless/trace.h:2599: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +drivers/gpu/drm/i915/intel_runtime_pm.c:2620: error: NULL_DEREFERENCE + pointer `well` last assigned on line 2619 could be null and is dereferenced by call to `intel_power_well_enable()` at line 2620, column 2. + 2618. + 2619. well = lookup_power_well(dev_priv, SKL_DISP_PW_1); + 2620. > intel_power_well_enable(dev_priv, well); + 2621. + 2622. well = lookup_power_well(dev_priv, SKL_DISP_PW_MISC_IO); + +net/core/sock.c:2609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2607. + 2608. rcu_read_lock(); + 2609. > wq = rcu_dereference(sk->sk_wq); + 2610. if (skwq_has_sleeper(wq)) + 2611. wake_up_interruptible_all(&wq->wait); + +block/blk-core.c:2613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2611. int cpu; + 2612. + 2613. > cpu = part_stat_lock(); + 2614. part = req->part; + 2615. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +block/blk-core.c:2613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2611. int cpu; + 2612. + 2613. > cpu = part_stat_lock(); + 2614. part = req->part; + 2615. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +drivers/cdrom/cdrom.c:2618: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 2616. return -EFAULT; + 2617. + 2618. > requested = q.cdsc_format; + 2619. if (requested != CDROM_MSF && requested != CDROM_LBA) + 2620. return -EINVAL; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +net/core/sock.c:2620: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2618. + 2619. rcu_read_lock(); + 2620. > wq = rcu_dereference(sk->sk_wq); + 2621. if (skwq_has_sleeper(wq)) + 2622. wake_up_interruptible_poll(&wq->wait, EPOLLERR); + +net/sunrpc/clnt.c:2657: error: NULL_DEREFERENCE + pointer `xprt` last assigned on line 2627 could be null and is dereferenced at line 2657, column 2. + 2655. xprt_put(xprt); + 2656. xprt_switch_put(xps); + 2657. > pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n", + 2658. status, xprt->address_strings[RPC_DISPLAY_ADDR]); + 2659. return status; + +drivers/net/ethernet/intel/e100.c:2631: error: DEAD_STORE + The value written to &err (type int) is never used. + 2629. + 2630. /* save speed, duplex & autoneg settings */ + 2631. > err = mii_ethtool_gset(&nic->mii, &cmd); + 2632. + 2633. if (netif_running(netdev)) + +drivers/net/ethernet/intel/e100.c:2640: error: DEAD_STORE + The value written to &err (type int) is never used. + 2638. + 2639. /* restore speed, duplex & autoneg settings */ + 2640. > err = mii_ethtool_sset(&nic->mii, &cmd); + 2641. + 2642. if (netif_running(netdev)) + +block/blk-core.c:2633: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2631. int cpu; + 2632. + 2633. > cpu = part_stat_lock(); + 2634. part = req->part; + 2635. + +block/blk-core.c:2633: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2631. int cpu; + 2632. + 2633. > cpu = part_stat_lock(); + 2634. part = req->part; + 2635. + +net/wireless/trace.h:2620: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/core/sock.c:2632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2630. + 2631. rcu_read_lock(); + 2632. > wq = rcu_dereference(sk->sk_wq); + 2633. if (skwq_has_sleeper(wq)) + 2634. wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI | + +net/ipv4/ipmr.c:2650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2648. if (t < s_t) + 2649. goto next_table; + 2650. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) { + 2651. if (e < s_e) + 2652. goto next_entry; + +net/wireless/trace.h:2635: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +kernel/rcu/tree.c:2663: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2661. */ + 2662. local_irq_save(flags); + 2663. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2664. bl = rdp->blimit; + 2665. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +kernel/rcu/tree.c:2663: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2661. */ + 2662. local_irq_save(flags); + 2663. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2664. bl = rdp->blimit; + 2665. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +net/core/sock.c:2650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2648. */ + 2649. if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) { + 2650. > wq = rcu_dereference(sk->sk_wq); + 2651. if (skwq_has_sleeper(wq)) + 2652. wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT | + +kernel/trace/ring_buffer.c:2661: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2659. + 2660. /* Don't let the compiler play games with cpu_buffer->tail_page */ + 2661. > tail_page = info->tail_page = READ_ONCE(cpu_buffer->tail_page); + 2662. write = local_add_return(info->length, &tail_page->write); + 2663. + +drivers/gpu/drm/i915/intel_sdvo.c:2695: error: UNINITIALIZED_VALUE + The value read from bytes[_] was never initialized. + 2693. intel_sdvo->controlled_output = 0; + 2694. memcpy(bytes, &intel_sdvo->caps.output_flags, 2); + 2695. > DRM_DEBUG_KMS("%s: Unknown SDVO output type (0x%02x%02x)\n", + 2696. SDVO_NAME(intel_sdvo), + 2697. bytes[0], bytes[1]); + +net/ipv4/fib_trie.c:2662: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2660. prefix = htonl(l->key); + 2661. + 2662. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 2663. const struct fib_info *fi = fa->fa_info; + 2664. __be32 mask = inet_make_mask(KEYLENGTH - fa->fa_slen); + +net/core/neighbour.c:2652: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2650. struct neigh_table *tbl = state->tbl; + 2651. struct pneigh_entry *pn = NULL; + 2652. > int bucket = state->bucket; + 2653. + 2654. state->flags |= NEIGH_SEQ_IS_PNEIGH; + +net/ipv6/mcast.c:2654: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2652. + 2653. state->idev = NULL; + 2654. > for_each_netdev_rcu(net, state->dev) { + 2655. struct inet6_dev *idev; + 2656. idev = __in6_dev_get(state->dev); + +net/wireless/trace.h:2651: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +drivers/cdrom/cdrom.c:2670: error: UNINITIALIZED_VALUE + The value read from entry.cdte_format was never initialized. + 2668. return -EFAULT; + 2669. + 2670. > requested_format = entry.cdte_format; + 2671. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2672. return -EINVAL; + +net/ipv4/igmp.c:2667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2665. int rv = 0; + 2666. + 2667. > mc_hash = rcu_dereference(in_dev->mc_hash); + 2668. if (mc_hash) { + 2669. u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); + +net/ipv4/igmp.c:2671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2669. u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); + 2670. + 2671. > for (im = rcu_dereference(mc_hash[hash]); + 2672. im != NULL; + 2673. im = rcu_dereference(im->next_hash)) { + +net/ipv4/igmp.c:2673: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2671. for (im = rcu_dereference(mc_hash[hash]); + 2672. im != NULL; + 2673. > im = rcu_dereference(im->next_hash)) { + 2674. if (im->multiaddr == mc_addr) + 2675. break; + +net/ipv4/igmp.c:2678: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2676. } + 2677. } else { + 2678. > for_each_pmc_rcu(in_dev, im) { + 2679. if (im->multiaddr == mc_addr) + 2680. break; + +drivers/tty/tty_io.c:2669: error: DEAD_STORE + The value written to &retval (type int) is never used. + 2667. struct tty_struct *tty = file_tty(file); + 2668. struct tty_ldisc *ld; + 2669. > int retval = -ENOIOCTLCMD; + 2670. + 2671. if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl")) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2688: error: NULL_DEREFERENCE + pointer `well` last assigned on line 2687 could be null and is dereferenced by call to `intel_power_well_enable()` at line 2688, column 2. + 2686. + 2687. well = lookup_power_well(dev_priv, SKL_DISP_PW_1); + 2688. > intel_power_well_enable(dev_priv, well); + 2689. + 2690. mutex_unlock(&power_domains->lock); + +net/wireless/trace.h:2667: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +block/blk-core.c:2679: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2677. return; + 2678. + 2679. > cpu = part_stat_lock(); + 2680. + 2681. if (!new_io) { + +block/blk-core.c:2679: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2677. return; + 2678. + 2679. > cpu = part_stat_lock(); + 2680. + 2681. if (!new_io) { + +drivers/usb/core/hub.c:2721: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 2719. return -EBUSY; + 2720. + 2721. > if (hub_port_warm_reset_required(hub, port1, portstatus)) + 2722. return -ENOTCONN; + 2723. + +kernel/cgroup/cgroup.c:2685: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2684 could be null and is dereferenced at line 2685, column 7. + 2683. percpu_up_write(&cgroup_threadgroup_rwsem); + 2684. for_each_subsys(ss, ssid) + 2685. > if (ss->post_attach) + 2686. ss->post_attach(); + 2687. } + +net/sunrpc/clnt.c:2692: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2690. + 2691. rcu_read_lock(); + 2692. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 2693. xprt = xprt_iter_xprt(&clnt->cl_xpi); + 2694. if (xps == NULL || xprt == NULL) { + +drivers/ata/libata-eh.c:2839: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2837. rc = ata_do_reset(link, reset, classes, deadline, true); + 2838. if (rc && rc != -EAGAIN) { + 2839. > failed_link = link; + 2840. goto fail; + 2841. } + +drivers/ata/libata-eh.c:2859: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2857. break; + 2858. default: + 2859. > failed_link = slave; + 2860. rc = tmp; + 2861. goto fail; + +drivers/ata/libata-eh.c:2873: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2871. ata_link_err(link, + 2872. "follow-up softreset required but no softreset available\n"); + 2873. > failed_link = link; + 2874. rc = -EINVAL; + 2875. goto fail; + +drivers/ata/libata-eh.c:2881: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2879. rc = ata_do_reset(link, reset, classes, deadline, true); + 2880. if (rc) { + 2881. > failed_link = link; + 2882. goto fail; + 2883. } + +drivers/ata/libata-eh.c:2988: error: DEAD_STORE + The value written to &failed_link (type ata_link*) is never used. + 2986. "link online but %d devices misclassified, retrying\n", + 2987. nr_unknown); + 2988. > failed_link = link; + 2989. rc = -EAGAIN; + 2990. goto fail; + +drivers/md/md.c:2687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2685. char *sep = ","; + 2686. size_t len = 0; + 2687. > unsigned long flags = READ_ONCE(rdev->flags); + 2688. + 2689. if (test_bit(Faulty, &flags) || + +net/wireless/trace.h:2682: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/socket.c:2697: error: UNINITIALIZED_VALUE + The value read from ifc32.ifc_len was never initialized. + 2695. return -EFAULT; + 2696. + 2697. > ifc.ifc_len = ifc32.ifc_len; + 2698. ifc.ifc_req = compat_ptr(ifc32.ifcbuf); + 2699. + +net/socket.c:2698: error: UNINITIALIZED_VALUE + The value read from ifc32.ifcbuf was never initialized. + 2696. + 2697. ifc.ifc_len = ifc32.ifc_len; + 2698. > ifc.ifc_req = compat_ptr(ifc32.ifcbuf); + 2699. + 2700. rtnl_lock(); + +net/wireless/trace.h:2697: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2695. ); + 2696. + 2697. > DECLARE_EVENT_CLASS(cfg80211_rx_evt, + 2698. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2699. TP_ARGS(netdev, addr), + +net/netfilter/nf_conntrack_netlink.c:2713: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2711. for (; cb->args[0] < nf_ct_expect_hsize; cb->args[0]++) { + 2712. restart: + 2713. > hlist_for_each_entry_rcu(exp, &nf_ct_expect_hash[cb->args[0]], + 2714. hnode) { + 2715. if (l3proto && exp->tuple.src.l3num != l3proto) + +block/blk-core.c:2709: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 2709, column 31. + 2707. { + 2708. struct request *rq; + 2709. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 2710. + 2711. WARN_ON_ONCE(q->mq_ops); + +sound/pci/hda/hda_codec.c:2712: error: DEAD_STORE + The value written to &end_time (type unsigned long) is never used. + 2710. unsigned int power_state) + 2711. { + 2712. > unsigned long end_time = jiffies + msecs_to_jiffies(500); + 2713. unsigned int state, actual_state; + 2714. + +sound/pci/hda/hda_codec.c:2728: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2726. msleep(1); + 2727. } + 2728. > return state; + 2729. } + 2730. + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/ipv4/igmp.c:2719: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2717. + 2718. state->in_dev = NULL; + 2719. > for_each_netdev_rcu(net, state->dev) { + 2720. struct in_device *in_dev; + 2721. + +net/ipv4/igmp.c:2725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2723. if (!in_dev) + 2724. continue; + 2725. > im = rcu_dereference(in_dev->mc_list); + 2726. if (im) { + 2727. state->in_dev = in_dev; + +drivers/net/ethernet/intel/e100.c:2732: error: DEAD_STORE + The value written to &i (type int) is never used. + 2730. data[i++] = nic->rx_tco_frames; + 2731. data[i++] = nic->rx_short_frame_errors; + 2732. > data[i++] = nic->rx_over_length_errors; + 2733. } + 2734. + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +drivers/tty/tty_io.c:2738: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2736. read_lock(&tasklist_lock); + 2737. /* Kill the entire session */ + 2738. > do_each_pid_task(session, PIDTYPE_SID, p) { + 2739. tty_notice(tty, "SAK: killed process %d (%s): by session\n", + 2740. task_pid_nr(p), p->comm); + +drivers/tty/tty_io.c:2745: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2743. + 2744. /* Now kill any processes that happen to have the tty open */ + 2745. > do_each_thread(g, p) { + 2746. if (p->signal->tty == tty) { + 2747. tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n", + +kernel/trace/trace.c:2743: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2741. */ + 2742. preempt_disable(); + 2743. > if (__this_cpu_read(user_stack_count)) + 2744. goto out; + 2745. + +net/wireless/trace.h:2721: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/core/neighbour.c:2733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2731. + 2732. rcu_read_lock_bh(); + 2733. > state->nht = rcu_dereference_bh(tbl->nht); + 2734. + 2735. return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN; + +net/ipv6/addrconf.c:2731: error: DEAD_STORE + The value written to &err (type int) is never used. + 2729. struct in6_ifreq ireq; + 2730. struct net_device *dev; + 2731. > int err = -EINVAL; + 2732. + 2733. rtnl_lock(); + +net/ipv6/addrconf.c:2739: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2737. goto err_exit; + 2738. + 2739. > dev = __dev_get_by_index(net, ireq.ifr6_ifindex); + 2740. + 2741. err = -ENODEV; + +net/ipv4/tcp_output.c:2737: error: NULL_DEREFERENCE + pointer `next_skb` last assigned on line 2733 could be null and is dereferenced at line 2737, column 18. + 2735. + 2736. skb_size = skb->len; + 2737. > next_skb_size = next_skb->len; + 2738. + 2739. BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1); + +net/ipv4/igmp.c:2738: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2736. struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); + 2737. + 2738. > im = rcu_dereference(im->next_rcu); + 2739. while (!im) { + 2740. state->dev = next_net_device_rcu(state->dev); + +net/ipv4/igmp.c:2748: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2746. if (!state->in_dev) + 2747. continue; + 2748. > im = rcu_dereference(state->in_dev->mc_list); + 2749. } + 2750. return im; + +net/wireless/trace.h:2739: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +kernel/sched/fair.c:2753: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2751. cfs_rq->runnable_weight -= se->runnable_weight; + 2752. + 2753. > sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + +kernel/sched/fair.c:2754: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2752. + 2753. sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. > sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + 2756. } + +net/core/dev.c:2764: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2762. + 2763. rcu_read_lock(); + 2764. > list_for_each_entry_rcu(ptype, &offload_base, list) { + 2765. if (ptype->type == type && ptype->callbacks.gso_segment) { + 2766. segs = ptype->callbacks.gso_segment(skb, features); + +net/netfilter/nf_conntrack_netlink.c:2765: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2763. last = (struct nf_conntrack_expect *)cb->args[1]; + 2764. restart: + 2765. > hlist_for_each_entry_rcu(exp, &help->expectations, lnode) { + 2766. if (l3proto && exp->tuple.src.l3num != l3proto) + 2767. continue; + +kernel/workqueue.c:2774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2772. mutex_lock(&wq->mutex); + 2773. + 2774. > for_each_pwq(pwq, wq) { + 2775. bool drained; + 2776. + +drivers/scsi/scsi_lib.c:2793: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2791. } + 2792. + 2793. > envp[idx++] = NULL; + 2794. + 2795. kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); + +net/wireless/trace.h:2760: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +sound/pci/hda/hda_codec.c:2798: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2796. } + 2797. + 2798. > return state; + 2799. } + 2800. + +drivers/usb/core/hub.c:2882: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 2880. up_read(&ehci_cf_port_reset_rwsem); + 2881. + 2882. > return status; + 2883. } + 2884. + +net/sunrpc/clnt.c:2766: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2764. { + 2765. rcu_read_lock(); + 2766. > xprt_switch_put(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 2767. rcu_read_unlock(); + 2768. } + +kernel/sched/fair.c:2768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2766. dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) + 2767. { + 2768. > sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + +kernel/sched/fair.c:2769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2767. { + 2768. sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. > sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + 2771. #else + +sound/core/pcm_native.c:2782: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2780. return -EFAULT; + 2781. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2782. > result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + +sound/core/pcm_native.c:2784: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2782. result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. > result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + 2785. __put_user(result, &_xferi->result); + 2786. return result < 0 ? result : 0; + +net/sunrpc/clnt.c:2774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2772. { + 2773. rcu_read_lock(); + 2774. > rpc_xprt_switch_add_xprt(rcu_dereference(clnt->cl_xpi.xpi_xpswitch), + 2775. xprt); + 2776. rcu_read_unlock(); + +net/ipv6/mcast.c:2783: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2781. state->idev = NULL; + 2782. state->im = NULL; + 2783. > for_each_netdev_rcu(net, state->dev) { + 2784. struct inet6_dev *idev; + 2785. idev = __in6_dev_get(state->dev); + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/sunrpc/clnt.c:2787: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2785. + 2786. rcu_read_lock(); + 2787. > xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch); + 2788. ret = rpc_xprt_switch_has_addr(xps, sap); + 2789. rcu_read_unlock(); + +net/wireless/trace.h:2782: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +drivers/gpu/drm/i915/intel_sdvo.c:2809: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2807. sdvo_state->tv.overscan_h = response; + 2808. + 2809. > intel_sdvo_connector->max_hscan = data_value[0]; + 2810. intel_sdvo_connector->left = + 2811. drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]); + +drivers/gpu/drm/i915/intel_sdvo.c:2811: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2809. intel_sdvo_connector->max_hscan = data_value[0]; + 2810. intel_sdvo_connector->left = + 2811. > drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]); + 2812. if (!intel_sdvo_connector->left) + 2813. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2819: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2817. + 2818. intel_sdvo_connector->right = + 2819. > drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]); + 2820. if (!intel_sdvo_connector->right) + 2821. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2825: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2823. drm_object_attach_property(&connector->base, + 2824. intel_sdvo_connector->right, 0); + 2825. > DRM_DEBUG_KMS("h_overscan: max %d, " + 2826. "default %d, current %d\n", + 2827. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2843: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2841. sdvo_state->tv.overscan_v = response; + 2842. + 2843. > intel_sdvo_connector->max_vscan = data_value[0]; + 2844. intel_sdvo_connector->top = + 2845. drm_property_create_range(dev, 0, + +drivers/gpu/drm/i915/intel_sdvo.c:2845: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2843. intel_sdvo_connector->max_vscan = data_value[0]; + 2844. intel_sdvo_connector->top = + 2845. > drm_property_create_range(dev, 0, + 2846. "top_margin", 0, data_value[0]); + 2847. if (!intel_sdvo_connector->top) + +drivers/gpu/drm/i915/intel_sdvo.c:2854: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2852. + 2853. intel_sdvo_connector->bottom = + 2854. > drm_property_create_range(dev, 0, + 2855. "bottom_margin", 0, data_value[0]); + 2856. if (!intel_sdvo_connector->bottom) + +drivers/gpu/drm/i915/intel_sdvo.c:2861: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2859. drm_object_attach_property(&connector->base, + 2860. intel_sdvo_connector->bottom, 0); + 2861. > DRM_DEBUG_KMS("v_overscan: max %d, " + 2862. "default %d, current %d\n", + 2863. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2866: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2864. } + 2865. + 2866. > ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + +drivers/gpu/drm/i915/intel_sdvo.c:2867: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2865. + 2866. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. > ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + +drivers/gpu/drm/i915/intel_sdvo.c:2868: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2866. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. > ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + +drivers/gpu/drm/i915/intel_sdvo.c:2869: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. > ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2870: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. > ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2871: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. > ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2872: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. > ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + +drivers/gpu/drm/i915/intel_sdvo.c:2873: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. > ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + +drivers/gpu/drm/i915/intel_sdvo.c:2874: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2875: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2876: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. > _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2878. + +drivers/gpu/drm/i915/intel_sdvo.c:2877: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. > _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2878. + 2879. if (enhancements.dot_crawl) { + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +sound/core/pcm_native.c:2810: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2808. return PTR_ERR(bufs); + 2809. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2810. > result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + +sound/core/pcm_native.c:2812: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2810. result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. > result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + 2813. kfree(bufs); + 2814. __put_user(result, &_xfern->result); + +net/ipv4/igmp.c:2809: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2807. #endif + 2808. + 2809. > if (rcu_access_pointer(state->in_dev->mc_list) == im) { + 2810. seq_printf(seq, "%d\t%-10s: %5d %7s\n", + 2811. state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier); + +net/wireless/trace.h:2803: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +drivers/iommu/intel-iommu.c:2832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2830. * is passed in. + 2831. */ + 2832. > for_each_active_dev_scope(rmrr->devices, + 2833. rmrr->devices_cnt, i, tmp) + 2834. if (tmp == dev) { + +net/wireless/trace.h:2821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +kernel/events/core.c:2850: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2848. goto unlock; + 2849. + 2850. > parent = rcu_dereference(ctx->parent_ctx); + 2851. next_parent = rcu_dereference(next_ctx->parent_ctx); + 2852. + +kernel/events/core.c:2851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2849. + 2850. parent = rcu_dereference(ctx->parent_ctx); + 2851. > next_parent = rcu_dereference(next_ctx->parent_ctx); + 2852. + 2853. /* If neither context have a parent context; they cannot be clones. */ + +drivers/cdrom/cdrom.c:2838: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2836. track_information ti; + 2837. __u32 last_track; + 2838. > int ret = -1, ti_size; + 2839. + 2840. if (!CDROM_CAN(CDC_GENERIC_PACKET)) + +kernel/rcu/tree.c:2842: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2840. + 2841. /* Funnel through hierarchy to reduce memory contention. */ + 2842. > rnp = __this_cpu_read(rsp->rda->mynode); + 2843. for (; rnp != NULL; rnp = rnp->parent) { + 2844. ret = (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) || + +kernel/rcu/tree.c:2842: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2840. + 2841. /* Funnel through hierarchy to reduce memory contention. */ + 2842. > rnp = __this_cpu_read(rsp->rda->mynode); + 2843. for (; rnp != NULL; rnp = rnp->parent) { + 2844. ret = (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) || + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +drivers/input/mouse/alps.c:2895: error: DEAD_STORE + The value written to &protocol (type alps_protocol_info const *) is never used. + 2893. protocol = &alps_v8_protocol_data; + 2894. } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0xc8) { + 2895. > protocol = &alps_v9_protocol_data; + 2896. psmouse_warn(psmouse, + 2897. "Unsupported ALPS V9 touchpad: E7=%3ph, EC=%3ph\n", + +net/ipv4/igmp.c:2863: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2861. state->idev = NULL; + 2862. state->im = NULL; + 2863. > for_each_netdev_rcu(net, state->dev) { + 2864. struct in_device *idev; + 2865. idev = __in_dev_get_rcu(state->dev); + +net/ipv4/igmp.c:2868: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2866. if (unlikely(!idev)) + 2867. continue; + 2868. > im = rcu_dereference(idev->mc_list); + 2869. if (likely(im)) { + 2870. spin_lock_bh(&im->lock); + +drivers/gpu/drm/i915/i915_gem_gtt.c:2885: error: UNINITIALIZED_VALUE + The value read from hole_end was never initialized. + 2883. /* Clear any non-preallocated blocks */ + 2884. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2885. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2886. hole_start, hole_end); + 2887. ggtt->base.clear_range(&ggtt->base, hole_start, + +drivers/gpu/drm/i915/i915_gem_gtt.c:2885: error: UNINITIALIZED_VALUE + The value read from hole_start was never initialized. + 2883. /* Clear any non-preallocated blocks */ + 2884. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2885. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2886. hole_start, hole_end); + 2887. ggtt->base.clear_range(&ggtt->base, hole_start, + +kernel/printk/printk.c:2860: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2858. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2859. { + 2860. > int pending = __this_cpu_xchg(printk_pending, 0); + 2861. + 2862. if (pending & PRINTK_PENDING_OUTPUT) { + +kernel/printk/printk.c:2860: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 2858. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2859. { + 2860. > int pending = __this_cpu_xchg(printk_pending, 0); + 2861. + 2862. if (pending & PRINTK_PENDING_OUTPUT) { + +drivers/ata/libata-core.c:2922: error: UNINITIALIZED_VALUE + The value read from classes[_] was never initialized. + 2920. ata_for_each_dev(dev, &ap->link, ALL_REVERSE) { + 2921. if (tries[dev->devno]) + 2922. > dev->class = classes[dev->devno]; + 2923. + 2924. if (!ata_dev_enabled(dev)) + +drivers/gpu/drm/i915/i915_debugfs.c:2879: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 2877 could be null and is dereferenced at line 2879, column 36. + 2877. struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base); + 2878. + 2879. > seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]); + 2880. seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio)); + 2881. if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) + +drivers/md/dm.c:2913: error: UNINITIALIZED_VALUE + The value read from front_pad was never initialized. + 2911. } + 2912. + 2913. > pools->bs = bioset_create(pool_size, front_pad, 0); + 2914. if (!pools->bs) + 2915. goto out; + +net/ipv4/igmp.c:2900: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2898. if (!state->idev) + 2899. continue; + 2900. > state->im = rcu_dereference(state->idev->mc_list); + 2901. } + 2902. if (!state->im) + +net/wireless/trace.h:2884: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2882. ); + 2883. + 2884. > DECLARE_EVENT_CLASS(wiphy_id_evt, + 2885. TP_PROTO(struct wiphy *wiphy, u64 id), + 2886. TP_ARGS(wiphy, id), + +drivers/tty/serial/8250/8250_port.c:2899: error: DEAD_STORE + The value written to &i (type int) is never used. + 2897. if (bytes < conf_type->rxtrig_bytes[i]) + 2898. /* Use the nearest lower value */ + 2899. > return (--i) << UART_FCR_R_TRIG_SHIFT; + 2900. } + 2901. + +lib/vsprintf.c:2911: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2909. */ + 2910. if (isspace(*fmt)) { + 2911. > fmt = skip_spaces(++fmt); + 2912. str = skip_spaces(str); + 2913. } + +lib/vsprintf.c:3116: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3114. while (next - str > field_width) { + 3115. if (is_sign) + 3116. > val.s = div_s64(val.s, base); + 3117. else + 3118. val.u = div_u64(val.u, base); + +lib/vsprintf.c:3118: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3116. val.s = div_s64(val.s, base); + 3117. else + 3118. > val.u = div_u64(val.u, base); + 3119. --next; + 3120. } + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +drivers/gpu/drm/i915/intel_sdvo.c:2906: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2904. uint16_t response, data_value[2]; + 2905. + 2906. > ENHANCEMENT(&connector->state->tv, brightness, BRIGHTNESS); + 2907. + 2908. return true; + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +kernel/cgroup/cgroup.c:2912: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2907 could be null and is dereferenced at line 2912, column 39. + 2910. WARN_ON_ONCE(css && percpu_ref_is_dying(&css->refcnt)); + 2911. + 2912. > if (!(cgroup_ss_mask(dsct) & (1 << ss->id))) + 2913. continue; + 2914. + +kernel/sched/fair.c:2905: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2903. struct task_group *tg = cfs_rq->tg; + 2904. + 2905. > tg_shares = READ_ONCE(tg->shares); + 2906. + 2907. load = max(scale_load_down(cfs_rq->load.weight), cfs_rq->avg.load_avg); + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +kernel/rcu/tree.c:2913: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2911. struct rcu_state *rsp; + 2912. + 2913. > if (cpu_is_offline(smp_processor_id())) + 2914. return; + 2915. trace_rcu_utilization(TPS("Start RCU core")); + +kernel/rcu/tree.c:2913: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2911. struct rcu_state *rsp; + 2912. + 2913. > if (cpu_is_offline(smp_processor_id())) + 2914. return; + 2915. trace_rcu_utilization(TPS("Start RCU core")); + +net/unix/af_unix.c:2920: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2918. static int __init af_unix_init(void) + 2919. { + 2920. > int rc = -1; + 2921. + 2922. BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb)); + +net/ipv4/tcp.c:2938: error: UNINITIALIZED_VALUE + The value read from stats[_] was never initialized. + 2936. + 2937. info->tcpi_busy_time = total; + 2938. > info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED]; + 2939. info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED]; + 2940. } + +net/ipv4/tcp.c:2939: error: UNINITIALIZED_VALUE + The value read from stats[_] was never initialized. + 2937. info->tcpi_busy_time = total; + 2938. info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED]; + 2939. > info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED]; + 2940. } + 2941. + +net/netfilter/nf_conntrack_netlink.c:2931: error: NULL_DEREFERENCE + pointer `m_help` last assigned on line 2929 could be null and is dereferenced at line 2931, column 16. + 2929. m_help = nfct_help(exp->master); + 2930. + 2931. > return strcmp(m_help->helper->name, name) == 0; + 2932. } + 2933. + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +kernel/rcu/tree.c:2941: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2939. static void invoke_rcu_core(void) + 2940. { + 2941. > if (cpu_online(smp_processor_id())) + 2942. raise_softirq(RCU_SOFTIRQ); + 2943. } + +kernel/rcu/tree.c:2941: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2939. static void invoke_rcu_core(void) + 2940. { + 2941. > if (cpu_online(smp_processor_id())) + 2942. raise_softirq(RCU_SOFTIRQ); + 2943. } + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +net/ipv4/tcp.c:2959: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2957. + 2958. /* Report meaningful fields for all TCP states, including listeners */ + 2959. > rate = READ_ONCE(sk->sk_pacing_rate); + 2960. rate64 = rate != ~0U ? rate : ~0ULL; + 2961. info->tcpi_pacing_rate = rate64; + +net/ipv4/tcp.c:2963: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2961. info->tcpi_pacing_rate = rate64; + 2962. + 2963. > rate = READ_ONCE(sk->sk_max_pacing_rate); + 2964. rate64 = rate != ~0U ? rate : ~0ULL; + 2965. info->tcpi_max_pacing_rate = rate64; + +net/ipv6/addrconf.c:2955: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2953. + 2954. rtnl_lock(); + 2955. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2956. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2957. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +net/ipv6/addrconf.c:2955: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2953. + 2954. rtnl_lock(); + 2955. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2956. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2957. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +kernel/cgroup/cgroup.c:2966: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2953 could be null and is dereferenced at line 2966, column 9. + 2964. } else if (!css_visible(css)) { + 2965. css_clear_dir(css); + 2966. > if (ss->css_reset) + 2967. ss->css_reset(css); + 2968. } + +kernel/rcu/tree.c:2961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2959. + 2960. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 2961. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 2962. return; + 2963. + +kernel/rcu/tree.c:2961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2959. + 2960. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 2961. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 2962. return; + 2963. + +net/core/neighbour.c:2955: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2953. + 2954. rcu_read_lock(); + 2955. > for_each_netdev_rcu(net, dev) { + 2956. struct neigh_parms *dst_p = + 2957. neigh_get_dev_parms_rcu(dev, family); + +drivers/gpu/drm/i915/intel_runtime_pm.c:2963: error: NULL_DEREFERENCE + pointer `cmn` last assigned on line 2957 could be null and is dereferenced at line 2963, column 6. + 2961. + 2962. /* If the display might be already active skip this */ + 2963. > if (cmn->ops->is_enabled(dev_priv, cmn) && + 2964. disp2d->ops->is_enabled(dev_priv, disp2d) && + 2965. I915_READ(DPIO_CTL) & DPIO_CMNRST) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2964: error: NULL_DEREFERENCE + pointer `disp2d` last assigned on line 2959 could be null and is dereferenced at line 2964, column 6. + 2962. /* If the display might be already active skip this */ + 2963. if (cmn->ops->is_enabled(dev_priv, cmn) && + 2964. > disp2d->ops->is_enabled(dev_priv, disp2d) && + 2965. I915_READ(DPIO_CTL) & DPIO_CMNRST) + 2966. return; + +net/ipv6/addrconf.c:2974: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2972. + 2973. rtnl_lock(); + 2974. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2975. ireq.ifr6_prefixlen); + 2976. rtnl_unlock(); + +net/ipv6/addrconf.c:2974: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2972. + 2973. rtnl_lock(); + 2974. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2975. ireq.ifr6_prefixlen); + 2976. rtnl_unlock(); + +drivers/iommu/intel-iommu.c:2983: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2981. } + 2982. + 2983. > for_each_active_iommu(iommu, drhd) + 2984. for_each_active_dev_scope(drhd->devices, drhd->devices_cnt, i, dev) { + 2985. struct acpi_device_physical_node *pn; + +drivers/iommu/intel-iommu.c:2984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2982. + 2983. for_each_active_iommu(iommu, drhd) + 2984. > for_each_active_dev_scope(drhd->devices, drhd->devices_cnt, i, dev) { + 2985. struct acpi_device_physical_node *pn; + 2986. struct acpi_device *adev; + +drivers/gpu/drm/drm_dp_mst_topology.c:3016: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3014. int ret; + 3015. + 3016. > ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + +drivers/gpu/drm/drm_dp_mst_topology.c:3018: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3016. ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. > ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + +drivers/gpu/drm/drm_dp_mst_topology.c:3020: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. > ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + 3021. seq_printf(m, "mst ctrl: %*ph\n", 1, buf); + 3022. + +drivers/gpu/drm/drm_dp_mst_topology.c:3024: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3022. + 3023. /* dump the standard OUI branch header */ + 3024. > ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE); + 3025. seq_printf(m, "branch oui: %*phN devid: ", 3, buf); + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + +net/wireless/trace.h:2970: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2968. ); + 2969. + 2970. > DECLARE_EVENT_CLASS(cfg80211_bss_evt, + 2971. TP_PROTO(struct cfg80211_bss *pub), + 2972. TP_ARGS(pub), + +kernel/events/core.c:2981: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2979. int ctxn; + 2980. + 2981. > if (__this_cpu_read(perf_sched_cb_usages)) + 2982. perf_pmu_sched_task(task, next, false); + 2983. + +kernel/sched/core.c:2988: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2986. raw_spin_lock_irqsave(&p->pi_lock, flags); + 2987. dest_cpu = p->sched_class->select_task_rq(p, task_cpu(p), SD_BALANCE_EXEC, 0); + 2988. > if (dest_cpu == smp_processor_id()) + 2989. goto unlock; + 2990. + +drivers/gpu/drm/drm_atomic_helper.c:3001: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2999. + 3000. if (ret) + 3001. > DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret); + 3002. + 3003. drm_modeset_drop_locks(&ctx); + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/ipv6/route.c:3009: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3007. + 3008. if (fn) { + 3009. > for_each_fib6_node_rt_rcu(fn) { + 3010. if (cfg->fc_flags & RTF_CACHE) { + 3011. rt_cache = rt6_find_cached_rt(rt, &cfg->fc_dst, + +net/wireless/trace.h:2989: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +drivers/cdrom/cdrom.c:3026: error: UNINITIALIZED_VALUE + The value read from ra.nframes was never initialized. + 3024. return -EINVAL; + 3025. + 3026. > return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes); + 3027. } + 3028. + +net/wireless/trace.h:3013: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/ipv4/tcp_input.c:3126: error: UNINITIALIZED_VALUE + The value read from last_ackt was never initialized. + 3124. if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) { + 3125. seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt); + 3126. > ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt); + 3127. + 3128. if (pkts_acked == 1 && last_in_flight < tp->mss_cache && + +kernel/printk/printk.c:3027: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3025. + 3026. rcu_read_lock(); + 3027. > list_for_each_entry_rcu(dumper, &dump_list, list) { + 3028. if (dumper->max_reason && reason > dumper->max_reason) + 3029. continue; + +drivers/cdrom/cdrom.c:3037: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 3035. if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q))) + 3036. return -EFAULT; + 3037. > requested = q.cdsc_format; + 3038. if (!((requested == CDROM_MSF) || + 3039. (requested == CDROM_LBA))) + +kernel/signal.c:3044: error: UNINITIALIZED_VALUE + The value read from from.si_code was never initialized. + 3042. to->si_signo = from.si_signo; + 3043. to->si_errno = from.si_errno; + 3044. > to->si_code = from.si_code; + 3045. switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + +kernel/signal.c:3045: error: UNINITIALIZED_VALUE + The value read from from.si_code was never initialized. + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. > switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + 3047. to->si_pid = from.si_pid; + +kernel/signal.c:3043: error: UNINITIALIZED_VALUE + The value read from from.si_errno was never initialized. + 3041. clear_siginfo(to); + 3042. to->si_signo = from.si_signo; + 3043. > to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. switch(siginfo_layout(from.si_signo, from.si_code)) { + +kernel/signal.c:3042: error: UNINITIALIZED_VALUE + The value read from from.si_signo was never initialized. + 3040. + 3041. clear_siginfo(to); + 3042. > to->si_signo = from.si_signo; + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + +kernel/signal.c:3045: error: UNINITIALIZED_VALUE + The value read from from.si_signo was never initialized. + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. > switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + 3047. to->si_pid = from.si_pid; + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/ipv4/tcp.c:3078: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3076. tp->total_retrans, TCP_NLA_PAD); + 3077. + 3078. > rate = READ_ONCE(sk->sk_pacing_rate); + 3079. rate64 = rate != ~0U ? rate : ~0ULL; + 3080. nla_put_u64_64bit(stats, TCP_NLA_PACING_RATE, rate64, TCP_NLA_PAD); + +drivers/cdrom/cdrom.c:3066: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame0 was never initialized. + 3064. cgc->cmd[3] = msf.cdmsf_min0; + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. > cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + +drivers/cdrom/cdrom.c:3069: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame1 was never initialized. + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + 3069. > cgc->cmd[8] = msf.cdmsf_frame1; + 3070. cgc->data_direction = CGC_DATA_NONE; + 3071. return cdo->generic_packet(cdi, cgc); + +drivers/cdrom/cdrom.c:3064: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min0 was never initialized. + 3062. return -EFAULT; + 3063. cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF; + 3064. > cgc->cmd[3] = msf.cdmsf_min0; + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + +drivers/cdrom/cdrom.c:3067: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min1 was never initialized. + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. > cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + 3069. cgc->cmd[8] = msf.cdmsf_frame1; + +drivers/cdrom/cdrom.c:3065: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec0 was never initialized. + 3063. cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF; + 3064. cgc->cmd[3] = msf.cdmsf_min0; + 3065. > cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + +drivers/cdrom/cdrom.c:3068: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec1 was never initialized. + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. > cgc->cmd[7] = msf.cdmsf_sec1; + 3069. cgc->cmd[8] = msf.cdmsf_frame1; + 3070. cgc->data_direction = CGC_DATA_NONE; + +drivers/gpu/drm/drm_dp_mst_topology.c:3069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3067. for (;;) { + 3068. mutex_lock(&mgr->destroy_connector_lock); + 3069. > port = list_first_entry_or_null(&mgr->destroy_connector_list, struct drm_dp_mst_port, next); + 3070. if (!port) { + 3071. mutex_unlock(&mgr->destroy_connector_lock); + +net/ipv4/ipmr.c:3068: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3066. rcu_read_lock(); + 3067. it->cache = &mrt->mfc_cache_list; + 3068. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) + 3069. if (pos-- == 0) + 3070. return mfc; + +kernel/sched/core.c:3077: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3075. void scheduler_tick(void) + 3076. { + 3077. > int cpu = smp_processor_id(); + 3078. struct rq *rq = cpu_rq(cpu); + 3079. struct task_struct *curr = rq->curr; + +kernel/sched/core.c:3077: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3075. void scheduler_tick(void) + 3076. { + 3077. > int cpu = smp_processor_id(); + 3078. struct rq *rq = cpu_rq(cpu); + 3079. struct task_struct *curr = rq->curr; + +net/wireless/trace.h:3077: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +drivers/gpu/drm/drm_edid.c:3150: error: UNINITIALIZED_VALUE + The value read from clock2 was never initialized. + 3148. newmode->clock = clock1; + 3149. else + 3150. > newmode->clock = clock2; + 3151. + 3152. list_add_tail(&newmode->head, &list); + +drivers/net/ethernet/intel/e1000/e1000_main.c:3107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3105. * made room available. + 3106. */ + 3107. > if (likely(E1000_DESC_UNUSED(tx_ring) < size)) + 3108. return -EBUSY; + 3109. + +net/wireless/trace.h:3092: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +drivers/cdrom/cdrom.c:3142: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3140. a CDROMVOLREAD, return these values */ + 3141. if (cmd == CDROMVOLREAD) { + 3142. > volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + +drivers/cdrom/cdrom.c:3143: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3141. if (cmd == CDROMVOLREAD) { + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. > volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + +drivers/cdrom/cdrom.c:3144: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. > volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + +drivers/cdrom/cdrom.c:3145: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. > volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + 3147. sizeof(volctrl))) + +net/ipv4/tcp.c:3220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3218. + 3219. rcu_read_lock(); + 3220. > ctx = rcu_dereference(icsk->icsk_accept_queue.fastopenq.ctx); + 3221. if (ctx) + 3222. memcpy(key, ctx->key, sizeof(key)); + +net/wireless/trace.h:3115: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +drivers/net/ethernet/intel/e1000/e1000_main.c:3119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3117. struct e1000_tx_ring *tx_ring, int size) + 3118. { + 3119. > if (likely(E1000_DESC_UNUSED(tx_ring) >= size)) + 3120. return 0; + 3121. return __e1000_maybe_stop_tx(netdev, size); + +net/core/filter.c:3143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3141. return -E2BIG; + 3142. + 3143. > cgrp = READ_ONCE(array->ptrs[idx]); + 3144. if (unlikely(!cgrp)) + 3145. return -EAGAIN; + +drivers/gpu/drm/drm_atomic_helper.c:3163: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 3161. drm_modeset_acquire_fini(&ctx); + 3162. + 3163. > return err; + 3164. } + 3165. EXPORT_SYMBOL(drm_atomic_helper_resume); + +net/wireless/trace.h:3138: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +drivers/net/ethernet/nvidia/forcedeth.c:3193: error: UNINITIALIZED_VALUE + The value read from mask[_] was never initialized. + 3191. writel(addr[0], base + NvRegMulticastAddrA); + 3192. writel(addr[1], base + NvRegMulticastAddrB); + 3193. > writel(mask[0], base + NvRegMulticastMaskA); + 3194. writel(mask[1], base + NvRegMulticastMaskB); + 3195. writel(pff, base + NvRegPacketFilterFlags); + +drivers/net/ethernet/nvidia/forcedeth.c:3194: error: UNINITIALIZED_VALUE + The value read from mask[_] was never initialized. + 3192. writel(addr[1], base + NvRegMulticastAddrB); + 3193. writel(mask[0], base + NvRegMulticastMaskA); + 3194. > writel(mask[1], base + NvRegMulticastMaskB); + 3195. writel(pff, base + NvRegPacketFilterFlags); + 3196. nv_start_rx(dev); + +net/socket.c:3159: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced at line 3159, column 2. + 3157. } + 3158. + 3159. > (*newsock)->ops = sock->ops; + 3160. __module_get((*newsock)->ops->owner); + 3161. + +net/socket.c:3154: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced by call to `sock_release()` at line 3154, column 3. + 3152. err = sock->ops->accept(sock, *newsock, flags, true); + 3153. if (err < 0) { + 3154. > sock_release(*newsock); + 3155. *newsock = NULL; + 3156. goto done; + +drivers/usb/core/hub.c:3146: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3145 could be null and is dereferenced at line 3146, column 30. + 3144. { + 3145. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3146. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3147. int port1 = udev->portnum; + 3148. int status; + +security/selinux/hooks.c:3149: error: MEMORY_LEAK + `return` is not reachable after line 3149, column 3. + 3147. + 3148. if (cap_capable(cred, &init_user_ns, CAP_MAC_ADMIN, cap_audit)) + 3149. > return false; + 3150. if (cred_has_capability(cred, CAP_MAC_ADMIN, cap_audit, true)) + 3151. return false; + +net/core/rtnetlink.c:3169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3167. */ + 3168. rcu_read_lock(); + 3169. > for_each_netdev_rcu(net, dev) { + 3170. min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size, + 3171. if_nlmsg_size(dev, + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +kernel/events/core.c:3182: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3180. perf_event_switch(task, prev, true); + 3181. + 3182. > if (__this_cpu_read(perf_sched_cb_usages)) + 3183. perf_pmu_sched_task(prev, task, true); + 3184. } + +net/wireless/trace.h:3158: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +block/blk-mq.c:3196: error: NULL_DEREFERENCE + pointer `rq` last assigned on line 3183 could be null and is dereferenced by call to `__blk_mq_poll()` at line 3196, column 9. + 3194. } + 3195. + 3196. > return __blk_mq_poll(hctx, rq); + 3197. } + 3198. + +kernel/cgroup/cgroup.c:3177: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 3176 could be null and is dereferenced at line 3177, column 28. + 3175. { + 3176. struct cgroup *parent = cgroup_parent(cgrp); + 3177. > struct cgroup *dom_cgrp = parent->dom_cgrp; + 3178. int ret; + 3179. + +drivers/tty/serial/8250/8250_port.c:3230: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 3228. + 3229. if (locked) + 3230. > spin_unlock_irqrestore(&port->lock, flags); + 3231. serial8250_rpm_put(up); + 3232. } + +net/core/rtnetlink.c:3199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3197. continue; + 3198. + 3199. > tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]); + 3200. if (!tab) + 3201. continue; + +net/ipv4/ipmr.c:3247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3245. + 3246. /* Notify on table MFC entries */ + 3247. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) + 3248. call_ipmr_mfc_entry_notifier(nb, net, + 3249. FIB_EVENT_ENTRY_ADD, mfc, + +drivers/iommu/intel-iommu.c:3240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3238. * endfor + 3239. */ + 3240. > for_each_drhd_unit(drhd) { + 3241. /* + 3242. * lock not needed as this is only incremented in the single + +drivers/iommu/intel-iommu.c:3265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3263. } + 3264. + 3265. > for_each_active_iommu(iommu, drhd) { + 3266. g_iommus[iommu->seq_id] = iommu; + 3267. + +drivers/iommu/intel-iommu.c:3330: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3328. * flush_context function will loop forever and the boot hangs. + 3329. */ + 3330. > for_each_active_iommu(iommu, drhd) { + 3331. iommu_flush_write_buffer(iommu); + 3332. iommu_set_root_entry(iommu); + +drivers/iommu/intel-iommu.c:3391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3389. for_each_rmrr_units(rmrr) { + 3390. /* some BIOS lists non-exist devices in DMAR table. */ + 3391. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 3392. i, dev) { + 3393. ret = iommu_prepare_rmrr_dev(rmrr, dev); + +drivers/iommu/intel-iommu.c:3410: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3408. * enable translation + 3409. */ + 3410. > for_each_iommu(iommu, drhd) { + 3411. if (drhd->ignored) { + 3412. /* + +drivers/iommu/intel-iommu.c:3443: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3441. + 3442. free_iommu: + 3443. > for_each_active_iommu(iommu, drhd) { + 3444. disable_dmar_iommu(iommu); + 3445. free_dmar_iommu(iommu); + +kernel/rcu/tree.c:3263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3261. * and cond_synchronize_rcu(). + 3262. */ + 3263. > return smp_load_acquire(&rcu_state_p->gpnum); + 3264. } + 3265. EXPORT_SYMBOL_GPL(get_state_synchronize_rcu); + +kernel/cgroup/cgroup.c:3258: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3256. { + 3257. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3258. > int descendants = READ_ONCE(cgrp->max_descendants); + 3259. + 3260. if (descendants == INT_MAX) + +net/core/sock.c:3276: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3274. #ifdef CONFIG_INET + 3275. if (family == AF_INET && + 3276. > !rcu_access_pointer(inet_protos[protocol])) + 3277. return -ENOENT; + 3278. #endif + +net/ipv6/route.c:3277: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3275. + 3276. rcu_read_lock(); + 3277. > for_each_fib6_node_rt_rcu(&table->tb6_root) { + 3278. if (dev == rt->dst.dev && + 3279. ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) && + +kernel/rcu/tree.c:3289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3287. * actions the caller might carry out after we return. + 3288. */ + 3289. > newstate = smp_load_acquire(&rcu_state_p->completed); + 3290. if (ULONG_CMP_GE(oldstate, newstate)) + 3291. synchronize_rcu(); + +kernel/printk/printk.c:3292: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3290. { + 3291. printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3292. > log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3293. print_tainted(), init_utsname()->release, + 3294. (int)strcspn(init_utsname()->version, " "), + +kernel/printk/printk.c:3291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3289. void dump_stack_print_info(const char *log_lvl) + 3290. { + 3291. > printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3292. log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3293. print_tainted(), init_utsname()->release, + +kernel/events/core.c:3315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3313. perf_pmu_disable(ctx->pmu); + 3314. + 3315. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 3316. if (event->state != PERF_EVENT_STATE_ACTIVE) + 3317. continue; + +kernel/cgroup/cgroup.c:3301: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3299. { + 3300. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3301. > int depth = READ_ONCE(cgrp->max_depth); + 3302. + 3303. if (depth == INT_MAX) + +kernel/rcu/tree.c:3315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3313. * and cond_synchronize_sched(). + 3314. */ + 3315. > return smp_load_acquire(&rcu_sched_state.gpnum); + 3316. } + 3317. EXPORT_SYMBOL_GPL(get_state_synchronize_sched); + +drivers/net/ethernet/nvidia/forcedeth.c:3321: error: DEAD_STORE + The value written to &newdup (type int) is never used. + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. int newls = np->linkspeed; + 3321. > int newdup = np->duplex; + 3322. int mii_status; + 3323. u32 bmcr; + +drivers/net/ethernet/nvidia/forcedeth.c:3320: error: DEAD_STORE + The value written to &newls (type int) is never used. + 3318. int lpa = 0; + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. > int newls = np->linkspeed; + 3321. int newdup = np->duplex; + 3322. int mii_status; + +net/ipv6/route.c:3324: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3322. restart: + 3323. rcu_read_lock(); + 3324. > for_each_fib6_node_rt_rcu(&table->tb6_root) { + 3325. if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) && + 3326. (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) { + +kernel/rcu/tree.c:3341: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3339. * actions the caller might carry out after we return. + 3340. */ + 3341. > newstate = smp_load_acquire(&rcu_sched_state.completed); + 3342. if (ULONG_CMP_GE(oldstate, newstate)) + 3343. synchronize_sched(); + +drivers/gpu/drm/i915/i915_drv.h:3338: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3336. static inline u32 i915_reset_count(struct i915_gpu_error *error) + 3337. { + 3338. > return READ_ONCE(error->reset_count); + 3339. } + 3340. + +drivers/gpu/drm/i915/i915_drv.h:3344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3342. struct intel_engine_cs *engine) + 3343. { + 3344. > return READ_ONCE(error->reset_engine_count[engine->id]); + 3345. } + 3346. + +net/ipv6/route.c:3351: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3349. for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { + 3350. head = &net->ipv6.fib_table_hash[h]; + 3351. > hlist_for_each_entry_rcu(table, head, tb6_hlist) { + 3352. if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER) + 3353. __rt6_purge_dflt_routers(table); + +kernel/sched/core.c:3358: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3356. int cpu; + 3357. + 3358. > cpu = smp_processor_id(); + 3359. rq = cpu_rq(cpu); + 3360. prev = rq->curr; + +kernel/sched/core.c:3358: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3356. int cpu; + 3357. + 3358. > cpu = smp_processor_id(); + 3359. rq = cpu_rq(cpu); + 3360. prev = rq->curr; + +kernel/rcu/tree.c:3370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3368. if (rcu_scheduler_fully_active && + 3369. rdp->core_needs_qs && rdp->cpu_no_qs.b.norm && + 3370. > rdp->rcu_qs_ctr_snap == __this_cpu_read(rcu_dynticks.rcu_qs_ctr)) { + 3371. rdp->n_rp_core_needs_qs++; + 3372. } else if (rdp->core_needs_qs && !rdp->cpu_no_qs.b.norm) { + +net/core/dev.c:3375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3373. + 3374. rcu_read_lock(); + 3375. > dev_maps = rcu_dereference(dev->xps_maps); + 3376. if (dev_maps) { + 3377. unsigned int tci = skb->sender_cpu - 1; + +net/core/dev.c:3384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3382. } + 3383. + 3384. > map = rcu_dereference(dev_maps->cpu_map[tci]); + 3385. if (map) { + 3386. if (map->len == 1) + +drivers/scsi/scsi_lib.c:3377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3375. + 3376. rcu_read_lock(); + 3377. > vpd_pg83 = rcu_dereference(sdev->vpd_pg83); + 3378. if (!vpd_pg83) { + 3379. rcu_read_unlock(); + +kernel/trace/trace.c:3393: error: DEAD_STORE + The value written to &name (type char const *) is never used. + 3391. unsigned long entries; + 3392. unsigned long total; + 3393. > const char *name = "preemption"; + 3394. + 3395. name = type->name; + +net/ipv4/tcp_input.c:3407: error: DEAD_STORE + The value written to &half (type unsigned int) is never used. + 3405. if (now != challenge_timestamp) { + 3406. u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit; + 3407. > u32 half = (ack_limit + 1) >> 1; + 3408. + 3409. challenge_timestamp = now; + +net/ipv4/tcp_input.c:3412: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3410. WRITE_ONCE(challenge_count, half + prandom_u32_max(ack_limit)); + 3411. } + 3412. > count = READ_ONCE(challenge_count); + 3413. if (count > 0) { + 3414. WRITE_ONCE(challenge_count, count - 1); + +drivers/iommu/amd_iommu.c:3421: error: UNINITIALIZED_VALUE + The value read from pte was never initialized. + 3419. } + 3420. + 3421. > return pte; + 3422. } + 3423. + +net/core/dev.c:3417: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3415. if (queue_index != new_index && sk && + 3416. sk_fullsock(sk) && + 3417. > rcu_access_pointer(sk->sk_dst_cache)) + 3418. sk_tx_queue_set(sk, new_index); + 3419. + +drivers/usb/core/hub.c:3415: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3414 could be null and is dereferenced at line 3415, column 30. + 3413. { + 3414. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3415. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3416. int port1 = udev->portnum; + 3417. int status; + +kernel/events/core.c:3425: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + 3427. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3424: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 3422. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + +kernel/events/core.c:3425: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + 3427. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3424: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 3422. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + +net/core/rtnetlink.c:3461: error: NULL_DEREFERENCE + pointer `br_dev` last assigned on line 3460 could be null and is dereferenced at line 3461, column 38. + 3459. (dev->priv_flags & IFF_BRIDGE_PORT)) { + 3460. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + 3461. > const struct net_device_ops *ops = br_dev->netdev_ops; + 3462. + 3463. err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, + +drivers/gpu/drm/i915/i915_debugfs.c:3442: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 3441 could be null and is dereferenced at line 3442, column 8. + 3440. + 3441. intel_dig_port = enc_to_dig_port(&intel_encoder->base); + 3442. > if (!intel_dig_port->dp.can_mst) + 3443. continue; + 3444. + +net/core/dev.c:3436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3434. + 3435. if (sender_cpu >= (u32)NR_CPUS) + 3436. > skb->sender_cpu = raw_smp_processor_id() + 1; + 3437. #endif + 3438. + +kernel/signal.c:3488: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3486. sigaddset(&mask, sig); + 3487. flush_sigqueue_mask(&mask, &p->signal->shared_pending); + 3488. > for_each_thread(p, t) + 3489. flush_sigqueue_mask(&mask, &t->pending); + 3490. } + +drivers/gpu/drm/i915/i915_debugfs.c:3499: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3499, column 5. + 3497. */ + 3498. if (val == 1) + 3499. > intel_dp->compliance.test_active = 1; + 3500. else + 3501. intel_dp->compliance.test_active = 0; + +drivers/gpu/drm/i915/i915_debugfs.c:3501: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3501, column 5. + 3499. intel_dp->compliance.test_active = 1; + 3500. else + 3501. > intel_dp->compliance.test_active = 0; + 3502. } + 3503. } + +drivers/net/ethernet/intel/e1000e/netdev.c:3474: error: UNINITIALIZED_VALUE + The value read from rss_key[_] was never initialized. + 3472. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 3473. for (i = 0; i < 10; i++) + 3474. > ew32(RSSRK(i), rss_key[i]); + 3475. + 3476. /* Direct all traffic to queue 0 */ + +kernel/sched/fair.c:3492: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3490. + 3491. /* Update parent cfs_rq utilization */ + 3492. > add_positive(&cfs_rq->avg.util_avg, delta); + 3493. cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX; + 3494. } + +net/core/dev.c:3521: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3519. + 3520. txq = netdev_pick_tx(dev, skb, accel_priv); + 3521. > q = rcu_dereference_bh(txq->qdisc); + 3522. + 3523. trace_net_dev_queue(skb); + +net/core/dev.c:3542: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3540. */ + 3541. if (dev->flags & IFF_UP) { + 3542. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + +net/core/dev.c:3545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + 3545. > if (unlikely(__this_cpu_read(xmit_recursion) > + 3546. XMIT_RECURSION_LIMIT)) + 3547. goto recursion_alert; + +net/core/dev.c:3542: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3540. */ + 3541. if (dev->flags & IFF_UP) { + 3542. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + +drivers/iommu/intel-iommu.c:3506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3504. rcu_read_lock(); + 3505. for_each_rmrr_units(rmrr) { + 3506. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 3507. i, i_dev) { + 3508. if (i_dev != dev) + +kernel/events/core.c:3501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3499. + 3500. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3501. > int local_cpu = smp_processor_id(); + 3502. + 3503. event_pkg = topology_physical_package_id(event_cpu); + +kernel/events/core.c:3501: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3499. + 3500. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3501. > int local_cpu = smp_processor_id(); + 3502. + 3503. event_pkg = topology_physical_package_id(event_cpu); + +kernel/sched/fair.c:3547: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3545. se->avg.load_sum = runnable_sum; + 3546. se->avg.load_avg = load_avg; + 3547. > add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + +kernel/sched/fair.c:3548: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3546. se->avg.load_avg = load_avg; + 3547. add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. > add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + 3550. runnable_load_sum = (s64)se_runnable(se) * runnable_sum; + +kernel/sched/fair.c:3559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3557. + 3558. if (se->on_rq) { + 3559. > add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + +kernel/sched/fair.c:3560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3558. if (se->on_rq) { + 3559. add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. > add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + 3562. } + +drivers/gpu/drm/i915/i915_debugfs.c:3534: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3533 could be null and is dereferenced at line 3534, column 8. + 3532. if (encoder && connector->status == connector_status_connected) { + 3533. intel_dp = enc_to_intel_dp(&encoder->base); + 3534. > if (intel_dp->compliance.test_active) + 3535. seq_puts(m, "1"); + 3536. else + +net/core/rtnetlink.c:3525: error: DEAD_STORE + The value written to &err (type int) is never used. + 3523. struct nlattr *tb[NDA_MAX+1]; + 3524. struct net_device *dev; + 3525. > int err = -EINVAL; + 3526. __u8 *addr; + 3527. u16 vid; + +drivers/scsi/scsi_lib.c:3526: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3524. + 3525. rcu_read_lock(); + 3526. > vpd_pg83 = rcu_dereference(sdev->vpd_pg83); + 3527. if (!vpd_pg83) { + 3528. rcu_read_unlock(); + +drivers/clk/clk.c:3549: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3547. { + 3548. struct clk_notifier *cn = NULL; + 3549. > int ret = -EINVAL; + 3550. + 3551. if (!clk || !nb) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3569: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3567. u32 flash_linear_addr; + 3568. u32 flash_data = 0; + 3569. > s32 ret_val = -E1000_ERR_NVM; + 3570. u8 count = 0; + 3571. + +drivers/gpu/drm/i915/i915_debugfs.c:3585: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3584 could be null and is dereferenced at line 3585, column 8. + 3583. if (encoder && connector->status == connector_status_connected) { + 3584. intel_dp = enc_to_intel_dp(&encoder->base); + 3585. > if (intel_dp->compliance.test_type == + 3586. DP_TEST_LINK_EDID_READ) + 3587. seq_printf(m, "%lx", + +drivers/gpu/drm/i915/i915_gem.c:3571: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 3569. static int wait_for_engines(struct drm_i915_private *i915) + 3570. { + 3571. > if (wait_for(intel_engines_are_idle(i915), I915_IDLE_ENGINES_TIMEOUT)) { + 3572. dev_err(i915->drm.dev, + 3573. "Failed to idle engines, declaring wedged!\n"); + +drivers/gpu/drm/i915/i915_gem.c:3571: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 3569. static int wait_for_engines(struct drm_i915_private *i915) + 3570. { + 3571. > if (wait_for(intel_engines_are_idle(i915), I915_IDLE_ENGINES_TIMEOUT)) { + 3572. dev_err(i915->drm.dev, + 3573. "Failed to idle engines, declaring wedged!\n"); + +drivers/usb/core/hub.c:3611: error: DEAD_STORE + The value written to &status (type int) is never used. + 3609. /* Enable hub to send remote wakeup for all ports. */ + 3610. for (port1 = 1; port1 <= hdev->maxchild; port1++) { + 3611. > status = set_port_feature(hdev, + 3612. port1 | + 3613. USB_PORT_FEAT_REMOTE_WAKE_CONNECT | + +drivers/video/fbdev/core/fbcon.c:3597: error: DEAD_STORE + The value written to &pending (type int) is never used. + 3595. + 3596. if (info->queue.func) + 3597. > pending = cancel_work_sync(&info->queue); + 3598. DPRINTK("fbcon: %s pending work\n", (pending ? "canceled" : + 3599. "no")); + +kernel/signal.c:3588: error: UNINITIALIZED_VALUE + The value read from uss32.ss_flags was never initialized. + 3586. return -EFAULT; + 3587. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. > uss.ss_flags = uss32.ss_flags; + 3589. uss.ss_size = uss32.ss_size; + 3590. } + +kernel/signal.c:3589: error: UNINITIALIZED_VALUE + The value read from uss32.ss_size was never initialized. + 3587. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. uss.ss_flags = uss32.ss_flags; + 3589. > uss.ss_size = uss32.ss_size; + 3590. } + 3591. ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, + +kernel/signal.c:3587: error: UNINITIALIZED_VALUE + The value read from uss32.ss_sp was never initialized. + 3585. if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t))) + 3586. return -EFAULT; + 3587. > uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. uss.ss_flags = uss32.ss_flags; + 3589. uss.ss_size = uss32.ss_size; + +include/linux/netdevice.h:3586: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3584. bool ok = spin_trylock(&txq->_xmit_lock); + 3585. if (likely(ok)) + 3586. > txq->xmit_lock_owner = smp_processor_id(); + 3587. return ok; + 3588. } + +include/linux/netdevice.h:3586: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3584. bool ok = spin_trylock(&txq->_xmit_lock); + 3585. if (likely(ok)) + 3586. > txq->xmit_lock_owner = smp_processor_id(); + 3587. return ok; + 3588. } + +net/ipv6/addrconf.c:3633: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3631. spin_lock_bh(&addrconf_hash_lock); + 3632. restart: + 3633. > hlist_for_each_entry_rcu(ifa, h, addr_lst) { + 3634. if (ifa->idev == idev) { + 3635. addrconf_del_dad_work(ifa); + +net/wireless/reg.c:3593: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3591. rcu_read_lock(); + 3592. + 3593. > regd = rcu_dereference(cfg80211_regdomain); + 3594. wiphy_regd = rcu_dereference(wiphy->regd); + 3595. if (!wiphy_regd) { + +net/wireless/reg.c:3594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3592. + 3593. regd = rcu_dereference(cfg80211_regdomain); + 3594. > wiphy_regd = rcu_dereference(wiphy->regd); + 3595. if (!wiphy_regd) { + 3596. if (regd->dfs_region == NL80211_DFS_ETSI) + +kernel/events/core.c:3616: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3614. /* If this is a per-CPU event, it must be for this CPU */ + 3615. if (!(event->attach_state & PERF_ATTACH_TASK) && + 3616. > event->cpu != smp_processor_id()) { + 3617. ret = -EINVAL; + 3618. goto out; + +kernel/events/core.c:3626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3624. * oncpu == -1). + 3625. */ + 3626. > if (event->oncpu == smp_processor_id()) + 3627. event->pmu->read(event); + 3628. + +kernel/workqueue.c:3610: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3608. link_pwq(pwq); + 3609. + 3610. > old_pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]); + 3611. rcu_assign_pointer(wq->numa_pwq_tbl[node], pwq); + 3612. return old_pwq; + +drivers/gpu/drm/i915/i915_debugfs.c:3643: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3642 could be null and is dereferenced at line 3643, column 27. + 3641. if (encoder && connector->status == connector_status_connected) { + 3642. intel_dp = enc_to_intel_dp(&encoder->base); + 3643. > seq_printf(m, "%02lx", intel_dp->compliance.test_type); + 3644. } else + 3645. seq_puts(m, "0"); + +include/linux/netdevice.h:3629: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3627. + 3628. spin_lock(&dev->tx_global_lock); + 3629. > cpu = smp_processor_id(); + 3630. for (i = 0; i < dev->num_tx_queues; i++) { + 3631. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3629: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3627. + 3628. spin_lock(&dev->tx_global_lock); + 3629. > cpu = smp_processor_id(); + 3630. for (i = 0; i < dev->num_tx_queues; i++) { + 3631. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3644: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3642. union ich8_hws_flash_ctrl hsflctl; + 3643. u32 flash_linear_addr; + 3644. > s32 ret_val = -E1000_ERR_NVM; + 3645. u8 count = 0; + 3646. + +net/core/dev.c:3660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3658. + 3659. rxqueue = dev->_rx + rxq_index; + 3660. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3661. if (!flow_table) + 3662. goto out; + +kernel/events/core.c:3648: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3646. static int perf_event_read(struct perf_event *event, bool group) + 3647. { + 3648. > enum perf_event_state state = READ_ONCE(event->state); + 3649. int event_cpu, ret = 0; + 3650. + +kernel/events/core.c:3667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3665. smp_rmb(); + 3666. + 3667. > event_cpu = READ_ONCE(event->oncpu); + 3668. if ((unsigned)event_cpu >= nr_cpu_ids) + 3669. return 0; + +kernel/sched/fair.c:3672: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3670. + 3671. r = removed_load; + 3672. > sub_positive(&sa->load_avg, r); + 3673. sub_positive(&sa->load_sum, r * divider); + 3674. + +kernel/sched/fair.c:3673: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3671. r = removed_load; + 3672. sub_positive(&sa->load_avg, r); + 3673. > sub_positive(&sa->load_sum, r * divider); + 3674. + 3675. r = removed_util; + +kernel/sched/fair.c:3676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3674. + 3675. r = removed_util; + 3676. > sub_positive(&sa->util_avg, r); + 3677. sub_positive(&sa->util_sum, r * divider); + 3678. + +kernel/sched/fair.c:3677: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3675. r = removed_util; + 3676. sub_positive(&sa->util_avg, r); + 3677. > sub_positive(&sa->util_sum, r * divider); + 3678. + 3679. add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum); + +drivers/gpu/drm/i915/intel_dp.c:3745: error: UNINITIALIZED_VALUE + The value read from sink_rates[_] was never initialized. + 3743. + 3744. for (i = 0; i < ARRAY_SIZE(sink_rates); i++) { + 3745. > int val = le16_to_cpu(sink_rates[i]); + 3746. + 3747. if (val == 0) + +net/core/dev.c:3714: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3712. /* Avoid computing hash if RFS/RPS is not active for this rxqueue */ + 3713. + 3714. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3715. map = rcu_dereference(rxqueue->rps_map); + 3716. if (!flow_table && !map) + +net/core/dev.c:3715: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3713. + 3714. flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3715. > map = rcu_dereference(rxqueue->rps_map); + 3716. if (!flow_table && !map) + 3717. goto done; + +net/core/dev.c:3724: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3722. goto done; + 3723. + 3724. > sock_flow_table = rcu_dereference(rps_sock_flow_table); + 3725. if (flow_table && sock_flow_table) { + 3726. struct rps_dev_flow *rflow; + +drivers/ata/libata-scsi.c:3697: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3695. struct scsi_cmnd *scmd = qc->scsicmd; + 3696. const u8 *cdb = scmd->cmnd; + 3697. > u16 sect, fp = (u16)-1; + 3698. u8 sa, options, bp = 0xff; + 3699. u64 block; + +drivers/gpu/drm/drm_edid.c:3734: error: UNINITIALIZED_VALUE + The value read from hdmi_len was never initialized. + 3732. */ + 3733. if (hdmi) + 3734. > modes += do_hdmi_vsdb_modes(connector, hdmi, hdmi_len, video, + 3735. video_len); + 3736. + +include/linux/netdevice.h:3701: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3699. + 3700. local_bh_disable(); + 3701. > cpu = smp_processor_id(); + 3702. for (i = 0; i < dev->num_tx_queues; i++) { + 3703. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3701: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3699. + 3700. local_bh_disable(); + 3701. > cpu = smp_processor_id(); + 3702. for (i = 0; i < dev->num_tx_queues; i++) { + 3703. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +drivers/ata/libata-core.c:3726: error: DEAD_STORE + The value written to &nodev_deadline (type unsigned long) is never used. + 3724. + 3725. if (time_after(nodev_deadline, deadline)) + 3726. > nodev_deadline = deadline; + 3727. + 3728. while (1) { + +drivers/ata/libata-core.c:3729: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 3727. + 3728. while (1) { + 3729. > unsigned long now = jiffies; + 3730. int ready, tmp; + 3731. + +drivers/ata/libata-core.c:3766: error: DEAD_STORE + The value written to &warned (type int) is never used. + 3764. "link is slow to respond, please be patient " + 3765. "(ready=%d)\n", tmp); + 3766. > warned = 1; + 3767. } + 3768. + +drivers/pci/quirks.c:3743: error: DEAD_STORE + The value written to &timeout (type unsigned long) is never used. + 3741. iowrite32(val, mmio_base + PCH_PP_CONTROL); + 3742. + 3743. > timeout = jiffies + msecs_to_jiffies(IGD_OPERATION_TIMEOUT); + 3744. do { + 3745. val = ioread32(mmio_base + PCH_PP_STATUS); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3821: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3819. + 3820. /* Convert offset to bytes. */ + 3821. > act_offset = (i + new_bank_offset) << 1; + 3822. + 3823. usleep_range(100, 200); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3867: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3865. * to 1's. We can write 1's to 0's without an erase + 3866. */ + 3867. > act_offset = (old_bank_offset + E1000_ICH_NVM_SIG_WORD) * 2 + 1; + 3868. + 3869. /* offset in words but we read dword */ + +kernel/sched/fair.c:3755: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3753. { + 3754. dequeue_load_avg(cfs_rq, se); + 3755. > sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + +kernel/sched/fair.c:3756: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3754. dequeue_load_avg(cfs_rq, se); + 3755. sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. > sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + 3758. add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum); + +drivers/ata/libata-scsi.c:3784: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3782. u64 block; + 3783. u32 n_block; + 3784. > u16 fp = (u16)-1; + 3785. + 3786. if (unlikely(scmd->cmd_len < 16)) { + +net/core/dev.c:3806: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3804. + 3805. rcu_read_lock(); + 3806. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3807. if (flow_table && flow_id <= flow_table->mask) { + 3808. rflow = &flow_table->flows[flow_id]; + +net/core/dev.c:3809: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3807. if (flow_table && flow_id <= flow_table->mask) { + 3808. rflow = &flow_table->flows[flow_id]; + 3809. > cpu = READ_ONCE(rflow->cpu); + 3810. if (rflow->filter == filter_id && cpu < nr_cpu_ids && + 3811. ((int)(per_cpu(softnet_data, cpu).input_queue_head - + +kernel/rcu/tree.c:3834: error: DEAD_STORE + The value written to &nbits (type int) is never used. + 3832. rnp->expmaskinitnext |= mask; + 3833. oldmask ^= rnp->expmaskinitnext; + 3834. > nbits = bitmap_weight(&oldmask, BITS_PER_LONG); + 3835. /* Allow lockless access for expedited grace periods. */ + 3836. smp_store_release(&rsp->ncpus, rsp->ncpus + nbits); /* ^^^ */ + +drivers/ata/libata-core.c:3828: error: DEAD_STORE + The value written to &deadline (type unsigned long) is never used. + 3826. t = ata_deadline(jiffies, params[2]); + 3827. if (time_before(t, deadline)) + 3828. > deadline = t; + 3829. + 3830. if ((rc = sata_scr_read(link, SCR_STATUS, &cur))) + +drivers/ata/libata-core.c:3834: error: DEAD_STORE + The value written to &last (type unsigned int) is never used. + 3832. cur &= 0xf; + 3833. + 3834. > last = cur; + 3835. last_jiffies = jiffies; + 3836. + +drivers/ata/libata-core.c:3835: error: DEAD_STORE + The value written to &last_jiffies (type unsigned long) is never used. + 3833. + 3834. last = cur; + 3835. > last_jiffies = jiffies; + 3836. + 3837. while (1) { + +kernel/cgroup/cgroup.c:3849: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3847. */ + 3848. if (!pos) { + 3849. > next = list_entry_rcu(parent->children.next, struct cgroup_subsys_state, sibling); + 3850. } else if (likely(!(pos->flags & CSS_RELEASED))) { + 3851. next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + +kernel/cgroup/cgroup.c:3851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3849. next = list_entry_rcu(parent->children.next, struct cgroup_subsys_state, sibling); + 3850. } else if (likely(!(pos->flags & CSS_RELEASED))) { + 3851. > next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + 3852. } else { + 3853. list_for_each_entry_rcu(next, &parent->children, sibling) + +kernel/cgroup/cgroup.c:3853: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3851. next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + 3852. } else { + 3853. > list_for_each_entry_rcu(next, &parent->children, sibling) + 3854. if (next->serial_nr > pos->serial_nr) + 3855. break; + +net/packet/af_packet.c:3875: error: DEAD_STORE + The value written to &val (type int) is never used. + 3873. break; + 3874. case PACKET_AUXDATA: + 3875. > val = po->auxdata; + 3876. break; + 3877. case PACKET_ORIGDEV: + +net/packet/af_packet.c:3878: error: DEAD_STORE + The value written to &val (type int) is never used. + 3876. break; + 3877. case PACKET_ORIGDEV: + 3878. > val = po->origdev; + 3879. break; + 3880. case PACKET_VNET_HDR: + +net/packet/af_packet.c:3881: error: DEAD_STORE + The value written to &val (type int) is never used. + 3879. break; + 3880. case PACKET_VNET_HDR: + 3881. > val = po->has_vnet_hdr; + 3882. break; + 3883. case PACKET_VERSION: + +net/packet/af_packet.c:3884: error: DEAD_STORE + The value written to &val (type int) is never used. + 3882. break; + 3883. case PACKET_VERSION: + 3884. > val = po->tp_version; + 3885. break; + 3886. case PACKET_HDRLEN: + +net/packet/af_packet.c:3895: error: DEAD_STORE + The value written to &val (type int) is never used. + 3893. switch (val) { + 3894. case TPACKET_V1: + 3895. > val = sizeof(struct tpacket_hdr); + 3896. break; + 3897. case TPACKET_V2: + +net/packet/af_packet.c:3898: error: DEAD_STORE + The value written to &val (type int) is never used. + 3896. break; + 3897. case TPACKET_V2: + 3898. > val = sizeof(struct tpacket2_hdr); + 3899. break; + 3900. case TPACKET_V3: + +net/packet/af_packet.c:3901: error: DEAD_STORE + The value written to &val (type int) is never used. + 3899. break; + 3900. case TPACKET_V3: + 3901. > val = sizeof(struct tpacket3_hdr); + 3902. break; + 3903. default: + +net/packet/af_packet.c:3908: error: DEAD_STORE + The value written to &val (type int) is never used. + 3906. break; + 3907. case PACKET_RESERVE: + 3908. > val = po->tp_reserve; + 3909. break; + 3910. case PACKET_LOSS: + +net/packet/af_packet.c:3911: error: DEAD_STORE + The value written to &val (type int) is never used. + 3909. break; + 3910. case PACKET_LOSS: + 3911. > val = po->tp_loss; + 3912. break; + 3913. case PACKET_TIMESTAMP: + +net/packet/af_packet.c:3914: error: DEAD_STORE + The value written to &val (type int) is never used. + 3912. break; + 3913. case PACKET_TIMESTAMP: + 3914. > val = po->tp_tstamp; + 3915. break; + 3916. case PACKET_FANOUT: + +net/packet/af_packet.c:3917: error: DEAD_STORE + The value written to &val (type int) is never used. + 3915. break; + 3916. case PACKET_FANOUT: + 3917. > val = (po->fanout ? + 3918. ((u32)po->fanout->id | + 3919. ((u32)po->fanout->type << 16) | + +net/packet/af_packet.c:3933: error: DEAD_STORE + The value written to &val (type int) is never used. + 3931. break; + 3932. case PACKET_TX_HAS_OFF: + 3933. > val = po->tp_tx_has_off; + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + +net/packet/af_packet.c:3936: error: DEAD_STORE + The value written to &val (type int) is never used. + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + 3936. > val = packet_use_direct_xmit(po); + 3937. break; + 3938. default: + +drivers/net/ethernet/intel/e1000/e1000_main.c:3856: error: DEAD_STORE + The value written to &hw (type e1000_hw*) is never used. + 3854. struct e1000_tx_ring *tx_ring) + 3855. { + 3856. > struct e1000_hw *hw = &adapter->hw; + 3857. struct net_device *netdev = adapter->netdev; + 3858. struct e1000_tx_desc *tx_desc, *eop_desc; + +drivers/net/ethernet/intel/e1000/e1000_main.c:3906: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3904. + 3905. #define TX_WAKE_THRESHOLD 32 + 3906. > if (unlikely(count && netif_carrier_ok(netdev) && + 3907. E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) { + 3908. /* Make sure that anybody stopping the queue after this + +net/core/dev.c:3872: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3870. + 3871. rcu_read_lock(); + 3872. > fl = rcu_dereference(sd->flow_limit); + 3873. if (fl) { + 3874. new_flow = skb_get_hash(skb) & (fl->num_buckets - 1); + +net/core/rtnetlink.c:3885: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3883. + 3884. rcu_read_lock(); + 3885. > for_each_netdev_rcu(net, dev) { + 3886. const struct net_device_ops *ops = dev->netdev_ops; + 3887. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + +kernel/module.c:3913: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3911. unsigned int i, best = 0; + 3912. unsigned long nextval; + 3913. > struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms); + 3914. + 3915. /* At worse, next value is at end of module */ + +net/core/rtnetlink.c:3947: error: DEAD_STORE + The value written to &err (type int) is never used. + 3945. struct net *net = dev_net(dev); + 3946. struct sk_buff *skb; + 3947. > int err = -EOPNOTSUPP; + 3948. + 3949. if (!dev->netdev_ops->ndo_bridge_getlink) + +kernel/workqueue.c:4043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4041. + 4042. mutex_lock(&wq->mutex); + 4043. > for_each_pwq(pwq, wq) + 4044. pwq_adjust_max_active(pwq); + 4045. mutex_unlock(&wq->mutex); + +drivers/iommu/intel-iommu.c:3976: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3974. int i; + 3975. + 3976. > for_each_drhd_unit(drhd) { + 3977. if (!drhd->include_all) { + 3978. for_each_active_dev_scope(drhd->devices, + +drivers/iommu/intel-iommu.c:3978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3976. for_each_drhd_unit(drhd) { + 3977. if (!drhd->include_all) { + 3978. > for_each_active_dev_scope(drhd->devices, + 3979. drhd->devices_cnt, i, dev) + 3980. break; + +drivers/iommu/intel-iommu.c:3987: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3985. } + 3986. + 3987. > for_each_active_drhd_unit(drhd) { + 3988. if (drhd->include_all) + 3989. continue; + +drivers/iommu/intel-iommu.c:3991: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3989. continue; + 3990. + 3991. > for_each_active_dev_scope(drhd->devices, + 3992. drhd->devices_cnt, i, dev) + 3993. if (!dev_is_pci(dev) || !IS_GFX_DEVICE(to_pci_dev(dev))) + +drivers/iommu/intel-iommu.c:4004: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4002. } else { + 4003. drhd->ignored = 1; + 4004. > for_each_active_dev_scope(drhd->devices, + 4005. drhd->devices_cnt, i, dev) + 4006. dev->archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO; + +net/packet/af_packet.c:3981: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3979. + 3980. rcu_read_lock(); + 3981. > sk_for_each_rcu(sk, &net->packet.sklist) { + 3982. struct packet_sock *po = pkt_sk(sk); + 3983. + +drivers/tty/vt/vt.c:3993: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3991. console_lock(); + 3992. for (i = k = 0; i < 16; i++) { + 3993. > default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + +drivers/tty/vt/vt.c:3994: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3992. for (i = k = 0; i < 16; i++) { + 3993. default_red[i] = colormap[k++]; + 3994. > default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + 3996. } + +drivers/tty/vt/vt.c:3995: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3993. default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. > default_blu[i] = colormap[k++]; + 3996. } + 3997. for (i = 0; i < MAX_NR_CONSOLES; i++) { + +kernel/module.c:3990: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3988. + 3989. preempt_disable(); + 3990. > list_for_each_entry_rcu(mod, &modules, list) { + 3991. if (mod->state == MODULE_STATE_UNFORMED) + 3992. continue; + +kernel/module.c:4015: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4013. + 4014. preempt_disable(); + 4015. > list_for_each_entry_rcu(mod, &modules, list) { + 4016. if (mod->state == MODULE_STATE_UNFORMED) + 4017. continue; + +drivers/iommu/intel-iommu.c:4017: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4015. struct intel_iommu *iommu = NULL; + 4016. + 4017. > for_each_active_iommu(iommu, drhd) + 4018. if (iommu->qi) + 4019. dmar_reenable_qi(iommu); + +drivers/iommu/intel-iommu.c:4021: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4019. dmar_reenable_qi(iommu); + 4020. + 4021. > for_each_iommu(iommu, drhd) { + 4022. if (drhd->ignored) { + 4023. /* + +kernel/module.c:4043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4041. + 4042. preempt_disable(); + 4043. > list_for_each_entry_rcu(mod, &modules, list) { + 4044. struct mod_kallsyms *kallsyms; + 4045. + +kernel/module.c:4048: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4046. if (mod->state == MODULE_STATE_UNFORMED) + 4047. continue; + 4048. > kallsyms = rcu_dereference_sched(mod->kallsyms); + 4049. if (symnum < kallsyms->num_symtab) { + 4050. *value = kallsyms->symtab[symnum].st_value; + +drivers/iommu/intel-iommu.c:4051: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4049. struct intel_iommu *iommu; + 4050. + 4051. > for_each_active_iommu(iommu, drhd) { + 4052. iommu->flush.flush_context(iommu, 0, 0, 0, + 4053. DMA_CCMD_GLOBAL_INVL); + +net/core/dev.c:4063: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4061. + 4062. txq = netdev_pick_tx(dev, skb, NULL); + 4063. > cpu = smp_processor_id(); + 4064. HARD_TX_LOCK(dev, txq, cpu); + 4065. if (!netif_xmit_stopped(txq)) { + +net/core/dev.c:4063: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4061. + 4062. txq = netdev_pick_tx(dev, skb, NULL); + 4063. > cpu = smp_processor_id(); + 4064. HARD_TX_LOCK(dev, txq, cpu); + 4065. if (!netif_xmit_stopped(txq)) { + +drivers/tty/vt/vt.c:4060: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4058. { + 4059. struct console_font font; + 4060. > int rc = -EINVAL; + 4061. int c; + 4062. + +drivers/tty/vt/vt.c:4101: error: UNINITIALIZED_VALUE + The value read from font.charcount was never initialized. + 4099. op->height = font.height; + 4100. op->width = font.width; + 4101. > op->charcount = font.charcount; + 4102. + 4103. if (op->data && copy_to_user(op->data, font.data, c)) + +drivers/tty/vt/vt.c:4099: error: UNINITIALIZED_VALUE + The value read from font.height was never initialized. + 4097. goto out; + 4098. + 4099. > op->height = font.height; + 4100. op->width = font.width; + 4101. op->charcount = font.charcount; + +drivers/tty/vt/vt.c:4100: error: UNINITIALIZED_VALUE + The value read from font.width was never initialized. + 4098. + 4099. op->height = font.height; + 4100. > op->width = font.width; + 4101. op->charcount = font.charcount; + 4102. + +drivers/iommu/intel-iommu.c:4065: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4063. unsigned long flag; + 4064. + 4065. > for_each_active_iommu(iommu, drhd) { + 4066. iommu->iommu_state = kzalloc(sizeof(u32) * MAX_SR_DMAR_REGS, + 4067. GFP_ATOMIC); + +drivers/iommu/intel-iommu.c:4074: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4072. iommu_flush_all(); + 4073. + 4074. > for_each_active_iommu(iommu, drhd) { + 4075. iommu_disable_translation(iommu); + 4076. + +drivers/iommu/intel-iommu.c:4093: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4091. + 4092. nomem: + 4093. > for_each_active_iommu(iommu, drhd) + 4094. kfree(iommu->iommu_state); + 4095. + +kernel/module.c:4067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4065. { + 4066. unsigned int i; + 4067. > struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms); + 4068. + 4069. for (i = 0; i < kallsyms->num_symtab; i++) + +kernel/sched/core.c:4073: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4071. + 4072. rcu_read_lock(); + 4073. > pcred = __task_cred(p); + 4074. match = (uid_eq(cred->euid, pcred->euid) || + 4075. uid_eq(cred->euid, pcred->uid)); + +kernel/workqueue.c:4079: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4077. /* sanity checks */ + 4078. mutex_lock(&wq->mutex); + 4079. > for_each_pwq(pwq, wq) { + 4080. int i; + 4081. + +kernel/workqueue.c:4126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4124. */ + 4125. for_each_node(node) { + 4126. > pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]); + 4127. RCU_INIT_POINTER(wq->numa_pwq_tbl[node], NULL); + 4128. put_pwq_unlocked(pwq); + +kernel/module.c:4089: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4087. ret = mod_find_symname(mod, colon+1); + 4088. } else { + 4089. > list_for_each_entry_rcu(mod, &modules, list) { + 4090. if (mod->state == MODULE_STATE_UNFORMED) + 4091. continue; + +drivers/gpu/drm/i915/intel_pm.c:4131: error: DEAD_STORE + The value written to &src_h (type unsigned int) is never used. + 4129. if (fb->format->format == DRM_FORMAT_NV12 && !y) { + 4130. src_w /= 2; + 4131. > src_h /= 2; + 4132. } + 4133. + +drivers/iommu/intel-iommu.c:4113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4111. } + 4112. + 4113. > for_each_active_iommu(iommu, drhd) { + 4114. + 4115. raw_spin_lock_irqsave(&iommu->register_lock, flag); + +drivers/iommu/intel-iommu.c:4129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4127. } + 4128. + 4129. > for_each_active_iommu(iommu, drhd) + 4130. kfree(iommu->iommu_state); + 4131. } + +net/core/dev.c:4121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4119. preempt_disable(); + 4120. rcu_read_lock(); + 4121. > ret = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb); + 4122. rcu_read_unlock(); + 4123. preempt_enable(); + +net/core/dev.c:4143: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4141. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4142. if (cpu < 0) + 4143. > cpu = smp_processor_id(); + 4144. + 4145. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4154: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4152. unsigned int qtail; + 4153. + 4154. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4155. put_cpu(); + 4156. } + +net/core/dev.c:4143: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4141. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4142. if (cpu < 0) + 4143. > cpu = smp_processor_id(); + 4144. + 4145. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4154: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4152. unsigned int qtail; + 4153. + 4154. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4155. put_cpu(); + 4156. } + +drivers/tty/vt/vt.c:4114: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4112. { + 4113. struct console_font font; + 4114. > int rc = -EINVAL; + 4115. int size; + 4116. + +net/ipv6/addrconf.c:4143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4141. + 4142. for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) { + 4143. > hlist_for_each_entry_rcu(ifa, &inet6_addr_lst[state->bucket], + 4144. addr_lst) { + 4145. if (!net_eq(dev_net(ifa->idev->dev), net)) + +drivers/net/ethernet/intel/e1000/e1000_main.c:4331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4329. rx_ring->next_to_clean = i; + 4330. + 4331. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4332. if (cleaned_count) + 4333. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +kernel/events/core.c:4162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4160. * owner->perf_event_mutex. + 4161. */ + 4162. > owner = READ_ONCE(event->owner); + 4163. if (owner) { + 4164. /* + +kernel/workqueue.c:4167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4165. wq->saved_max_active = max_active; + 4166. + 4167. > for_each_pwq(pwq, wq) + 4168. pwq_adjust_max_active(pwq); + 4169. + +drivers/gpu/drm/i915/i915_gem.c:4158: error: DEAD_STORE + The value written to &recent_enough (type unsigned long) is never used. + 4156. struct drm_i915_private *dev_priv = to_i915(dev); + 4157. struct drm_i915_file_private *file_priv = file->driver_priv; + 4158. > unsigned long recent_enough = jiffies - DRM_I915_THROTTLE_JIFFIES; + 4159. struct drm_i915_gem_request *request, *target = NULL; + 4160. long ret; + +kernel/sched/fair.c:4184: error: NULL_DEREFERENCE + pointer `se` last assigned on line 4183 could be null and is dereferenced at line 4184, column 27. + 4182. + 4183. se = __pick_first_entity(cfs_rq); + 4184. > delta = curr->vruntime - se->vruntime; + 4185. + 4186. if (delta < 0) + +net/ipv6/addrconf.c:4169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4167. struct net *net = seq_file_net(seq); + 4168. + 4169. > hlist_for_each_entry_continue_rcu(ifa, addr_lst) { + 4170. if (!net_eq(dev_net(ifa->idev->dev), net)) + 4171. continue; + +net/ipv6/addrconf.c:4178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4176. while (++state->bucket < IN6_ADDR_HSIZE) { + 4177. state->offset = 0; + 4178. > hlist_for_each_entry_rcu(ifa, + 4179. &inet6_addr_lst[state->bucket], addr_lst) { + 4180. if (!net_eq(dev_net(ifa->idev->dev), net)) + +net/core/dev.c:4191: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4189. preempt_disable(); + 4190. err = netif_rx_internal(skb); + 4191. > if (local_softirq_pending()) + 4192. do_softirq(); + 4193. preempt_enable(); + +drivers/iommu/intel-iommu.c:4192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4190. struct acpi_dmar_atsr *tmp; + 4191. + 4192. > list_for_each_entry_rcu(atsru, &dmar_atsr_units, list) { + 4193. tmp = (struct acpi_dmar_atsr *)atsru->hdr; + 4194. if (atsr->segment != tmp->segment) + +net/packet/af_packet.c:4209: error: DEAD_STORE + The value written to &err (type int) is never used. + 4207. struct sk_buff_head *rb_queue; + 4208. __be16 num; + 4209. > int err = -EINVAL; + 4210. /* Added to avoid minimal code churn */ + 4211. struct tpacket_req *req = &req_u->req; + +net/ipv6/route.c:4211: error: DEAD_STORE + The value written to &err (type int) is never used. + 4209. int remaining; + 4210. int attrlen; + 4211. > int err = 1, last_err = 0; + 4212. + 4213. remaining = cfg->fc_mp_len; + +drivers/usb/core/hub.c:4212: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 4210 could be null and is dereferenced by call to `hub_port_disable()` at line 4212, column 9. + 4210. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 4211. + 4212. > return hub_port_disable(hub, udev->portnum, 0); + 4213. } + 4214. + +kernel/events/core.c:4260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4258. * comment with perf_event_ctx_lock_nested(). + 4259. */ + 4260. > ctx = READ_ONCE(child->ctx); + 4261. /* + 4262. * Since child_mutex nests inside ctx::mutex, we must jump + +kernel/events/core.c:4285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4283. * and we can continue doing so. + 4284. */ + 4285. > tmp = list_first_entry_or_null(&event->child_list, + 4286. struct perf_event, child_list); + 4287. if (tmp == child) { + +net/core/rtnetlink.c:4322: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4320. + 4321. rcu_read_lock(); + 4322. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 4323. if (af_ops->fill_stats_af) { + 4324. struct nlattr *af; + +kernel/workqueue.c:4231: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4229. + 4230. if (cpu == WORK_CPU_UNBOUND) + 4231. > cpu = smp_processor_id(); + 4232. + 4233. if (!(wq->flags & WQ_UNBOUND)) + +kernel/workqueue.c:4231: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4229. + 4230. if (cpu == WORK_CPU_UNBOUND) + 4231. > cpu = smp_processor_id(); + 4232. + 4233. if (!(wq->flags & WQ_UNBOUND)) + +drivers/usb/core/hub.c:4265: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4263. } + 4264. + 4265. > dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n", + 4266. total_time, stable_time, portstatus); + 4267. + +drivers/usb/core/hub.c:4270: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4268. if (stable_time < HUB_DEBOUNCE_STABLE) + 4269. return -ETIMEDOUT; + 4270. > return portstatus; + 4271. } + 4272. + +drivers/gpu/drm/i915/intel_display.c:4266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4264. struct drm_crtc_commit *commit; + 4265. spin_lock(&crtc->commit_lock); + 4266. > commit = list_first_entry_or_null(&crtc->commit_list, + 4267. struct drm_crtc_commit, commit_entry); + 4268. cleanup_done = commit ? + +drivers/iommu/intel-iommu.c:4280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4278. + 4279. if (!atsru->include_all && atsru->devices && atsru->devices_cnt) { + 4280. > for_each_active_dev_scope(atsru->devices, atsru->devices_cnt, + 4281. i, dev) + 4282. return -EBUSY; + +net/core/dev.c:4276: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4274. { + 4275. #ifdef CONFIG_NET_CLS_ACT + 4276. > struct mini_Qdisc *miniq = rcu_dereference_bh(skb->dev->miniq_ingress); + 4277. struct tcf_result cl_res; + 4278. + +drivers/net/ethernet/marvell/sky2.c:4282: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 4280. static int sky2_vpd_wait(const struct sky2_hw *hw, int cap, u16 busy) + 4281. { + 4282. > unsigned long start = jiffies; + 4283. + 4284. while ( (sky2_pci_read16(hw, cap + PCI_VPD_ADDR) & PCI_VPD_ADDR_F) == busy) { + +drivers/gpu/drm/i915/intel_display.c:4338: error: UNINITIALIZED_VALUE + The value read from divsel was never initialized. + 4336. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4337. + 4338. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4339. clock, + 4340. auxdiv, + +drivers/gpu/drm/i915/intel_display.c:4338: error: UNINITIALIZED_VALUE + The value read from phaseinc was never initialized. + 4336. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4337. + 4338. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4339. clock, + 4340. auxdiv, + +net/ipv6/addrconf.c:4316: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4314. for (i = 0; i < IN6_ADDR_HSIZE; i++) { + 4315. restart: + 4316. > hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) { + 4317. unsigned long age; + 4318. + +net/ipv4/tcp_input.c:4346: error: UNINITIALIZED_VALUE + The value read from fragstolen was never initialized. + 4344. __skb_queue_tail(&sk->sk_receive_queue, skb); + 4345. else + 4346. > kfree_skb_partial(skb, fragstolen); + 4347. + 4348. if (unlikely(fin)) { + +kernel/cgroup/cgroup.c:4330: error: NULL_DEREFERENCE + pointer `com_cgrp` last assigned on line 4331 could be null and is dereferenced by call to `cgroup_is_descendant()` at line 4330, column 10. + 4328. + 4329. /* find the common ancestor */ + 4330. > while (!cgroup_is_descendant(dst_cgrp, com_cgrp)) + 4331. com_cgrp = cgroup_parent(com_cgrp); + 4332. + +drivers/gpu/drm/i915/i915_gem.c:4372: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4370. + 4371. /* Translate the exclusive fence to the READ *and* WRITE engine */ + 4372. > args->busy = busy_check_writer(rcu_dereference(obj->resv->fence_excl)); + 4373. + 4374. /* Translate shared fences to READ set of engines */ + +drivers/gpu/drm/i915/i915_gem.c:4375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4373. + 4374. /* Translate shared fences to READ set of engines */ + 4375. > list = rcu_dereference(obj->resv->fence); + 4376. if (list) { + 4377. unsigned int shared_count = list->shared_count, i; + +drivers/gpu/drm/i915/i915_gem.c:4381: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4379. for (i = 0; i < shared_count; ++i) { + 4380. struct dma_fence *fence = + 4381. > rcu_dereference(list->shared[i]); + 4382. + 4383. args->busy |= busy_check_reader(fence); + +drivers/net/ethernet/intel/e1000e/netdev.c:4365: error: DEAD_STORE + The value written to &temp (type unsigned long long) is never used. + 4363. temp = time_delta; + 4364. /* VMWare users have seen incvalue of zero, don't div / 0 */ + 4365. > rem = incvalue ? do_div(temp, incvalue) : (time_delta != 0); + 4366. + 4367. systim = systim_next; + +kernel/module.c:4368: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4366. /* Most callers should already have preempt disabled, but make sure */ + 4367. preempt_disable(); + 4368. > list_for_each_entry_rcu(mod, &modules, list) { + 4369. if (mod->state == MODULE_STATE_UNFORMED) + 4370. continue; + +net/core/rtnetlink.c:4414: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4412. + 4413. rcu_read_lock(); + 4414. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 4415. if (af_ops->get_stats_af_size) { + 4416. size += nla_total_size( + +net/core/filter.c:4375: error: DEAD_STORE + The value written to &insn (type bpf_insn*) is never used. + 4373. struct bpf_prog *prog, u32 *target_size) + 4374. { + 4375. > struct bpf_insn *insn = insn_buf; + 4376. + 4377. switch (si->off) { + +net/core/filter.c:4379: error: NULL_DEREFERENCE + pointer `insn` last assigned on line 4379 could be null and is dereferenced at line 4379, column 13. + 4377. switch (si->off) { + 4378. case offsetof(struct __sk_buff, ifindex): + 4379. > *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, dev), + 4380. si->dst_reg, si->src_reg, + 4381. offsetof(struct sk_buff, dev)); + +drivers/net/ethernet/intel/e1000/e1000_main.c:4504: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4502. rx_ring->next_to_clean = i; + 4503. + 4504. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4505. if (cleaned_count) + 4506. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +drivers/iommu/intel-iommu.c:4433: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4431. + 4432. rcu_read_lock(); + 4433. > list_for_each_entry_rcu(atsru, &dmar_atsr_units, list) { + 4434. atsr = container_of(atsru->hdr, struct acpi_dmar_atsr, header); + 4435. if (atsr->segment != pci_domain_nr(dev->bus)) + +drivers/iommu/intel-iommu.c:4438: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4436. continue; + 4437. + 4438. > for_each_dev_scope(atsru->devices, atsru->devices_cnt, i, tmp) + 4439. if (tmp == &bridge->dev) + 4440. goto out; + +net/core/dev.c:4471: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4469. goto skip_taps; + 4470. + 4471. > list_for_each_entry_rcu(ptype, &ptype_all, list) { + 4472. if (pt_prev) + 4473. ret = deliver_skb(skb, pt_prev, orig_dev); + +net/core/dev.c:4477: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4475. } + 4476. + 4477. > list_for_each_entry_rcu(ptype, &skb->dev->ptype_all, list) { + 4478. if (pt_prev) + 4479. ret = deliver_skb(skb, pt_prev, orig_dev); + +net/core/dev.c:4510: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4508. } + 4509. + 4510. > rx_handler = rcu_dereference(skb->dev->rx_handler); + 4511. if (rx_handler) { + 4512. if (pt_prev) { + +drivers/md/md.c:4482: error: DEAD_STORE + The value written to &namelen (type unsigned long) is never used. + 4480. mddev->metadata_type[namelen] = 0; + 4481. if (namelen && mddev->metadata_type[namelen-1] == '\n') + 4482. > mddev->metadata_type[--namelen] = 0; + 4483. mddev->persistent = 0; + 4484. mddev->external = 1; + +kernel/workqueue.c:4466: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4464. pr_info("Showing busy workqueues and worker pools:\n"); + 4465. + 4466. > list_for_each_entry_rcu(wq, &workqueues, list) { + 4467. struct pool_workqueue *pwq; + 4468. bool idle = true; + +kernel/workqueue.c:4470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4468. bool idle = true; + 4469. + 4470. > for_each_pwq(pwq, wq) { + 4471. if (pwq->nr_active || !list_empty(&pwq->delayed_works)) { + 4472. idle = false; + +kernel/workqueue.c:4481: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4479. pr_info("workqueue %s: flags=0x%x\n", wq->name, wq->flags); + 4480. + 4481. > for_each_pwq(pwq, wq) { + 4482. spin_lock_irqsave(&pwq->pool->lock, flags); + 4483. if (pwq->nr_active || !list_empty(&pwq->delayed_works)) + +drivers/gpu/drm/i915/i915_gem.c:4562: error: NULL_DEREFERENCE + pointer `obj->base.filp` last assigned on line 4551 could be null and is dereferenced at line 4562, column 12. + 4560. } + 4561. + 4562. > mapping = obj->base.filp->f_mapping; + 4563. mapping_set_gfp_mask(mapping, mask); + 4564. GEM_BUG_ON(!(mapping_gfp_mask(mapping) & __GFP_RECLAIM)); + +drivers/iommu/intel-iommu.c:4583: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4581. + 4582. rcu_read_lock(); + 4583. > for_each_active_iommu(iommu, drhd) + 4584. iommu_flush_iotlb_psi(iommu, si_domain, + 4585. iova->pfn_lo, iova_size(iova), + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &preferred_lft (type unsigned int) is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &valid_lft (type unsigned int) is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +drivers/ata/libata-scsi.c:4621: error: UNINITIALIZED_VALUE + The value read from dev was never initialized. + 4619. if (dev != last_failed_dev) { + 4620. msleep(100); + 4621. > last_failed_dev = dev; + 4622. goto repeat; + 4623. } + +kernel/workqueue.c:4656: error: DEAD_STORE + The value written to &worker_flags (type unsigned int) is never used. + 4654. WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND)); + 4655. worker_flags |= WORKER_REBOUND; + 4656. > worker_flags &= ~WORKER_UNBOUND; + 4657. WRITE_ONCE(worker->flags, worker_flags); + 4658. } + +drivers/gpu/drm/i915/intel_display.c:4618: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4616. u32 temp; + 4617. + 4618. > temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + +drivers/gpu/drm/i915/intel_display.c:4620: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 4618. temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4621: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4623. } + +drivers/gpu/drm/i915/intel_display.c:4620: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 4618. temp = I915_READ(dslreg); + 4619. udelay(500); + 4620. > if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + +drivers/gpu/drm/i915/intel_display.c:4621: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 4619. udelay(500); + 4620. if (wait_for(I915_READ(dslreg) != temp, 5)) { + 4621. > if (wait_for(I915_READ(dslreg) != temp, 5)) + 4622. DRM_ERROR("mode set failed: pipe %c stuck\n", pipe_name(pipe)); + 4623. } + +drivers/iommu/intel-iommu.c:4637: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4635. struct dmar_drhd_unit *drhd; + 4636. + 4637. > for_each_iommu(iommu, drhd) + 4638. iommu_disable_translation(iommu); + 4639. } + +net/core/dev.c:4680: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4678. preempt_disable(); + 4679. rcu_read_lock(); + 4680. > ret = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb); + 4681. rcu_read_unlock(); + 4682. preempt_enable(); + +kernel/events/core.c:4739: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4737. + 4738. rcu_read_lock(); + 4739. > rb = rcu_dereference(event->rb); + 4740. if (!rb || !rb->nr_pages) { + 4741. rcu_read_unlock(); + +kernel/sched/core.c:4732: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4730. if (!check_same_owner(p)) { + 4731. rcu_read_lock(); + 4732. > if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) { + 4733. rcu_read_unlock(); + 4734. goto out_free_new_mask; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4705: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4703. volatile u32 temp; + 4704. + 4705. > temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4706: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4704. + 4705. temp = er32(CRCERRS); + 4706. > temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4707: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4705. temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. > temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4708: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. > temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4709: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. > temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4710: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. > temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4711: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. > temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4712: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. > temp = er32(COLC); + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4713: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. > temp = er32(DC); + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4714: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + 4714. > temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4715: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + 4715. > temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4716: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. > temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4717: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. > temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4718: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. > temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4719: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. > temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + 4721. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4720: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. > temp = er32(FCRUC); + 4721. + 4722. temp = er32(PRC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4722: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4720. temp = er32(FCRUC); + 4721. + 4722. > temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4723: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4721. + 4722. temp = er32(PRC64); + 4723. > temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4724: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4722. temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. > temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4725: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. > temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4726: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. > temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + 4728. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4727: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. > temp = er32(PRC1522); + 4728. + 4729. temp = er32(GPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4729: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4727. temp = er32(PRC1522); + 4728. + 4729. > temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4730: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4728. + 4729. temp = er32(GPRC); + 4730. > temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4731: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4729. temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. > temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4732: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. > temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4733: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. > temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4734: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. > temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4735: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. > temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4736: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. > temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4737: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. > temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4738: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. > temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4739: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. > temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4740: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. > temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4741: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. > temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4742: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. > temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4743: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. > temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4744: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. > temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4745: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. > temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. temp = er32(TPT); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4746: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. > temp = er32(TPR); + 4747. temp = er32(TPT); + 4748. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4747: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. > temp = er32(TPT); + 4748. + 4749. temp = er32(PTC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4749: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4747. temp = er32(TPT); + 4748. + 4749. > temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4750: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4748. + 4749. temp = er32(PTC64); + 4750. > temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4751: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4749. temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. > temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4752: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. > temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4753: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. > temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + 4755. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4754: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. > temp = er32(PTC1522); + 4755. + 4756. temp = er32(MPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4756: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4754. temp = er32(PTC1522); + 4755. + 4756. > temp = er32(MPTC); + 4757. temp = er32(BPTC); + 4758. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4757: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4755. + 4756. temp = er32(MPTC); + 4757. > temp = er32(BPTC); + 4758. + 4759. if (hw->mac_type < e1000_82543) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4762: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4760. return; + 4761. + 4762. > temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4763: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4761. + 4762. temp = er32(ALGNERRC); + 4763. > temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4764: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4762. temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. > temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4765: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. > temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4766: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. > temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + 4768. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4767: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. > temp = er32(TSCTFC); + 4768. + 4769. if (hw->mac_type <= e1000_82544) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4772: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4770. return; + 4771. + 4772. > temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4773: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4771. + 4772. temp = er32(MGTPRC); + 4773. > temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + 4775. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4774: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4772. temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. > temp = er32(MGTPTC); + 4775. } + 4776. + +drivers/pci/quirks.c:4792: error: DEAD_STORE + The value written to &i (type int) is never used. + 4790. pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &cap[i++]); + 4791. pcie_capability_read_word(pdev, PCI_EXP_LNKCTL2, &cap[i++]); + 4792. > pcie_capability_read_word(pdev, PCI_EXP_SLTCTL2, &cap[i++]); + 4793. hlist_add_head(&state->next, &pdev->saved_cap_space); + 4794. } + +drivers/iommu/intel-iommu.c:4773: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4771. */ + 4772. if (intel_iommu_tboot_noforce) { + 4773. > for_each_iommu(iommu, drhd) + 4774. iommu_disable_protect_mem_regions(iommu); + 4775. } + +drivers/iommu/intel-iommu.c:4817: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4815. init_iommu_pm_ops(); + 4816. + 4817. > for_each_active_iommu(iommu, drhd) { + 4818. iommu_device_sysfs_add(&iommu->iommu, NULL, + 4819. intel_iommu_groups, + +kernel/workqueue.c:4736: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4734. + 4735. /* unbinding per-cpu workers should happen on the local CPU */ + 4736. > if (WARN_ON(cpu != smp_processor_id())) + 4737. return -1; + 4738. + +drivers/gpu/drm/i915/i915_gem.c:4780: error: DEAD_STORE + The value written to &kernel_context (type i915_gem_context*) is never used. + 4778. static void assert_kernel_context_is_current(struct drm_i915_private *i915) + 4779. { + 4780. > struct i915_gem_context *kernel_context = i915->kernel_context; + 4781. struct intel_engine_cs *engine; + 4782. enum intel_engine_id id; + +net/core/dev.c:4793: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4791. + 4792. rcu_read_lock(); + 4793. > list_for_each_entry_rcu(ptype, head, list) { + 4794. if (ptype->type != type || !ptype->callbacks.gro_complete) + 4795. continue; + +kernel/workqueue.c:4837: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4835. list_for_each_entry(wq, &workqueues, list) { + 4836. mutex_lock(&wq->mutex); + 4837. > for_each_pwq(pwq, wq) + 4838. pwq_adjust_max_active(pwq); + 4839. mutex_unlock(&wq->mutex); + +kernel/events/core.c:4857: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4855. + 4856. rcu_read_lock(); + 4857. > rb = rcu_dereference(event->rb); + 4858. if (!rb) + 4859. goto unlock; + +kernel/workqueue.c:4876: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4874. */ + 4875. rcu_read_lock_sched(); + 4876. > for_each_pwq(pwq, wq) { + 4877. WARN_ON_ONCE(pwq->nr_active < 0); + 4878. if (pwq->nr_active) { + +net/ipv6/addrconf.c:4883: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4881. idx = 0; + 4882. head = &net->dev_index_head[h]; + 4883. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 4884. if (idx < s_idx) + 4885. goto cont; + +kernel/events/core.c:4890: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4888. + 4889. rcu_read_lock(); + 4890. > rb = rcu_dereference(event->rb); + 4891. if (!rb) + 4892. goto unlock; + +kernel/workqueue.c:4915: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4913. list_for_each_entry(wq, &workqueues, list) { + 4914. mutex_lock(&wq->mutex); + 4915. > for_each_pwq(pwq, wq) + 4916. pwq_adjust_max_active(pwq); + 4917. mutex_unlock(&wq->mutex); + +net/core/dev.c:4928: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4926. + 4927. rcu_read_lock(); + 4928. > list_for_each_entry_rcu(ptype, head, list) { + 4929. if (ptype->type != type || !ptype->callbacks.gro_receive) + 4930. continue; + +kernel/events/core.c:4947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4945. + 4946. rcu_read_lock(); + 4947. > rb = rcu_dereference(event->rb); + 4948. if (!rb) + 4949. goto unlock; + +drivers/gpu/drm/i915/intel_dp.c:4944: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 4941 could be null and is dereferenced by call to `intel_dp_mst_encoder_cleanup()` at line 4944, column 2. + 4942. struct intel_dp *intel_dp = &intel_dig_port->dp; + 4943. + 4944. > intel_dp_mst_encoder_cleanup(intel_dig_port); + 4945. if (intel_dp_is_edp(intel_dp)) { + 4946. cancel_delayed_work_sync(&intel_dp->panel_vdd_work); + +drivers/gpu/drm/i915/intel_dp.c:5025: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5025, column 18. + 5023. + 5024. if (!HAS_DDI(dev_priv)) + 5025. > intel_dp->DP = I915_READ(intel_dp->output_reg); + 5026. + 5027. if (lspcon->active) + +drivers/gpu/drm/i915/intel_dp.c:5030: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5030, column 2. + 5028. lspcon_resume(lspcon); + 5029. + 5030. > intel_dp->reset_link_params = true; + 5031. + 5032. pps_lock(intel_dp); + +net/core/dev.c:5029: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5027. struct packet_offload *ptype; + 5028. + 5029. > list_for_each_entry_rcu(ptype, offload_head, list) { + 5030. if (ptype->type != type || !ptype->callbacks.gro_receive) + 5031. continue; + +kernel/events/core.c:5033: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5031. + 5032. rcu_read_lock(); + 5033. > rb = rcu_dereference(event->rb); + 5034. if (rb) { + 5035. list_for_each_entry_rcu(event, &rb->event_list, rb_entry) + +kernel/events/core.c:5035: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5033. rb = rcu_dereference(event->rb); + 5034. if (rb) { + 5035. > list_for_each_entry_rcu(event, &rb->event_list, rb_entry) + 5036. wake_up_all(&event->waitq); + 5037. } + +net/core/dev.c:5043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5041. struct packet_offload *ptype; + 5042. + 5043. > list_for_each_entry_rcu(ptype, offload_head, list) { + 5044. if (ptype->type != type || !ptype->callbacks.gro_complete) + 5045. continue; + +kernel/events/core.c:5046: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5044. + 5045. rcu_read_lock(); + 5046. > rb = rcu_dereference(event->rb); + 5047. if (rb) { + 5048. if (!atomic_inc_not_zero(&rb->refcount)) + +kernel/cgroup/cgroup.c:5097: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5095. + 5096. /* initiate massacre of all css's */ + 5097. > for_each_css(css, ssid, cgrp) + 5098. kill_css(css); + 5099. + +drivers/iommu/intel-iommu.c:5095: error: DEAD_STORE + The value written to &iommu (type intel_iommu*) is never used. + 5093. + 5094. for_each_domain_iommu(iommu_id, dmar_domain) { + 5095. > iommu = g_iommus[iommu_id]; + 5096. + 5097. iommu_flush_iotlb_psi(g_iommus[iommu_id], dmar_domain, + +kernel/events/core.c:5147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5145. again: + 5146. rcu_read_lock(); + 5147. > list_for_each_entry_rcu(event, &rb->event_list, rb_entry) { + 5148. if (!atomic_long_inc_not_zero(&event->refcount)) { + 5149. /* + +drivers/ata/libata-core.c:5126: error: NULL_DEREFERENCE + pointer `qc` last assigned on line 5125 could be null and is dereferenced at line 5126, column 2. + 5124. + 5125. qc = __ata_qc_from_tag(ap, tag); + 5126. > qc->tag = tag; + 5127. qc->scsicmd = NULL; + 5128. qc->ap = ap; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:5141: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 5139. * stability + 5140. */ + 5141. > ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); + 5142. if (!link) + 5143. return 0; + +drivers/iommu/intel-iommu.c:5179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5177. rcu_read_lock(); + 5178. for_each_rmrr_units(rmrr) { + 5179. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 5180. i, i_dev) { + 5181. if (i_dev != device) + +kernel/events/core.c:5253: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5251. goto aux_unlock; + 5252. + 5253. > aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5254. aux_size = READ_ONCE(rb->user_page->aux_size); + 5255. + +kernel/events/core.c:5254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5252. + 5253. aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5254. > aux_size = READ_ONCE(rb->user_page->aux_size); + 5255. + 5256. if (aux_offset < perf_data_size(rb) + PAGE_SIZE) + +kernel/cgroup/cgroup.c:5219: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5218 could be null and is dereferenced at line 5219, column 3. + 5217. + 5218. for_each_subsys(ss, i) { + 5219. > WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id, + 5220. "invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p id:name=%d:%s\n", + 5221. i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free, + +kernel/trace/trace.c:5245: error: DEAD_STORE + The value written to &ret (type int) is never used. + 5243. unsigned long size, int cpu_id) + 5244. { + 5245. > int ret = size; + 5246. + 5247. mutex_lock(&trace_types_lock); + +kernel/sched/core.c:5264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5262. rcu_read_lock(); + 5263. if (pid_alive(p)) + 5264. > ppid = task_pid_nr(rcu_dereference(p->real_parent)); + 5265. rcu_read_unlock(); + 5266. printk(KERN_CONT "%5lu %5d %6d 0x%08lx\n", free, + +kernel/sched/core.c:5310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5308. #endif + 5309. rcu_read_lock(); + 5310. > for_each_process_thread(g, p) { + 5311. /* + 5312. * reset the NMI-timeout, listing all files on a slow + +net/core/dev.c:5370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5368. + 5369. do { + 5370. > val = READ_ONCE(n->state); + 5371. if (unlikely(val & NAPIF_STATE_DISABLE)) + 5372. return false; + +net/core/dev.c:5435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5433. + 5434. do { + 5435. > val = READ_ONCE(n->state); + 5436. + 5437. WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED)); + +drivers/net/ethernet/broadcom/tg3.c:5440: error: UNINITIALIZED_VALUE + The value read from aninfo.txconfig was never initialized. + 5438. udelay(40); + 5439. + 5440. > *txflags = aninfo.txconfig; + 5441. *rxflags = aninfo.flags; + 5442. + +net/ipv6/addrconf.c:5433: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5431. idx = 0; + 5432. head = &net->dev_index_head[h]; + 5433. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 5434. if (idx < s_idx) + 5435. goto cont; + +net/core/dev.c:5464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5462. struct napi_struct *napi; + 5463. + 5464. > hlist_for_each_entry_rcu(napi, &napi_hash[hash], napi_hash_node) + 5465. if (napi->napi_id == napi_id) + 5466. return napi; + +kernel/cgroup/cgroup.c:5495: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5492 could be null and is dereferenced at line 5495, column 7. + 5493. if (j >= i) + 5494. break; + 5495. > if (ss->cancel_fork) + 5496. ss->cancel_fork(child); + 5497. } + +drivers/gpu/drm/i915/intel_dp.c:5500: error: DEAD_STORE + The value written to &encoder (type intel_encoder*) is never used. + 5498. + 5499. dig_port = dp_to_dig_port(intel_dp); + 5500. > encoder = &dig_port->base; + 5501. + 5502. if (!intel_crtc) { + +kernel/sched/core.c:5505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5503. struct mm_struct *mm = current->active_mm; + 5504. + 5505. > BUG_ON(cpu_online(smp_processor_id())); + 5506. + 5507. if (mm != &init_mm) { + +kernel/sched/core.c:5505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5503. struct mm_struct *mm = current->active_mm; + 5504. + 5505. > BUG_ON(cpu_online(smp_processor_id())); + 5506. + 5507. if (mm != &init_mm) { + +net/core/dev.c:5528: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5526. local_bh_disable(); + 5527. if (!napi_poll) { + 5528. > unsigned long val = READ_ONCE(napi->state); + 5529. + 5530. /* If multiple threads are competing for this napi, + +kernel/sched/fair.c:5513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5511. return; + 5512. + 5513. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), 0); + 5514. } + 5515. + +kernel/cgroup/cgroup.c:5515: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5514 could be null and is dereferenced at line 5515, column 7. + 5513. + 5514. for_each_subsys(ss, i) + 5515. > if (ss->cancel_fork) + 5516. ss->cancel_fork(child); + 5517. } + +kernel/sched/fair.c:5539: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5537. void cpu_load_update_nohz_stop(void) + 5538. { + 5539. > unsigned long curr_jiffies = READ_ONCE(jiffies); + 5540. struct rq *this_rq = this_rq(); + 5541. unsigned long load; + +net/ipv6/addrconf.c:5569: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5567. * to do it again + 5568. */ + 5569. > if (!rcu_access_pointer(ifp->rt->rt6i_node)) + 5570. ip6_ins_rt(ifp->rt); + 5571. if (ifp->idev->cnf.forwarding) + +kernel/sched/fair.c:5563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5561. #ifdef CONFIG_NO_HZ_COMMON + 5562. /* See the mess around cpu_load_update_nohz(). */ + 5563. > this_rq->last_load_update_tick = READ_ONCE(jiffies); + 5564. #endif + 5565. cpu_load_update(this_rq, load, 1); + +kernel/sched/fair.c:5576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5574. + 5575. if (tick_nohz_tick_stopped()) + 5576. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), load); + 5577. else + 5578. cpu_load_update_periodic(this_rq, load); + +kernel/sched/fair.c:5627: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5625. { + 5626. struct rq *rq = cpu_rq(cpu); + 5627. > unsigned long nr_running = READ_ONCE(rq->cfs.h_nr_running); + 5628. unsigned long load_avg = weighted_cpuload(rq); + 5629. + +drivers/gpu/drm/i915/intel_pm.c:5657: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 5655. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5656. + 5657. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5658. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5659. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +drivers/gpu/drm/i915/intel_pm.c:5657: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 5655. vlv_punit_write(dev_priv, PUNIT_REG_DDR_SETUP2, val); + 5656. + 5657. > if (wait_for((vlv_punit_read(dev_priv, PUNIT_REG_DDR_SETUP2) & + 5658. FORCE_DDR_FREQ_REQ_ACK) == 0, 3)) { + 5659. DRM_DEBUG_KMS("Punit not acking DDR DVFS request, " + +kernel/events/core.c:5661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5659. + 5660. if (sample_type & PERF_SAMPLE_CPU) { + 5661. > data->cpu_entry.cpu = raw_smp_processor_id(); + 5662. data->cpu_entry.reserved = 0; + 5663. } + +kernel/events/core.c:5661: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5659. + 5660. if (sample_type & PERF_SAMPLE_CPU) { + 5661. > data->cpu_entry.cpu = raw_smp_processor_id(); + 5662. data->cpu_entry.reserved = 0; + 5663. } + +kernel/cgroup/cgroup.c:5648: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5647 could be null and is dereferenced at line 5648, column 22. + 5646. + 5647. for_each_subsys(ss, i) { + 5648. > if (strcmp(token, ss->name) && + 5649. strcmp(token, ss->legacy_name)) + 5650. continue; + +drivers/usb/core/hub.c:5674: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5659 could be null and is dereferenced at line 5674, column 13. + 5672. } + 5673. + 5674. > port_dev = hub->ports[udev->portnum - 1]; + 5675. + 5676. /* + +kernel/workqueue.c:5678: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5676. + 5677. list_for_each_entry(wq, &workqueues, list) { + 5678. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5679. WARN(init_rescuer(wq), + 5680. "workqueue: failed to create early rescuer for %s", + +kernel/workqueue.c:5678: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5676. + 5677. list_for_each_entry(wq, &workqueues, list) { + 5678. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5679. WARN(init_rescuer(wq), + 5680. "workqueue: failed to create early rescuer for %s", + +kernel/cgroup/cgroup.c:5687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5685. * protected for this access. See css_release_work_fn() for details. + 5686. */ + 5687. > cgrp = rcu_dereference(*(void __rcu __force **)&kn->priv); + 5688. if (cgrp) + 5689. css = cgroup_css(cgrp, ss); + +kernel/sched/fair.c:5674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5672. unsigned int master = current->wakee_flips; + 5673. unsigned int slave = p->wakee_flips; + 5674. > int factor = this_cpu_read(sd_llc_size); + 5675. + 5676. if (master < slave) + +kernel/sched/fair.c:5674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5672. unsigned int master = current->wakee_flips; + 5673. unsigned int slave = p->wakee_flips; + 5674. > int factor = this_cpu_read(sd_llc_size); + 5675. + 5676. if (master < slave) + +net/wireless/nl80211.c:5711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5709. * even possible. + 5710. */ + 5711. > if (unlikely(!rcu_access_pointer(cfg80211_regdomain))) + 5712. return -EINPROGRESS; + 5713. + +drivers/md/md.c:5745: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5743. + 5744. rcu_read_lock(); + 5745. > rdev_for_each_rcu(rdev, mddev) { + 5746. if (test_bit(Journal, &rdev->flags) && + 5747. !test_bit(Faulty, &rdev->flags)) + +net/core/dev.c:5751: error: DEAD_STORE + The value written to &time_limit (type unsigned long) is never used. + 5749. { + 5750. struct softnet_data *sd = this_cpu_ptr(&softnet_data); + 5751. > unsigned long time_limit = jiffies + + 5752. usecs_to_jiffies(netdev_budget_usecs); + 5753. int budget = netdev_budget; + +net/wireless/nl80211.c:5803: error: UNINITIALIZED_VALUE + The value read from cur_params.auto_open_plinks was never initialized. + 5801. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5802. cur_params.element_ttl) || + 5803. > nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5804. cur_params.auto_open_plinks) || + 5805. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + +net/wireless/nl80211.c:5841: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshAwakeWindowDuration was never initialized. + 5839. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5840. cur_params.power_mode) || + 5841. > nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5842. cur_params.dot11MeshAwakeWindowDuration) || + 5843. nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + +net/wireless/nl80211.c:5791: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshConfirmTimeout was never initialized. + 5789. nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5790. cur_params.dot11MeshRetryTimeout) || + 5791. > nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5792. cur_params.dot11MeshConfirmTimeout) || + 5793. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + +net/wireless/nl80211.c:5827: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshForwarding was never initialized. + 5825. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5826. cur_params.dot11MeshGateAnnouncementProtocol) || + 5827. > nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5828. cur_params.dot11MeshForwarding) || + 5829. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + +net/wireless/nl80211.c:5825: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshGateAnnouncementProtocol was never initialized. + 5823. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5824. cur_params.dot11MeshHWMPRannInterval) || + 5825. > nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5826. cur_params.dot11MeshGateAnnouncementProtocol) || + 5827. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + +net/wireless/nl80211.c:5823: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRannInterval was never initialized. + 5821. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5822. cur_params.dot11MeshHWMPRootMode) || + 5823. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5824. cur_params.dot11MeshHWMPRannInterval) || + 5825. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + +net/wireless/nl80211.c:5821: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRootMode was never initialized. + 5819. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5820. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5821. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5822. cur_params.dot11MeshHWMPRootMode) || + 5823. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + +net/wireless/nl80211.c:5813: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathTimeout was never initialized. + 5811. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5812. cur_params.min_discovery_timeout) || + 5813. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5814. cur_params.dot11MeshHWMPactivePathTimeout) || + 5815. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + +net/wireless/nl80211.c:5833: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathToRootTimeout was never initialized. + 5831. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5832. cur_params.ht_opmode) || + 5833. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5834. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5835. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + +net/wireless/nl80211.c:5837: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPconfirmationInterval was never initialized. + 5835. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5836. cur_params.dot11MeshHWMProotInterval) || + 5837. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5838. cur_params.dot11MeshHWMPconfirmationInterval) || + 5839. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + +net/wireless/nl80211.c:5807: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPmaxPREQretries was never initialized. + 5805. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5806. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5807. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5808. cur_params.dot11MeshHWMPmaxPREQretries) || + 5809. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + +net/wireless/nl80211.c:5819: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPnetDiameterTraversalTime was never initialized. + 5817. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5818. cur_params.dot11MeshHWMPperrMinInterval) || + 5819. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5820. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5821. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + +net/wireless/nl80211.c:5817: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPperrMinInterval was never initialized. + 5815. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5816. cur_params.dot11MeshHWMPpreqMinInterval) || + 5817. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5818. cur_params.dot11MeshHWMPperrMinInterval) || + 5819. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + +net/wireless/nl80211.c:5815: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPpreqMinInterval was never initialized. + 5813. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5814. cur_params.dot11MeshHWMPactivePathTimeout) || + 5815. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5816. cur_params.dot11MeshHWMPpreqMinInterval) || + 5817. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + +net/wireless/nl80211.c:5835: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMProotInterval was never initialized. + 5833. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5834. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5835. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5836. cur_params.dot11MeshHWMProotInterval) || + 5837. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + +net/wireless/nl80211.c:5793: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHoldingTimeout was never initialized. + 5791. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5792. cur_params.dot11MeshConfirmTimeout) || + 5793. > nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5794. cur_params.dot11MeshHoldingTimeout) || + 5795. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + +net/wireless/nl80211.c:5795: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxPeerLinks was never initialized. + 5793. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5794. cur_params.dot11MeshHoldingTimeout) || + 5795. > nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5796. cur_params.dot11MeshMaxPeerLinks) || + 5797. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + +net/wireless/nl80211.c:5797: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxRetries was never initialized. + 5795. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5796. cur_params.dot11MeshMaxPeerLinks) || + 5797. > nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5798. cur_params.dot11MeshMaxRetries) || + 5799. nla_put_u8(msg, NL80211_MESHCONF_TTL, + +net/wireless/nl80211.c:5805: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshNbrOffsetMaxNeighbor was never initialized. + 5803. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5804. cur_params.auto_open_plinks) || + 5805. > nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5806. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5807. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + +net/wireless/nl80211.c:5789: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshRetryTimeout was never initialized. + 5787. goto nla_put_failure; + 5788. if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || + 5789. > nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5790. cur_params.dot11MeshRetryTimeout) || + 5791. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + +net/wireless/nl80211.c:5799: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshTTL was never initialized. + 5797. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5798. cur_params.dot11MeshMaxRetries) || + 5799. > nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5800. cur_params.dot11MeshTTL) || + 5801. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + +net/wireless/nl80211.c:5801: error: UNINITIALIZED_VALUE + The value read from cur_params.element_ttl was never initialized. + 5799. nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5800. cur_params.dot11MeshTTL) || + 5801. > nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5802. cur_params.element_ttl) || + 5803. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + +net/wireless/nl80211.c:5831: error: UNINITIALIZED_VALUE + The value read from cur_params.ht_opmode was never initialized. + 5829. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5830. cur_params.rssi_threshold) || + 5831. > nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5832. cur_params.ht_opmode) || + 5833. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + +net/wireless/nl80211.c:5811: error: UNINITIALIZED_VALUE + The value read from cur_params.min_discovery_timeout was never initialized. + 5809. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5810. cur_params.path_refresh_time) || + 5811. > nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5812. cur_params.min_discovery_timeout) || + 5813. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + +net/wireless/nl80211.c:5809: error: UNINITIALIZED_VALUE + The value read from cur_params.path_refresh_time was never initialized. + 5807. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5808. cur_params.dot11MeshHWMPmaxPREQretries) || + 5809. > nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5810. cur_params.path_refresh_time) || + 5811. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + +net/wireless/nl80211.c:5843: error: UNINITIALIZED_VALUE + The value read from cur_params.plink_timeout was never initialized. + 5841. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5842. cur_params.dot11MeshAwakeWindowDuration) || + 5843. > nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + 5844. cur_params.plink_timeout)) + 5845. goto nla_put_failure; + +net/wireless/nl80211.c:5839: error: UNINITIALIZED_VALUE + The value read from cur_params.power_mode was never initialized. + 5837. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5838. cur_params.dot11MeshHWMPconfirmationInterval) || + 5839. > nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5840. cur_params.power_mode) || + 5841. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + +net/wireless/nl80211.c:5829: error: UNINITIALIZED_VALUE + The value read from cur_params.rssi_threshold was never initialized. + 5827. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5828. cur_params.dot11MeshForwarding) || + 5829. > nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5830. cur_params.rssi_threshold) || + 5831. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + +kernel/sched/fair.c:5756: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5754. int prev_cpu, int sync) + 5755. { + 5756. > int this_cpu = smp_processor_id(); + 5757. int target = nr_cpumask_bits; + 5758. + +kernel/sched/fair.c:5756: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5754. int prev_cpu, int sync) + 5755. { + 5756. > int this_cpu = smp_processor_id(); + 5757. int target = nr_cpumask_bits; + 5758. + +drivers/usb/core/hub.c:5795: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5791 could be null and is dereferenced at line 5795, column 9. + 5793. if (port1 < 1 || port1 > hdev->maxchild) + 5794. return NULL; + 5795. > return hub->ports[port1 - 1]->child; + 5796. } + 5797. EXPORT_SYMBOL_GPL(usb_hub_find_child); + +drivers/net/ethernet/broadcom/tg3.c:5990: error: UNINITIALIZED_VALUE + The value read from local_adv was never initialized. + 5988. fiber_setup_done: + 5989. if (current_link_up && current_duplex == DUPLEX_FULL) + 5990. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5991. + 5992. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +drivers/net/ethernet/broadcom/tg3.c:5990: error: UNINITIALIZED_VALUE + The value read from remote_adv was never initialized. + 5988. fiber_setup_done: + 5989. if (current_link_up && current_duplex == DUPLEX_FULL) + 5990. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5991. + 5992. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +kernel/sched/core.c:5862: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5860. static int __init migration_init(void) + 5861. { + 5862. > sched_rq_cpu_starting(smp_processor_id()); + 5863. return 0; + 5864. } + +kernel/sched/core.c:5862: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5860. static int __init migration_init(void) + 5861. { + 5862. > sched_rq_cpu_starting(smp_processor_id()); + 5863. return 0; + 5864. } + +kernel/sched/core.c:5918: error: DEAD_STORE + The value written to &ptr (type unsigned long) is never used. + 5916. + 5917. root_task_group.cfs_rq = (struct cfs_rq **)ptr; + 5918. > ptr += nr_cpu_ids * sizeof(void **); + 5919. + 5920. #endif /* CONFIG_FAIR_GROUP_SCHED */ + +kernel/sched/core.c:6049: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6047. * when this runqueue becomes "idle". + 6048. */ + 6049. > init_idle(current, smp_processor_id()); + 6050. + 6051. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:6055: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6053. #ifdef CONFIG_SMP + 6054. idle_thread_set_boot_cpu(); + 6055. > set_cpu_rq_start_time(smp_processor_id()); + 6056. #endif + 6057. init_sched_fair_class(); + +kernel/sched/core.c:6049: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6047. * when this runqueue becomes "idle". + 6048. */ + 6049. > init_idle(current, smp_processor_id()); + 6050. + 6051. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:6055: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6053. #ifdef CONFIG_SMP + 6054. idle_thread_set_boot_cpu(); + 6055. > set_cpu_rq_start_time(smp_processor_id()); + 6056. #endif + 6057. init_sched_fair_class(); + +security/selinux/hooks.c:5908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5906. + 5907. rcu_read_lock(); + 5908. > __tsec = __task_cred(p)->security; + 5909. + 5910. if (current != p) { + +kernel/cgroup/cgroup.c:5913: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5912 could be null and is dereferenced at line 5913, column 33. + 5911. + 5912. for_each_subsys(ss, ssid) + 5913. > ret += show_delegatable_files(ss->dfl_cftypes, buf + ret, + 5914. PAGE_SIZE - ret, + 5915. cgroup_subsys_name[ssid]); + +drivers/gpu/drm/i915/intel_pm.c:5976: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5974. I915_WRITE(MEMMODECTL, rgvmodectl); + 5975. + 5976. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5977. DRM_ERROR("stuck trying to change perf mode\n"); + 5978. mdelay(1); + +drivers/gpu/drm/i915/intel_pm.c:5976: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5974. I915_WRITE(MEMMODECTL, rgvmodectl); + 5975. + 5976. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5977. DRM_ERROR("stuck trying to change perf mode\n"); + 5978. mdelay(1); + +net/core/dev.c:5947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5945. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 5946. + 5947. > upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 5948. + 5949. if (&upper->list == &dev->adj_list.upper) + +security/selinux/hooks.c:6040: error: DEAD_STORE + The value written to &error (type int) is never used. + 6038. + 6039. /* Only allow single threaded processes to change context */ + 6040. > error = -EPERM; + 6041. if (!current_is_single_threaded()) { + 6042. error = security_bounded_transition(tsec->sid, sid); + +net/core/dev.c:5965: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5963. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 5964. + 5965. > upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 5966. + 5967. if (&upper->list == &dev->adj_list.upper) + +kernel/sched/fair.c:6004: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6002. weight = sd->span_weight; + 6003. sd = NULL; + 6004. > for_each_domain(cpu, tmp) { + 6005. if (weight <= tmp->span_weight) + 6006. break; + +kernel/sched/fair.c:6022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6020. struct sched_domain_shared *sds; + 6021. + 6022. > sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6023. if (sds) + 6024. WRITE_ONCE(sds->has_idle_cores, val); + +kernel/sched/fair.c:6031: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6029. struct sched_domain_shared *sds; + 6030. + 6031. > sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6032. if (sds) + 6033. return READ_ONCE(sds->has_idle_cores); + +kernel/sched/fair.c:6033: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6031. sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6032. if (sds) + 6033. > return READ_ONCE(sds->has_idle_cores); + 6034. + 6035. return def; + +net/core/dev.c:6047: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6045. WARN_ON_ONCE(!rcu_read_lock_held()); + 6046. + 6047. > lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 6048. + 6049. if (&lower->list == &dev->adj_list.lower) + +net/core/dev.c:6132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6130. struct netdev_adjacent *lower; + 6131. + 6132. > lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 6133. if (&lower->list == &dev->adj_list.lower) + 6134. return NULL; + +kernel/sched/core.c:6148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6146. + 6147. read_lock(&tasklist_lock); + 6148. > for_each_process_thread(g, p) { + 6149. /* + 6150. * Only normalize user tasks: + +kernel/sched/fair.c:6153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6151. int cpu, nr = INT_MAX; + 6152. + 6153. > this_sd = rcu_dereference(*this_cpu_ptr(&sd_llc)); + 6154. if (!this_sd) + 6155. return -1; + +net/core/dev.c:6182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6180. struct netdev_adjacent *lower; + 6181. + 6182. > lower = list_first_or_null_rcu(&dev->adj_list.lower, + 6183. struct netdev_adjacent, list); + 6184. if (lower) + +drivers/md/md.c:6191: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6189. nr = working = insync = failed = spare = 0; + 6190. rcu_read_lock(); + 6191. > rdev_for_each_rcu(rdev, mddev) { + 6192. nr++; + 6193. if (test_bit(Faulty, &rdev->flags)) + +kernel/sched/fair.c:6226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6224. } + 6225. + 6226. > sd = rcu_dereference(per_cpu(sd_llc, target)); + 6227. if (!sd) + 6228. return target; + +net/core/dev.c:6201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6199. struct netdev_adjacent *upper; + 6200. + 6201. > upper = list_first_or_null_rcu(&dev->adj_list.upper, + 6202. struct netdev_adjacent, list); + 6203. if (upper && likely(upper->master)) + +kernel/events/core.c:6242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6240. struct perf_event *event; + 6241. + 6242. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 6243. if (!all) { + 6244. if (event->state < PERF_EVENT_STATE_INACTIVE) + +kernel/events/core.c:6259: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6257. struct perf_event *event; + 6258. + 6259. > list_for_each_entry_rcu(event, &pel->list, sb_list) { + 6260. /* + 6261. * Skip events that are not fully formed yet; ensure that + +kernel/events/core.c:6265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6263. * complete enough. See perf_install_in_context(). + 6264. */ + 6265. > if (!smp_load_acquire(&event->ctx)) + 6266. continue; + 6267. + +net/wireless/nl80211.c:6319: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6317. + 6318. if (!regdom) + 6319. > regdom = rcu_dereference(cfg80211_regdomain); + 6320. + 6321. if (nl80211_put_regdom(regdom, msg)) + +drivers/md/md.c:6284: error: UNINITIALIZED_VALUE + The value read from info.number was never initialized. + 6282. + 6283. rcu_read_lock(); + 6284. > rdev = md_find_rdev_nr_rcu(mddev, info.number); + 6285. if (rdev) { + 6286. info.major = MAJOR(rdev->bdev->bd_dev); + +kernel/events/core.c:6305: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6303. + 6304. for_each_task_context_nr(ctxn) { + 6305. > ctx = rcu_dereference(current->perf_event_ctxp[ctxn]); + 6306. if (ctx) + 6307. perf_iterate_ctx(ctx, output, data, false); + +kernel/sched/core.c:6313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6311. * to prevent lockdep warnings. + 6312. */ + 6313. > tg = container_of(task_css_check(tsk, cpu_cgrp_id, true), + 6314. struct task_group, css); + 6315. tg = autogroup_task_group(tsk, tg); + +drivers/net/ethernet/intel/e1000e/netdev.c:6420: error: DEAD_STORE + The value written to &retval (type int) is never used. + 6418. lpi_ctrl |= I82579_LPI_CTRL_1000_ENABLE; + 6419. + 6420. > retval = e1e_wphy_locked(hw, I82579_LPI_CTRL, + 6421. lpi_ctrl); + 6422. } + +kernel/sched/fair.c:6354: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6352. + 6353. rcu_read_lock(); + 6354. > for_each_domain(cpu, tmp) { + 6355. if (!(tmp->flags & SD_LOAD_BALANCE)) + 6356. break; + +kernel/sched/fair.c:6342: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6340. { + 6341. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6342. > int cpu = smp_processor_id(); + 6343. int new_cpu = prev_cpu; + 6344. int want_affine = 0; + +kernel/sched/fair.c:6342: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6340. { + 6341. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6342. > int cpu = smp_processor_id(); + 6343. int new_cpu = prev_cpu; + 6344. int want_affine = 0; + +kernel/events/core.c:6395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6393. * its rb pointer. + 6394. */ + 6395. > if (rcu_dereference(parent->rb) == rb) + 6396. ro->err = __perf_event_stop(&sd); + 6397. } + +kernel/sched/core.c:6399: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6397 could be null and is dereferenced by call to `sched_offline_group()` at line 6399, column 2. + 6397. struct task_group *tg = css_tg(css); + 6398. + 6399. > sched_offline_group(tg); + 6400. } + 6401. + +kernel/events/core.c:6425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6423. restart: + 6424. rcu_read_lock(); + 6425. > list_for_each_entry_rcu(iter, &event->rb->event_list, rb_entry) { + 6426. /* + 6427. * For per-CPU events, we need to make sure that neither they + +kernel/events/core.c:6434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6432. cpu = iter->cpu; + 6433. if (cpu == -1) + 6434. > cpu = READ_ONCE(iter->oncpu); + 6435. + 6436. if (cpu == -1) + +kernel/sched/core.c:6485: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6483 could be null and is dereferenced at line 6485, column 15. + 6483. struct task_group *tg = css_tg(css); + 6484. + 6485. > return (u64) scale_load_down(tg->shares); + 6486. } + 6487. + +drivers/net/ethernet/broadcom/tg3.c:6619: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6617. if (unlikely(netif_tx_queue_stopped(txq) && + 6618. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6619. > __netif_tx_lock(txq, smp_processor_id()); + 6620. if (netif_tx_queue_stopped(txq) && + 6621. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +drivers/net/ethernet/broadcom/tg3.c:6619: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6617. if (unlikely(netif_tx_queue_stopped(txq) && + 6618. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6619. > __netif_tx_lock(txq, smp_processor_id()); + 6620. if (netif_tx_queue_stopped(txq) && + 6621. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +kernel/sched/core.c:6831: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6830 could be null and is dereferenced at line 6831, column 15. + 6829. { + 6830. struct task_group *tg = css_tg(css); + 6831. > u64 weight = scale_load_down(tg->shares); + 6832. + 6833. return DIV_ROUND_CLOSEST_ULL(weight * CGROUP_WEIGHT_DFL, 1024); + +kernel/events/core.c:7058: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7056. rcu_read_lock(); + 7057. for_each_task_context_nr(ctxn) { + 7058. > ctx = rcu_dereference(current->perf_event_ctxp[ctxn]); + 7059. if (!ctx) + 7060. continue; + +drivers/ata/libata-core.c:7104: error: DEAD_STORE + The value written to &deadline (type unsigned long) is never used. + 7102. * eat away the timeout. + 7103. */ + 7104. > deadline = ata_deadline(jiffies, timeout); + 7105. + 7106. while ((tmp & mask) == val && time_before(jiffies, deadline)) { + +drivers/ata/libata-core.c:7128: error: DEAD_STORE + The value written to &lpm_timeout (type unsigned long) is never used. + 7126. bool sata_lpm_ignore_phy_events(struct ata_link *link) + 7127. { + 7128. > unsigned long lpm_timeout = link->last_lpm_change + + 7129. msecs_to_jiffies(ATA_TMOUT_SPURIOUS_PHY); + 7130. + +kernel/events/core.c:7343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7341. u64 seq; + 7342. + 7343. > seq = __this_cpu_read(perf_throttled_seq); + 7344. if (seq != hwc->interrupts_seq) { + 7345. hwc->interrupts_seq = seq; + +kernel/events/core.c:7352: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7350. && hwc->interrupts >= max_samples_per_tick)) { + 7351. __this_cpu_inc(perf_throttled_count); + 7352. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7353. hwc->interrupts = MAX_INTERRUPTS; + 7354. perf_log_throttle(event, 0); + +kernel/events/core.c:7343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7341. u64 seq; + 7342. + 7343. > seq = __this_cpu_read(perf_throttled_seq); + 7344. if (seq != hwc->interrupts_seq) { + 7345. hwc->interrupts_seq = seq; + +kernel/events/core.c:7352: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7350. && hwc->interrupts >= max_samples_per_tick)) { + 7351. __this_cpu_inc(perf_throttled_count); + 7352. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7353. hwc->interrupts = MAX_INTERRUPTS; + 7354. perf_log_throttle(event, 0); + +drivers/gpu/drm/i915/intel_display.c:7480: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7478. + 7479. if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) { + 7480. > offset = I915_READ(DSPOFFSET(i9xx_plane)); + 7481. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + +drivers/gpu/drm/i915/intel_display.c:7484: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + 7483. if (plane_config->tiling) + 7484. > offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. offset = I915_READ(DSPLINOFF(i9xx_plane)); + +drivers/gpu/drm/i915/intel_display.c:7486: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7484. offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. > offset = I915_READ(DSPLINOFF(i9xx_plane)); + 7487. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7488. } else { + +net/wireless/nl80211.c:7487: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced at line 7487, column 11. + 7485. */ + 7486. if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) { + 7487. > while (!sched_scan_req->reqid) + 7488. sched_scan_req->reqid = rdev->wiphy.cookie_counter++; + 7489. } + +net/wireless/nl80211.c:7491: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced by call to `rdev_sched_scan_start()` at line 7491, column 8. + 7489. } + 7490. + 7491. > err = rdev_sched_scan_start(rdev, dev, sched_scan_req); + 7492. if (err) + 7493. goto out_free; + +net/wireless/nl80211.c:7527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7525. } + 7526. + 7527. > req = list_first_or_null_rcu(&rdev->sched_scan_req_list, + 7528. struct cfg80211_sched_scan_request, + 7529. list); + +kernel/sched/fair.c:7577: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7575. * we read them once before doing sanity checks on them. + 7576. */ + 7577. > age_stamp = READ_ONCE(rq->age_stamp); + 7578. avg = READ_ONCE(rq->rt_avg); + 7579. delta = __rq_clock_broken(rq) - age_stamp; + +kernel/sched/fair.c:7578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7576. */ + 7577. age_stamp = READ_ONCE(rq->age_stamp); + 7578. > avg = READ_ONCE(rq->rt_avg); + 7579. delta = __rq_clock_broken(rq) - age_stamp; + 7580. + +kernel/events/core.c:7583: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7581. struct swevent_hlist *hlist; + 7582. + 7583. > hlist = rcu_dereference(swhash->swevent_hlist); + 7584. if (!hlist) + 7585. return NULL; + +kernel/events/core.c:7625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7623. goto end; + 7624. + 7625. > hlist_for_each_entry_rcu(event, head, hlist_entry) { + 7626. if (perf_swevent_match(event, type, event_id, data, regs)) + 7627. perf_swevent_event(event, nr, data, regs); + +drivers/md/md.c:7750: error: DEAD_STORE + The value written to &l (type long long) is never used. + 7748. } + 7749. spin_unlock(&all_mddevs_lock); + 7750. > if (!l--) + 7751. return (void*)2;/* tail */ + 7752. return NULL; + +net/wireless/nl80211.c:7799: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7797. rcu_read_lock(); + 7798. /* indicate whether we have probe response data or not */ + 7799. > if (rcu_access_pointer(res->proberesp_ies) && + 7800. nla_put_flag(msg, NL80211_BSS_PRESP_DATA)) + 7801. goto fail_unlock_rcu; + +net/wireless/nl80211.c:7806: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7804. * but is always valid + 7805. */ + 7806. > ies = rcu_dereference(res->ies); + 7807. if (ies) { + 7808. if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf, + +net/wireless/nl80211.c:7817: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7815. + 7816. /* and this pointer is always (unless driver didn't know) beacon data */ + 7817. > ies = rcu_dereference(res->beacon_ies); + 7818. if (ies && ies->from_beacon) { + 7819. if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf, + +drivers/md/md.c:7828: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7826. sectors = 0; + 7827. rcu_read_lock(); + 7828. > rdev_for_each_rcu(rdev, mddev) { + 7829. char b[BDEVNAME_SIZE]; + 7830. seq_printf(seq, " %s[%d]", + +drivers/gpu/drm/i915/intel_display.c:7835: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/net/ethernet/broadcom/tg3.c:8153: error: DEAD_STORE + The value written to &i (type int) is never used. + 8151. + 8152. dma_error: + 8153. > tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, --i); + 8154. tnapi->tx_buffers[tnapi->tx_prod].skb = NULL; + 8155. drop: + +kernel/events/core.c:7940: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7938. perf_trace_buf_update(record, event_type); + 7939. + 7940. > hlist_for_each_entry_rcu(event, head, hlist_entry) { + 7941. if (perf_tp_event_match(event, &data, regs)) + 7942. perf_swevent_event(event, count, &data, regs); + +kernel/events/core.c:7954: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7952. + 7953. rcu_read_lock(); + 7954. > ctx = rcu_dereference(task->perf_event_ctxp[perf_sw_context]); + 7955. if (!ctx) + 7956. goto unlock; + +kernel/events/core.c:7958: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7956. goto unlock; + 7957. + 7958. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 7959. if (event->attr.type != PERF_TYPE_TRACEPOINT) + 7960. continue; + +drivers/md/md.c:8015: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8013. idle = 1; + 8014. rcu_read_lock(); + 8015. > rdev_for_each_rcu(rdev, mddev) { + 8016. struct gendisk *disk = rdev->bdev->bd_contains->bd_disk; + 8017. curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + + +net/core/dev.c:8049: error: DEAD_STORE + The value written to &rebroadcast_time (type unsigned long) is never used. + 8047. linkwatch_forget_dev(dev); + 8048. + 8049. > rebroadcast_time = warning_time = jiffies; + 8050. refcnt = netdev_refcnt_read(dev); + 8051. + +net/core/dev.c:8087: error: DEAD_STORE + The value written to &warning_time (type unsigned long) is never used. + 8085. pr_emerg("unregister_netdevice: waiting for %s to become free. Usage count = %d\n", + 8086. dev->name, refcnt); + 8087. > warning_time = jiffies; + 8088. } + 8089. } + +net/core/dev.c:8154: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8152. BUG_ON(!list_empty(&dev->ptype_all)); + 8153. BUG_ON(!list_empty(&dev->ptype_specific)); + 8154. > WARN_ON(rcu_access_pointer(dev->ip_ptr)); + 8155. WARN_ON(rcu_access_pointer(dev->ip6_ptr)); + 8156. WARN_ON(dev->dn_ptr); + +net/core/dev.c:8155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8153. BUG_ON(!list_empty(&dev->ptype_specific)); + 8154. WARN_ON(rcu_access_pointer(dev->ip_ptr)); + 8155. > WARN_ON(rcu_access_pointer(dev->ip6_ptr)); + 8156. WARN_ON(dev->dn_ptr); + 8157. + +kernel/trace/trace.c:8197: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8195. break; + 8196. case DUMP_ORIG: + 8197. > iter.cpu_file = raw_smp_processor_id(); + 8198. break; + 8199. case DUMP_NONE: + +kernel/trace/trace.c:8197: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8195. break; + 8196. case DUMP_ORIG: + 8197. > iter.cpu_file = raw_smp_processor_id(); + 8198. break; + 8199. case DUMP_NONE: + +kernel/events/core.c:8275: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8273. { + 8274. struct perf_addr_filters_head *ifh = perf_event_addr_filters(event); + 8275. > struct task_struct *task = READ_ONCE(event->ctx->task); + 8276. struct perf_addr_filter *filter; + 8277. struct mm_struct *mm = NULL; + +drivers/gpu/drm/i915/intel_display.c:8540: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 8538. plane_config->base = base; + 8539. + 8540. > offset = I915_READ(PLANE_OFFSET(pipe, plane_id)); + 8541. + 8542. val = I915_READ(PLANE_SIZE(pipe, plane_id)); + +net/core/dev.c:8562: error: DEAD_STORE + The value written to &err (type int) is never used. + 8560. + 8561. /* And unlink it from device chain */ + 8562. > err = -ENODEV; + 8563. unlist_netdevice(dev); + 8564. + +net/core/dev.c:8640: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8638. + 8639. local_irq_disable(); + 8640. > cpu = smp_processor_id(); + 8641. sd = &per_cpu(softnet_data, cpu); + 8642. oldsd = &per_cpu(softnet_data, oldcpu); + +net/core/dev.c:8640: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8638. + 8639. local_irq_disable(); + 8640. > cpu = smp_processor_id(); + 8641. sd = &per_cpu(softnet_data, cpu); + 8642. oldsd = &per_cpu(softnet_data, oldcpu); + +drivers/gpu/drm/i915/intel_display.c:8765: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8784: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8782. ndelay(100); + 8783. + 8784. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8785. 1)) + 8786. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8784: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 8782. ndelay(100); + 8783. + 8784. > if (wait_for((hsw_read_dcomp(dev_priv) & D_COMP_RCOMP_IN_PROGRESS) == 0, + 8785. 1)) + 8786. DRM_ERROR("D_COMP RCOMP still in progress\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +kernel/sched/fair.c:8781: error: DEAD_STORE + The value written to &next_balance (type unsigned long) is never used. + 8779. static int idle_balance(struct rq *this_rq, struct rq_flags *rf) + 8780. { + 8781. > unsigned long next_balance = jiffies + HZ; + 8782. int this_cpu = this_rq->cpu; + 8783. struct sched_domain *sd; + +kernel/sched/fair.c:8810: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8808. !this_rq->rd->overload) { + 8809. rcu_read_lock(); + 8810. > sd = rcu_dereference_check_sched_domain(this_rq->sd); + 8811. if (sd) + 8812. update_next_balance(sd, &next_balance); + +kernel/sched/fair.c:8822: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8820. update_blocked_averages(this_cpu); + 8821. rcu_read_lock(); + 8822. > for_each_domain(this_cpu, sd) { + 8823. int continue_balancing = 1; + 8824. u64 t0, domain_cost; + +drivers/gpu/drm/i915/intel_display.c:8841: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +kernel/events/core.c:8886: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8884. static int perf_pmu_commit_txn(struct pmu *pmu) + 8885. { + 8886. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8887. + 8888. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8886: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8884. static int perf_pmu_commit_txn(struct pmu *pmu) + 8885. { + 8886. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8887. + 8888. __this_cpu_write(nop_txn_flags, 0); + +kernel/sched/fair.c:8932: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8930. /* Search for an sd spanning us and the target CPU. */ + 8931. rcu_read_lock(); + 8932. > for_each_domain(target_cpu, sd) { + 8933. if ((sd->flags & SD_LOAD_BALANCE) && + 8934. cpumask_test_cpu(busiest_cpu, sched_domain_span(sd))) + +kernel/sched/fair.c:8915: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8913. + 8914. /* make sure the requested cpu hasn't gone down in the meantime */ + 8915. > if (unlikely(busiest_cpu != smp_processor_id() || + 8916. !busiest_rq->active_balance)) + 8917. goto out_unlock; + +kernel/events/core.c:8899: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8897. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8898. { + 8899. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8900. + 8901. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8899: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8897. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8898. { + 8899. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8900. + 8901. __this_cpu_write(nop_txn_flags, 0); + +kernel/sched/fair.c:8982: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8980. static inline int on_null_domain(struct rq *rq) + 8981. { + 8982. > return unlikely(!rcu_dereference_sched(rq->sd)); + 8983. } + 8984. + +drivers/md/md.c:9014: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9012. "unacknowledged_bad_blocks"); + 9013. sysfs_notify_dirent_safe(rdev->sysfs_state); + 9014. > set_mask_bits(&mddev->sb_flags, 0, + 9015. BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING)); + 9016. md_wakeup_thread(rdev->mddev->thread); + +kernel/sched/fair.c:9056: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9054. + 9055. rcu_read_lock(); + 9056. > sd = rcu_dereference(per_cpu(sd_llc, cpu)); + 9057. + 9058. if (!sd || !sd->nohz_idle) + +kernel/sched/fair.c:9053: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9051. { + 9052. struct sched_domain *sd; + 9053. > int cpu = smp_processor_id(); + 9054. + 9055. rcu_read_lock(); + +kernel/sched/fair.c:9053: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9051. { + 9052. struct sched_domain *sd; + 9053. > int cpu = smp_processor_id(); + 9054. + 9055. rcu_read_lock(); + +kernel/sched/fair.c:9073: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9071. + 9072. rcu_read_lock(); + 9073. > sd = rcu_dereference(per_cpu(sd_llc, cpu)); + 9074. + 9075. if (!sd || sd->nohz_idle) + +kernel/sched/fair.c:9070: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9068. { + 9069. struct sched_domain *sd; + 9070. > int cpu = smp_processor_id(); + 9071. + 9072. rcu_read_lock(); + +kernel/sched/fair.c:9070: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9068. { + 9069. struct sched_domain *sd; + 9070. > int cpu = smp_processor_id(); + 9071. + 9072. rcu_read_lock(); + +drivers/md/md.c:9161: error: DEAD_STORE + The value written to &ret (type int) is never used. + 9159. if (rdev2->raid_disk == -1 && role != 0xffff) { + 9160. rdev2->saved_raid_disk = role; + 9161. > ret = remove_and_add_spares(mddev, rdev2); + 9162. pr_info("Activated spare: %s\n", + 9163. bdevname(rdev2->bdev,b)); + +kernel/sched/fair.c:9134: error: DEAD_STORE + The value written to &continue_balancing (type int) is never used. + 9132. static void rebalance_domains(struct rq *rq, enum cpu_idle_type idle) + 9133. { + 9134. > int continue_balancing = 1; + 9135. int cpu = rq->cpu; + 9136. unsigned long interval; + +kernel/sched/fair.c:9147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9145. + 9146. rcu_read_lock(); + 9147. > for_each_domain(cpu, sd) { + 9148. /* + 9149. * Decay the newidle max times here because this is a regular + +drivers/gpu/drm/i915/intel_pm.c:9249: error: DEAD_STORE + The value written to &timeout__ (type unsigned long) is never used. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/gpu/drm/i915/intel_pm.c:9249: error: DEAD_STORE + The value written to &wait__ (type long) is never used. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9249: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/md/md.c:9242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9240. + 9241. /* Find the rdev */ + 9242. > rdev_for_each_rcu(rdev, mddev) { + 9243. if (rdev->desc_nr == nr) + 9244. break; + +drivers/md/md.c:9259: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9257. + 9258. /* Read all rdev's to update recovery_offset */ + 9259. > rdev_for_each_rcu(rdev, mddev) + 9260. read_rdev(mddev, rdev); + 9261. } + +drivers/gpu/drm/i915/intel_display.c:9260: error: NULL_DEREFERENCE + pointer `obj` last assigned on line 9256 could be null and is dereferenced at line 9260, column 10. + 9258. + 9259. if (INTEL_INFO(dev_priv)->cursor_needs_physical) + 9260. > base = obj->phys_handle->busaddr; + 9261. else + 9262. base = intel_plane_ggtt_offset(plane_state); + +kernel/events/core.c:9290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9288. } + 9289. + 9290. > list_for_each_entry_rcu(pmu, &pmus, entry) { + 9291. ret = perf_try_init_event(pmu, event); + 9292. if (!ret) + +kernel/sched/fair.c:9312: error: DEAD_STORE + The value written to &now (type unsigned long) is never used. + 9310. static inline bool nohz_kick_needed(struct rq *rq) + 9311. { + 9312. > unsigned long now = jiffies; + 9313. struct sched_domain_shared *sds; + 9314. struct sched_domain *sd; + +drivers/gpu/drm/i915/intel_pm.c:9381: error: DEAD_STORE + The value written to &loop (type int) is never used. + 9379. _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH)); + 9380. upper = I915_READ_FW(reg); + 9381. > } while (upper != tmp && --loop); + 9382. + 9383. /* Everywhere else we always use VLV_COUNTER_CONTROL with the + +kernel/events/core.c:9869: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9867. again: + 9868. rcu_read_lock(); + 9869. > gctx = READ_ONCE(group_leader->ctx); + 9870. if (!atomic_inc_not_zero(&gctx->refcount)) { + 9871. rcu_read_unlock(); + +drivers/net/ethernet/broadcom/tg3.c:10778: error: DEAD_STORE + The value written to &off (type unsigned int) is never used. + 10776. + 10777. tg3_ape_scratchpad_read(tp, (u32 *) ocir, off, len); + 10778. > off += len; + 10779. + 10780. if (ocir->signature != TG3_OCIR_SIG_MAGIC || + +kernel/events/core.c:11198: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11196. perf_pmu_register(&perf_task_clock, NULL, -1); + 11197. perf_tp_register(); + 11198. > perf_event_init_cpu(smp_processor_id()); + 11199. register_reboot_notifier(&perf_reboot_notifier); + 11200. + +kernel/events/core.c:11198: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11196. perf_pmu_register(&perf_task_clock, NULL, -1); + 11197. perf_tp_register(); + 11198. > perf_event_init_cpu(smp_processor_id()); + 11199. register_reboot_notifier(&perf_reboot_notifier); + 11200. + +drivers/net/ethernet/broadcom/tg3.c:12197: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 12196 could be null and is dereferenced by call to `phy_ethtool_ksettings_set()` at line 12197, column 10. + 12195. return -EAGAIN; + 12196. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 12197. > return phy_ethtool_ksettings_set(phydev, cmd); + 12198. } + 12199. + +drivers/gpu/drm/i915/intel_display.c:12320: error: UNINITIALIZED_VALUE + The value read from put_domains[_] was never initialized. + 12318. + 12319. if (put_domains[i]) + 12320. > modeset_put_power_domains(dev_priv, put_domains[i]); + 12321. + 12322. intel_modeset_verify_crtc(crtc, state, old_crtc_state, new_crtc_state); + +drivers/net/ethernet/broadcom/tg3.c:12980: error: UNINITIALIZED_VALUE + The value read from data[_] was never initialized. + 12978. err = -EIO; + 12979. for (i = 0; i < NVRAM_SELFBOOT_DATA_SIZE; i++) { + 12980. > u8 hw8 = hweight8(data[i]); + 12981. + 12982. if ((hw8 & 0x1) && parity[i]) + +net/wireless/nl80211.c:14334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 14332. struct sk_buff *msg; + 14333. void *hdr; + 14334. > u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid); + 14335. + 14336. if (!nlportid) + +drivers/gpu/drm/i915/intel_display.c:15182: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 15180. + 15181. if (ret) + 15182. > DRM_ERROR("Restoring old state failed with %i\n", ret); + 15183. if (state) + 15184. drm_atomic_state_put(state); + +net/wireless/nl80211.c:15210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15208. rcu_read_lock(); + 15209. + 15210. > list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) { + 15211. struct cfg80211_sched_scan_request *sched_scan_req; + 15212. + +net/wireless/nl80211.c:15213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15211. struct cfg80211_sched_scan_request *sched_scan_req; + 15212. + 15213. > list_for_each_entry_rcu(sched_scan_req, + 15214. &rdev->sched_scan_req_list, + 15215. list) { + +net/wireless/nl80211.c:15222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15220. } + 15221. + 15222. > list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) { + 15223. cfg80211_mlme_unregister_socket(wdev, notify->portid); + 15224. + +Summary of the reports + + UNINITIALIZED_VALUE: 4664 + DEAD_STORE: 895 + NULL_DEREFERENCE: 211 + MEMORY_LEAK: 16 + RESOURCE_LEAK: 9 \ No newline at end of file diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/InferOutOfMemoryFailure.md b/infer/results/v416/infer0150/maxyesconfig-fail/InferOutOfMemoryFailure.md new file mode 100644 index 0000000..8cf732f --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/InferOutOfMemoryFailure.md @@ -0,0 +1,16 @@ +## Infer Failure Report ## +**Infer Version:** Infer 0.15.0 +**Kernel Version:** Linux-4.16 +**Kernel Configuration:** [Maximalyesconfig](failure-files/SigKillFailureFiles/maximalyesconfig) +**Infer Configuration:** [Inferconfig](failure-files/SigKillFailureFiles/infermaximalyesconfig) +**Command:** ```infer analyze --jobs 1``` +**Error Message:** [Out-of-Memory-Error](failure-files/OutOfMemoryFiles/error_message.txt) + +## Summary ## +- First I read end of the log file with using ```cat logs | tail -n 1000``` [tail-file](failure-files/OutOfMemoryFiles/tail_logs.txt) , as you can see in there there are many debug lines about ```struct driver_attribute```, ```struct pv_irq_ops``` and ```struct pv_lock_ops```. +- Since before end of file, infer continuously printed about ```struct driver_attribute```, I focused on it. +- Output of ```cat tail_logs.txt | grep "typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute" | wc -l``` is ```1260``` that value is significanlty low in comparision to values that I found in the previous [sigkill-failure-report](InferSigKillFailure.md) +- Then I found first ```typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute``` line with using ```cat logs | grep -n "typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute" | head``` command and it's line number is : ```3843065``` and its result is [here](failure-files/OutOfMemoryFiles/first_struct_driver_attribute_line.txt) +- As a next step, I checked ```logs``` file with ```awk 'NR >= 3843060 && NR <= 3843066' logs``` command to find-out what was the output of infer, before first ```typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute``` printed. You can find result in [here](failure-files/OutOfMemoryFiles/before_first_driver_attribute.txt) +- Since we ran this infer analyze with only 1 thread, I think ```struct pv_lock_ops``` is safe. + diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/InferSigKillFailure.md b/infer/results/v416/infer0150/maxyesconfig-fail/InferSigKillFailure.md new file mode 100644 index 0000000..6520465 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/InferSigKillFailure.md @@ -0,0 +1,24 @@ +## Infer Failure Report ## +**Infer Version:** Infer 0.15.0 +**Kernel Version:** Linux-4.16 +**Kernel Configuration:** [Maximalyesconfig](failure-files/SigKillFailureFiles/maximalyesconfig) +**Infer Configuration:** [Inferconfig](failure-files/SigKillFailureFiles/infermaximalyesconfig) +**Command:** ```infer analyze --jobs 2``` +**Error Message:** [Die-After-Receiving-Sigkill](failure-files/SigKillFailureFiles/infer_failure_log.txt) + +## Summary ## +Since ```infer-out/logs``` file is so huge, I can't upload it to here.It is ```1,2G``` and ```wc -l``` result is ```17808166```. +I will describe my investigation process. +- First, I looked at end of the log file with using ```cat logs | tail -n 1000``` [tail-file](failure-files/SigKillFailureFiles/tail_logs.txt), and saw that there are +so many lines related with ```pv_irq_ops``` and ```pv_lock_ops```. +- Then searched in the ```logs``` file, to find out how many lines has ```typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops``` +with using ```cat logs | grep "typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops" | wc -l``` and result was ```5136499```. +- Next, I found the first encounter with ```typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops``` in ```bugs``` file with command: + ```cat logs | grep -n "typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops" | head``` and result was: +```3375898:[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops```. +- So I checked have opened ```bugs``` file again with using: ```awk 'NR >= 3374500 && NR <= 3375900' logs``` command [starting-from-pv-irq-ops](failure-files/SigKillFailureFiles/logs_starting_from_first_pv_irq_ops.txt). After looking a file , I saw that, before lines about ```struct pv_lock_ops``` started, there are debug messages like ```typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root```. +- Then I started to investigate ```mod_tree_root``` lines, and checked file with ```cat logs | grep -n "typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root" | head``` and result was: ```3373979``` +- Finally I opened ```logs``` file with ```cat logs | grep -nawk 'NR >= 3373950 && NR <= 3373980' logs```,[starting-from-mod-tree](failure-files/SigKillFailureFiles/logs_starting_from_first_mod_tree_root.txt). As you can see in the file, Infer started to print```typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root``` just after ```infer analyze``` started. + + + diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/before_first_driver_attribute.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/before_first_driver_attribute.txt new file mode 100644 index 0000000..2ee896c --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/before_first_driver_attribute.txt @@ -0,0 +1,7 @@ +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ progress] ... +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/error_message.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/error_message.txt new file mode 100644 index 0000000..1821186 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/error_message.txt @@ -0,0 +1,64 @@ +Uncaught Internal Error: ("Out of memory") +Error backtrace: +Raised by primitive operation at file "marshal.ml" (inlined), line 43, characters 0-60 +Called from file "base/Serialization.ml", line 53, characters 61-87 +Called from file "base/Utils.ml" (inlined), line 180, characters 13-17 +Called from file "base/Utils.ml" (inlined), line 165, characters 8-12 +Called from file "base/Utils.ml" (inlined), line 174, characters 16-54 +Called from file "base/Utils.ml", line 182, characters 2-41 +Re-raised at file "istd/IExn.ml" (inlined), line 13, characters 2-50 +Called from file "base/Utils.ml" (inlined), line 166, characters 6-141 +Called from file "base/Utils.ml" (inlined), line 174, characters 16-54 +Called from file "base/Utils.ml", line 182, characters 2-41 +Called from file "base/Serialization.ml", line 53, characters 8-97 +Called from file "backend/Summary.ml" (inlined), line 169, characters 32-90 +Called from file "backend/Summary.ml", line 190, characters 6-55 +Called from file "backend/Summary.ml" (inlined), line 220, characters 8-21 +Called from file "checkers/annotations.ml" (inlined), line 148, characters 8-28 +Called from file "concurrency/RacerDConfig.ml" (inlined), line 312, characters 4-99 +Called from file "concurrency/RacerDConfig.ml" (inlined), line 316, characters 34-79 +Called from file "concurrency/RacerDConfig.ml", line 339, characters 4-33 +Called from file "absint/PatternMatch.ml", line 307, characters 27-38 +Called from file "absint/PatternMatch.ml" (inlined), line 320, characters 2-52 +Called from file "concurrency/RacerD.ml" (inlined), line 504, characters 13-69 +Called from file "concurrency/RacerD.ml", line 509, characters 10-86 +Called from file "absint/LowerHil.ml", line 80, characters 28-91 +Called from file "absint/AbstractInterpreter.ml" (inlined), line 72, characters 39-92 +Called from file "array.ml" (inlined), line 158, characters 9-30 +Called from file "src/array0.ml" (inlined), line 50, characters 29-62 +Called from file "IR/Instrs.ml" (inlined), line 109, characters 6-32 +Called from file "absint/AbstractInterpreter.ml", line 73, characters 10-54 +Called from file "absint/AbstractInterpreter.ml", line 130, characters 14-76 +Called from file "absint/AbstractInterpreter.ml" (inlined), line 145, characters 4-59 +Called from file "absint/AbstractInterpreter.ml" (inlined), line 156, characters 18-56 +Called from file "absint/LowerHil.ml" (inlined), line 97, characters 22-89 +Called from file "concurrency/RacerD.ml", line 738, characters 10-50 +Called from file "list.ml", line 111, characters 24-34 +Called from file "backend/ondemand.ml", line 152, characters 51-92 +Re-raised at file "istd/IExn.ml" (inlined), line 18, characters 15-63 +Called from file "backend/ondemand.ml", line 158, characters 4-93 +Called from file "backend/ondemand.ml" (inlined), line 173, characters 7-80 +Called from file "backend/ondemand.ml" (inlined), line 204, characters 14-53 +Called from file "backend/callbacks.ml" (inlined), line 148, characters 40-72 +Called from file "list.ml", line 100, characters 12-15 +Called from file "list.ml" (inlined), line 98, characters 13-64 +Called from file "src/list0.ml" (inlined), line 26, characters 40-75 +Called from file "backend/callbacks.ml", line 149, characters 2-49 +Called from file "backend/InferAnalyze.ml", line 21, characters 8-43 +Called from file "backend/Tasks.ml" (inlined), line 34, characters 25-29 +Called from file "list.ml" (inlined), line 100, characters 12-15 +Called from file "list.ml" (inlined), line 98, characters 13-64 +Called from file "src/list0.ml" (inlined), line 26, characters 40-75 +Called from file "backend/Tasks.ml", line 34, characters 2-41 +Called from file "backend/InferAnalyze.ml" (inlined), line 32, characters 38-86 +Called from file "list.ml", line 100, characters 12-15 +Called from file "list.ml" (inlined), line 98, characters 13-64 +Called from file "list.ml" (inlined), line 100, characters 17-25 +Called from file "list.ml" (inlined), line 98, characters 13-64 +Called from file "src/list0.ml" (inlined), line 26, characters 40-75 +Called from file "backend/InferAnalyze.ml", line 112, characters 4-60 +Called from file "integration/Driver.ml", line 301, characters 2-34 +Called from file "integration/Driver.ml" (inlined), line 380, characters 32-62 +Called from file "infer.ml" (inlined), line 21, characters 2-47 +Called from file "infer.ml", line 128, characters 8-26 + diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/first_struct_driver_attribute_line.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/first_struct_driver_attribute_line.txt new file mode 100644 index 0000000..47dd9f5 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/first_struct_driver_attribute_line.txt @@ -0,0 +1,10 @@ +3843065:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843067:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843069:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843071:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843073:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843075:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843077:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843079:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843081:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +3843083:[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/tail_logs.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/tail_logs.txt new file mode 100644 index 0000000..d25fa8a --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/OutOfMemoryFiles/tail_logs.txt @@ -0,0 +1,1000 @@ +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ progress] ... +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ progress] ........ +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[730][ progress] ......F............ +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ debug] +[730][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct driver_attribute +[730][ progress] .......... +[730][ intern err] Uninit analyzer failed to compute post for proc_entry_rundown \ No newline at end of file diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infer_failure_log.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infer_failure_log.txt new file mode 100644 index 0000000..e756c13 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infer_failure_log.txt @@ -0,0 +1,18 @@ +Internal Error: Error in infer subprocess: died after receiving sigkill (signal number 9) + +Error backtrace: +Raised at file "base/Die.ml", line 25, characters 6-36 +Called from file "base/ProcessPool.ml", line 24, characters 6-93 +Called from file "base/ProcessPool.ml" (inlined), line 40, characters 31-40 +Called from file "backend/Tasks.ml" (inlined), line 56, characters 19-83 +Called from file "list.ml", line 100, characters 12-15 +Called from file "backend/InferAnalyze.ml" (inlined), line 121, characters 6-54 +Called from file "list.ml", line 100, characters 12-15 +Called from file "list.ml" (inlined), line 98, characters 13-64 +Called from file "src/list0.ml" (inlined), line 26, characters 40-75 +Called from file "backend/InferAnalyze.ml", line 123, characters 4-48 +Called from file "integration/Driver.ml", line 301, characters 2-34 +Called from file "integration/Driver.ml" (inlined), line 380, characters 32-62 +Called from file "infer.ml" (inlined), line 21, characters 2-47 +Called from file "infer.ml", line 128, characters 8-26 + diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infermaximalyesconfig b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infermaximalyesconfig new file mode 100644 index 0000000..0835b2a --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/infermaximalyesconfig @@ -0,0 +1,13 @@ +{"skip-analysis-in-path": [ +"linux/arch/x86/entry/vdso", +"linux/arch/x86/kernel", +"linux/arch/x86/boot", +"linux/arch/x86/include/asm", +"linux/drivers/char/mwave", +"linux/drivers/acpi", +"linux/drivers/edac", +"linux/drivers/firmware/efi", +"linux/drivers/media/pci", +"linux/drivers/xen", +"linux/drivers/staging/rtl8723bs"] +} diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_mod_tree_root.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_mod_tree_root.txt new file mode 100644 index 0000000..a3e88c4 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_mod_tree_root.txt @@ -0,0 +1,31 @@ +[386][environment] +[386][environment] command line arguments: infer analyze --jobs 2Analyzer: checkers +[386][environment] Active checkers: annotation reachability (Java), biabduction (C/C++/ObjC, Java), fragment retains view (Java), immutable cast (Java), liveness (C/C++/ObjC), printf args (Java), ownership (C/C++/ObjC), RacerD (C/C++/ObjC, Java), SIOF (C/C++/ObjC), uninitialized variables (C/C++/ObjC) +[386][environment] Infer log identifier is +Infer version v0.15.0 +[386][environment] Copyright 2009 - present Facebook. All Rights Reserved. +[386][environment] +[386][ progress] Found 15920 source files to analyze in /linux/infer-out +[386][ progress] Starting analysis... +[386][ progress] +[386][ progress] legend: +[386][ progress] "F" analyzing a file +[386][ progress] "." analyzing a procedure +[386][ progress] +[386][ progress] +[386][environment] Parallel jobs: 2 +[386][ progress] FF + +F +[392][ progress] ..[393][ progress] .................... +[392][ intern err] Pvar &__ptr appears on the LHS of >1 heap predicate! +[392][ progress] ... +[393][ intern err] Pvar &__ptr appears on the LHS of >1 heap predicate! +[393][ progress] .................................................................................................................................................. +[392][ intern err] Pvar &__ptr appears on the LHS of >1 heap predicate! + +[393][ intern err] Uninit analyzer failed to compute post for __const_udelayPvar &__ptr appears on the LHS of >1 heap predicate! +[393][ progress] ..[392][ progress] ........................................................................................................................................................................... +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_pv_irq_ops.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_pv_irq_ops.txt new file mode 100644 index 0000000..bf98c90 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/logs_starting_from_first_pv_irq_ops.txt @@ -0,0 +1,1401 @@ +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct mod_tree_root +[393][ progress] ..[392][ progress] ........................................................................................................................................................................................................................................................................................... +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ progress] ............................. +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops + +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ debug] +[393][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[393][ progress] ..............[392][ progress] .................................... +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[392][ debug] +[392][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/maximalyesconfig b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/maximalyesconfig new file mode 100644 index 0000000..04ccaf9 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/maximalyesconfig @@ -0,0 +1,11502 @@ +# +# Automatically generated file; DO NOT EDIT. +# Linux/x86 4.16.0 Kernel Configuration +# +CONFIG_64BIT=y +CONFIG_X86_64=y +CONFIG_X86=y +CONFIG_INSTRUCTION_DECODER=y +CONFIG_OUTPUT_FORMAT="elf64-x86-64" +CONFIG_ARCH_DEFCONFIG="arch/x86/configs/x86_64_defconfig" +CONFIG_LOCKDEP_SUPPORT=y +CONFIG_STACKTRACE_SUPPORT=y +CONFIG_MMU=y +CONFIG_ARCH_MMAP_RND_BITS_MIN=28 +CONFIG_ARCH_MMAP_RND_BITS_MAX=32 +CONFIG_ARCH_MMAP_RND_COMPAT_BITS_MIN=8 +CONFIG_ARCH_MMAP_RND_COMPAT_BITS_MAX=16 +CONFIG_NEED_DMA_MAP_STATE=y +CONFIG_NEED_SG_DMA_LENGTH=y +CONFIG_GENERIC_ISA_DMA=y +CONFIG_GENERIC_BUG=y +CONFIG_GENERIC_BUG_RELATIVE_POINTERS=y +CONFIG_GENERIC_HWEIGHT=y +CONFIG_ARCH_MAY_HAVE_PC_FDC=y +CONFIG_RWSEM_XCHGADD_ALGORITHM=y +CONFIG_GENERIC_CALIBRATE_DELAY=y +CONFIG_ARCH_HAS_CPU_RELAX=y +CONFIG_ARCH_HAS_CACHE_LINE_SIZE=y +CONFIG_HAVE_SETUP_PER_CPU_AREA=y +CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK=y +CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK=y +CONFIG_ARCH_HIBERNATION_POSSIBLE=y +CONFIG_ARCH_SUSPEND_POSSIBLE=y +CONFIG_ARCH_WANT_HUGE_PMD_SHARE=y +CONFIG_ARCH_WANT_GENERAL_HUGETLB=y +CONFIG_ZONE_DMA32=y +CONFIG_AUDIT_ARCH=y +CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING=y +CONFIG_ARCH_SUPPORTS_DEBUG_PAGEALLOC=y +CONFIG_KASAN_SHADOW_OFFSET=0xdffffc0000000000 +CONFIG_HAVE_INTEL_TXT=y +CONFIG_X86_64_SMP=y +CONFIG_ARCH_SUPPORTS_UPROBES=y +CONFIG_FIX_EARLYCON_MEM=y +CONFIG_PGTABLE_LEVELS=5 +CONFIG_CONSTRUCTORS=y +CONFIG_IRQ_WORK=y +CONFIG_BUILDTIME_EXTABLE_SORT=y +CONFIG_THREAD_INFO_IN_TASK=y + +# +# General setup +# +CONFIG_INIT_ENV_ARG_LIMIT=32 +CONFIG_CROSS_COMPILE="" +CONFIG_COMPILE_TEST=y +CONFIG_LOCALVERSION="" +CONFIG_HAVE_KERNEL_GZIP=y +CONFIG_HAVE_KERNEL_BZIP2=y +CONFIG_HAVE_KERNEL_LZMA=y +CONFIG_HAVE_KERNEL_XZ=y +CONFIG_HAVE_KERNEL_LZO=y +CONFIG_HAVE_KERNEL_LZ4=y +CONFIG_KERNEL_GZIP=y +# CONFIG_KERNEL_BZIP2 is not set +# CONFIG_KERNEL_LZMA is not set +# CONFIG_KERNEL_XZ is not set +# CONFIG_KERNEL_LZO is not set +# CONFIG_KERNEL_LZ4 is not set +CONFIG_DEFAULT_HOSTNAME="(none)" +CONFIG_SWAP=y +CONFIG_SYSVIPC=y +CONFIG_SYSVIPC_SYSCTL=y +CONFIG_POSIX_MQUEUE=y +CONFIG_POSIX_MQUEUE_SYSCTL=y +CONFIG_CROSS_MEMORY_ATTACH=y +CONFIG_USELIB=y +CONFIG_AUDIT=y +CONFIG_HAVE_ARCH_AUDITSYSCALL=y +CONFIG_AUDITSYSCALL=y +CONFIG_AUDIT_WATCH=y +CONFIG_AUDIT_TREE=y + +# +# IRQ subsystem +# +CONFIG_GENERIC_IRQ_PROBE=y +CONFIG_GENERIC_IRQ_SHOW=y +CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK=y +CONFIG_GENERIC_PENDING_IRQ=y +CONFIG_GENERIC_IRQ_MIGRATION=y +CONFIG_GENERIC_IRQ_CHIP=y +CONFIG_IRQ_DOMAIN=y +CONFIG_IRQ_SIM=y +CONFIG_IRQ_DOMAIN_HIERARCHY=y +CONFIG_IRQ_FASTEOI_HIERARCHY_HANDLERS=y +CONFIG_GENERIC_MSI_IRQ=y +CONFIG_GENERIC_MSI_IRQ_DOMAIN=y +CONFIG_GENERIC_IRQ_MATRIX_ALLOCATOR=y +CONFIG_GENERIC_IRQ_RESERVATION_MODE=y +CONFIG_IRQ_FORCED_THREADING=y +CONFIG_SPARSE_IRQ=y +CONFIG_GENERIC_IRQ_DEBUGFS=y +CONFIG_CLOCKSOURCE_WATCHDOG=y +CONFIG_ARCH_CLOCKSOURCE_DATA=y +CONFIG_CLOCKSOURCE_VALIDATE_LAST_CYCLE=y +CONFIG_GENERIC_TIME_VSYSCALL=y +CONFIG_GENERIC_CLOCKEVENTS=y +CONFIG_GENERIC_CLOCKEVENTS_BROADCAST=y +CONFIG_GENERIC_CLOCKEVENTS_MIN_ADJUST=y +CONFIG_GENERIC_CMOS_UPDATE=y + +# +# Timers subsystem +# +CONFIG_TICK_ONESHOT=y +CONFIG_NO_HZ_COMMON=y +# CONFIG_HZ_PERIODIC is not set +CONFIG_NO_HZ_IDLE=y +# CONFIG_NO_HZ_FULL is not set +CONFIG_NO_HZ=y +CONFIG_HIGH_RES_TIMERS=y + +# +# CPU/Task time and stats accounting +# +CONFIG_TICK_CPU_ACCOUNTING=y +# CONFIG_VIRT_CPU_ACCOUNTING_GEN is not set +CONFIG_IRQ_TIME_ACCOUNTING=y +CONFIG_BSD_PROCESS_ACCT=y +CONFIG_BSD_PROCESS_ACCT_V3=y +CONFIG_TASKSTATS=y +CONFIG_TASK_DELAY_ACCT=y +CONFIG_TASK_XACCT=y +CONFIG_TASK_IO_ACCOUNTING=y +CONFIG_CPU_ISOLATION=y + +# +# RCU Subsystem +# +CONFIG_TREE_RCU=y +CONFIG_RCU_EXPERT=y +CONFIG_SRCU=y +CONFIG_TREE_SRCU=y +CONFIG_TASKS_RCU=y +CONFIG_RCU_STALL_COMMON=y +CONFIG_RCU_NEED_SEGCBLIST=y +CONFIG_RCU_FANOUT=64 +CONFIG_RCU_FANOUT_LEAF=16 +CONFIG_RCU_FAST_NO_HZ=y +CONFIG_RCU_NOCB_CPU=y +CONFIG_BUILD_BIN2C=y +CONFIG_IKCONFIG=y +CONFIG_IKCONFIG_PROC=y +CONFIG_LOG_BUF_SHIFT=17 +CONFIG_LOG_CPU_MAX_BUF_SHIFT=12 +CONFIG_PRINTK_SAFE_LOG_BUF_SHIFT=13 +CONFIG_HAVE_UNSTABLE_SCHED_CLOCK=y +CONFIG_ARCH_SUPPORTS_NUMA_BALANCING=y +CONFIG_ARCH_WANT_BATCHED_UNMAP_TLB_FLUSH=y +CONFIG_ARCH_SUPPORTS_INT128=y +CONFIG_NUMA_BALANCING=y +CONFIG_NUMA_BALANCING_DEFAULT_ENABLED=y +CONFIG_CGROUPS=y +CONFIG_PAGE_COUNTER=y +CONFIG_MEMCG=y +CONFIG_MEMCG_SWAP=y +CONFIG_MEMCG_SWAP_ENABLED=y +CONFIG_BLK_CGROUP=y +CONFIG_DEBUG_BLK_CGROUP=y +CONFIG_CGROUP_WRITEBACK=y +CONFIG_CGROUP_SCHED=y +CONFIG_FAIR_GROUP_SCHED=y +CONFIG_CFS_BANDWIDTH=y +CONFIG_RT_GROUP_SCHED=y +CONFIG_CGROUP_PIDS=y +CONFIG_CGROUP_RDMA=y +CONFIG_CGROUP_FREEZER=y +CONFIG_CGROUP_HUGETLB=y +CONFIG_CPUSETS=y +CONFIG_PROC_PID_CPUSET=y +CONFIG_CGROUP_DEVICE=y +CONFIG_CGROUP_CPUACCT=y +CONFIG_CGROUP_PERF=y +CONFIG_CGROUP_BPF=y +CONFIG_CGROUP_DEBUG=y +CONFIG_SOCK_CGROUP_DATA=y +CONFIG_NAMESPACES=y +CONFIG_UTS_NS=y +CONFIG_IPC_NS=y +CONFIG_USER_NS=y +CONFIG_PID_NS=y +CONFIG_NET_NS=y +CONFIG_SCHED_AUTOGROUP=y +CONFIG_SYSFS_DEPRECATED=y +CONFIG_SYSFS_DEPRECATED_V2=y +CONFIG_RELAY=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_INITRAMFS_SOURCE="" +CONFIG_RD_GZIP=y +CONFIG_RD_BZIP2=y +CONFIG_RD_LZMA=y +CONFIG_RD_XZ=y +CONFIG_RD_LZO=y +CONFIG_RD_LZ4=y +CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE=y +# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set +CONFIG_SYSCTL=y +CONFIG_ANON_INODES=y +CONFIG_HAVE_UID16=y +CONFIG_SYSCTL_EXCEPTION_TRACE=y +CONFIG_HAVE_PCSPKR_PLATFORM=y +CONFIG_BPF=y +CONFIG_EXPERT=y +CONFIG_UID16=y +CONFIG_MULTIUSER=y +CONFIG_SGETMASK_SYSCALL=y +CONFIG_SYSFS_SYSCALL=y +CONFIG_SYSCTL_SYSCALL=y +CONFIG_FHANDLE=y +CONFIG_POSIX_TIMERS=y +CONFIG_PRINTK=y +CONFIG_PRINTK_NMI=y +CONFIG_BUG=y +CONFIG_ELF_CORE=y +CONFIG_PCSPKR_PLATFORM=y +CONFIG_BASE_FULL=y +CONFIG_FUTEX=y +CONFIG_FUTEX_PI=y +CONFIG_EPOLL=y +CONFIG_SIGNALFD=y +CONFIG_TIMERFD=y +CONFIG_EVENTFD=y +CONFIG_SHMEM=y +CONFIG_AIO=y +CONFIG_ADVISE_SYSCALLS=y +CONFIG_MEMBARRIER=y +CONFIG_CHECKPOINT_RESTORE=y +CONFIG_KALLSYMS=y +CONFIG_KALLSYMS_ALL=y +CONFIG_KALLSYMS_ABSOLUTE_PERCPU=y +CONFIG_KALLSYMS_BASE_RELATIVE=y +CONFIG_BPF_SYSCALL=y +CONFIG_BPF_JIT_ALWAYS_ON=y +CONFIG_USERFAULTFD=y +CONFIG_ARCH_HAS_MEMBARRIER_SYNC_CORE=y +CONFIG_EMBEDDED=y +CONFIG_HAVE_PERF_EVENTS=y +CONFIG_PERF_USE_VMALLOC=y +CONFIG_PC104=y + +# +# Kernel Performance Events And Counters +# +CONFIG_PERF_EVENTS=y +CONFIG_DEBUG_PERF_USE_VMALLOC=y +CONFIG_VM_EVENT_COUNTERS=y +CONFIG_SLUB_DEBUG=y +CONFIG_SLUB_MEMCG_SYSFS_ON=y +CONFIG_COMPAT_BRK=y +# CONFIG_SLAB is not set +CONFIG_SLUB=y +# CONFIG_SLOB is not set +CONFIG_SLAB_MERGE_DEFAULT=y +CONFIG_SLAB_FREELIST_RANDOM=y +CONFIG_SLAB_FREELIST_HARDENED=y +CONFIG_SLUB_CPU_PARTIAL=y +CONFIG_SYSTEM_DATA_VERIFICATION=y +CONFIG_PROFILING=y +CONFIG_TRACEPOINTS=y +CONFIG_CRASH_CORE=y +CONFIG_KEXEC_CORE=y +CONFIG_OPROFILE=y +CONFIG_OPROFILE_EVENT_MULTIPLEX=y +CONFIG_HAVE_OPROFILE=y +CONFIG_OPROFILE_NMI_TIMER=y +CONFIG_KPROBES=y +CONFIG_JUMP_LABEL=y +CONFIG_STATIC_KEYS_SELFTEST=y +CONFIG_OPTPROBES=y +CONFIG_KPROBES_ON_FTRACE=y +CONFIG_UPROBES=y +# CONFIG_HAVE_64BIT_ALIGNED_ACCESS is not set +CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y +CONFIG_ARCH_USE_BUILTIN_BSWAP=y +CONFIG_KRETPROBES=y +CONFIG_USER_RETURN_NOTIFIER=y +CONFIG_HAVE_IOREMAP_PROT=y +CONFIG_HAVE_KPROBES=y +CONFIG_HAVE_KRETPROBES=y +CONFIG_HAVE_OPTPROBES=y +CONFIG_HAVE_KPROBES_ON_FTRACE=y +CONFIG_HAVE_FUNCTION_ERROR_INJECTION=y +CONFIG_HAVE_NMI=y +CONFIG_HAVE_ARCH_TRACEHOOK=y +CONFIG_HAVE_DMA_CONTIGUOUS=y +CONFIG_GENERIC_SMP_IDLE_THREAD=y +CONFIG_ARCH_HAS_FORTIFY_SOURCE=y +CONFIG_ARCH_HAS_SET_MEMORY=y +CONFIG_HAVE_ARCH_THREAD_STRUCT_WHITELIST=y +CONFIG_ARCH_WANTS_DYNAMIC_TASK_STRUCT=y +CONFIG_HAVE_REGS_AND_STACK_ACCESS_API=y +CONFIG_HAVE_CLK=y +CONFIG_HAVE_DMA_API_DEBUG=y +CONFIG_HAVE_HW_BREAKPOINT=y +CONFIG_HAVE_MIXED_BREAKPOINTS_REGS=y +CONFIG_HAVE_USER_RETURN_NOTIFIER=y +CONFIG_HAVE_PERF_EVENTS_NMI=y +CONFIG_HAVE_HARDLOCKUP_DETECTOR_PERF=y +CONFIG_HAVE_PERF_REGS=y +CONFIG_HAVE_PERF_USER_STACK_DUMP=y +CONFIG_HAVE_ARCH_JUMP_LABEL=y +CONFIG_HAVE_RCU_TABLE_FREE=y +CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG=y +CONFIG_HAVE_ALIGNED_STRUCT_PAGE=y +CONFIG_HAVE_CMPXCHG_LOCAL=y +CONFIG_HAVE_CMPXCHG_DOUBLE=y +CONFIG_ARCH_WANT_COMPAT_IPC_PARSE_VERSION=y +CONFIG_ARCH_WANT_OLD_COMPAT_IPC=y +CONFIG_HAVE_ARCH_SECCOMP_FILTER=y +CONFIG_SECCOMP_FILTER=y +CONFIG_HAVE_GCC_PLUGINS=y +CONFIG_HAVE_CC_STACKPROTECTOR=y +# CONFIG_CC_STACKPROTECTOR_NONE is not set +# CONFIG_CC_STACKPROTECTOR_REGULAR is not set +# CONFIG_CC_STACKPROTECTOR_STRONG is not set +CONFIG_CC_STACKPROTECTOR_AUTO=y +CONFIG_THIN_ARCHIVES=y +CONFIG_HAVE_ARCH_WITHIN_STACK_FRAMES=y +CONFIG_HAVE_CONTEXT_TRACKING=y +CONFIG_HAVE_VIRT_CPU_ACCOUNTING_GEN=y +CONFIG_HAVE_IRQ_TIME_ACCOUNTING=y +CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE=y +CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD=y +CONFIG_HAVE_ARCH_HUGE_VMAP=y +CONFIG_HAVE_ARCH_SOFT_DIRTY=y +CONFIG_HAVE_MOD_ARCH_SPECIFIC=y +CONFIG_MODULES_USE_ELF_RELA=y +CONFIG_HAVE_IRQ_EXIT_ON_IRQ_STACK=y +CONFIG_ARCH_HAS_ELF_RANDOMIZE=y +CONFIG_HAVE_ARCH_MMAP_RND_BITS=y +CONFIG_HAVE_EXIT_THREAD=y +CONFIG_ARCH_MMAP_RND_BITS=28 +CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS=y +CONFIG_ARCH_MMAP_RND_COMPAT_BITS=8 +CONFIG_HAVE_ARCH_COMPAT_MMAP_BASES=y +CONFIG_HAVE_COPY_THREAD_TLS=y +CONFIG_HAVE_STACK_VALIDATION=y +# CONFIG_HAVE_ARCH_HASH is not set +CONFIG_ISA_BUS_API=y +CONFIG_OLD_SIGSUSPEND3=y +CONFIG_COMPAT_OLD_SIGACTION=y +# CONFIG_CPU_NO_EFFICIENT_FFS is not set +CONFIG_HAVE_ARCH_VMAP_STACK=y +# CONFIG_ARCH_OPTIONAL_KERNEL_RWX is not set +# CONFIG_ARCH_OPTIONAL_KERNEL_RWX_DEFAULT is not set +CONFIG_ARCH_HAS_STRICT_KERNEL_RWX=y +CONFIG_STRICT_KERNEL_RWX=y +CONFIG_ARCH_HAS_STRICT_MODULE_RWX=y +CONFIG_STRICT_MODULE_RWX=y +CONFIG_ARCH_HAS_PHYS_TO_DMA=y +CONFIG_ARCH_HAS_REFCOUNT=y +CONFIG_REFCOUNT_FULL=y + +# +# GCOV-based kernel profiling +# +CONFIG_GCOV_KERNEL=y +CONFIG_ARCH_HAS_GCOV_PROFILE_ALL=y +CONFIG_GCOV_FORMAT_AUTODETECT=y +# CONFIG_GCOV_FORMAT_3_4 is not set +# CONFIG_GCOV_FORMAT_4_7 is not set +# CONFIG_HAVE_GENERIC_DMA_COHERENT is not set +CONFIG_RT_MUTEXES=y +CONFIG_BASE_SMALL=0 +CONFIG_MODULES=y +CONFIG_MODULE_FORCE_LOAD=y +CONFIG_MODULE_UNLOAD=y +CONFIG_MODULE_FORCE_UNLOAD=y +CONFIG_MODVERSIONS=y +CONFIG_MODULE_SRCVERSION_ALL=y +CONFIG_MODULE_SIG=y +CONFIG_MODULE_SIG_FORCE=y +CONFIG_MODULE_SIG_ALL=y +CONFIG_MODULE_SIG_SHA1=y +# CONFIG_MODULE_SIG_SHA224 is not set +# CONFIG_MODULE_SIG_SHA256 is not set +# CONFIG_MODULE_SIG_SHA384 is not set +# CONFIG_MODULE_SIG_SHA512 is not set +CONFIG_MODULE_SIG_HASH="sha1" +CONFIG_MODULE_COMPRESS=y +CONFIG_MODULE_COMPRESS_GZIP=y +# CONFIG_MODULE_COMPRESS_XZ is not set +CONFIG_MODULES_TREE_LOOKUP=y +CONFIG_BLOCK=y +CONFIG_BLK_SCSI_REQUEST=y +CONFIG_BLK_DEV_BSG=y +CONFIG_BLK_DEV_BSGLIB=y +CONFIG_BLK_DEV_INTEGRITY=y +CONFIG_BLK_DEV_ZONED=y +CONFIG_BLK_DEV_THROTTLING=y +CONFIG_BLK_DEV_THROTTLING_LOW=y +CONFIG_BLK_CMDLINE_PARSER=y +CONFIG_BLK_WBT=y +CONFIG_BLK_WBT_SQ=y +CONFIG_BLK_WBT_MQ=y +CONFIG_BLK_DEBUG_FS=y +CONFIG_BLK_SED_OPAL=y + +# +# Partition Types +# +CONFIG_PARTITION_ADVANCED=y +CONFIG_ACORN_PARTITION=y +CONFIG_ACORN_PARTITION_CUMANA=y +CONFIG_ACORN_PARTITION_EESOX=y +CONFIG_ACORN_PARTITION_ICS=y +CONFIG_ACORN_PARTITION_ADFS=y +CONFIG_ACORN_PARTITION_POWERTEC=y +CONFIG_ACORN_PARTITION_RISCIX=y +CONFIG_AIX_PARTITION=y +CONFIG_OSF_PARTITION=y +CONFIG_AMIGA_PARTITION=y +CONFIG_ATARI_PARTITION=y +CONFIG_MAC_PARTITION=y +CONFIG_MSDOS_PARTITION=y +CONFIG_BSD_DISKLABEL=y +CONFIG_MINIX_SUBPARTITION=y +CONFIG_SOLARIS_X86_PARTITION=y +CONFIG_UNIXWARE_DISKLABEL=y +CONFIG_LDM_PARTITION=y +CONFIG_LDM_DEBUG=y +CONFIG_SGI_PARTITION=y +CONFIG_ULTRIX_PARTITION=y +CONFIG_SUN_PARTITION=y +CONFIG_KARMA_PARTITION=y +CONFIG_EFI_PARTITION=y +CONFIG_SYSV68_PARTITION=y +CONFIG_CMDLINE_PARTITION=y +CONFIG_BLOCK_COMPAT=y +CONFIG_BLK_MQ_PCI=y +CONFIG_BLK_MQ_VIRTIO=y +CONFIG_BLK_MQ_RDMA=y + +# +# IO Schedulers +# +CONFIG_IOSCHED_NOOP=y +CONFIG_IOSCHED_DEADLINE=y +CONFIG_IOSCHED_CFQ=y +CONFIG_CFQ_GROUP_IOSCHED=y +# CONFIG_DEFAULT_DEADLINE is not set +CONFIG_DEFAULT_CFQ=y +# CONFIG_DEFAULT_NOOP is not set +CONFIG_DEFAULT_IOSCHED="cfq" +CONFIG_MQ_IOSCHED_DEADLINE=y +CONFIG_MQ_IOSCHED_KYBER=y +CONFIG_IOSCHED_BFQ=y +CONFIG_BFQ_GROUP_IOSCHED=y +CONFIG_PREEMPT_NOTIFIERS=y +CONFIG_PADATA=y +CONFIG_ASN1=y +CONFIG_UNINLINE_SPIN_UNLOCK=y +CONFIG_ARCH_SUPPORTS_ATOMIC_RMW=y +CONFIG_MUTEX_SPIN_ON_OWNER=y +CONFIG_RWSEM_SPIN_ON_OWNER=y +CONFIG_LOCK_SPIN_ON_OWNER=y +CONFIG_ARCH_USE_QUEUED_SPINLOCKS=y +CONFIG_QUEUED_SPINLOCKS=y +CONFIG_ARCH_USE_QUEUED_RWLOCKS=y +CONFIG_QUEUED_RWLOCKS=y +CONFIG_ARCH_HAS_SYNC_CORE_BEFORE_USERMODE=y +CONFIG_FREEZER=y + +# +# Processor type and features +# +CONFIG_ZONE_DMA=y +CONFIG_SMP=y +CONFIG_X86_FEATURE_NAMES=y +CONFIG_X86_FAST_FEATURE_TESTS=y +CONFIG_X86_X2APIC=y +CONFIG_X86_MPPARSE=y +CONFIG_GOLDFISH=y +CONFIG_RETPOLINE=y +CONFIG_INTEL_RDT=y +CONFIG_X86_EXTENDED_PLATFORM=y +CONFIG_X86_NUMACHIP=y +CONFIG_X86_VSMP=y +CONFIG_X86_UV=y +CONFIG_X86_GOLDFISH=y +CONFIG_X86_INTEL_MID=y +CONFIG_X86_INTEL_LPSS=y +CONFIG_X86_AMD_PLATFORM_DEVICE=y +CONFIG_IOSF_MBI=y +CONFIG_IOSF_MBI_DEBUG=y +CONFIG_X86_SUPPORTS_MEMORY_FAILURE=y +CONFIG_SCHED_OMIT_FRAME_POINTER=y +CONFIG_HYPERVISOR_GUEST=y +CONFIG_PARAVIRT=y +CONFIG_PARAVIRT_DEBUG=y +CONFIG_PARAVIRT_SPINLOCKS=y +CONFIG_QUEUED_LOCK_STAT=y +CONFIG_XEN=y +CONFIG_XEN_PVHVM=y +CONFIG_XEN_PVHVM_SMP=y +CONFIG_XEN_SAVE_RESTORE=y +CONFIG_XEN_DEBUG_FS=y +CONFIG_KVM_GUEST=y +CONFIG_KVM_DEBUG_FS=y +CONFIG_PARAVIRT_TIME_ACCOUNTING=y +CONFIG_PARAVIRT_CLOCK=y +CONFIG_JAILHOUSE_GUEST=y +CONFIG_NO_BOOTMEM=y +# CONFIG_MK8 is not set +# CONFIG_MPSC is not set +# CONFIG_MCORE2 is not set +# CONFIG_MATOM is not set +CONFIG_GENERIC_CPU=y +CONFIG_X86_INTERNODE_CACHE_SHIFT=12 +CONFIG_X86_L1_CACHE_SHIFT=6 +CONFIG_X86_TSC=y +CONFIG_X86_CMPXCHG64=y +CONFIG_X86_CMOV=y +CONFIG_X86_MINIMUM_CPU_FAMILY=64 +CONFIG_X86_DEBUGCTLMSR=y +CONFIG_PROCESSOR_SELECT=y +CONFIG_CPU_SUP_INTEL=y +CONFIG_CPU_SUP_AMD=y +CONFIG_CPU_SUP_CENTAUR=y +CONFIG_HPET_TIMER=y +CONFIG_HPET_EMULATE_RTC=y +CONFIG_APB_TIMER=y +CONFIG_DMI=y +CONFIG_GART_IOMMU=y +CONFIG_CALGARY_IOMMU=y +CONFIG_CALGARY_IOMMU_ENABLED_BY_DEFAULT=y +CONFIG_SWIOTLB=y +CONFIG_IOMMU_HELPER=y +CONFIG_MAXSMP=y +CONFIG_NR_CPUS_RANGE_BEGIN=8192 +CONFIG_NR_CPUS_RANGE_END=8192 +CONFIG_NR_CPUS_DEFAULT=8192 +CONFIG_NR_CPUS=8192 +CONFIG_SCHED_SMT=y +CONFIG_SCHED_MC=y +CONFIG_SCHED_MC_PRIO=y +CONFIG_PREEMPT_NONE=y +# CONFIG_PREEMPT_VOLUNTARY is not set +# CONFIG_PREEMPT is not set +CONFIG_PREEMPT_COUNT=y +CONFIG_X86_LOCAL_APIC=y +CONFIG_X86_IO_APIC=y +CONFIG_X86_REROUTE_FOR_BROKEN_BOOT_IRQS=y +CONFIG_X86_MCE=y +CONFIG_X86_MCELOG_LEGACY=y +CONFIG_X86_MCE_INTEL=y +CONFIG_X86_MCE_AMD=y +CONFIG_X86_MCE_THRESHOLD=y +CONFIG_X86_MCE_INJECT=y +CONFIG_X86_THERMAL_VECTOR=y + +# +# Performance monitoring +# +CONFIG_PERF_EVENTS_INTEL_UNCORE=y +CONFIG_PERF_EVENTS_INTEL_RAPL=y +CONFIG_PERF_EVENTS_INTEL_CSTATE=y +CONFIG_PERF_EVENTS_AMD_POWER=y +# CONFIG_VM86 is not set +CONFIG_X86_16BIT=y +CONFIG_X86_ESPFIX64=y +CONFIG_X86_VSYSCALL_EMULATION=y +CONFIG_I8K=y +CONFIG_MICROCODE=y +CONFIG_MICROCODE_INTEL=y +CONFIG_MICROCODE_AMD=y +CONFIG_MICROCODE_OLD_INTERFACE=y +CONFIG_X86_MSR=y +CONFIG_X86_CPUID=y +CONFIG_X86_5LEVEL=y +CONFIG_ARCH_PHYS_ADDR_T_64BIT=y +CONFIG_ARCH_DMA_ADDR_T_64BIT=y +CONFIG_ARCH_HAS_MEM_ENCRYPT=y +CONFIG_AMD_MEM_ENCRYPT=y +CONFIG_AMD_MEM_ENCRYPT_ACTIVE_BY_DEFAULT=y +CONFIG_ARCH_USE_MEMREMAP_PROT=y +CONFIG_NUMA=y +CONFIG_AMD_NUMA=y +CONFIG_X86_64_ACPI_NUMA=y +CONFIG_NODES_SPAN_OTHER_NODES=y +CONFIG_NUMA_EMU=y +CONFIG_NODES_SHIFT=10 +CONFIG_ARCH_SPARSEMEM_ENABLE=y +CONFIG_ARCH_SPARSEMEM_DEFAULT=y +CONFIG_ARCH_SELECT_MEMORY_MODEL=y +CONFIG_ARCH_MEMORY_PROBE=y +CONFIG_ARCH_PROC_KCORE_TEXT=y +CONFIG_ILLEGAL_POINTER_VALUE=0xdead000000000000 +CONFIG_SELECT_MEMORY_MODEL=y +CONFIG_SPARSEMEM_MANUAL=y +CONFIG_SPARSEMEM=y +CONFIG_NEED_MULTIPLE_NODES=y +CONFIG_HAVE_MEMORY_PRESENT=y +CONFIG_SPARSEMEM_EXTREME=y +CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y +CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER=y +CONFIG_SPARSEMEM_VMEMMAP=y +CONFIG_HAVE_MEMBLOCK=y +CONFIG_HAVE_MEMBLOCK_NODE_MAP=y +CONFIG_HAVE_GENERIC_GUP=y +CONFIG_ARCH_DISCARD_MEMBLOCK=y +CONFIG_MEMORY_ISOLATION=y +CONFIG_HAVE_BOOTMEM_INFO_NODE=y +CONFIG_MEMORY_HOTPLUG=y +CONFIG_MEMORY_HOTPLUG_SPARSE=y +CONFIG_MEMORY_HOTPLUG_DEFAULT_ONLINE=y +CONFIG_MEMORY_HOTREMOVE=y +CONFIG_SPLIT_PTLOCK_CPUS=4 +CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK=y +CONFIG_MEMORY_BALLOON=y +CONFIG_BALLOON_COMPACTION=y +CONFIG_COMPACTION=y +CONFIG_MIGRATION=y +CONFIG_ARCH_ENABLE_HUGEPAGE_MIGRATION=y +CONFIG_ARCH_ENABLE_THP_MIGRATION=y +CONFIG_PHYS_ADDR_T_64BIT=y +CONFIG_BOUNCE=y +CONFIG_VIRT_TO_BUS=y +CONFIG_MMU_NOTIFIER=y +CONFIG_KSM=y +CONFIG_DEFAULT_MMAP_MIN_ADDR=4096 +CONFIG_ARCH_SUPPORTS_MEMORY_FAILURE=y +CONFIG_MEMORY_FAILURE=y +CONFIG_HWPOISON_INJECT=y +CONFIG_TRANSPARENT_HUGEPAGE=y +CONFIG_TRANSPARENT_HUGEPAGE_ALWAYS=y +# CONFIG_TRANSPARENT_HUGEPAGE_MADVISE is not set +CONFIG_ARCH_WANTS_THP_SWAP=y +CONFIG_THP_SWAP=y +CONFIG_TRANSPARENT_HUGE_PAGECACHE=y +CONFIG_CLEANCACHE=y +CONFIG_FRONTSWAP=y +CONFIG_CMA=y +CONFIG_CMA_DEBUG=y +CONFIG_CMA_DEBUGFS=y +CONFIG_CMA_AREAS=7 +CONFIG_MEM_SOFT_DIRTY=y +CONFIG_ZSWAP=y +CONFIG_ZPOOL=y +CONFIG_ZBUD=y +CONFIG_Z3FOLD=y +CONFIG_ZSMALLOC=y +CONFIG_PGTABLE_MAPPING=y +CONFIG_ZSMALLOC_STAT=y +CONFIG_GENERIC_EARLY_IOREMAP=y +CONFIG_DEFERRED_STRUCT_PAGE_INIT=y +CONFIG_IDLE_PAGE_TRACKING=y +CONFIG_ARCH_HAS_ZONE_DEVICE=y +CONFIG_ZONE_DEVICE=y +CONFIG_ARCH_HAS_HMM=y +CONFIG_MIGRATE_VMA_HELPER=y +CONFIG_HMM=y +CONFIG_HMM_MIRROR=y +CONFIG_DEVICE_PRIVATE=y +CONFIG_DEVICE_PUBLIC=y +CONFIG_FRAME_VECTOR=y +CONFIG_ARCH_USES_HIGH_VMA_FLAGS=y +CONFIG_ARCH_HAS_PKEYS=y +CONFIG_PERCPU_STATS=y +CONFIG_GUP_BENCHMARK=y +CONFIG_X86_PMEM_LEGACY_DEVICE=y +CONFIG_X86_PMEM_LEGACY=y +CONFIG_X86_CHECK_BIOS_CORRUPTION=y +CONFIG_X86_BOOTPARAM_MEMORY_CORRUPTION_CHECK=y +CONFIG_X86_RESERVE_LOW=64 +CONFIG_MTRR=y +CONFIG_MTRR_SANITIZER=y +CONFIG_MTRR_SANITIZER_ENABLE_DEFAULT=0 +CONFIG_MTRR_SANITIZER_SPARE_REG_NR_DEFAULT=1 +CONFIG_X86_PAT=y +CONFIG_ARCH_USES_PG_UNCACHED=y +CONFIG_ARCH_RANDOM=y +CONFIG_X86_SMAP=y +CONFIG_X86_INTEL_UMIP=y +CONFIG_X86_INTEL_MPX=y +CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS=y +CONFIG_EFI=y +CONFIG_EFI_STUB=y +CONFIG_EFI_MIXED=y +CONFIG_SECCOMP=y +# CONFIG_HZ_100 is not set +CONFIG_HZ_250=y +# CONFIG_HZ_300 is not set +# CONFIG_HZ_1000 is not set +CONFIG_HZ=250 +CONFIG_SCHED_HRTICK=y +CONFIG_KEXEC=y +CONFIG_KEXEC_FILE=y +CONFIG_KEXEC_VERIFY_SIG=y +CONFIG_KEXEC_BZIMAGE_VERIFY_SIG=y +CONFIG_CRASH_DUMP=y +CONFIG_KEXEC_JUMP=y +CONFIG_PHYSICAL_START=0x1000000 +CONFIG_RELOCATABLE=y +CONFIG_RANDOMIZE_BASE=y +CONFIG_X86_NEED_RELOCS=y +CONFIG_PHYSICAL_ALIGN=0x200000 +CONFIG_RANDOMIZE_MEMORY=y +CONFIG_RANDOMIZE_MEMORY_PHYSICAL_PADDING=0xa +CONFIG_HOTPLUG_CPU=y +CONFIG_BOOTPARAM_HOTPLUG_CPU0=y +CONFIG_DEBUG_HOTPLUG_CPU0=y +CONFIG_COMPAT_VDSO=y +CONFIG_LEGACY_VSYSCALL_EMULATE=y +# CONFIG_LEGACY_VSYSCALL_NONE is not set +CONFIG_CMDLINE_BOOL=y +CONFIG_CMDLINE="" +CONFIG_CMDLINE_OVERRIDE=y +CONFIG_MODIFY_LDT_SYSCALL=y +CONFIG_HAVE_LIVEPATCH=y +CONFIG_LIVEPATCH=y +CONFIG_ARCH_HAS_ADD_PAGES=y +CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y +CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y +CONFIG_USE_PERCPU_NUMA_NODE_ID=y + +# +# Power management and ACPI options +# +CONFIG_ARCH_HIBERNATION_HEADER=y +CONFIG_SUSPEND=y +CONFIG_SUSPEND_FREEZER=y +CONFIG_SUSPEND_SKIP_SYNC=y +CONFIG_HIBERNATE_CALLBACKS=y +CONFIG_HIBERNATION=y +CONFIG_PM_STD_PARTITION="" +CONFIG_PM_SLEEP=y +CONFIG_PM_SLEEP_SMP=y +CONFIG_PM_AUTOSLEEP=y +CONFIG_PM_WAKELOCKS=y +CONFIG_PM_WAKELOCKS_LIMIT=100 +CONFIG_PM_WAKELOCKS_GC=y +CONFIG_PM=y +CONFIG_PM_DEBUG=y +CONFIG_PM_ADVANCED_DEBUG=y +CONFIG_PM_TEST_SUSPEND=y +CONFIG_PM_SLEEP_DEBUG=y +CONFIG_DPM_WATCHDOG=y +CONFIG_DPM_WATCHDOG_TIMEOUT=120 +CONFIG_PM_TRACE=y +CONFIG_PM_TRACE_RTC=y +CONFIG_PM_CLK=y +CONFIG_PM_GENERIC_DOMAINS=y +CONFIG_WQ_POWER_EFFICIENT_DEFAULT=y +CONFIG_PM_GENERIC_DOMAINS_SLEEP=y +CONFIG_PM_GENERIC_DOMAINS_OF=y +CONFIG_ACPI=y +CONFIG_ACPI_LEGACY_TABLES_LOOKUP=y +CONFIG_ARCH_MIGHT_HAVE_ACPI_PDC=y +CONFIG_ACPI_SYSTEM_POWER_STATES_SUPPORT=y +CONFIG_ACPI_DEBUGGER=y +CONFIG_ACPI_DEBUGGER_USER=y +CONFIG_ACPI_SPCR_TABLE=y +CONFIG_ACPI_LPIT=y +CONFIG_ACPI_SLEEP=y +CONFIG_ACPI_PROCFS_POWER=y +CONFIG_ACPI_REV_OVERRIDE_POSSIBLE=y +CONFIG_ACPI_EC_DEBUGFS=y +CONFIG_ACPI_AC=y +CONFIG_ACPI_BATTERY=y +CONFIG_ACPI_BUTTON=y +CONFIG_ACPI_VIDEO=y +CONFIG_ACPI_FAN=y +CONFIG_ACPI_DOCK=y +CONFIG_ACPI_CPU_FREQ_PSS=y +CONFIG_ACPI_PROCESSOR_CSTATE=y +CONFIG_ACPI_PROCESSOR_IDLE=y +CONFIG_ACPI_CPPC_LIB=y +CONFIG_ACPI_PROCESSOR=y +CONFIG_ACPI_IPMI=y +CONFIG_ACPI_HOTPLUG_CPU=y +CONFIG_ACPI_PROCESSOR_AGGREGATOR=y +CONFIG_ACPI_THERMAL=y +CONFIG_ACPI_NUMA=y +# CONFIG_ACPI_CUSTOM_DSDT is not set +CONFIG_ARCH_HAS_ACPI_TABLE_UPGRADE=y +CONFIG_ACPI_TABLE_UPGRADE=y +CONFIG_ACPI_DEBUG=y +CONFIG_ACPI_PCI_SLOT=y +CONFIG_ACPI_CONTAINER=y +CONFIG_ACPI_HOTPLUG_MEMORY=y +CONFIG_ACPI_HOTPLUG_IOAPIC=y +CONFIG_ACPI_SBS=y +CONFIG_ACPI_HED=y +CONFIG_ACPI_CUSTOM_METHOD=y +CONFIG_ACPI_BGRT=y +CONFIG_ACPI_REDUCED_HARDWARE_ONLY=y +CONFIG_ACPI_NFIT=y +CONFIG_HAVE_ACPI_APEI=y +CONFIG_HAVE_ACPI_APEI_NMI=y +CONFIG_ACPI_APEI=y +CONFIG_ACPI_APEI_GHES=y +CONFIG_ACPI_APEI_PCIEAER=y +CONFIG_ACPI_APEI_MEMORY_FAILURE=y +CONFIG_ACPI_APEI_EINJ=y +CONFIG_ACPI_APEI_ERST_DEBUG=y +CONFIG_DPTF_POWER=y +CONFIG_ACPI_WATCHDOG=y +CONFIG_ACPI_EXTLOG=y +CONFIG_PMIC_OPREGION=y +CONFIG_CRC_PMIC_OPREGION=y +CONFIG_XPOWER_PMIC_OPREGION=y +CONFIG_BXT_WC_PMIC_OPREGION=y +CONFIG_CHT_WC_PMIC_OPREGION=y +CONFIG_CHT_DC_TI_PMIC_OPREGION=y +CONFIG_ACPI_CONFIGFS=y +CONFIG_TPS68470_PMIC_OPREGION=y +CONFIG_X86_PM_TIMER=y +CONFIG_SFI=y + +# +# CPU Frequency scaling +# +CONFIG_CPU_FREQ=y +CONFIG_CPU_FREQ_GOV_ATTR_SET=y +CONFIG_CPU_FREQ_GOV_COMMON=y +CONFIG_CPU_FREQ_STAT=y +CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y +# CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set +# CONFIG_CPU_FREQ_DEFAULT_GOV_SCHEDUTIL is not set +CONFIG_CPU_FREQ_GOV_PERFORMANCE=y +CONFIG_CPU_FREQ_GOV_POWERSAVE=y +CONFIG_CPU_FREQ_GOV_USERSPACE=y +CONFIG_CPU_FREQ_GOV_ONDEMAND=y +CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y +CONFIG_CPU_FREQ_GOV_SCHEDUTIL=y + +# +# CPU frequency scaling drivers +# +CONFIG_CPUFREQ_DT=y +CONFIG_CPUFREQ_DT_PLATDEV=y +CONFIG_X86_INTEL_PSTATE=y +CONFIG_X86_PCC_CPUFREQ=y +CONFIG_X86_ACPI_CPUFREQ=y +CONFIG_X86_ACPI_CPUFREQ_CPB=y +CONFIG_X86_SFI_CPUFREQ=y +CONFIG_X86_POWERNOW_K8=y +CONFIG_X86_AMD_FREQ_SENSITIVITY=y +CONFIG_X86_SPEEDSTEP_CENTRINO=y +CONFIG_X86_P4_CLOCKMOD=y + +# +# shared options +# +CONFIG_X86_SPEEDSTEP_LIB=y + +# +# CPU Idle +# +CONFIG_CPU_IDLE=y +CONFIG_CPU_IDLE_GOV_LADDER=y +CONFIG_CPU_IDLE_GOV_MENU=y +# CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED is not set +CONFIG_INTEL_IDLE=y + +# +# Bus options (PCI etc.) +# +CONFIG_PCI=y +CONFIG_PCI_DIRECT=y +CONFIG_PCI_MMCONFIG=y +CONFIG_PCI_XEN=y +CONFIG_PCI_DOMAINS=y +CONFIG_PCI_CNB20LE_QUIRK=y +CONFIG_PCIEPORTBUS=y +CONFIG_HOTPLUG_PCI_PCIE=y +CONFIG_PCIEAER=y +CONFIG_PCIE_ECRC=y +CONFIG_PCIEAER_INJECT=y +CONFIG_PCIEASPM=y +CONFIG_PCIEASPM_DEBUG=y +CONFIG_PCIEASPM_DEFAULT=y +# CONFIG_PCIEASPM_POWERSAVE is not set +# CONFIG_PCIEASPM_POWER_SUPERSAVE is not set +# CONFIG_PCIEASPM_PERFORMANCE is not set +CONFIG_PCIE_PME=y +CONFIG_PCIE_DPC=y +CONFIG_PCIE_PTM=y +CONFIG_PCI_BUS_ADDR_T_64BIT=y +CONFIG_PCI_MSI=y +CONFIG_PCI_MSI_IRQ_DOMAIN=y +CONFIG_PCI_QUIRKS=y +CONFIG_PCI_DEBUG=y +CONFIG_PCI_REALLOC_ENABLE_AUTO=y +CONFIG_PCI_STUB=y +CONFIG_XEN_PCIDEV_FRONTEND=y +CONFIG_PCI_ATS=y +CONFIG_PCI_LOCKLESS_CONFIG=y +CONFIG_PCI_IOV=y +CONFIG_PCI_PRI=y +CONFIG_PCI_PASID=y +CONFIG_PCI_LABEL=y +CONFIG_PCI_HYPERV=y +CONFIG_HOTPLUG_PCI=y +CONFIG_HOTPLUG_PCI_ACPI=y +CONFIG_HOTPLUG_PCI_ACPI_IBM=y +CONFIG_HOTPLUG_PCI_CPCI=y +CONFIG_HOTPLUG_PCI_CPCI_ZT5550=y +CONFIG_HOTPLUG_PCI_CPCI_GENERIC=y +CONFIG_HOTPLUG_PCI_SHPC=y + +# +# Cadence PCIe controllers support +# +CONFIG_PCIE_CADENCE=y +CONFIG_PCIE_CADENCE_HOST=y +CONFIG_PCIE_CADENCE_EP=y + +# +# DesignWare PCI Core Support +# +CONFIG_PCIE_DW=y +CONFIG_PCIE_DW_HOST=y +CONFIG_PCIE_DW_PLAT=y + +# +# PCI host controller drivers +# +CONFIG_PCIE_ROCKCHIP=y +CONFIG_VMD=y + +# +# PCI Endpoint +# +CONFIG_PCI_ENDPOINT=y +CONFIG_PCI_ENDPOINT_CONFIGFS=y +CONFIG_PCI_EPF_TEST=y + +# +# PCI switch controller drivers +# +CONFIG_PCI_SW_SWITCHTEC=y +CONFIG_ISA_BUS=y +CONFIG_ISA_DMA_API=y +CONFIG_AMD_NB=y +CONFIG_PCCARD=y +CONFIG_PCMCIA=y +CONFIG_PCMCIA_LOAD_CIS=y +CONFIG_CARDBUS=y + +# +# PC-card bridges +# +CONFIG_YENTA=y +CONFIG_YENTA_O2=y +CONFIG_YENTA_RICOH=y +CONFIG_YENTA_TI=y +CONFIG_YENTA_ENE_TUNE=y +CONFIG_YENTA_TOSHIBA=y +CONFIG_PD6729=y +CONFIG_I82092=y +CONFIG_PCCARD_NONSTATIC=y +CONFIG_RAPIDIO=y +CONFIG_RAPIDIO_TSI721=y +CONFIG_RAPIDIO_DISC_TIMEOUT=30 +CONFIG_RAPIDIO_ENABLE_RX_TX_PORTS=y +CONFIG_RAPIDIO_DMA_ENGINE=y +CONFIG_RAPIDIO_DEBUG=y +CONFIG_RAPIDIO_ENUM_BASIC=y +CONFIG_RAPIDIO_CHMAN=y +CONFIG_RAPIDIO_MPORT_CDEV=y + +# +# RapidIO Switch drivers +# +CONFIG_RAPIDIO_TSI57X=y +CONFIG_RAPIDIO_CPS_XX=y +CONFIG_RAPIDIO_TSI568=y +CONFIG_RAPIDIO_CPS_GEN2=y +CONFIG_RAPIDIO_RXS_GEN3=y +CONFIG_X86_SYSFB=y + +# +# Executable file formats / Emulations +# +CONFIG_BINFMT_ELF=y +CONFIG_COMPAT_BINFMT_ELF=y +CONFIG_ELFCORE=y +CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS=y +CONFIG_BINFMT_SCRIPT=y +# CONFIG_HAVE_AOUT is not set +CONFIG_BINFMT_MISC=y +CONFIG_COREDUMP=y +CONFIG_IA32_EMULATION=y +CONFIG_IA32_AOUT=y +CONFIG_X86_X32=y +CONFIG_COMPAT_32=y +CONFIG_COMPAT=y +CONFIG_COMPAT_FOR_U64_ALIGNMENT=y +CONFIG_SYSVIPC_COMPAT=y +CONFIG_X86_DEV_DMA_OPS=y +CONFIG_NET=y +CONFIG_COMPAT_NETLINK_MESSAGES=y +CONFIG_NET_INGRESS=y +CONFIG_NET_EGRESS=y + +# +# Networking options +# +CONFIG_PACKET=y +CONFIG_PACKET_DIAG=y +CONFIG_UNIX=y +CONFIG_UNIX_DIAG=y +CONFIG_TLS=y +CONFIG_XFRM=y +CONFIG_XFRM_OFFLOAD=y +CONFIG_XFRM_ALGO=y +CONFIG_XFRM_USER=y +CONFIG_XFRM_SUB_POLICY=y +CONFIG_XFRM_MIGRATE=y +CONFIG_XFRM_STATISTICS=y +CONFIG_XFRM_IPCOMP=y +CONFIG_NET_KEY=y +CONFIG_NET_KEY_MIGRATE=y +CONFIG_SMC=y +CONFIG_SMC_DIAG=y +CONFIG_INET=y +CONFIG_IP_MULTICAST=y +CONFIG_IP_ADVANCED_ROUTER=y +CONFIG_IP_FIB_TRIE_STATS=y +CONFIG_IP_MULTIPLE_TABLES=y +CONFIG_IP_ROUTE_MULTIPATH=y +CONFIG_IP_ROUTE_VERBOSE=y +CONFIG_IP_ROUTE_CLASSID=y +CONFIG_IP_PNP=y +CONFIG_IP_PNP_DHCP=y +CONFIG_IP_PNP_BOOTP=y +CONFIG_IP_PNP_RARP=y +CONFIG_NET_IPIP=y +CONFIG_NET_IPGRE_DEMUX=y +CONFIG_NET_IP_TUNNEL=y +CONFIG_NET_IPGRE=y +CONFIG_NET_IPGRE_BROADCAST=y +CONFIG_IP_MROUTE=y +CONFIG_IP_MROUTE_MULTIPLE_TABLES=y +CONFIG_IP_PIMSM_V1=y +CONFIG_IP_PIMSM_V2=y +CONFIG_SYN_COOKIES=y +CONFIG_NET_IPVTI=y +CONFIG_NET_UDP_TUNNEL=y +CONFIG_NET_FOU=y +CONFIG_NET_FOU_IP_TUNNELS=y +CONFIG_INET_AH=y +CONFIG_INET_ESP=y +CONFIG_INET_ESP_OFFLOAD=y +CONFIG_INET_IPCOMP=y +CONFIG_INET_XFRM_TUNNEL=y +CONFIG_INET_TUNNEL=y +CONFIG_INET_XFRM_MODE_TRANSPORT=y +CONFIG_INET_XFRM_MODE_TUNNEL=y +CONFIG_INET_XFRM_MODE_BEET=y +CONFIG_INET_DIAG=y +CONFIG_INET_TCP_DIAG=y +CONFIG_INET_UDP_DIAG=y +CONFIG_INET_RAW_DIAG=y +CONFIG_INET_DIAG_DESTROY=y +CONFIG_TCP_CONG_ADVANCED=y +CONFIG_TCP_CONG_BIC=y +CONFIG_TCP_CONG_CUBIC=y +CONFIG_TCP_CONG_WESTWOOD=y +CONFIG_TCP_CONG_HTCP=y +CONFIG_TCP_CONG_HSTCP=y +CONFIG_TCP_CONG_HYBLA=y +CONFIG_TCP_CONG_VEGAS=y +CONFIG_TCP_CONG_NV=y +CONFIG_TCP_CONG_SCALABLE=y +CONFIG_TCP_CONG_LP=y +CONFIG_TCP_CONG_VENO=y +CONFIG_TCP_CONG_YEAH=y +CONFIG_TCP_CONG_ILLINOIS=y +CONFIG_TCP_CONG_DCTCP=y +CONFIG_TCP_CONG_CDG=y +CONFIG_TCP_CONG_BBR=y +# CONFIG_DEFAULT_BIC is not set +CONFIG_DEFAULT_CUBIC=y +# CONFIG_DEFAULT_HTCP is not set +# CONFIG_DEFAULT_HYBLA is not set +# CONFIG_DEFAULT_VEGAS is not set +# CONFIG_DEFAULT_VENO is not set +# CONFIG_DEFAULT_WESTWOOD is not set +# CONFIG_DEFAULT_DCTCP is not set +# CONFIG_DEFAULT_CDG is not set +# CONFIG_DEFAULT_BBR is not set +# CONFIG_DEFAULT_RENO is not set +CONFIG_DEFAULT_TCP_CONG="cubic" +CONFIG_TCP_MD5SIG=y +CONFIG_IPV6=y +CONFIG_IPV6_ROUTER_PREF=y +CONFIG_IPV6_ROUTE_INFO=y +CONFIG_IPV6_OPTIMISTIC_DAD=y +CONFIG_INET6_AH=y +CONFIG_INET6_ESP=y +CONFIG_INET6_ESP_OFFLOAD=y +CONFIG_INET6_IPCOMP=y +CONFIG_IPV6_MIP6=y +CONFIG_IPV6_ILA=y +CONFIG_INET6_XFRM_TUNNEL=y +CONFIG_INET6_TUNNEL=y +CONFIG_INET6_XFRM_MODE_TRANSPORT=y +CONFIG_INET6_XFRM_MODE_TUNNEL=y +CONFIG_INET6_XFRM_MODE_BEET=y +CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION=y +CONFIG_IPV6_VTI=y +CONFIG_IPV6_SIT=y +CONFIG_IPV6_SIT_6RD=y +CONFIG_IPV6_NDISC_NODETYPE=y +CONFIG_IPV6_TUNNEL=y +CONFIG_IPV6_GRE=y +CONFIG_IPV6_FOU=y +CONFIG_IPV6_FOU_TUNNEL=y +CONFIG_IPV6_MULTIPLE_TABLES=y +CONFIG_IPV6_SUBTREES=y +CONFIG_IPV6_MROUTE=y +CONFIG_IPV6_MROUTE_MULTIPLE_TABLES=y +CONFIG_IPV6_PIMSM_V2=y +CONFIG_IPV6_SEG6_LWTUNNEL=y +CONFIG_IPV6_SEG6_HMAC=y +CONFIG_NETLABEL=y +CONFIG_NETWORK_SECMARK=y +CONFIG_NET_PTP_CLASSIFY=y +CONFIG_NETWORK_PHY_TIMESTAMPING=y +CONFIG_NETFILTER=y +CONFIG_NETFILTER_ADVANCED=y +CONFIG_BRIDGE_NETFILTER=y + +# +# Core Netfilter Configuration +# +CONFIG_NETFILTER_INGRESS=y +CONFIG_NETFILTER_NETLINK=y +CONFIG_NETFILTER_FAMILY_BRIDGE=y +CONFIG_NETFILTER_FAMILY_ARP=y +CONFIG_NETFILTER_NETLINK_ACCT=y +CONFIG_NETFILTER_NETLINK_QUEUE=y +CONFIG_NETFILTER_NETLINK_LOG=y +CONFIG_NF_CONNTRACK=y +CONFIG_NF_LOG_COMMON=y +CONFIG_NF_LOG_NETDEV=y +CONFIG_NETFILTER_CONNCOUNT=y +CONFIG_NF_CONNTRACK_MARK=y +CONFIG_NF_CONNTRACK_SECMARK=y +CONFIG_NF_CONNTRACK_ZONES=y +CONFIG_NF_CONNTRACK_PROCFS=y +CONFIG_NF_CONNTRACK_EVENTS=y +CONFIG_NF_CONNTRACK_TIMEOUT=y +CONFIG_NF_CONNTRACK_TIMESTAMP=y +CONFIG_NF_CONNTRACK_LABELS=y +CONFIG_NF_CT_PROTO_DCCP=y +CONFIG_NF_CT_PROTO_GRE=y +CONFIG_NF_CT_PROTO_SCTP=y +CONFIG_NF_CT_PROTO_UDPLITE=y +CONFIG_NF_CONNTRACK_AMANDA=y +CONFIG_NF_CONNTRACK_FTP=y +CONFIG_NF_CONNTRACK_H323=y +CONFIG_NF_CONNTRACK_IRC=y +CONFIG_NF_CONNTRACK_BROADCAST=y +CONFIG_NF_CONNTRACK_NETBIOS_NS=y +CONFIG_NF_CONNTRACK_SNMP=y +CONFIG_NF_CONNTRACK_PPTP=y +CONFIG_NF_CONNTRACK_SANE=y +CONFIG_NF_CONNTRACK_SIP=y +CONFIG_NF_CONNTRACK_TFTP=y +CONFIG_NF_CT_NETLINK=y +CONFIG_NF_CT_NETLINK_TIMEOUT=y +CONFIG_NF_CT_NETLINK_HELPER=y +CONFIG_NETFILTER_NETLINK_GLUE_CT=y +CONFIG_NF_NAT=y +CONFIG_NF_NAT_NEEDED=y +CONFIG_NF_NAT_PROTO_DCCP=y +CONFIG_NF_NAT_PROTO_UDPLITE=y +CONFIG_NF_NAT_PROTO_SCTP=y +CONFIG_NF_NAT_AMANDA=y +CONFIG_NF_NAT_FTP=y +CONFIG_NF_NAT_IRC=y +CONFIG_NF_NAT_SIP=y +CONFIG_NF_NAT_TFTP=y +CONFIG_NF_NAT_REDIRECT=y +CONFIG_NETFILTER_SYNPROXY=y +CONFIG_NF_TABLES=y +CONFIG_NF_TABLES_INET=y +CONFIG_NF_TABLES_NETDEV=y +CONFIG_NFT_EXTHDR=y +CONFIG_NFT_META=y +CONFIG_NFT_RT=y +CONFIG_NFT_NUMGEN=y +CONFIG_NFT_CT=y +CONFIG_NFT_FLOW_OFFLOAD=y +CONFIG_NFT_SET_RBTREE=y +CONFIG_NFT_SET_HASH=y +CONFIG_NFT_SET_BITMAP=y +CONFIG_NFT_COUNTER=y +CONFIG_NFT_LOG=y +CONFIG_NFT_LIMIT=y +CONFIG_NFT_MASQ=y +CONFIG_NFT_REDIR=y +CONFIG_NFT_NAT=y +CONFIG_NFT_OBJREF=y +CONFIG_NFT_QUEUE=y +CONFIG_NFT_QUOTA=y +CONFIG_NFT_REJECT=y +CONFIG_NFT_REJECT_INET=y +CONFIG_NFT_COMPAT=y +CONFIG_NFT_HASH=y +CONFIG_NFT_FIB=y +CONFIG_NFT_FIB_INET=y +CONFIG_NF_DUP_NETDEV=y +CONFIG_NFT_DUP_NETDEV=y +CONFIG_NFT_FWD_NETDEV=y +CONFIG_NFT_FIB_NETDEV=y +CONFIG_NF_FLOW_TABLE_INET=y +CONFIG_NF_FLOW_TABLE=y +CONFIG_NETFILTER_XTABLES=y + +# +# Xtables combined modules +# +CONFIG_NETFILTER_XT_MARK=y +CONFIG_NETFILTER_XT_CONNMARK=y +CONFIG_NETFILTER_XT_SET=y + +# +# Xtables targets +# +CONFIG_NETFILTER_XT_TARGET_AUDIT=y +CONFIG_NETFILTER_XT_TARGET_CHECKSUM=y +CONFIG_NETFILTER_XT_TARGET_CLASSIFY=y +CONFIG_NETFILTER_XT_TARGET_CONNMARK=y +CONFIG_NETFILTER_XT_TARGET_CONNSECMARK=y +CONFIG_NETFILTER_XT_TARGET_CT=y +CONFIG_NETFILTER_XT_TARGET_DSCP=y +CONFIG_NETFILTER_XT_TARGET_HL=y +CONFIG_NETFILTER_XT_TARGET_HMARK=y +CONFIG_NETFILTER_XT_TARGET_IDLETIMER=y +CONFIG_NETFILTER_XT_TARGET_LED=y +CONFIG_NETFILTER_XT_TARGET_LOG=y +CONFIG_NETFILTER_XT_TARGET_MARK=y +CONFIG_NETFILTER_XT_NAT=y +CONFIG_NETFILTER_XT_TARGET_NETMAP=y +CONFIG_NETFILTER_XT_TARGET_NFLOG=y +CONFIG_NETFILTER_XT_TARGET_NFQUEUE=y +CONFIG_NETFILTER_XT_TARGET_NOTRACK=y +CONFIG_NETFILTER_XT_TARGET_RATEEST=y +CONFIG_NETFILTER_XT_TARGET_REDIRECT=y +CONFIG_NETFILTER_XT_TARGET_TEE=y +CONFIG_NETFILTER_XT_TARGET_TPROXY=y +CONFIG_NETFILTER_XT_TARGET_TRACE=y +CONFIG_NETFILTER_XT_TARGET_SECMARK=y +CONFIG_NETFILTER_XT_TARGET_TCPMSS=y +CONFIG_NETFILTER_XT_TARGET_TCPOPTSTRIP=y + +# +# Xtables matches +# +CONFIG_NETFILTER_XT_MATCH_ADDRTYPE=y +CONFIG_NETFILTER_XT_MATCH_BPF=y +CONFIG_NETFILTER_XT_MATCH_CGROUP=y +CONFIG_NETFILTER_XT_MATCH_CLUSTER=y +CONFIG_NETFILTER_XT_MATCH_COMMENT=y +CONFIG_NETFILTER_XT_MATCH_CONNBYTES=y +CONFIG_NETFILTER_XT_MATCH_CONNLABEL=y +CONFIG_NETFILTER_XT_MATCH_CONNLIMIT=y +CONFIG_NETFILTER_XT_MATCH_CONNMARK=y +CONFIG_NETFILTER_XT_MATCH_CONNTRACK=y +CONFIG_NETFILTER_XT_MATCH_CPU=y +CONFIG_NETFILTER_XT_MATCH_DCCP=y +CONFIG_NETFILTER_XT_MATCH_DEVGROUP=y +CONFIG_NETFILTER_XT_MATCH_DSCP=y +CONFIG_NETFILTER_XT_MATCH_ECN=y +CONFIG_NETFILTER_XT_MATCH_ESP=y +CONFIG_NETFILTER_XT_MATCH_HASHLIMIT=y +CONFIG_NETFILTER_XT_MATCH_HELPER=y +CONFIG_NETFILTER_XT_MATCH_HL=y +CONFIG_NETFILTER_XT_MATCH_IPCOMP=y +CONFIG_NETFILTER_XT_MATCH_IPRANGE=y +CONFIG_NETFILTER_XT_MATCH_IPVS=y +CONFIG_NETFILTER_XT_MATCH_L2TP=y +CONFIG_NETFILTER_XT_MATCH_LENGTH=y +CONFIG_NETFILTER_XT_MATCH_LIMIT=y +CONFIG_NETFILTER_XT_MATCH_MAC=y +CONFIG_NETFILTER_XT_MATCH_MARK=y +CONFIG_NETFILTER_XT_MATCH_MULTIPORT=y +CONFIG_NETFILTER_XT_MATCH_NFACCT=y +CONFIG_NETFILTER_XT_MATCH_OSF=y +CONFIG_NETFILTER_XT_MATCH_OWNER=y +CONFIG_NETFILTER_XT_MATCH_POLICY=y +CONFIG_NETFILTER_XT_MATCH_PHYSDEV=y +CONFIG_NETFILTER_XT_MATCH_PKTTYPE=y +CONFIG_NETFILTER_XT_MATCH_QUOTA=y +CONFIG_NETFILTER_XT_MATCH_RATEEST=y +CONFIG_NETFILTER_XT_MATCH_REALM=y +CONFIG_NETFILTER_XT_MATCH_RECENT=y +CONFIG_NETFILTER_XT_MATCH_SCTP=y +CONFIG_NETFILTER_XT_MATCH_SOCKET=y +CONFIG_NETFILTER_XT_MATCH_STATE=y +CONFIG_NETFILTER_XT_MATCH_STATISTIC=y +CONFIG_NETFILTER_XT_MATCH_STRING=y +CONFIG_NETFILTER_XT_MATCH_TCPMSS=y +CONFIG_NETFILTER_XT_MATCH_TIME=y +CONFIG_NETFILTER_XT_MATCH_U32=y +CONFIG_IP_SET=y +CONFIG_IP_SET_MAX=256 +CONFIG_IP_SET_BITMAP_IP=y +CONFIG_IP_SET_BITMAP_IPMAC=y +CONFIG_IP_SET_BITMAP_PORT=y +CONFIG_IP_SET_HASH_IP=y +CONFIG_IP_SET_HASH_IPMARK=y +CONFIG_IP_SET_HASH_IPPORT=y +CONFIG_IP_SET_HASH_IPPORTIP=y +CONFIG_IP_SET_HASH_IPPORTNET=y +CONFIG_IP_SET_HASH_IPMAC=y +CONFIG_IP_SET_HASH_MAC=y +CONFIG_IP_SET_HASH_NETPORTNET=y +CONFIG_IP_SET_HASH_NET=y +CONFIG_IP_SET_HASH_NETNET=y +CONFIG_IP_SET_HASH_NETPORT=y +CONFIG_IP_SET_HASH_NETIFACE=y +CONFIG_IP_SET_LIST_SET=y +CONFIG_IP_VS=y +CONFIG_IP_VS_IPV6=y +CONFIG_IP_VS_DEBUG=y +CONFIG_IP_VS_TAB_BITS=12 + +# +# IPVS transport protocol load balancing support +# +CONFIG_IP_VS_PROTO_TCP=y +CONFIG_IP_VS_PROTO_UDP=y +CONFIG_IP_VS_PROTO_AH_ESP=y +CONFIG_IP_VS_PROTO_ESP=y +CONFIG_IP_VS_PROTO_AH=y +CONFIG_IP_VS_PROTO_SCTP=y + +# +# IPVS scheduler +# +CONFIG_IP_VS_RR=y +CONFIG_IP_VS_WRR=y +CONFIG_IP_VS_LC=y +CONFIG_IP_VS_WLC=y +CONFIG_IP_VS_FO=y +CONFIG_IP_VS_OVF=y +CONFIG_IP_VS_LBLC=y +CONFIG_IP_VS_LBLCR=y +CONFIG_IP_VS_DH=y +CONFIG_IP_VS_SH=y +CONFIG_IP_VS_SED=y +CONFIG_IP_VS_NQ=y + +# +# IPVS SH scheduler +# +CONFIG_IP_VS_SH_TAB_BITS=8 + +# +# IPVS application helper +# +CONFIG_IP_VS_FTP=y +CONFIG_IP_VS_NFCT=y +CONFIG_IP_VS_PE_SIP=y + +# +# IP: Netfilter Configuration +# +CONFIG_NF_DEFRAG_IPV4=y +CONFIG_NF_CONNTRACK_IPV4=y +CONFIG_NF_SOCKET_IPV4=y +CONFIG_NF_TABLES_IPV4=y +CONFIG_NFT_CHAIN_ROUTE_IPV4=y +CONFIG_NFT_REJECT_IPV4=y +CONFIG_NFT_DUP_IPV4=y +CONFIG_NFT_FIB_IPV4=y +CONFIG_NF_TABLES_ARP=y +CONFIG_NF_FLOW_TABLE_IPV4=y +CONFIG_NF_DUP_IPV4=y +CONFIG_NF_LOG_ARP=y +CONFIG_NF_LOG_IPV4=y +CONFIG_NF_REJECT_IPV4=y +CONFIG_NF_NAT_IPV4=y +CONFIG_NFT_CHAIN_NAT_IPV4=y +CONFIG_NF_NAT_MASQUERADE_IPV4=y +CONFIG_NFT_MASQ_IPV4=y +CONFIG_NFT_REDIR_IPV4=y +CONFIG_NF_NAT_SNMP_BASIC=y +CONFIG_NF_NAT_PROTO_GRE=y +CONFIG_NF_NAT_PPTP=y +CONFIG_NF_NAT_H323=y +CONFIG_IP_NF_IPTABLES=y +CONFIG_IP_NF_MATCH_AH=y +CONFIG_IP_NF_MATCH_ECN=y +CONFIG_IP_NF_MATCH_RPFILTER=y +CONFIG_IP_NF_MATCH_TTL=y +CONFIG_IP_NF_FILTER=y +CONFIG_IP_NF_TARGET_REJECT=y +CONFIG_IP_NF_TARGET_SYNPROXY=y +CONFIG_IP_NF_NAT=y +CONFIG_IP_NF_TARGET_MASQUERADE=y +CONFIG_IP_NF_TARGET_NETMAP=y +CONFIG_IP_NF_TARGET_REDIRECT=y +CONFIG_IP_NF_MANGLE=y +CONFIG_IP_NF_TARGET_CLUSTERIP=y +CONFIG_IP_NF_TARGET_ECN=y +CONFIG_IP_NF_TARGET_TTL=y +CONFIG_IP_NF_RAW=y +CONFIG_IP_NF_SECURITY=y +CONFIG_IP_NF_ARPTABLES=y +CONFIG_IP_NF_ARPFILTER=y +CONFIG_IP_NF_ARP_MANGLE=y + +# +# IPv6: Netfilter Configuration +# +CONFIG_NF_DEFRAG_IPV6=y +CONFIG_NF_CONNTRACK_IPV6=y +CONFIG_NF_SOCKET_IPV6=y +CONFIG_NF_TABLES_IPV6=y +CONFIG_NFT_CHAIN_ROUTE_IPV6=y +CONFIG_NFT_REJECT_IPV6=y +CONFIG_NFT_DUP_IPV6=y +CONFIG_NFT_FIB_IPV6=y +CONFIG_NF_FLOW_TABLE_IPV6=y +CONFIG_NF_DUP_IPV6=y +CONFIG_NF_REJECT_IPV6=y +CONFIG_NF_LOG_IPV6=y +CONFIG_NF_NAT_IPV6=y +CONFIG_NFT_CHAIN_NAT_IPV6=y +CONFIG_NF_NAT_MASQUERADE_IPV6=y +CONFIG_NFT_MASQ_IPV6=y +CONFIG_NFT_REDIR_IPV6=y +CONFIG_IP6_NF_IPTABLES=y +CONFIG_IP6_NF_MATCH_AH=y +CONFIG_IP6_NF_MATCH_EUI64=y +CONFIG_IP6_NF_MATCH_FRAG=y +CONFIG_IP6_NF_MATCH_OPTS=y +CONFIG_IP6_NF_MATCH_HL=y +CONFIG_IP6_NF_MATCH_IPV6HEADER=y +CONFIG_IP6_NF_MATCH_MH=y +CONFIG_IP6_NF_MATCH_RPFILTER=y +CONFIG_IP6_NF_MATCH_RT=y +CONFIG_IP6_NF_MATCH_SRH=y +CONFIG_IP6_NF_TARGET_HL=y +CONFIG_IP6_NF_FILTER=y +CONFIG_IP6_NF_TARGET_REJECT=y +CONFIG_IP6_NF_TARGET_SYNPROXY=y +CONFIG_IP6_NF_MANGLE=y +CONFIG_IP6_NF_RAW=y +CONFIG_IP6_NF_SECURITY=y +CONFIG_IP6_NF_NAT=y +CONFIG_IP6_NF_TARGET_MASQUERADE=y +CONFIG_IP6_NF_TARGET_NPT=y + +# +# DECnet: Netfilter Configuration +# +CONFIG_DECNET_NF_GRABULATOR=y +CONFIG_NF_TABLES_BRIDGE=y +CONFIG_NFT_BRIDGE_META=y +CONFIG_NFT_BRIDGE_REJECT=y +CONFIG_NF_LOG_BRIDGE=y +CONFIG_BRIDGE_NF_EBTABLES=y +CONFIG_BRIDGE_EBT_BROUTE=y +CONFIG_BRIDGE_EBT_T_FILTER=y +CONFIG_BRIDGE_EBT_T_NAT=y +CONFIG_BRIDGE_EBT_802_3=y +CONFIG_BRIDGE_EBT_AMONG=y +CONFIG_BRIDGE_EBT_ARP=y +CONFIG_BRIDGE_EBT_IP=y +CONFIG_BRIDGE_EBT_IP6=y +CONFIG_BRIDGE_EBT_LIMIT=y +CONFIG_BRIDGE_EBT_MARK=y +CONFIG_BRIDGE_EBT_PKTTYPE=y +CONFIG_BRIDGE_EBT_STP=y +CONFIG_BRIDGE_EBT_VLAN=y +CONFIG_BRIDGE_EBT_ARPREPLY=y +CONFIG_BRIDGE_EBT_DNAT=y +CONFIG_BRIDGE_EBT_MARK_T=y +CONFIG_BRIDGE_EBT_REDIRECT=y +CONFIG_BRIDGE_EBT_SNAT=y +CONFIG_BRIDGE_EBT_LOG=y +CONFIG_BRIDGE_EBT_NFLOG=y +CONFIG_IP_DCCP=y +CONFIG_INET_DCCP_DIAG=y + +# +# DCCP CCIDs Configuration +# +CONFIG_IP_DCCP_CCID2_DEBUG=y +CONFIG_IP_DCCP_CCID3=y +CONFIG_IP_DCCP_CCID3_DEBUG=y +CONFIG_IP_DCCP_TFRC_LIB=y +CONFIG_IP_DCCP_TFRC_DEBUG=y + +# +# DCCP Kernel Hacking +# +CONFIG_IP_DCCP_DEBUG=y +CONFIG_IP_SCTP=y +CONFIG_SCTP_DBG_OBJCNT=y +CONFIG_SCTP_DEFAULT_COOKIE_HMAC_MD5=y +# CONFIG_SCTP_DEFAULT_COOKIE_HMAC_SHA1 is not set +# CONFIG_SCTP_DEFAULT_COOKIE_HMAC_NONE is not set +CONFIG_SCTP_COOKIE_HMAC_MD5=y +CONFIG_SCTP_COOKIE_HMAC_SHA1=y +CONFIG_INET_SCTP_DIAG=y +CONFIG_RDS=y +CONFIG_RDS_RDMA=y +CONFIG_RDS_TCP=y +CONFIG_RDS_DEBUG=y +CONFIG_TIPC=y +CONFIG_TIPC_MEDIA_IB=y +CONFIG_TIPC_MEDIA_UDP=y +CONFIG_ATM=y +CONFIG_ATM_CLIP=y +CONFIG_ATM_CLIP_NO_ICMP=y +CONFIG_ATM_LANE=y +CONFIG_ATM_MPOA=y +CONFIG_ATM_BR2684=y +CONFIG_ATM_BR2684_IPFILTER=y +CONFIG_L2TP=y +CONFIG_L2TP_DEBUGFS=y +CONFIG_L2TP_V3=y +CONFIG_L2TP_IP=y +CONFIG_L2TP_ETH=y +CONFIG_STP=y +CONFIG_GARP=y +CONFIG_MRP=y +CONFIG_BRIDGE=y +CONFIG_BRIDGE_IGMP_SNOOPING=y +CONFIG_BRIDGE_VLAN_FILTERING=y +CONFIG_HAVE_NET_DSA=y +CONFIG_NET_DSA=y +CONFIG_NET_DSA_LEGACY=y +CONFIG_NET_DSA_TAG_BRCM=y +CONFIG_NET_DSA_TAG_BRCM_PREPEND=y +CONFIG_NET_DSA_TAG_DSA=y +CONFIG_NET_DSA_TAG_EDSA=y +CONFIG_NET_DSA_TAG_KSZ=y +CONFIG_NET_DSA_TAG_LAN9303=y +CONFIG_NET_DSA_TAG_MTK=y +CONFIG_NET_DSA_TAG_TRAILER=y +CONFIG_NET_DSA_TAG_QCA=y +CONFIG_VLAN_8021Q=y +CONFIG_VLAN_8021Q_GVRP=y +CONFIG_VLAN_8021Q_MVRP=y +CONFIG_DECNET=y +CONFIG_DECNET_ROUTER=y +CONFIG_LLC=y +CONFIG_LLC2=y +CONFIG_ATALK=y +CONFIG_DEV_APPLETALK=y +CONFIG_IPDDP=y +CONFIG_IPDDP_ENCAP=y +CONFIG_X25=y +CONFIG_LAPB=y +CONFIG_PHONET=y +CONFIG_6LOWPAN=y +CONFIG_6LOWPAN_DEBUGFS=y +CONFIG_6LOWPAN_NHC=y +CONFIG_6LOWPAN_NHC_DEST=y +CONFIG_6LOWPAN_NHC_FRAGMENT=y +CONFIG_6LOWPAN_NHC_HOP=y +CONFIG_6LOWPAN_NHC_IPV6=y +CONFIG_6LOWPAN_NHC_MOBILITY=y +CONFIG_6LOWPAN_NHC_ROUTING=y +CONFIG_6LOWPAN_NHC_UDP=y +CONFIG_6LOWPAN_GHC_EXT_HDR_HOP=y +CONFIG_6LOWPAN_GHC_UDP=y +CONFIG_6LOWPAN_GHC_ICMPV6=y +CONFIG_6LOWPAN_GHC_EXT_HDR_DEST=y +CONFIG_6LOWPAN_GHC_EXT_HDR_FRAG=y +CONFIG_6LOWPAN_GHC_EXT_HDR_ROUTE=y +CONFIG_IEEE802154=y +CONFIG_IEEE802154_NL802154_EXPERIMENTAL=y +CONFIG_IEEE802154_SOCKET=y +CONFIG_IEEE802154_6LOWPAN=y +CONFIG_MAC802154=y +CONFIG_NET_SCHED=y + +# +# Queueing/Scheduling +# +CONFIG_NET_SCH_CBQ=y +CONFIG_NET_SCH_HTB=y +CONFIG_NET_SCH_HFSC=y +CONFIG_NET_SCH_ATM=y +CONFIG_NET_SCH_PRIO=y +CONFIG_NET_SCH_MULTIQ=y +CONFIG_NET_SCH_RED=y +CONFIG_NET_SCH_SFB=y +CONFIG_NET_SCH_SFQ=y +CONFIG_NET_SCH_TEQL=y +CONFIG_NET_SCH_TBF=y +CONFIG_NET_SCH_CBS=y +CONFIG_NET_SCH_GRED=y +CONFIG_NET_SCH_DSMARK=y +CONFIG_NET_SCH_NETEM=y +CONFIG_NET_SCH_DRR=y +CONFIG_NET_SCH_MQPRIO=y +CONFIG_NET_SCH_CHOKE=y +CONFIG_NET_SCH_QFQ=y +CONFIG_NET_SCH_CODEL=y +CONFIG_NET_SCH_FQ_CODEL=y +CONFIG_NET_SCH_FQ=y +CONFIG_NET_SCH_HHF=y +CONFIG_NET_SCH_PIE=y +CONFIG_NET_SCH_INGRESS=y +CONFIG_NET_SCH_PLUG=y +CONFIG_NET_SCH_DEFAULT=y +# CONFIG_DEFAULT_FQ is not set +# CONFIG_DEFAULT_CODEL is not set +# CONFIG_DEFAULT_FQ_CODEL is not set +# CONFIG_DEFAULT_SFQ is not set +CONFIG_DEFAULT_PFIFO_FAST=y +CONFIG_DEFAULT_NET_SCH="pfifo_fast" + +# +# Classification +# +CONFIG_NET_CLS=y +CONFIG_NET_CLS_BASIC=y +CONFIG_NET_CLS_TCINDEX=y +CONFIG_NET_CLS_ROUTE4=y +CONFIG_NET_CLS_FW=y +CONFIG_NET_CLS_U32=y +CONFIG_CLS_U32_PERF=y +CONFIG_CLS_U32_MARK=y +CONFIG_NET_CLS_RSVP=y +CONFIG_NET_CLS_RSVP6=y +CONFIG_NET_CLS_FLOW=y +CONFIG_NET_CLS_CGROUP=y +CONFIG_NET_CLS_BPF=y +CONFIG_NET_CLS_FLOWER=y +CONFIG_NET_CLS_MATCHALL=y +CONFIG_NET_EMATCH=y +CONFIG_NET_EMATCH_STACK=32 +CONFIG_NET_EMATCH_CMP=y +CONFIG_NET_EMATCH_NBYTE=y +CONFIG_NET_EMATCH_U32=y +CONFIG_NET_EMATCH_META=y +CONFIG_NET_EMATCH_TEXT=y +CONFIG_NET_EMATCH_CANID=y +CONFIG_NET_EMATCH_IPSET=y +CONFIG_NET_CLS_ACT=y +CONFIG_NET_ACT_POLICE=y +CONFIG_NET_ACT_GACT=y +CONFIG_GACT_PROB=y +CONFIG_NET_ACT_MIRRED=y +CONFIG_NET_ACT_SAMPLE=y +CONFIG_NET_ACT_IPT=y +CONFIG_NET_ACT_NAT=y +CONFIG_NET_ACT_PEDIT=y +CONFIG_NET_ACT_SIMP=y +CONFIG_NET_ACT_SKBEDIT=y +CONFIG_NET_ACT_CSUM=y +CONFIG_NET_ACT_VLAN=y +CONFIG_NET_ACT_BPF=y +CONFIG_NET_ACT_CONNMARK=y +CONFIG_NET_ACT_SKBMOD=y +CONFIG_NET_ACT_IFE=y +CONFIG_NET_ACT_TUNNEL_KEY=y +CONFIG_NET_IFE_SKBMARK=y +CONFIG_NET_IFE_SKBPRIO=y +CONFIG_NET_IFE_SKBTCINDEX=y +CONFIG_NET_CLS_IND=y +CONFIG_NET_SCH_FIFO=y +CONFIG_DCB=y +CONFIG_DNS_RESOLVER=y +CONFIG_BATMAN_ADV=y +CONFIG_BATMAN_ADV_BATMAN_V=y +CONFIG_BATMAN_ADV_BLA=y +CONFIG_BATMAN_ADV_DAT=y +CONFIG_BATMAN_ADV_NC=y +CONFIG_BATMAN_ADV_MCAST=y +CONFIG_BATMAN_ADV_DEBUGFS=y +CONFIG_BATMAN_ADV_DEBUG=y +CONFIG_OPENVSWITCH=y +CONFIG_OPENVSWITCH_GRE=y +CONFIG_OPENVSWITCH_VXLAN=y +CONFIG_OPENVSWITCH_GENEVE=y +CONFIG_VSOCKETS=y +CONFIG_VSOCKETS_DIAG=y +CONFIG_VMWARE_VMCI_VSOCKETS=y +CONFIG_VIRTIO_VSOCKETS=y +CONFIG_VIRTIO_VSOCKETS_COMMON=y +CONFIG_HYPERV_VSOCKETS=y +CONFIG_NETLINK_DIAG=y +CONFIG_MPLS=y +CONFIG_NET_MPLS_GSO=y +CONFIG_MPLS_ROUTING=y +CONFIG_MPLS_IPTUNNEL=y +CONFIG_NET_NSH=y +CONFIG_HSR=y +CONFIG_NET_SWITCHDEV=y +CONFIG_NET_L3_MASTER_DEV=y +CONFIG_QRTR=y +CONFIG_QRTR_SMD=y +CONFIG_NET_NCSI=y +CONFIG_RPS=y +CONFIG_RFS_ACCEL=y +CONFIG_XPS=y +CONFIG_CGROUP_NET_PRIO=y +CONFIG_CGROUP_NET_CLASSID=y +CONFIG_NET_RX_BUSY_POLL=y +CONFIG_BQL=y +CONFIG_BPF_JIT=y +CONFIG_BPF_STREAM_PARSER=y +CONFIG_NET_FLOW_LIMIT=y + +# +# Network testing +# +CONFIG_NET_PKTGEN=y +CONFIG_NET_DROP_MONITOR=y +CONFIG_HAMRADIO=y + +# +# Packet Radio protocols +# +CONFIG_AX25=y +CONFIG_AX25_DAMA_SLAVE=y +CONFIG_NETROM=y +CONFIG_ROSE=y + +# +# AX.25 network device drivers +# +CONFIG_MKISS=y +CONFIG_6PACK=y +CONFIG_BPQETHER=y +CONFIG_BAYCOM_SER_FDX=y +CONFIG_BAYCOM_SER_HDX=y +CONFIG_BAYCOM_PAR=y +CONFIG_YAM=y +CONFIG_CAN=y +CONFIG_CAN_RAW=y +CONFIG_CAN_BCM=y +CONFIG_CAN_GW=y + +# +# CAN Device Drivers +# +CONFIG_CAN_VCAN=y +CONFIG_CAN_VXCAN=y +CONFIG_CAN_SLCAN=y +CONFIG_CAN_DEV=y +CONFIG_CAN_CALC_BITTIMING=y +CONFIG_CAN_LEDS=y +CONFIG_CAN_AT91=y +CONFIG_CAN_GRCAN=y +CONFIG_CAN_JANZ_ICAN3=y +CONFIG_CAN_SUN4I=y +CONFIG_CAN_XILINXCAN=y +CONFIG_PCH_CAN=y +CONFIG_CAN_C_CAN=y +CONFIG_CAN_C_CAN_PLATFORM=y +CONFIG_CAN_C_CAN_PCI=y +CONFIG_CAN_CC770=y +CONFIG_CAN_CC770_ISA=y +CONFIG_CAN_CC770_PLATFORM=y +CONFIG_CAN_IFI_CANFD=y +CONFIG_CAN_M_CAN=y +CONFIG_CAN_PEAK_PCIEFD=y +CONFIG_CAN_SJA1000=y +CONFIG_CAN_SJA1000_ISA=y +CONFIG_CAN_SJA1000_PLATFORM=y +CONFIG_CAN_EMS_PCMCIA=y +CONFIG_CAN_EMS_PCI=y +CONFIG_CAN_PEAK_PCMCIA=y +CONFIG_CAN_PEAK_PCI=y +CONFIG_CAN_PEAK_PCIEC=y +CONFIG_CAN_KVASER_PCI=y +CONFIG_CAN_PLX_PCI=y +CONFIG_CAN_SOFTING=y +CONFIG_CAN_SOFTING_CS=y + +# +# CAN SPI interfaces +# +CONFIG_CAN_HI311X=y +CONFIG_CAN_MCP251X=y + +# +# CAN USB interfaces +# +CONFIG_CAN_EMS_USB=y +CONFIG_CAN_ESD_USB2=y +CONFIG_CAN_GS_USB=y +CONFIG_CAN_KVASER_USB=y +CONFIG_CAN_PEAK_USB=y +CONFIG_CAN_8DEV_USB=y +CONFIG_CAN_MCBA_USB=y +CONFIG_CAN_DEBUG_DEVICES=y +CONFIG_BT=y +CONFIG_BT_BREDR=y +CONFIG_BT_RFCOMM=y +CONFIG_BT_RFCOMM_TTY=y +CONFIG_BT_BNEP=y +CONFIG_BT_BNEP_MC_FILTER=y +CONFIG_BT_BNEP_PROTO_FILTER=y +CONFIG_BT_CMTP=y +CONFIG_BT_HIDP=y +CONFIG_BT_HS=y +CONFIG_BT_LE=y +CONFIG_BT_6LOWPAN=y +CONFIG_BT_LEDS=y +CONFIG_BT_SELFTEST=y +CONFIG_BT_SELFTEST_ECDH=y +CONFIG_BT_SELFTEST_SMP=y +CONFIG_BT_DEBUGFS=y + +# +# Bluetooth device drivers +# +CONFIG_BT_INTEL=y +CONFIG_BT_BCM=y +CONFIG_BT_RTL=y +CONFIG_BT_QCA=y +CONFIG_BT_HCIBTUSB=y +CONFIG_BT_HCIBTUSB_AUTOSUSPEND=y +CONFIG_BT_HCIBTUSB_BCM=y +CONFIG_BT_HCIBTUSB_RTL=y +CONFIG_BT_HCIBTSDIO=y +CONFIG_BT_HCIUART=y +CONFIG_BT_HCIUART_SERDEV=y +CONFIG_BT_HCIUART_H4=y +CONFIG_BT_HCIUART_NOKIA=y +CONFIG_BT_HCIUART_BCSP=y +CONFIG_BT_HCIUART_ATH3K=y +CONFIG_BT_HCIUART_LL=y +CONFIG_BT_HCIUART_3WIRE=y +CONFIG_BT_HCIUART_INTEL=y +CONFIG_BT_HCIUART_BCM=y +CONFIG_BT_HCIUART_QCA=y +CONFIG_BT_HCIUART_AG6XX=y +CONFIG_BT_HCIUART_MRVL=y +CONFIG_BT_HCIBCM203X=y +CONFIG_BT_HCIBPA10X=y +CONFIG_BT_HCIBFUSB=y +CONFIG_BT_HCIDTL1=y +CONFIG_BT_HCIBT3C=y +CONFIG_BT_HCIBLUECARD=y +CONFIG_BT_HCIBTUART=y +CONFIG_BT_HCIVHCI=y +CONFIG_BT_MRVL=y +CONFIG_BT_MRVL_SDIO=y +CONFIG_BT_ATH3K=y +CONFIG_BT_WILINK=y +CONFIG_BT_QCOMSMD=y +CONFIG_AF_RXRPC=y +CONFIG_AF_RXRPC_IPV6=y +CONFIG_AF_RXRPC_INJECT_LOSS=y +CONFIG_AF_RXRPC_DEBUG=y +CONFIG_RXKAD=y +CONFIG_AF_KCM=y +CONFIG_STREAM_PARSER=y +CONFIG_FIB_RULES=y +CONFIG_WIRELESS=y +CONFIG_WIRELESS_EXT=y +CONFIG_WEXT_CORE=y +CONFIG_WEXT_PROC=y +CONFIG_WEXT_SPY=y +CONFIG_WEXT_PRIV=y +CONFIG_CFG80211=y +CONFIG_NL80211_TESTMODE=y +CONFIG_CFG80211_DEVELOPER_WARNINGS=y +CONFIG_CFG80211_CERTIFICATION_ONUS=y +CONFIG_CFG80211_REQUIRE_SIGNED_REGDB=y +CONFIG_CFG80211_USE_KERNEL_REGDB_KEYS=y +CONFIG_CFG80211_EXTRA_REGDB_KEYDIR="" +CONFIG_CFG80211_REG_CELLULAR_HINTS=y +CONFIG_CFG80211_REG_RELAX_NO_IR=y +CONFIG_CFG80211_DEFAULT_PS=y +CONFIG_CFG80211_DEBUGFS=y +CONFIG_CFG80211_CRDA_SUPPORT=y +CONFIG_CFG80211_WEXT=y +CONFIG_CFG80211_WEXT_EXPORT=y +CONFIG_LIB80211=y +CONFIG_LIB80211_CRYPT_WEP=y +CONFIG_LIB80211_CRYPT_CCMP=y +CONFIG_LIB80211_CRYPT_TKIP=y +CONFIG_LIB80211_DEBUG=y +CONFIG_MAC80211=y +CONFIG_MAC80211_HAS_RC=y +CONFIG_MAC80211_RC_MINSTREL=y +CONFIG_MAC80211_RC_MINSTREL_HT=y +CONFIG_MAC80211_RC_MINSTREL_VHT=y +CONFIG_MAC80211_RC_DEFAULT_MINSTREL=y +CONFIG_MAC80211_RC_DEFAULT="minstrel_ht" +CONFIG_MAC80211_MESH=y +CONFIG_MAC80211_LEDS=y +CONFIG_MAC80211_DEBUGFS=y +CONFIG_MAC80211_MESSAGE_TRACING=y +CONFIG_MAC80211_DEBUG_MENU=y +CONFIG_MAC80211_NOINLINE=y +CONFIG_MAC80211_VERBOSE_DEBUG=y +CONFIG_MAC80211_MLME_DEBUG=y +CONFIG_MAC80211_STA_DEBUG=y +CONFIG_MAC80211_HT_DEBUG=y +CONFIG_MAC80211_OCB_DEBUG=y +CONFIG_MAC80211_IBSS_DEBUG=y +CONFIG_MAC80211_PS_DEBUG=y +CONFIG_MAC80211_MPL_DEBUG=y +CONFIG_MAC80211_MPATH_DEBUG=y +CONFIG_MAC80211_MHWMP_DEBUG=y +CONFIG_MAC80211_MESH_SYNC_DEBUG=y +CONFIG_MAC80211_MESH_CSA_DEBUG=y +CONFIG_MAC80211_MESH_PS_DEBUG=y +CONFIG_MAC80211_TDLS_DEBUG=y +CONFIG_MAC80211_DEBUG_COUNTERS=y +CONFIG_MAC80211_STA_HASH_MAX_SIZE=0 +CONFIG_WIMAX=y +CONFIG_WIMAX_DEBUG_LEVEL=8 +CONFIG_RFKILL=y +CONFIG_RFKILL_LEDS=y +CONFIG_RFKILL_INPUT=y +CONFIG_RFKILL_GPIO=y +CONFIG_NET_9P=y +CONFIG_NET_9P_VIRTIO=y +CONFIG_NET_9P_XEN=y +CONFIG_NET_9P_RDMA=y +CONFIG_NET_9P_DEBUG=y +CONFIG_CAIF=y +CONFIG_CAIF_DEBUG=y +CONFIG_CAIF_NETDEV=y +CONFIG_CAIF_USB=y +CONFIG_CEPH_LIB=y +CONFIG_CEPH_LIB_PRETTYDEBUG=y +CONFIG_CEPH_LIB_USE_DNS_RESOLVER=y +CONFIG_NFC=y +CONFIG_NFC_DIGITAL=y +CONFIG_NFC_NCI=y +CONFIG_NFC_NCI_SPI=y +CONFIG_NFC_NCI_UART=y +CONFIG_NFC_HCI=y +CONFIG_NFC_SHDLC=y + +# +# Near Field Communication (NFC) devices +# +CONFIG_NFC_TRF7970A=y +CONFIG_NFC_MEI_PHY=y +CONFIG_NFC_SIM=y +CONFIG_NFC_PORT100=y +CONFIG_NFC_FDP=y +CONFIG_NFC_FDP_I2C=y +CONFIG_NFC_PN544=y +CONFIG_NFC_PN544_I2C=y +CONFIG_NFC_PN544_MEI=y +CONFIG_NFC_PN533=y +CONFIG_NFC_PN533_USB=y +CONFIG_NFC_PN533_I2C=y +CONFIG_NFC_MICROREAD=y +CONFIG_NFC_MICROREAD_I2C=y +CONFIG_NFC_MICROREAD_MEI=y +CONFIG_NFC_MRVL=y +CONFIG_NFC_MRVL_USB=y +CONFIG_NFC_MRVL_UART=y +CONFIG_NFC_MRVL_I2C=y +CONFIG_NFC_MRVL_SPI=y +CONFIG_NFC_ST21NFCA=y +CONFIG_NFC_ST21NFCA_I2C=y +CONFIG_NFC_ST_NCI=y +CONFIG_NFC_ST_NCI_I2C=y +CONFIG_NFC_ST_NCI_SPI=y +CONFIG_NFC_NXP_NCI=y +CONFIG_NFC_NXP_NCI_I2C=y +CONFIG_NFC_S3FWRN5=y +CONFIG_NFC_S3FWRN5_I2C=y +CONFIG_NFC_ST95HF=y +CONFIG_PSAMPLE=y +CONFIG_NET_IFE=y +CONFIG_LWTUNNEL=y +CONFIG_LWTUNNEL_BPF=y +CONFIG_DST_CACHE=y +CONFIG_GRO_CELLS=y +CONFIG_NET_DEVLINK=y +CONFIG_MAY_USE_DEVLINK=y +CONFIG_HAVE_EBPF_JIT=y + +# +# Device Drivers +# + +# +# Generic Driver Options +# +CONFIG_UEVENT_HELPER=y +CONFIG_UEVENT_HELPER_PATH="" +CONFIG_DEVTMPFS=y +CONFIG_DEVTMPFS_MOUNT=y +CONFIG_STANDALONE=y +CONFIG_PREVENT_FIRMWARE_BUILD=y +CONFIG_FW_LOADER=y +CONFIG_EXTRA_FIRMWARE="" +CONFIG_FW_LOADER_USER_HELPER=y +CONFIG_FW_LOADER_USER_HELPER_FALLBACK=y +CONFIG_WANT_DEV_COREDUMP=y +CONFIG_ALLOW_DEV_COREDUMP=y +CONFIG_DEV_COREDUMP=y +CONFIG_DEBUG_DRIVER=y +CONFIG_DEBUG_DEVRES=y +CONFIG_DEBUG_TEST_DRIVER_REMOVE=y +CONFIG_TEST_ASYNC_DRIVER_PROBE=m +CONFIG_SYS_HYPERVISOR=y +# CONFIG_GENERIC_CPU_DEVICES is not set +CONFIG_GENERIC_CPU_AUTOPROBE=y +CONFIG_GENERIC_CPU_VULNERABILITIES=y +CONFIG_SOC_BUS=y +CONFIG_REGMAP=y +CONFIG_REGMAP_AC97=y +CONFIG_REGMAP_I2C=y +CONFIG_REGMAP_SPI=y +CONFIG_REGMAP_SPMI=y +CONFIG_REGMAP_W1=y +CONFIG_REGMAP_MMIO=y +CONFIG_REGMAP_IRQ=y +CONFIG_REGMAP_SOUNDWIRE=y +CONFIG_DMA_SHARED_BUFFER=y +CONFIG_DMA_FENCE_TRACE=y +CONFIG_DMA_CMA=y + +# +# Default contiguous memory area size: +# +CONFIG_CMA_SIZE_MBYTES=0 +CONFIG_CMA_SIZE_SEL_MBYTES=y +# CONFIG_CMA_SIZE_SEL_PERCENTAGE is not set +# CONFIG_CMA_SIZE_SEL_MIN is not set +# CONFIG_CMA_SIZE_SEL_MAX is not set +CONFIG_CMA_ALIGNMENT=8 + +# +# Bus devices +# +CONFIG_QCOM_EBI2=y +CONFIG_SIMPLE_PM_BUS=y +CONFIG_CONNECTOR=y +CONFIG_PROC_EVENTS=y +CONFIG_MTD=y +CONFIG_MTD_TESTS=m +CONFIG_MTD_REDBOOT_PARTS=y +CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-1 +CONFIG_MTD_REDBOOT_PARTS_UNALLOCATED=y +CONFIG_MTD_REDBOOT_PARTS_READONLY=y +CONFIG_MTD_CMDLINE_PARTS=y +CONFIG_MTD_OF_PARTS=y +CONFIG_MTD_AR7_PARTS=y +CONFIG_MTD_BCM63XX_PARTS=y + +# +# Partition parsers +# +CONFIG_MTD_PARSER_TRX=y +CONFIG_MTD_SHARPSL_PARTS=y + +# +# User Modules And Translation Layers +# +CONFIG_MTD_BLKDEVS=y +CONFIG_MTD_BLOCK=y +CONFIG_FTL=y +CONFIG_NFTL=y +CONFIG_NFTL_RW=y +CONFIG_INFTL=y +CONFIG_RFD_FTL=y +CONFIG_SSFDC=y +CONFIG_SM_FTL=y +CONFIG_MTD_OOPS=y +CONFIG_MTD_SWAP=y +CONFIG_MTD_PARTITIONED_MASTER=y + +# +# RAM/ROM/Flash chip drivers +# +CONFIG_MTD_CFI=y +CONFIG_MTD_JEDECPROBE=y +CONFIG_MTD_GEN_PROBE=y +CONFIG_MTD_CFI_ADV_OPTIONS=y +CONFIG_MTD_CFI_NOSWAP=y +# CONFIG_MTD_CFI_BE_BYTE_SWAP is not set +# CONFIG_MTD_CFI_LE_BYTE_SWAP is not set +CONFIG_MTD_CFI_GEOMETRY=y +CONFIG_MTD_MAP_BANK_WIDTH_1=y +CONFIG_MTD_MAP_BANK_WIDTH_2=y +CONFIG_MTD_MAP_BANK_WIDTH_4=y +CONFIG_MTD_MAP_BANK_WIDTH_8=y +CONFIG_MTD_MAP_BANK_WIDTH_16=y +CONFIG_MTD_MAP_BANK_WIDTH_32=y +CONFIG_MTD_CFI_I1=y +CONFIG_MTD_CFI_I2=y +CONFIG_MTD_CFI_I4=y +CONFIG_MTD_CFI_I8=y +CONFIG_MTD_OTP=y +CONFIG_MTD_CFI_INTELEXT=y +CONFIG_MTD_CFI_AMDSTD=y +CONFIG_MTD_CFI_STAA=y +CONFIG_MTD_CFI_UTIL=y +CONFIG_MTD_RAM=y +CONFIG_MTD_ROM=y +CONFIG_MTD_ABSENT=y + +# +# Mapping drivers for chip access +# +CONFIG_MTD_COMPLEX_MAPPINGS=y +CONFIG_MTD_PHYSMAP=y +CONFIG_MTD_PHYSMAP_COMPAT=y +CONFIG_MTD_PHYSMAP_START=0x8000000 +CONFIG_MTD_PHYSMAP_LEN=0 +CONFIG_MTD_PHYSMAP_BANKWIDTH=2 +CONFIG_MTD_PHYSMAP_OF=y +CONFIG_MTD_PHYSMAP_OF_VERSATILE=y +CONFIG_MTD_PHYSMAP_OF_GEMINI=y +CONFIG_MTD_SC520CDP=y +CONFIG_MTD_NETSC520=y +CONFIG_MTD_TS5500=y +CONFIG_MTD_SBC_GXX=y +CONFIG_MTD_AMD76XROM=y +CONFIG_MTD_ICHXROM=y +CONFIG_MTD_ESB2ROM=y +CONFIG_MTD_CK804XROM=y +CONFIG_MTD_SCB2_FLASH=y +CONFIG_MTD_NETtel=y +CONFIG_MTD_L440GX=y +CONFIG_MTD_PCI=y +CONFIG_MTD_PCMCIA=y +CONFIG_MTD_PCMCIA_ANONYMOUS=y +CONFIG_MTD_GPIO_ADDR=y +CONFIG_MTD_INTEL_VR_NOR=y +CONFIG_MTD_PLATRAM=y +CONFIG_MTD_LATCH_ADDR=y + +# +# Self-contained MTD device drivers +# +CONFIG_MTD_PMC551=y +CONFIG_MTD_PMC551_BUGFIX=y +CONFIG_MTD_PMC551_DEBUG=y +CONFIG_MTD_DATAFLASH=y +CONFIG_MTD_DATAFLASH_WRITE_VERIFY=y +CONFIG_MTD_DATAFLASH_OTP=y +CONFIG_MTD_M25P80=y +CONFIG_MTD_MCHP23K256=y +CONFIG_MTD_SST25L=y +CONFIG_MTD_SLRAM=y +CONFIG_MTD_PHRAM=y +CONFIG_MTD_MTDRAM=y +CONFIG_MTDRAM_TOTAL_SIZE=4096 +CONFIG_MTDRAM_ERASE_SIZE=128 +CONFIG_MTD_BLOCK2MTD=y + +# +# Disk-On-Chip Device Drivers +# +CONFIG_MTD_DOCG3=y +CONFIG_BCH_CONST_M=14 +CONFIG_BCH_CONST_T=4 +CONFIG_MTD_NAND_ECC=y +CONFIG_MTD_NAND_ECC_SMC=y +CONFIG_MTD_NAND=y +CONFIG_MTD_NAND_BCH=y +CONFIG_MTD_NAND_ECC_BCH=y +CONFIG_MTD_SM_COMMON=y +CONFIG_MTD_NAND_DENALI=y +CONFIG_MTD_NAND_DENALI_PCI=y +CONFIG_MTD_NAND_DENALI_DT=y +CONFIG_MTD_NAND_GPIO=y +# CONFIG_MTD_NAND_OMAP_BCH_BUILD is not set +CONFIG_MTD_NAND_RICOH=y +CONFIG_MTD_NAND_TANGO=y +CONFIG_MTD_NAND_DISKONCHIP=y +CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADVANCED=y +CONFIG_MTD_NAND_DISKONCHIP_PROBE_ADDRESS=0 +CONFIG_MTD_NAND_DISKONCHIP_PROBE_HIGH=y +CONFIG_MTD_NAND_DISKONCHIP_BBTWRITE=y +CONFIG_MTD_NAND_DOCG4=y +CONFIG_MTD_NAND_CAFE=y +CONFIG_MTD_NAND_MARVELL=y +CONFIG_MTD_NAND_NANDSIM=y +CONFIG_MTD_NAND_GPMI_NAND=y +CONFIG_MTD_NAND_PLATFORM=y +CONFIG_MTD_NAND_OXNAS=y +CONFIG_MTD_NAND_VF610_NFC=y +CONFIG_MTD_NAND_SH_FLCTL=y +CONFIG_MTD_NAND_HISI504=y +CONFIG_MTD_NAND_MTK=y +CONFIG_MTD_ONENAND=y +CONFIG_MTD_ONENAND_VERIFY_WRITE=y +CONFIG_MTD_ONENAND_GENERIC=y +CONFIG_MTD_ONENAND_OTP=y +CONFIG_MTD_ONENAND_2X_PROGRAM=y + +# +# LPDDR & LPDDR2 PCM memory drivers +# +CONFIG_MTD_LPDDR=y +CONFIG_MTD_QINFO_PROBE=y +CONFIG_MTD_SPI_NOR=y +CONFIG_MTD_MT81xx_NOR=y +CONFIG_MTD_SPI_NOR_USE_4K_SECTORS=y +CONFIG_SPI_ASPEED_SMC=y +CONFIG_SPI_CADENCE_QUADSPI=y +CONFIG_SPI_FSL_QUADSPI=y +CONFIG_SPI_HISI_SFC=y +CONFIG_SPI_NXP_SPIFI=y +CONFIG_SPI_INTEL_SPI=y +CONFIG_SPI_INTEL_SPI_PCI=y +CONFIG_SPI_INTEL_SPI_PLATFORM=y +CONFIG_SPI_STM32_QUADSPI=y +CONFIG_MTD_UBI=y +CONFIG_MTD_UBI_WL_THRESHOLD=4096 +CONFIG_MTD_UBI_BEB_LIMIT=20 +CONFIG_MTD_UBI_FASTMAP=y +CONFIG_MTD_UBI_GLUEBI=y +CONFIG_MTD_UBI_BLOCK=y +CONFIG_DTC=y +CONFIG_OF=y +CONFIG_OF_UNITTEST=y +CONFIG_OF_ALL_DTBS=y +CONFIG_OF_FLATTREE=y +CONFIG_OF_EARLY_FLATTREE=y +CONFIG_OF_KOBJ=y +CONFIG_OF_DYNAMIC=y +CONFIG_OF_ADDRESS=y +CONFIG_OF_IRQ=y +CONFIG_OF_NET=y +CONFIG_OF_MDIO=y +CONFIG_OF_RESOLVE=y +CONFIG_OF_OVERLAY=y +CONFIG_ARCH_MIGHT_HAVE_PC_PARPORT=y +CONFIG_PARPORT=y +CONFIG_PARPORT_PC=y +CONFIG_PARPORT_SERIAL=y +CONFIG_PARPORT_PC_FIFO=y +CONFIG_PARPORT_PC_SUPERIO=y +CONFIG_PARPORT_PC_PCMCIA=y +# CONFIG_PARPORT_GSC is not set +CONFIG_PARPORT_AX88796=y +CONFIG_PARPORT_1284=y +CONFIG_PARPORT_NOT_PC=y +CONFIG_PNP=y +CONFIG_PNP_DEBUG_MESSAGES=y + +# +# Protocols +# +CONFIG_PNPACPI=y +CONFIG_BLK_DEV=y +CONFIG_BLK_DEV_NULL_BLK=y +CONFIG_BLK_DEV_NULL_BLK_FAULT_INJECTION=y +CONFIG_BLK_DEV_FD=y +CONFIG_CDROM=y +CONFIG_PARIDE=y + +# +# Parallel IDE high-level drivers +# +CONFIG_PARIDE_PD=y +CONFIG_PARIDE_PCD=y +CONFIG_PARIDE_PF=y +CONFIG_PARIDE_PT=y +CONFIG_PARIDE_PG=y + +# +# Parallel IDE protocol modules +# +CONFIG_PARIDE_ATEN=y +CONFIG_PARIDE_BPCK=y +CONFIG_PARIDE_COMM=y +CONFIG_PARIDE_DSTR=y +CONFIG_PARIDE_FIT2=y +CONFIG_PARIDE_FIT3=y +CONFIG_PARIDE_EPAT=y +CONFIG_PARIDE_EPATC8=y +CONFIG_PARIDE_EPIA=y +CONFIG_PARIDE_FRIQ=y +CONFIG_PARIDE_FRPW=y +CONFIG_PARIDE_KBIC=y +CONFIG_PARIDE_KTTI=y +CONFIG_PARIDE_ON20=y +CONFIG_PARIDE_ON26=y +CONFIG_BLK_DEV_PCIESSD_MTIP32XX=y +CONFIG_ZRAM=y +CONFIG_ZRAM_WRITEBACK=y +CONFIG_BLK_DEV_DAC960=y +CONFIG_BLK_DEV_UMEM=y +# CONFIG_BLK_DEV_COW_COMMON is not set +CONFIG_BLK_DEV_LOOP=y +CONFIG_BLK_DEV_LOOP_MIN_COUNT=8 +CONFIG_BLK_DEV_CRYPTOLOOP=y +CONFIG_BLK_DEV_DRBD=y +CONFIG_DRBD_FAULT_INJECTION=y +CONFIG_BLK_DEV_NBD=y +CONFIG_BLK_DEV_SKD=y +CONFIG_BLK_DEV_SX8=y +CONFIG_BLK_DEV_RAM=y +CONFIG_BLK_DEV_RAM_COUNT=16 +CONFIG_BLK_DEV_RAM_SIZE=4096 +CONFIG_CDROM_PKTCDVD=y +CONFIG_CDROM_PKTCDVD_BUFFERS=8 +CONFIG_CDROM_PKTCDVD_WCACHE=y +CONFIG_ATA_OVER_ETH=y +CONFIG_XEN_BLKDEV_FRONTEND=y +CONFIG_VIRTIO_BLK=y +CONFIG_VIRTIO_BLK_SCSI=y +CONFIG_BLK_DEV_RBD=y +CONFIG_BLK_DEV_RSXX=y + +# +# NVME Support +# +CONFIG_NVME_CORE=y +CONFIG_BLK_DEV_NVME=y +CONFIG_NVME_MULTIPATH=y +CONFIG_NVME_FABRICS=y +CONFIG_NVME_RDMA=y +CONFIG_NVME_FC=y +CONFIG_NVME_TARGET=y +CONFIG_NVME_TARGET_LOOP=y +CONFIG_NVME_TARGET_RDMA=y +CONFIG_NVME_TARGET_FC=y +CONFIG_NVME_TARGET_FCLOOP=y + +# +# Misc devices +# +CONFIG_SENSORS_LIS3LV02D=y +CONFIG_AD525X_DPOT=y +CONFIG_AD525X_DPOT_I2C=y +CONFIG_AD525X_DPOT_SPI=y +CONFIG_DUMMY_IRQ=y +CONFIG_IBM_ASM=y +CONFIG_PHANTOM=y +CONFIG_INTEL_MID_PTI=y +CONFIG_SGI_IOC4=y +CONFIG_TIFM_CORE=y +CONFIG_TIFM_7XX1=y +CONFIG_ICS932S401=y +CONFIG_ATMEL_SSC=y +CONFIG_ENCLOSURE_SERVICES=y +CONFIG_SGI_XP=y +CONFIG_CS5535_MFGPT=y +CONFIG_CS5535_MFGPT_DEFAULT_IRQ=7 +CONFIG_CS5535_CLOCK_EVENT_SRC=y +CONFIG_HP_ILO=y +CONFIG_QCOM_COINCELL=y +CONFIG_SGI_GRU=y +CONFIG_SGI_GRU_DEBUG=y +CONFIG_APDS9802ALS=y +CONFIG_ISL29003=y +CONFIG_ISL29020=y +CONFIG_SENSORS_TSL2550=y +CONFIG_SENSORS_BH1770=y +CONFIG_SENSORS_APDS990X=y +CONFIG_HMC6352=y +CONFIG_DS1682=y +CONFIG_VMWARE_BALLOON=y +CONFIG_PCH_PHUB=y +CONFIG_USB_SWITCH_FSA9480=y +CONFIG_LATTICE_ECP3_CONFIG=y +CONFIG_SRAM=y +CONFIG_ASPEED_LPC_CTRL=y +CONFIG_ASPEED_LPC_SNOOP=y +CONFIG_PCI_ENDPOINT_TEST=y +CONFIG_MISC_RTSX=y +CONFIG_C2PORT=y +CONFIG_C2PORT_DURAMAR_2150=y + +# +# EEPROM support +# +CONFIG_EEPROM_AT24=y +CONFIG_EEPROM_AT25=y +CONFIG_EEPROM_LEGACY=y +CONFIG_EEPROM_MAX6875=y +CONFIG_EEPROM_93CX6=y +CONFIG_EEPROM_93XX46=y +CONFIG_EEPROM_IDT_89HPESX=y +CONFIG_CB710_CORE=y +CONFIG_CB710_DEBUG=y +CONFIG_CB710_DEBUG_ASSUMPTIONS=y + +# +# Texas Instruments shared transport line discipline +# +CONFIG_TI_ST=y +CONFIG_SENSORS_LIS3_I2C=y +CONFIG_ALTERA_STAPL=y +CONFIG_INTEL_MEI=y +CONFIG_INTEL_MEI_ME=y +CONFIG_INTEL_MEI_TXE=y +CONFIG_VMWARE_VMCI=y + +# +# Intel MIC & related support +# + +# +# Intel MIC Bus Driver +# +CONFIG_INTEL_MIC_BUS=y + +# +# SCIF Bus Driver +# +CONFIG_SCIF_BUS=y + +# +# VOP Bus Driver +# +CONFIG_VOP_BUS=y + +# +# Intel MIC Host Driver +# +CONFIG_INTEL_MIC_HOST=y + +# +# Intel MIC Card Driver +# +CONFIG_INTEL_MIC_CARD=y + +# +# SCIF Driver +# +CONFIG_SCIF=y + +# +# Intel MIC Coprocessor State Management (COSM) Drivers +# +CONFIG_MIC_COSM=y + +# +# VOP Driver +# +CONFIG_VOP=y +CONFIG_VHOST_RING=y +CONFIG_GENWQE=y +CONFIG_GENWQE_PLATFORM_ERROR_RECOVERY=0 +CONFIG_ECHO=y +# CONFIG_CXL_BASE is not set +# CONFIG_CXL_AFU_DRIVER_OPS is not set +# CONFIG_CXL_LIB is not set +# CONFIG_OCXL_BASE is not set +CONFIG_MISC_RTSX_PCI=y +CONFIG_MISC_RTSX_USB=y +CONFIG_HAVE_IDE=y +CONFIG_IDE=y + +# +# Please see Documentation/ide/ide.txt for help/info on IDE drives +# +CONFIG_IDE_XFER_MODE=y +CONFIG_IDE_TIMINGS=y +CONFIG_IDE_ATAPI=y +CONFIG_BLK_DEV_IDE_SATA=y +CONFIG_IDE_GD=y +CONFIG_IDE_GD_ATA=y +CONFIG_IDE_GD_ATAPI=y +CONFIG_BLK_DEV_IDECS=y +CONFIG_BLK_DEV_DELKIN=y +CONFIG_BLK_DEV_IDECD=y +CONFIG_BLK_DEV_IDECD_VERBOSE_ERRORS=y +CONFIG_BLK_DEV_IDETAPE=y +CONFIG_BLK_DEV_IDEACPI=y +CONFIG_IDE_TASK_IOCTL=y +CONFIG_IDE_PROC_FS=y + +# +# IDE chipset support/bugfixes +# +CONFIG_IDE_GENERIC=y +CONFIG_BLK_DEV_PLATFORM=y +CONFIG_BLK_DEV_CMD640=y +CONFIG_BLK_DEV_CMD640_ENHANCED=y +CONFIG_BLK_DEV_IDEPNP=y +CONFIG_BLK_DEV_IDEDMA_SFF=y + +# +# PCI IDE chipsets support +# +CONFIG_BLK_DEV_IDEPCI=y +CONFIG_IDEPCI_PCIBUS_ORDER=y +CONFIG_BLK_DEV_OFFBOARD=y +CONFIG_BLK_DEV_GENERIC=y +CONFIG_BLK_DEV_OPTI621=y +CONFIG_BLK_DEV_RZ1000=y +CONFIG_BLK_DEV_IDEDMA_PCI=y +CONFIG_BLK_DEV_AEC62XX=y +CONFIG_BLK_DEV_ALI15X3=y +CONFIG_BLK_DEV_AMD74XX=y +CONFIG_BLK_DEV_ATIIXP=y +CONFIG_BLK_DEV_CMD64X=y +CONFIG_BLK_DEV_TRIFLEX=y +CONFIG_BLK_DEV_CS5520=y +CONFIG_BLK_DEV_CS5530=y +CONFIG_BLK_DEV_HPT366=y +CONFIG_BLK_DEV_JMICRON=y +CONFIG_BLK_DEV_SC1200=y +CONFIG_BLK_DEV_PIIX=y +CONFIG_BLK_DEV_IT8172=y +CONFIG_BLK_DEV_IT8213=y +CONFIG_BLK_DEV_IT821X=y +CONFIG_BLK_DEV_NS87415=y +CONFIG_BLK_DEV_PDC202XX_OLD=y +CONFIG_BLK_DEV_PDC202XX_NEW=y +CONFIG_BLK_DEV_SVWKS=y +CONFIG_BLK_DEV_SIIMAGE=y +CONFIG_BLK_DEV_SIS5513=y +CONFIG_BLK_DEV_SLC90E66=y +CONFIG_BLK_DEV_TRM290=y +CONFIG_BLK_DEV_VIA82CXXX=y +CONFIG_BLK_DEV_TC86C001=y +CONFIG_BLK_DEV_IDEDMA=y + +# +# SCSI device support +# +CONFIG_SCSI_MOD=y +CONFIG_RAID_ATTRS=y +CONFIG_SCSI=y +CONFIG_SCSI_DMA=y +CONFIG_SCSI_NETLINK=y +CONFIG_SCSI_MQ_DEFAULT=y +CONFIG_SCSI_PROC_FS=y + +# +# SCSI support type (disk, tape, CD-ROM) +# +CONFIG_BLK_DEV_SD=y +CONFIG_CHR_DEV_ST=y +CONFIG_CHR_DEV_OSST=y +CONFIG_BLK_DEV_SR=y +CONFIG_BLK_DEV_SR_VENDOR=y +CONFIG_CHR_DEV_SG=y +CONFIG_CHR_DEV_SCH=y +CONFIG_SCSI_ENCLOSURE=y +CONFIG_SCSI_CONSTANTS=y +CONFIG_SCSI_LOGGING=y +CONFIG_SCSI_SCAN_ASYNC=y + +# +# SCSI Transports +# +CONFIG_SCSI_SPI_ATTRS=y +CONFIG_SCSI_FC_ATTRS=y +CONFIG_SCSI_ISCSI_ATTRS=y +CONFIG_SCSI_SAS_ATTRS=y +CONFIG_SCSI_SAS_LIBSAS=y +CONFIG_SCSI_SAS_ATA=y +CONFIG_SCSI_SAS_HOST_SMP=y +CONFIG_SCSI_SRP_ATTRS=y +CONFIG_SCSI_LOWLEVEL=y +CONFIG_ISCSI_TCP=y +CONFIG_ISCSI_BOOT_SYSFS=y +CONFIG_SCSI_CXGB3_ISCSI=y +CONFIG_SCSI_CXGB4_ISCSI=y +CONFIG_SCSI_BNX2_ISCSI=y +CONFIG_SCSI_BNX2X_FCOE=y +CONFIG_BE2ISCSI=y +CONFIG_BLK_DEV_3W_XXXX_RAID=y +CONFIG_SCSI_HPSA=y +CONFIG_SCSI_3W_9XXX=y +CONFIG_SCSI_3W_SAS=y +CONFIG_SCSI_ACARD=y +CONFIG_SCSI_AACRAID=y +CONFIG_SCSI_AIC7XXX=y +CONFIG_AIC7XXX_CMDS_PER_DEVICE=32 +CONFIG_AIC7XXX_RESET_DELAY_MS=5000 +CONFIG_AIC7XXX_DEBUG_ENABLE=y +CONFIG_AIC7XXX_DEBUG_MASK=0 +CONFIG_AIC7XXX_REG_PRETTY_PRINT=y +CONFIG_SCSI_AIC79XX=y +CONFIG_AIC79XX_CMDS_PER_DEVICE=32 +CONFIG_AIC79XX_RESET_DELAY_MS=5000 +CONFIG_AIC79XX_DEBUG_ENABLE=y +CONFIG_AIC79XX_DEBUG_MASK=0 +CONFIG_AIC79XX_REG_PRETTY_PRINT=y +CONFIG_SCSI_AIC94XX=y +CONFIG_AIC94XX_DEBUG=y +CONFIG_SCSI_HISI_SAS=y +CONFIG_SCSI_HISI_SAS_PCI=y +CONFIG_SCSI_MVSAS=y +CONFIG_SCSI_MVSAS_DEBUG=y +CONFIG_SCSI_MVSAS_TASKLET=y +CONFIG_SCSI_MVUMI=y +CONFIG_SCSI_DPT_I2O=y +CONFIG_SCSI_ADVANSYS=y +CONFIG_SCSI_ARCMSR=y +CONFIG_SCSI_ESAS2R=y +CONFIG_MEGARAID_NEWGEN=y +CONFIG_MEGARAID_MM=y +CONFIG_MEGARAID_MAILBOX=y +CONFIG_MEGARAID_LEGACY=y +CONFIG_MEGARAID_SAS=y +CONFIG_SCSI_MPT3SAS=y +CONFIG_SCSI_MPT2SAS_MAX_SGE=128 +CONFIG_SCSI_MPT3SAS_MAX_SGE=128 +CONFIG_SCSI_MPT2SAS=y +CONFIG_SCSI_SMARTPQI=y +CONFIG_SCSI_UFSHCD=y +CONFIG_SCSI_UFSHCD_PCI=y +CONFIG_SCSI_UFS_DWC_TC_PCI=y +CONFIG_SCSI_UFSHCD_PLATFORM=y +CONFIG_SCSI_UFS_DWC_TC_PLATFORM=y +CONFIG_SCSI_HPTIOP=y +CONFIG_SCSI_BUSLOGIC=y +CONFIG_SCSI_FLASHPOINT=y +CONFIG_VMWARE_PVSCSI=y +CONFIG_XEN_SCSI_FRONTEND=y +CONFIG_HYPERV_STORAGE=y +CONFIG_LIBFC=y +CONFIG_LIBFCOE=y +CONFIG_FCOE=y +CONFIG_FCOE_FNIC=y +CONFIG_SCSI_SNIC=y +CONFIG_SCSI_SNIC_DEBUG_FS=y +CONFIG_SCSI_DMX3191D=y +CONFIG_SCSI_EATA=y +CONFIG_SCSI_EATA_TAGGED_QUEUE=y +CONFIG_SCSI_EATA_LINKED_COMMANDS=y +CONFIG_SCSI_EATA_MAX_TAGS=16 +CONFIG_SCSI_FUTURE_DOMAIN=y +CONFIG_SCSI_GDTH=y +CONFIG_SCSI_ISCI=y +CONFIG_SCSI_IPS=y +CONFIG_SCSI_INITIO=y +CONFIG_SCSI_INIA100=y +CONFIG_SCSI_PPA=y +CONFIG_SCSI_IMM=y +CONFIG_SCSI_IZIP_EPP16=y +CONFIG_SCSI_IZIP_SLOW_CTR=y +CONFIG_SCSI_STEX=y +CONFIG_SCSI_SYM53C8XX_2=y +CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=1 +CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16 +CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64 +CONFIG_SCSI_SYM53C8XX_MMIO=y +CONFIG_SCSI_IPR=y +CONFIG_SCSI_IPR_TRACE=y +CONFIG_SCSI_IPR_DUMP=y +CONFIG_SCSI_QLOGIC_1280=y +CONFIG_SCSI_QLA_FC=y +CONFIG_TCM_QLA2XXX=y +CONFIG_TCM_QLA2XXX_DEBUG=y +CONFIG_SCSI_QLA_ISCSI=y +CONFIG_QEDI=y +CONFIG_QEDF=y +CONFIG_SCSI_LPFC=y +CONFIG_SCSI_LPFC_DEBUG_FS=y +CONFIG_SCSI_DC395x=y +CONFIG_SCSI_AM53C974=y +CONFIG_SCSI_WD719X=y +CONFIG_SCSI_DEBUG=y +CONFIG_SCSI_PMCRAID=y +CONFIG_SCSI_PM8001=y +CONFIG_SCSI_BFA_FC=y +CONFIG_SCSI_VIRTIO=y +CONFIG_SCSI_CHELSIO_FCOE=y +CONFIG_SCSI_LOWLEVEL_PCMCIA=y +CONFIG_PCMCIA_AHA152X=m +CONFIG_PCMCIA_FDOMAIN=m +CONFIG_PCMCIA_QLOGIC=m +CONFIG_PCMCIA_SYM53C500=m +CONFIG_SCSI_DH=y +CONFIG_SCSI_DH_RDAC=y +CONFIG_SCSI_DH_HP_SW=y +CONFIG_SCSI_DH_EMC=y +CONFIG_SCSI_DH_ALUA=y +CONFIG_SCSI_OSD_INITIATOR=y +CONFIG_SCSI_OSD_ULD=y +CONFIG_SCSI_OSD_DPRINT_SENSE=1 +CONFIG_SCSI_OSD_DEBUG=y +CONFIG_ATA=y +# CONFIG_ATA_NONSTANDARD is not set +CONFIG_ATA_VERBOSE_ERROR=y +CONFIG_ATA_ACPI=y +CONFIG_SATA_ZPODD=y +CONFIG_SATA_PMP=y + +# +# Controllers with non-SFF native interface +# +CONFIG_SATA_AHCI=y +CONFIG_SATA_MOBILE_LPM_POLICY=0 +CONFIG_SATA_AHCI_PLATFORM=y +CONFIG_AHCI_IMX=y +CONFIG_AHCI_CEVA=y +CONFIG_AHCI_XGENE=y +CONFIG_AHCI_QORIQ=y +CONFIG_SATA_GEMINI=y +CONFIG_SATA_INIC162X=y +CONFIG_SATA_ACARD_AHCI=y +CONFIG_SATA_SIL24=y +CONFIG_ATA_SFF=y + +# +# SFF controllers with custom DMA interface +# +CONFIG_PDC_ADMA=y +CONFIG_SATA_QSTOR=y +CONFIG_SATA_SX4=y +CONFIG_ATA_BMDMA=y + +# +# SATA SFF controllers with BMDMA +# +CONFIG_ATA_PIIX=y +CONFIG_SATA_DWC=y +CONFIG_SATA_DWC_OLD_DMA=y +CONFIG_SATA_DWC_DEBUG=y +CONFIG_SATA_DWC_VDEBUG=y +CONFIG_SATA_HIGHBANK=y +CONFIG_SATA_MV=y +CONFIG_SATA_NV=y +CONFIG_SATA_PROMISE=y +CONFIG_SATA_RCAR=y +CONFIG_SATA_SIL=y +CONFIG_SATA_SIS=y +CONFIG_SATA_SVW=y +CONFIG_SATA_ULI=y +CONFIG_SATA_VIA=y +CONFIG_SATA_VITESSE=y + +# +# PATA SFF controllers with BMDMA +# +CONFIG_PATA_ALI=y +CONFIG_PATA_AMD=y +CONFIG_PATA_ARASAN_CF=y +CONFIG_PATA_ARTOP=y +CONFIG_PATA_ATIIXP=y +CONFIG_PATA_ATP867X=y +CONFIG_PATA_CMD64X=y +CONFIG_PATA_CS5520=y +CONFIG_PATA_CS5530=y +CONFIG_PATA_CS5536=y +CONFIG_PATA_CYPRESS=y +CONFIG_PATA_EFAR=y +CONFIG_PATA_HPT366=y +CONFIG_PATA_HPT37X=y +CONFIG_PATA_HPT3X2N=y +CONFIG_PATA_HPT3X3=y +CONFIG_PATA_HPT3X3_DMA=y +CONFIG_PATA_IT8213=y +CONFIG_PATA_IT821X=y +CONFIG_PATA_JMICRON=y +CONFIG_PATA_MARVELL=y +CONFIG_PATA_NETCELL=y +CONFIG_PATA_NINJA32=y +CONFIG_PATA_NS87415=y +CONFIG_PATA_OLDPIIX=y +CONFIG_PATA_OPTIDMA=y +CONFIG_PATA_PDC2027X=y +CONFIG_PATA_PDC_OLD=y +CONFIG_PATA_RADISYS=y +CONFIG_PATA_RDC=y +CONFIG_PATA_SC1200=y +CONFIG_PATA_SCH=y +CONFIG_PATA_SERVERWORKS=y +CONFIG_PATA_SIL680=y +CONFIG_PATA_SIS=y +CONFIG_PATA_TOSHIBA=y +CONFIG_PATA_TRIFLEX=y +CONFIG_PATA_VIA=y +CONFIG_PATA_WINBOND=y + +# +# PIO-only SFF controllers +# +CONFIG_PATA_CMD640_PCI=y +CONFIG_PATA_MPIIX=y +CONFIG_PATA_NS87410=y +CONFIG_PATA_OPTI=y +CONFIG_PATA_PCMCIA=y +CONFIG_PATA_PLATFORM=y +CONFIG_PATA_OF_PLATFORM=y +CONFIG_PATA_RZ1000=y + +# +# Generic fallback / legacy drivers +# +CONFIG_PATA_ACPI=y +CONFIG_ATA_GENERIC=y +CONFIG_PATA_LEGACY=y +CONFIG_MD=y +CONFIG_BLK_DEV_MD=y +CONFIG_MD_AUTODETECT=y +CONFIG_MD_LINEAR=y +CONFIG_MD_RAID0=y +CONFIG_MD_RAID1=y +CONFIG_MD_RAID10=y +CONFIG_MD_RAID456=y +CONFIG_MD_MULTIPATH=y +CONFIG_MD_FAULTY=y +CONFIG_MD_CLUSTER=y +CONFIG_BCACHE=y +CONFIG_BCACHE_DEBUG=y +CONFIG_BCACHE_CLOSURES_DEBUG=y +CONFIG_BLK_DEV_DM_BUILTIN=y +CONFIG_BLK_DEV_DM=y +CONFIG_DM_MQ_DEFAULT=y +CONFIG_DM_DEBUG=y +CONFIG_DM_BUFIO=y +CONFIG_DM_DEBUG_BLOCK_MANAGER_LOCKING=y +CONFIG_DM_DEBUG_BLOCK_STACK_TRACING=y +CONFIG_DM_BIO_PRISON=y +CONFIG_DM_PERSISTENT_DATA=y +CONFIG_DM_UNSTRIPED=y +CONFIG_DM_CRYPT=y +CONFIG_DM_SNAPSHOT=y +CONFIG_DM_THIN_PROVISIONING=y +CONFIG_DM_CACHE=y +CONFIG_DM_CACHE_SMQ=y +CONFIG_DM_ERA=y +CONFIG_DM_MIRROR=y +CONFIG_DM_LOG_USERSPACE=y +CONFIG_DM_RAID=y +CONFIG_DM_ZERO=y +CONFIG_DM_MULTIPATH=y +CONFIG_DM_MULTIPATH_QL=y +CONFIG_DM_MULTIPATH_ST=y +CONFIG_DM_DELAY=y +CONFIG_DM_UEVENT=y +CONFIG_DM_FLAKEY=y +CONFIG_DM_VERITY=y +CONFIG_DM_VERITY_FEC=y +CONFIG_DM_SWITCH=y +CONFIG_DM_LOG_WRITES=y +CONFIG_DM_INTEGRITY=y +CONFIG_DM_ZONED=y +CONFIG_TARGET_CORE=y +CONFIG_TCM_IBLOCK=y +CONFIG_TCM_FILEIO=y +CONFIG_TCM_PSCSI=y +CONFIG_TCM_USER2=y +CONFIG_LOOPBACK_TARGET=y +CONFIG_TCM_FC=y +CONFIG_ISCSI_TARGET=y +CONFIG_ISCSI_TARGET_CXGB4=y +CONFIG_SBP_TARGET=y +CONFIG_FUSION=y +CONFIG_FUSION_SPI=y +CONFIG_FUSION_FC=y +CONFIG_FUSION_SAS=y +CONFIG_FUSION_MAX_SGE=128 +CONFIG_FUSION_CTL=y +CONFIG_FUSION_LAN=y +CONFIG_FUSION_LOGGING=y + +# +# IEEE 1394 (FireWire) support +# +CONFIG_FIREWIRE=y +CONFIG_FIREWIRE_OHCI=y +CONFIG_FIREWIRE_SBP2=y +CONFIG_FIREWIRE_NET=y +CONFIG_FIREWIRE_NOSY=y +CONFIG_MACINTOSH_DRIVERS=y +CONFIG_MAC_EMUMOUSEBTN=y +CONFIG_NETDEVICES=y +CONFIG_MII=y +CONFIG_NET_CORE=y +CONFIG_BONDING=y +CONFIG_DUMMY=y +CONFIG_EQUALIZER=y +CONFIG_NET_FC=y +CONFIG_IFB=y +CONFIG_NET_TEAM=y +CONFIG_NET_TEAM_MODE_BROADCAST=y +CONFIG_NET_TEAM_MODE_ROUNDROBIN=y +CONFIG_NET_TEAM_MODE_RANDOM=y +CONFIG_NET_TEAM_MODE_ACTIVEBACKUP=y +CONFIG_NET_TEAM_MODE_LOADBALANCE=y +CONFIG_MACVLAN=y +CONFIG_MACVTAP=y +CONFIG_IPVLAN=y +CONFIG_IPVTAP=y +CONFIG_VXLAN=y +CONFIG_GENEVE=y +CONFIG_GTP=y +CONFIG_MACSEC=y +CONFIG_NETCONSOLE=y +CONFIG_NETCONSOLE_DYNAMIC=y +CONFIG_NETPOLL=y +CONFIG_NET_POLL_CONTROLLER=y +CONFIG_NTB_NETDEV=y +CONFIG_RIONET=y +CONFIG_RIONET_TX_SIZE=128 +CONFIG_RIONET_RX_SIZE=128 +CONFIG_TUN=y +CONFIG_TAP=y +CONFIG_TUN_VNET_CROSS_LE=y +CONFIG_VETH=y +CONFIG_VIRTIO_NET=y +CONFIG_NLMON=y +CONFIG_NET_VRF=y +CONFIG_VSOCKMON=y +CONFIG_SUNGEM_PHY=y +CONFIG_ARCNET=y +CONFIG_ARCNET_1201=y +CONFIG_ARCNET_1051=y +CONFIG_ARCNET_RAW=y +CONFIG_ARCNET_CAP=y +CONFIG_ARCNET_COM90xx=y +CONFIG_ARCNET_COM90xxIO=y +CONFIG_ARCNET_RIM_I=y +CONFIG_ARCNET_COM20020=y +CONFIG_ARCNET_COM20020_PCI=y +CONFIG_ARCNET_COM20020_CS=y +CONFIG_ATM_DRIVERS=y +CONFIG_ATM_DUMMY=y +CONFIG_ATM_TCP=y +CONFIG_ATM_LANAI=y +CONFIG_ATM_ENI=y +CONFIG_ATM_ENI_DEBUG=y +CONFIG_ATM_ENI_TUNE_BURST=y +CONFIG_ATM_ENI_BURST_TX_16W=y +CONFIG_ATM_ENI_BURST_TX_8W=y +CONFIG_ATM_ENI_BURST_TX_4W=y +CONFIG_ATM_ENI_BURST_TX_2W=y +CONFIG_ATM_ENI_BURST_RX_16W=y +CONFIG_ATM_ENI_BURST_RX_8W=y +CONFIG_ATM_ENI_BURST_RX_4W=y +CONFIG_ATM_ENI_BURST_RX_2W=y +CONFIG_ATM_FIRESTREAM=y +CONFIG_ATM_ZATM=y +CONFIG_ATM_ZATM_DEBUG=y +CONFIG_ATM_NICSTAR=y +CONFIG_ATM_NICSTAR_USE_SUNI=y +CONFIG_ATM_NICSTAR_USE_IDT77105=y +CONFIG_ATM_IDT77252=y +CONFIG_ATM_IDT77252_DEBUG=y +CONFIG_ATM_IDT77252_RCV_ALL=y +CONFIG_ATM_IDT77252_USE_SUNI=y +CONFIG_ATM_AMBASSADOR=y +CONFIG_ATM_AMBASSADOR_DEBUG=y +CONFIG_ATM_HORIZON=y +CONFIG_ATM_HORIZON_DEBUG=y +CONFIG_ATM_IA=y +CONFIG_ATM_IA_DEBUG=y +CONFIG_ATM_FORE200E=y +CONFIG_ATM_FORE200E_USE_TASKLET=y +CONFIG_ATM_FORE200E_TX_RETRY=16 +CONFIG_ATM_FORE200E_DEBUG=0 +CONFIG_ATM_HE=y +CONFIG_ATM_HE_USE_SUNI=y +CONFIG_ATM_SOLOS=y + +# +# CAIF transport drivers +# +CONFIG_CAIF_TTY=y +CONFIG_CAIF_SPI_SLAVE=y +CONFIG_CAIF_SPI_SYNC=y +CONFIG_CAIF_HSI=y +CONFIG_CAIF_VIRTIO=y + +# +# Distributed Switch Architecture drivers +# +CONFIG_B53=y +CONFIG_B53_SPI_DRIVER=y +CONFIG_B53_MDIO_DRIVER=y +CONFIG_B53_MMAP_DRIVER=y +CONFIG_B53_SRAB_DRIVER=y +CONFIG_NET_DSA_BCM_SF2=y +CONFIG_NET_DSA_LOOP=y +CONFIG_NET_DSA_MT7530=y +CONFIG_NET_DSA_MV88E6060=y +CONFIG_MICROCHIP_KSZ=y +CONFIG_MICROCHIP_KSZ_SPI_DRIVER=y +CONFIG_NET_DSA_MV88E6XXX=y +CONFIG_NET_DSA_MV88E6XXX_GLOBAL2=y +CONFIG_NET_DSA_QCA8K=y +CONFIG_NET_DSA_SMSC_LAN9303=y +CONFIG_NET_DSA_SMSC_LAN9303_I2C=y +CONFIG_NET_DSA_SMSC_LAN9303_MDIO=y +CONFIG_ETHERNET=y +CONFIG_MDIO=y +CONFIG_NET_VENDOR_3COM=y +CONFIG_PCMCIA_3C574=y +CONFIG_PCMCIA_3C589=y +CONFIG_VORTEX=y +CONFIG_TYPHOON=y +CONFIG_NET_VENDOR_ADAPTEC=y +CONFIG_ADAPTEC_STARFIRE=y +CONFIG_NET_VENDOR_AGERE=y +CONFIG_ET131X=y +CONFIG_NET_VENDOR_ALACRITECH=y +CONFIG_SLICOSS=y +CONFIG_NET_VENDOR_ALTEON=y +CONFIG_ACENIC=y +CONFIG_ACENIC_OMIT_TIGON_I=y +CONFIG_ALTERA_TSE=y +CONFIG_NET_VENDOR_AMAZON=y +CONFIG_ENA_ETHERNET=y +CONFIG_NET_VENDOR_AMD=y +CONFIG_AMD8111_ETH=y +CONFIG_PCNET32=y +CONFIG_PCMCIA_NMCLAN=y +CONFIG_AMD_XGBE=y +CONFIG_AMD_XGBE_DCB=y +CONFIG_AMD_XGBE_HAVE_ECC=y +CONFIG_NET_XGENE=y +CONFIG_NET_XGENE_V2=y +CONFIG_NET_VENDOR_AQUANTIA=y +CONFIG_AQTION=y +CONFIG_NET_VENDOR_ARC=y +CONFIG_ARC_EMAC_CORE=y +CONFIG_ARC_EMAC=y +CONFIG_EMAC_ROCKCHIP=y +CONFIG_NET_VENDOR_ATHEROS=y +CONFIG_ATL2=y +CONFIG_ATL1=y +CONFIG_ATL1E=y +CONFIG_ATL1C=y +CONFIG_ALX=y +CONFIG_NET_VENDOR_AURORA=y +CONFIG_AURORA_NB8800=y +CONFIG_NET_CADENCE=y +CONFIG_MACB=y +CONFIG_MACB_USE_HWSTAMP=y +CONFIG_MACB_PCI=y +CONFIG_NET_VENDOR_BROADCOM=y +CONFIG_B44=y +CONFIG_B44_PCI_AUTOSELECT=y +CONFIG_B44_PCICORE_AUTOSELECT=y +CONFIG_B44_PCI=y +CONFIG_BCMGENET=y +CONFIG_BNX2=y +CONFIG_CNIC=y +CONFIG_TIGON3=y +CONFIG_TIGON3_HWMON=y +CONFIG_BNX2X=y +CONFIG_BNX2X_SRIOV=y +CONFIG_BGMAC=y +CONFIG_BGMAC_BCMA=y +CONFIG_BGMAC_PLATFORM=y +CONFIG_SYSTEMPORT=y +CONFIG_BNXT=y +CONFIG_BNXT_SRIOV=y +CONFIG_BNXT_FLOWER_OFFLOAD=y +CONFIG_BNXT_DCB=y +CONFIG_NET_VENDOR_BROCADE=y +CONFIG_BNA=y +CONFIG_NET_CALXEDA_XGMAC=y +CONFIG_NET_VENDOR_CAVIUM=y +CONFIG_THUNDER_NIC_PF=y +CONFIG_THUNDER_NIC_VF=y +CONFIG_THUNDER_NIC_BGX=y +CONFIG_THUNDER_NIC_RGX=y +CONFIG_CAVIUM_PTP=y +CONFIG_LIQUIDIO=y +CONFIG_LIQUIDIO_VF=y +CONFIG_NET_VENDOR_CHELSIO=y +CONFIG_CHELSIO_T1=y +CONFIG_CHELSIO_T1_1G=y +CONFIG_CHELSIO_T3=y +CONFIG_CHELSIO_T4=y +CONFIG_CHELSIO_T4_DCB=y +CONFIG_CHELSIO_T4_FCOE=y +CONFIG_CHELSIO_T4VF=y +CONFIG_CHELSIO_LIB=y +CONFIG_NET_VENDOR_CISCO=y +CONFIG_ENIC=y +CONFIG_NET_VENDOR_CORTINA=y +CONFIG_GEMINI_ETHERNET=y +CONFIG_CX_ECAT=y +CONFIG_DNET=y +CONFIG_NET_VENDOR_DEC=y +CONFIG_NET_TULIP=y +CONFIG_DE2104X=y +CONFIG_DE2104X_DSL=0 +CONFIG_TULIP=y +CONFIG_TULIP_MWI=y +CONFIG_TULIP_MMIO=y +CONFIG_TULIP_NAPI=y +CONFIG_TULIP_NAPI_HW_MITIGATION=y +CONFIG_DE4X5=y +CONFIG_WINBOND_840=y +CONFIG_DM9102=y +CONFIG_ULI526X=y +CONFIG_PCMCIA_XIRCOM=y +CONFIG_NET_VENDOR_DLINK=y +CONFIG_DL2K=y +CONFIG_SUNDANCE=y +CONFIG_SUNDANCE_MMIO=y +CONFIG_NET_VENDOR_EMULEX=y +CONFIG_BE2NET=y +CONFIG_BE2NET_HWMON=y +CONFIG_NET_VENDOR_EZCHIP=y +CONFIG_EZCHIP_NPS_MANAGEMENT_ENET=y +CONFIG_NET_VENDOR_EXAR=y +CONFIG_S2IO=y +CONFIG_VXGE=y +CONFIG_VXGE_DEBUG_TRACE_ALL=y +CONFIG_NET_VENDOR_FREESCALE=y +CONFIG_FSL_FMAN=y +CONFIG_FSL_PQ_MDIO=y +CONFIG_FSL_XGMAC_MDIO=y +CONFIG_GIANFAR=y +CONFIG_NET_VENDOR_FUJITSU=y +CONFIG_PCMCIA_FMVJ18X=y +CONFIG_NET_VENDOR_HISILICON=y +CONFIG_HIX5HD2_GMAC=y +CONFIG_HISI_FEMAC=y +CONFIG_HIP04_ETH=y +CONFIG_HNS_MDIO=y +CONFIG_HNS=y +CONFIG_HNS_DSAF=y +CONFIG_HNS_ENET=y +CONFIG_HNS3=y +CONFIG_HNS3_HCLGE=y +CONFIG_HNS3_DCB=y +CONFIG_HNS3_HCLGEVF=y +CONFIG_HNS3_ENET=y +CONFIG_NET_VENDOR_HP=y +CONFIG_HP100=y +CONFIG_NET_VENDOR_HUAWEI=y +CONFIG_HINIC=y +CONFIG_NET_VENDOR_INTEL=y +CONFIG_E100=y +CONFIG_E1000=y +CONFIG_E1000E=y +CONFIG_E1000E_HWTS=y +CONFIG_IGB=y +CONFIG_IGB_HWMON=y +CONFIG_IGB_DCA=y +CONFIG_IGBVF=y +CONFIG_IXGB=y +CONFIG_IXGBE=y +CONFIG_IXGBE_HWMON=y +CONFIG_IXGBE_DCA=y +CONFIG_IXGBE_DCB=y +CONFIG_IXGBEVF=y +CONFIG_I40E=y +CONFIG_I40E_DCB=y +CONFIG_I40EVF=y +CONFIG_FM10K=y +CONFIG_NET_VENDOR_I825XX=y +CONFIG_JME=y +CONFIG_NET_VENDOR_MARVELL=y +CONFIG_MV643XX_ETH=y +CONFIG_MVMDIO=y +CONFIG_MVNETA=y +CONFIG_MVPP2=y +CONFIG_PXA168_ETH=y +CONFIG_SKGE=y +CONFIG_SKGE_DEBUG=y +CONFIG_SKGE_GENESIS=y +CONFIG_SKY2=y +CONFIG_SKY2_DEBUG=y +CONFIG_NET_VENDOR_MELLANOX=y +CONFIG_MLX4_EN=y +CONFIG_MLX4_EN_DCB=y +CONFIG_MLX4_CORE=y +CONFIG_MLX4_DEBUG=y +CONFIG_MLX4_CORE_GEN2=y +CONFIG_MLX5_CORE=y +CONFIG_MLX5_ACCEL=y +CONFIG_MLX5_FPGA=y +CONFIG_MLX5_CORE_EN=y +CONFIG_MLX5_MPFS=y +CONFIG_MLX5_ESWITCH=y +CONFIG_MLX5_CORE_EN_DCB=y +CONFIG_MLX5_CORE_IPOIB=y +CONFIG_MLX5_EN_IPSEC=y +CONFIG_MLXSW_CORE=y +CONFIG_MLXSW_CORE_HWMON=y +CONFIG_MLXSW_CORE_THERMAL=y +CONFIG_MLXSW_PCI=y +CONFIG_MLXSW_I2C=y +CONFIG_MLXSW_SWITCHIB=y +CONFIG_MLXSW_SWITCHX2=y +CONFIG_MLXSW_SPECTRUM=y +CONFIG_MLXSW_SPECTRUM_DCB=y +CONFIG_MLXSW_MINIMAL=y +CONFIG_MLXFW=y +CONFIG_NET_VENDOR_MICREL=y +CONFIG_KS8842=y +CONFIG_KS8851=y +CONFIG_KS8851_MLL=y +CONFIG_KSZ884X_PCI=y +CONFIG_NET_VENDOR_MICROCHIP=y +CONFIG_ENC28J60=y +CONFIG_ENC28J60_WRITEVERIFY=y +CONFIG_ENCX24J600=y +CONFIG_NET_VENDOR_MYRI=y +CONFIG_MYRI10GE=y +CONFIG_MYRI10GE_DCA=y +CONFIG_FEALNX=y +CONFIG_NET_VENDOR_NATSEMI=y +CONFIG_NATSEMI=y +CONFIG_NS83820=y +CONFIG_NET_VENDOR_NETRONOME=y +CONFIG_NFP=y +CONFIG_NFP_APP_FLOWER=y +CONFIG_NFP_DEBUG=y +CONFIG_NET_VENDOR_8390=y +CONFIG_PCMCIA_AXNET=y +CONFIG_NE2K_PCI=y +CONFIG_PCMCIA_PCNET=y +CONFIG_NET_VENDOR_NVIDIA=y +CONFIG_FORCEDETH=y +CONFIG_NET_VENDOR_OKI=y +CONFIG_PCH_GBE=y +CONFIG_ETHOC=y +CONFIG_NET_PACKET_ENGINE=y +CONFIG_HAMACHI=y +CONFIG_YELLOWFIN=y +CONFIG_NET_VENDOR_QLOGIC=y +CONFIG_QLA3XXX=y +CONFIG_QLCNIC=y +CONFIG_QLCNIC_SRIOV=y +CONFIG_QLCNIC_DCB=y +CONFIG_QLCNIC_HWMON=y +CONFIG_QLGE=y +CONFIG_NETXEN_NIC=y +CONFIG_QED=y +CONFIG_QED_LL2=y +CONFIG_QED_SRIOV=y +CONFIG_QEDE=y +CONFIG_QED_RDMA=y +CONFIG_QED_ISCSI=y +CONFIG_QED_FCOE=y +CONFIG_QED_OOO=y +CONFIG_NET_VENDOR_QUALCOMM=y +CONFIG_QCA7000=y +CONFIG_QCA7000_SPI=y +CONFIG_QCA7000_UART=y +CONFIG_QCOM_EMAC=y +CONFIG_RMNET=y +CONFIG_NET_VENDOR_REALTEK=y +CONFIG_ATP=y +CONFIG_8139CP=y +CONFIG_8139TOO=y +CONFIG_8139TOO_PIO=y +CONFIG_8139TOO_TUNE_TWISTER=y +CONFIG_8139TOO_8129=y +CONFIG_8139_OLD_RX_RESET=y +CONFIG_R8169=y +CONFIG_NET_VENDOR_RENESAS=y +CONFIG_SH_ETH=y +CONFIG_RAVB=y +CONFIG_NET_VENDOR_RDC=y +CONFIG_R6040=y +CONFIG_NET_VENDOR_ROCKER=y +CONFIG_ROCKER=y +CONFIG_NET_VENDOR_SAMSUNG=y +CONFIG_SXGBE_ETH=y +CONFIG_NET_VENDOR_SEEQ=y +CONFIG_NET_VENDOR_SILAN=y +CONFIG_SC92031=y +CONFIG_NET_VENDOR_SIS=y +CONFIG_SIS900=y +CONFIG_SIS190=y +CONFIG_NET_VENDOR_SOLARFLARE=y +CONFIG_SFC=y +CONFIG_SFC_MTD=y +CONFIG_SFC_MCDI_MON=y +CONFIG_SFC_SRIOV=y +CONFIG_SFC_MCDI_LOGGING=y +CONFIG_SFC_FALCON=y +CONFIG_SFC_FALCON_MTD=y +CONFIG_NET_VENDOR_SMSC=y +CONFIG_PCMCIA_SMC91C92=y +CONFIG_EPIC100=y +CONFIG_SMSC911X=y +# CONFIG_SMSC911X_ARCH_HOOKS is not set +CONFIG_SMSC9420=y +CONFIG_NET_VENDOR_SOCIONEXT=y +CONFIG_SNI_AVE=y +CONFIG_SNI_NETSEC=y +CONFIG_NET_VENDOR_STMICRO=y +CONFIG_STMMAC_ETH=y +CONFIG_STMMAC_PLATFORM=y +CONFIG_DWMAC_DWC_QOS_ETH=y +CONFIG_DWMAC_GENERIC=y +CONFIG_DWMAC_ANARION=y +CONFIG_DWMAC_IPQ806X=y +CONFIG_DWMAC_LPC18XX=y +CONFIG_DWMAC_MESON=y +CONFIG_DWMAC_OXNAS=y +CONFIG_DWMAC_ROCKCHIP=y +CONFIG_DWMAC_SOCFPGA=y +CONFIG_DWMAC_STI=y +CONFIG_DWMAC_STM32=y +CONFIG_DWMAC_SUNXI=y +CONFIG_DWMAC_SUN8I=y +CONFIG_STMMAC_PCI=y +CONFIG_NET_VENDOR_SUN=y +CONFIG_HAPPYMEAL=y +CONFIG_SUNGEM=y +CONFIG_CASSINI=y +CONFIG_NIU=y +CONFIG_NET_VENDOR_TEHUTI=y +CONFIG_TEHUTI=y +CONFIG_NET_VENDOR_TI=y +CONFIG_TI_CPSW_ALE=y +CONFIG_TLAN=y +CONFIG_NET_VENDOR_VIA=y +CONFIG_VIA_RHINE=y +CONFIG_VIA_RHINE_MMIO=y +CONFIG_VIA_VELOCITY=y +CONFIG_NET_VENDOR_WIZNET=y +CONFIG_WIZNET_W5100=y +CONFIG_WIZNET_W5300=y +# CONFIG_WIZNET_BUS_DIRECT is not set +# CONFIG_WIZNET_BUS_INDIRECT is not set +CONFIG_WIZNET_BUS_ANY=y +CONFIG_WIZNET_W5100_SPI=y +CONFIG_NET_VENDOR_XIRCOM=y +CONFIG_PCMCIA_XIRC2PS=y +CONFIG_NET_VENDOR_SYNOPSYS=y +CONFIG_DWC_XLGMAC=y +CONFIG_DWC_XLGMAC_PCI=y +CONFIG_FDDI=y +CONFIG_DEFXX=y +CONFIG_DEFXX_MMIO=y +CONFIG_SKFP=y +CONFIG_HIPPI=y +CONFIG_ROADRUNNER=y +CONFIG_ROADRUNNER_LARGE_RINGS=y +CONFIG_NET_SB1000=y +CONFIG_MDIO_DEVICE=y +CONFIG_MDIO_BUS=y +CONFIG_MDIO_BCM_IPROC=y +CONFIG_MDIO_BCM_UNIMAC=y +CONFIG_MDIO_BITBANG=y +CONFIG_MDIO_BUS_MUX=y +CONFIG_MDIO_BUS_MUX_BCM_IPROC=y +CONFIG_MDIO_BUS_MUX_GPIO=y +CONFIG_MDIO_BUS_MUX_MMIOREG=y +CONFIG_MDIO_CAVIUM=y +CONFIG_MDIO_GPIO=y +CONFIG_MDIO_HISI_FEMAC=y +CONFIG_MDIO_I2C=y +CONFIG_MDIO_OCTEON=y +CONFIG_MDIO_THUNDER=y +CONFIG_MDIO_XGENE=y +CONFIG_PHYLINK=y +CONFIG_PHYLIB=y +CONFIG_SWPHY=y +CONFIG_LED_TRIGGER_PHY=y + +# +# MII PHY device drivers +# +CONFIG_SFP=y +CONFIG_AMD_PHY=y +CONFIG_AQUANTIA_PHY=y +CONFIG_AT803X_PHY=y +CONFIG_BCM7XXX_PHY=y +CONFIG_BCM87XX_PHY=y +CONFIG_BCM_CYGNUS_PHY=y +CONFIG_BCM_NET_PHYLIB=y +CONFIG_BROADCOM_PHY=y +CONFIG_CICADA_PHY=y +CONFIG_CORTINA_PHY=y +CONFIG_DAVICOM_PHY=y +CONFIG_DP83822_PHY=y +CONFIG_DP83848_PHY=y +CONFIG_DP83867_PHY=y +CONFIG_FIXED_PHY=y +CONFIG_ICPLUS_PHY=y +CONFIG_INTEL_XWAY_PHY=y +CONFIG_LSI_ET1011C_PHY=y +CONFIG_LXT_PHY=y +CONFIG_MARVELL_PHY=y +CONFIG_MARVELL_10G_PHY=y +CONFIG_MESON_GXL_PHY=y +CONFIG_MICREL_PHY=y +CONFIG_MICROCHIP_PHY=y +CONFIG_MICROSEMI_PHY=y +CONFIG_NATIONAL_PHY=y +CONFIG_QSEMI_PHY=y +CONFIG_REALTEK_PHY=y +CONFIG_RENESAS_PHY=y +CONFIG_ROCKCHIP_PHY=y +CONFIG_SMSC_PHY=y +CONFIG_STE10XP=y +CONFIG_TERANETICS_PHY=y +CONFIG_VITESSE_PHY=y +CONFIG_XILINX_GMII2RGMII=y +CONFIG_MICREL_KS8995MA=y +CONFIG_PLIP=y +CONFIG_PPP=y +CONFIG_PPP_BSDCOMP=y +CONFIG_PPP_DEFLATE=y +CONFIG_PPP_FILTER=y +CONFIG_PPP_MPPE=y +CONFIG_PPP_MULTILINK=y +CONFIG_PPPOATM=y +CONFIG_PPPOE=y +CONFIG_PPTP=y +CONFIG_PPPOL2TP=y +CONFIG_PPP_ASYNC=y +CONFIG_PPP_SYNC_TTY=y +CONFIG_SLIP=y +CONFIG_SLHC=y +CONFIG_SLIP_COMPRESSED=y +CONFIG_SLIP_SMART=y +CONFIG_SLIP_MODE_SLIP6=y +CONFIG_USB_NET_DRIVERS=y +CONFIG_USB_CATC=y +CONFIG_USB_KAWETH=y +CONFIG_USB_PEGASUS=y +CONFIG_USB_RTL8150=y +CONFIG_USB_RTL8152=y +CONFIG_USB_LAN78XX=y +CONFIG_USB_USBNET=y +CONFIG_USB_NET_AX8817X=y +CONFIG_USB_NET_AX88179_178A=y +CONFIG_USB_NET_CDCETHER=y +CONFIG_USB_NET_CDC_EEM=y +CONFIG_USB_NET_CDC_NCM=y +CONFIG_USB_NET_HUAWEI_CDC_NCM=y +CONFIG_USB_NET_CDC_MBIM=y +CONFIG_USB_NET_DM9601=y +CONFIG_USB_NET_SR9700=y +CONFIG_USB_NET_SR9800=y +CONFIG_USB_NET_SMSC75XX=y +CONFIG_USB_NET_SMSC95XX=y +CONFIG_USB_NET_GL620A=y +CONFIG_USB_NET_NET1080=y +CONFIG_USB_NET_PLUSB=y +CONFIG_USB_NET_MCS7830=y +CONFIG_USB_NET_RNDIS_HOST=y +CONFIG_USB_NET_CDC_SUBSET_ENABLE=y +CONFIG_USB_NET_CDC_SUBSET=y +CONFIG_USB_ALI_M5632=y +CONFIG_USB_AN2720=y +CONFIG_USB_BELKIN=y +CONFIG_USB_ARMLINUX=y +CONFIG_USB_EPSON2888=y +CONFIG_USB_KC2190=y +CONFIG_USB_NET_ZAURUS=y +CONFIG_USB_NET_CX82310_ETH=y +CONFIG_USB_NET_KALMIA=y +CONFIG_USB_NET_QMI_WWAN=y +CONFIG_USB_HSO=y +CONFIG_USB_NET_INT51X1=y +CONFIG_USB_CDC_PHONET=y +CONFIG_USB_IPHETH=y +CONFIG_USB_SIERRA_NET=y +CONFIG_USB_VL600=y +CONFIG_USB_NET_CH9200=y +CONFIG_WLAN=y +CONFIG_WIRELESS_WDS=y +CONFIG_WLAN_VENDOR_ADMTEK=y +CONFIG_ADM8211=y +CONFIG_ATH_COMMON=y +CONFIG_WLAN_VENDOR_ATH=y +CONFIG_ATH_DEBUG=y +CONFIG_ATH_TRACEPOINTS=y +CONFIG_ATH_REG_DYNAMIC_USER_REG_HINTS=y +CONFIG_ATH_REG_DYNAMIC_USER_CERT_TESTING=y +CONFIG_ATH5K=y +CONFIG_ATH5K_DEBUG=y +CONFIG_ATH5K_TRACER=y +CONFIG_ATH5K_PCI=y +CONFIG_ATH5K_TEST_CHANNELS=y +CONFIG_ATH9K_HW=y +CONFIG_ATH9K_COMMON=y +CONFIG_ATH9K_COMMON_DEBUG=y +CONFIG_ATH9K_DFS_DEBUGFS=y +CONFIG_ATH9K_BTCOEX_SUPPORT=y +CONFIG_ATH9K=y +CONFIG_ATH9K_PCI=y +CONFIG_ATH9K_AHB=y +CONFIG_ATH9K_DEBUGFS=y +CONFIG_ATH9K_STATION_STATISTICS=y +CONFIG_ATH9K_TX99=y +CONFIG_ATH9K_DFS_CERTIFIED=y +CONFIG_ATH9K_DYNACK=y +CONFIG_ATH9K_WOW=y +CONFIG_ATH9K_RFKILL=y +CONFIG_ATH9K_CHANNEL_CONTEXT=y +CONFIG_ATH9K_PCOEM=y +CONFIG_ATH9K_HTC=y +CONFIG_ATH9K_HTC_DEBUGFS=y +CONFIG_ATH9K_HWRNG=y +CONFIG_ATH9K_COMMON_SPECTRAL=y +CONFIG_CARL9170=y +CONFIG_CARL9170_LEDS=y +CONFIG_CARL9170_DEBUGFS=y +CONFIG_CARL9170_WPC=y +CONFIG_CARL9170_HWRNG=y +CONFIG_ATH6KL=y +CONFIG_ATH6KL_SDIO=y +CONFIG_ATH6KL_USB=y +CONFIG_ATH6KL_DEBUG=y +CONFIG_ATH6KL_TRACING=y +CONFIG_ATH6KL_REGDOMAIN=y +CONFIG_AR5523=y +CONFIG_WIL6210=y +CONFIG_WIL6210_ISR_COR=y +CONFIG_WIL6210_TRACING=y +CONFIG_WIL6210_DEBUGFS=y +CONFIG_ATH10K=y +CONFIG_ATH10K_PCI=y +CONFIG_ATH10K_AHB=y +CONFIG_ATH10K_SDIO=y +CONFIG_ATH10K_USB=y +CONFIG_ATH10K_DEBUG=y +CONFIG_ATH10K_DEBUGFS=y +CONFIG_ATH10K_SPECTRAL=y +CONFIG_ATH10K_TRACING=y +CONFIG_ATH10K_DFS_CERTIFIED=y +CONFIG_WCN36XX=y +CONFIG_WCN36XX_DEBUGFS=y +CONFIG_WLAN_VENDOR_ATMEL=y +CONFIG_ATMEL=y +CONFIG_PCI_ATMEL=y +CONFIG_PCMCIA_ATMEL=y +CONFIG_AT76C50X_USB=y +CONFIG_WLAN_VENDOR_BROADCOM=y +CONFIG_B43=y +CONFIG_B43_BCMA=y +CONFIG_B43_SSB=y +CONFIG_B43_BUSES_BCMA_AND_SSB=y +# CONFIG_B43_BUSES_BCMA is not set +# CONFIG_B43_BUSES_SSB is not set +CONFIG_B43_PCI_AUTOSELECT=y +CONFIG_B43_PCICORE_AUTOSELECT=y +CONFIG_B43_SDIO=y +CONFIG_B43_BCMA_PIO=y +CONFIG_B43_PIO=y +CONFIG_B43_PHY_G=y +CONFIG_B43_PHY_N=y +CONFIG_B43_PHY_LP=y +CONFIG_B43_PHY_HT=y +CONFIG_B43_LEDS=y +CONFIG_B43_HWRNG=y +CONFIG_B43_DEBUG=y +CONFIG_B43LEGACY=y +CONFIG_B43LEGACY_PCI_AUTOSELECT=y +CONFIG_B43LEGACY_PCICORE_AUTOSELECT=y +CONFIG_B43LEGACY_LEDS=y +CONFIG_B43LEGACY_HWRNG=y +CONFIG_B43LEGACY_DEBUG=y +CONFIG_B43LEGACY_DMA=y +CONFIG_B43LEGACY_PIO=y +CONFIG_B43LEGACY_DMA_AND_PIO_MODE=y +# CONFIG_B43LEGACY_DMA_MODE is not set +# CONFIG_B43LEGACY_PIO_MODE is not set +CONFIG_BRCMUTIL=y +CONFIG_BRCMSMAC=y +CONFIG_BRCMFMAC=y +CONFIG_BRCMFMAC_PROTO_BCDC=y +CONFIG_BRCMFMAC_PROTO_MSGBUF=y +CONFIG_BRCMFMAC_SDIO=y +CONFIG_BRCMFMAC_USB=y +CONFIG_BRCMFMAC_PCIE=y +CONFIG_BRCM_TRACING=y +CONFIG_BRCMDBG=y +CONFIG_WLAN_VENDOR_CISCO=y +CONFIG_AIRO=y +CONFIG_AIRO_CS=y +CONFIG_WLAN_VENDOR_INTEL=y +CONFIG_IPW2100=y +CONFIG_IPW2100_MONITOR=y +CONFIG_IPW2100_DEBUG=y +CONFIG_IPW2200=y +CONFIG_IPW2200_MONITOR=y +CONFIG_IPW2200_RADIOTAP=y +CONFIG_IPW2200_PROMISCUOUS=y +CONFIG_IPW2200_QOS=y +CONFIG_IPW2200_DEBUG=y +CONFIG_LIBIPW=y +CONFIG_LIBIPW_DEBUG=y +CONFIG_IWLEGACY=y +CONFIG_IWL4965=y +CONFIG_IWL3945=y + +# +# iwl3945 / iwl4965 Debugging Options +# +CONFIG_IWLEGACY_DEBUG=y +CONFIG_IWLEGACY_DEBUGFS=y +CONFIG_IWLWIFI=y +CONFIG_IWLWIFI_LEDS=y +CONFIG_IWLDVM=y +CONFIG_IWLMVM=y +CONFIG_IWLWIFI_BCAST_FILTERING=y +CONFIG_IWLWIFI_PCIE_RTPM=y + +# +# Debugging Options +# +CONFIG_IWLWIFI_DEBUG=y +CONFIG_IWLWIFI_DEBUGFS=y +CONFIG_IWLWIFI_DEVICE_TRACING=y +CONFIG_WLAN_VENDOR_INTERSIL=y +CONFIG_HOSTAP=y +CONFIG_HOSTAP_FIRMWARE=y +CONFIG_HOSTAP_FIRMWARE_NVRAM=y +CONFIG_HOSTAP_PLX=y +CONFIG_HOSTAP_PCI=y +CONFIG_HOSTAP_CS=y +CONFIG_HERMES=y +CONFIG_HERMES_PRISM=y +CONFIG_HERMES_CACHE_FW_ON_INIT=y +CONFIG_PLX_HERMES=y +CONFIG_TMD_HERMES=y +CONFIG_NORTEL_HERMES=y +CONFIG_PCI_HERMES=y +CONFIG_PCMCIA_HERMES=y +CONFIG_PCMCIA_SPECTRUM=y +CONFIG_ORINOCO_USB=y +CONFIG_P54_COMMON=y +CONFIG_P54_USB=y +CONFIG_P54_PCI=y +CONFIG_P54_SPI=y +CONFIG_P54_SPI_DEFAULT_EEPROM=y +CONFIG_P54_LEDS=y +CONFIG_PRISM54=y +CONFIG_WLAN_VENDOR_MARVELL=y +CONFIG_LIBERTAS=y +CONFIG_LIBERTAS_USB=y +CONFIG_LIBERTAS_CS=y +CONFIG_LIBERTAS_SDIO=y +CONFIG_LIBERTAS_SPI=y +CONFIG_LIBERTAS_DEBUG=y +CONFIG_LIBERTAS_MESH=y +CONFIG_LIBERTAS_THINFIRM=y +CONFIG_LIBERTAS_THINFIRM_DEBUG=y +CONFIG_LIBERTAS_THINFIRM_USB=y +CONFIG_MWIFIEX=y +CONFIG_MWIFIEX_SDIO=y +CONFIG_MWIFIEX_PCIE=y +CONFIG_MWIFIEX_USB=y +CONFIG_MWL8K=y +CONFIG_WLAN_VENDOR_MEDIATEK=y +CONFIG_MT7601U=y +CONFIG_MT76_CORE=y +CONFIG_MT76x2E=y +CONFIG_WLAN_VENDOR_RALINK=y +CONFIG_RT2X00=y +CONFIG_RT2400PCI=y +CONFIG_RT2500PCI=y +CONFIG_RT61PCI=y +CONFIG_RT2800PCI=y +CONFIG_RT2800PCI_RT33XX=y +CONFIG_RT2800PCI_RT35XX=y +CONFIG_RT2800PCI_RT53XX=y +CONFIG_RT2800PCI_RT3290=y +CONFIG_RT2500USB=y +CONFIG_RT73USB=y +CONFIG_RT2800USB=y +CONFIG_RT2800USB_RT33XX=y +CONFIG_RT2800USB_RT35XX=y +CONFIG_RT2800USB_RT3573=y +CONFIG_RT2800USB_RT53XX=y +CONFIG_RT2800USB_RT55XX=y +CONFIG_RT2800USB_UNKNOWN=y +CONFIG_RT2800_LIB=y +CONFIG_RT2800_LIB_MMIO=y +CONFIG_RT2X00_LIB_MMIO=y +CONFIG_RT2X00_LIB_PCI=y +CONFIG_RT2X00_LIB_USB=y +CONFIG_RT2X00_LIB=y +CONFIG_RT2X00_LIB_FIRMWARE=y +CONFIG_RT2X00_LIB_CRYPTO=y +CONFIG_RT2X00_LIB_LEDS=y +CONFIG_RT2X00_LIB_DEBUGFS=y +CONFIG_RT2X00_DEBUG=y +CONFIG_WLAN_VENDOR_REALTEK=y +CONFIG_RTL8180=y +CONFIG_RTL8187=y +CONFIG_RTL8187_LEDS=y +CONFIG_RTL_CARDS=y +CONFIG_RTL8192CE=y +CONFIG_RTL8192SE=y +CONFIG_RTL8192DE=y +CONFIG_RTL8723AE=y +CONFIG_RTL8723BE=y +CONFIG_RTL8188EE=y +CONFIG_RTL8192EE=y +CONFIG_RTL8821AE=y +CONFIG_RTL8192CU=y +CONFIG_RTLWIFI=y +CONFIG_RTLWIFI_PCI=y +CONFIG_RTLWIFI_USB=y +CONFIG_RTLWIFI_DEBUG=y +CONFIG_RTL8192C_COMMON=y +CONFIG_RTL8723_COMMON=y +CONFIG_RTLBTCOEXIST=y +CONFIG_RTL8XXXU=y +CONFIG_RTL8XXXU_UNTESTED=y +CONFIG_WLAN_VENDOR_RSI=y +CONFIG_RSI_91X=y +CONFIG_RSI_DEBUGFS=y +CONFIG_RSI_SDIO=y +CONFIG_RSI_USB=y +CONFIG_WLAN_VENDOR_ST=y +CONFIG_CW1200=y +CONFIG_CW1200_WLAN_SDIO=y +CONFIG_CW1200_WLAN_SPI=y +CONFIG_WLAN_VENDOR_TI=y +CONFIG_WL1251=y +CONFIG_WL1251_SPI=y +CONFIG_WL1251_SDIO=y +CONFIG_WL12XX=y +CONFIG_WL18XX=y +CONFIG_WLCORE=y +CONFIG_WLCORE_SPI=y +CONFIG_WLCORE_SDIO=y +CONFIG_WILINK_PLATFORM_DATA=y +CONFIG_WLAN_VENDOR_ZYDAS=y +CONFIG_USB_ZD1201=y +CONFIG_ZD1211RW=y +CONFIG_ZD1211RW_DEBUG=y +CONFIG_WLAN_VENDOR_QUANTENNA=y +CONFIG_QTNFMAC=y +CONFIG_QTNFMAC_PEARL_PCIE=y +CONFIG_PCMCIA_RAYCS=y +CONFIG_PCMCIA_WL3501=y +CONFIG_MAC80211_HWSIM=y +CONFIG_USB_NET_RNDIS_WLAN=y + +# +# WiMAX Wireless Broadband devices +# +CONFIG_WIMAX_I2400M=y +CONFIG_WIMAX_I2400M_USB=y +CONFIG_WIMAX_I2400M_DEBUG_LEVEL=8 +CONFIG_WAN=y +CONFIG_LANMEDIA=y +CONFIG_HDLC=y +CONFIG_HDLC_RAW=y +CONFIG_HDLC_RAW_ETH=y +CONFIG_HDLC_CISCO=y +CONFIG_HDLC_FR=y +CONFIG_HDLC_PPP=y +CONFIG_HDLC_X25=y +CONFIG_PCI200SYN=y +CONFIG_WANXL=y +CONFIG_PC300TOO=y +CONFIG_FARSYNC=y +CONFIG_DSCC4=m +CONFIG_SLIC_DS26522=y +CONFIG_DSCC4_PCISYNC=y +CONFIG_DSCC4_PCI_RST=y +CONFIG_DLCI=y +CONFIG_DLCI_MAX=8 +CONFIG_LAPBETHER=y +CONFIG_X25_ASY=y +CONFIG_SBNI=y +CONFIG_SBNI_MULTILINE=y +CONFIG_IEEE802154_DRIVERS=y +CONFIG_IEEE802154_FAKELB=y +CONFIG_IEEE802154_AT86RF230=y +CONFIG_IEEE802154_AT86RF230_DEBUGFS=y +CONFIG_IEEE802154_MRF24J40=y +CONFIG_IEEE802154_CC2520=y +CONFIG_IEEE802154_ATUSB=y +CONFIG_IEEE802154_ADF7242=y +CONFIG_IEEE802154_CA8210=y +CONFIG_IEEE802154_CA8210_DEBUGFS=y +CONFIG_XEN_NETDEV_FRONTEND=y +CONFIG_VMXNET3=y +CONFIG_FUJITSU_ES=y +CONFIG_THUNDERBOLT_NET=y +CONFIG_HYPERV_NET=y +CONFIG_NETDEVSIM=y +CONFIG_ISDN=y +CONFIG_ISDN_I4L=y +CONFIG_ISDN_PPP=y +CONFIG_ISDN_PPP_VJ=y +CONFIG_ISDN_MPP=y +CONFIG_IPPP_FILTER=y +CONFIG_ISDN_PPP_BSDCOMP=y +CONFIG_ISDN_AUDIO=y +CONFIG_ISDN_TTY_FAX=y +CONFIG_ISDN_X25=y + +# +# ISDN feature submodules +# +CONFIG_ISDN_DIVERSION=y + +# +# ISDN4Linux hardware drivers +# + +# +# Passive cards +# +CONFIG_ISDN_DRV_HISAX=y + +# +# D-channel protocol features +# +CONFIG_HISAX_EURO=y +CONFIG_DE_AOC=y +CONFIG_HISAX_NO_SENDCOMPLETE=y +CONFIG_HISAX_NO_LLC=y +CONFIG_HISAX_NO_KEYPAD=y +CONFIG_HISAX_1TR6=y +CONFIG_HISAX_NI1=y +CONFIG_HISAX_MAX_CARDS=8 + +# +# HiSax supported cards +# +CONFIG_HISAX_16_3=y +CONFIG_HISAX_TELESPCI=y +CONFIG_HISAX_S0BOX=y +CONFIG_HISAX_FRITZPCI=y +CONFIG_HISAX_AVM_A1_PCMCIA=y +CONFIG_HISAX_ELSA=y +CONFIG_HISAX_DIEHLDIVA=y +CONFIG_HISAX_SEDLBAUER=y +CONFIG_HISAX_NETJET=y +CONFIG_HISAX_NETJET_U=y +CONFIG_HISAX_NICCY=y +CONFIG_HISAX_BKM_A4T=y +CONFIG_HISAX_SCT_QUADRO=y +CONFIG_HISAX_GAZEL=y +CONFIG_HISAX_HFC_PCI=y +CONFIG_HISAX_W6692=y +CONFIG_HISAX_HFC_SX=y +CONFIG_HISAX_ENTERNOW_PCI=y +CONFIG_HISAX_DEBUG=y + +# +# HiSax PCMCIA card service modules +# +CONFIG_HISAX_SEDLBAUER_CS=y +CONFIG_HISAX_ELSA_CS=y +CONFIG_HISAX_AVM_A1_CS=y +CONFIG_HISAX_TELES_CS=y + +# +# HiSax sub driver modules +# +CONFIG_HISAX_ST5481=y +CONFIG_HISAX_HFCUSB=y +CONFIG_HISAX_HFC4S8S=y +CONFIG_HISAX_FRITZ_PCIPNP=y +CONFIG_ISDN_CAPI=y +CONFIG_CAPI_TRACE=y +CONFIG_ISDN_CAPI_CAPI20=y +CONFIG_ISDN_CAPI_MIDDLEWARE=y +CONFIG_ISDN_CAPI_CAPIDRV=y +CONFIG_ISDN_CAPI_CAPIDRV_VERBOSE=y + +# +# CAPI hardware drivers +# +CONFIG_CAPI_AVM=y +CONFIG_ISDN_DRV_AVMB1_B1PCI=y +CONFIG_ISDN_DRV_AVMB1_B1PCIV4=y +CONFIG_ISDN_DRV_AVMB1_B1PCMCIA=y +CONFIG_ISDN_DRV_AVMB1_AVM_CS=y +CONFIG_ISDN_DRV_AVMB1_T1PCI=y +CONFIG_ISDN_DRV_AVMB1_C4=y +CONFIG_CAPI_EICON=y +CONFIG_ISDN_DIVAS=y +CONFIG_ISDN_DIVAS_BRIPCI=y +CONFIG_ISDN_DIVAS_PRIPCI=y +CONFIG_ISDN_DIVAS_DIVACAPI=y +CONFIG_ISDN_DIVAS_USERIDI=y +CONFIG_ISDN_DIVAS_MAINT=m +CONFIG_ISDN_DRV_GIGASET=y +CONFIG_GIGASET_CAPI=y +# CONFIG_GIGASET_I4L is not set +# CONFIG_GIGASET_DUMMYLL is not set +CONFIG_GIGASET_BASE=y +CONFIG_GIGASET_M105=y +CONFIG_GIGASET_M101=y +CONFIG_GIGASET_DEBUG=y +CONFIG_HYSDN=m +CONFIG_HYSDN_CAPI=y +CONFIG_MISDN=y +CONFIG_MISDN_DSP=y +CONFIG_MISDN_L1OIP=y + +# +# mISDN hardware drivers +# +CONFIG_MISDN_HFCPCI=y +CONFIG_MISDN_HFCMULTI=y +CONFIG_MISDN_HFCUSB=y +CONFIG_MISDN_AVMFRITZ=y +CONFIG_MISDN_SPEEDFAX=y +CONFIG_MISDN_INFINEON=y +CONFIG_MISDN_W6692=y +CONFIG_MISDN_NETJET=y +CONFIG_MISDN_IPAC=y +CONFIG_MISDN_ISAR=y +CONFIG_ISDN_HDLC=y +CONFIG_NVM=y +CONFIG_NVM_DEBUG=y +CONFIG_NVM_PBLK=y + +# +# Input device support +# +CONFIG_INPUT=y +CONFIG_INPUT_LEDS=y +CONFIG_INPUT_FF_MEMLESS=y +CONFIG_INPUT_POLLDEV=y +CONFIG_INPUT_SPARSEKMAP=y +CONFIG_INPUT_MATRIXKMAP=y + +# +# Userland interfaces +# +CONFIG_INPUT_MOUSEDEV=y +CONFIG_INPUT_MOUSEDEV_PSAUX=y +CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024 +CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768 +CONFIG_INPUT_JOYDEV=y +CONFIG_INPUT_EVDEV=y +CONFIG_INPUT_EVBUG=y + +# +# Input Device Drivers +# +CONFIG_INPUT_KEYBOARD=y +CONFIG_KEYBOARD_ADC=y +CONFIG_KEYBOARD_ADP5520=y +CONFIG_KEYBOARD_ADP5588=y +CONFIG_KEYBOARD_ADP5589=y +CONFIG_KEYBOARD_ATKBD=y +CONFIG_KEYBOARD_QT1070=y +CONFIG_KEYBOARD_QT2160=y +CONFIG_KEYBOARD_CLPS711X=y +CONFIG_KEYBOARD_DLINK_DIR685=y +CONFIG_KEYBOARD_LKKBD=y +CONFIG_KEYBOARD_GPIO=y +CONFIG_KEYBOARD_GPIO_POLLED=y +CONFIG_KEYBOARD_TCA6416=y +CONFIG_KEYBOARD_TCA8418=y +CONFIG_KEYBOARD_MATRIX=y +CONFIG_KEYBOARD_LM8323=y +CONFIG_KEYBOARD_LM8333=y +CONFIG_KEYBOARD_MAX7359=y +CONFIG_KEYBOARD_MCS=y +CONFIG_KEYBOARD_MPR121=y +CONFIG_KEYBOARD_NEWTON=y +CONFIG_KEYBOARD_OPENCORES=y +CONFIG_KEYBOARD_PMIC8XXX=y +CONFIG_KEYBOARD_SAMSUNG=y +CONFIG_KEYBOARD_GOLDFISH_EVENTS=y +CONFIG_KEYBOARD_STOWAWAY=y +CONFIG_KEYBOARD_ST_KEYSCAN=y +CONFIG_KEYBOARD_SUNKBD=y +CONFIG_KEYBOARD_SH_KEYSC=y +CONFIG_KEYBOARD_STMPE=y +CONFIG_KEYBOARD_OMAP4=y +CONFIG_KEYBOARD_TC3589X=y +CONFIG_KEYBOARD_TM2_TOUCHKEY=y +CONFIG_KEYBOARD_TWL4030=y +CONFIG_KEYBOARD_XTKBD=y +CONFIG_KEYBOARD_CROS_EC=y +CONFIG_KEYBOARD_CAP11XX=y +CONFIG_KEYBOARD_BCM=y +CONFIG_INPUT_MOUSE=y +CONFIG_MOUSE_PS2=y +CONFIG_MOUSE_PS2_ALPS=y +CONFIG_MOUSE_PS2_BYD=y +CONFIG_MOUSE_PS2_LOGIPS2PP=y +CONFIG_MOUSE_PS2_SYNAPTICS=y +CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS=y +CONFIG_MOUSE_PS2_CYPRESS=y +CONFIG_MOUSE_PS2_LIFEBOOK=y +CONFIG_MOUSE_PS2_TRACKPOINT=y +CONFIG_MOUSE_PS2_ELANTECH=y +CONFIG_MOUSE_PS2_SENTELIC=y +CONFIG_MOUSE_PS2_TOUCHKIT=y +CONFIG_MOUSE_PS2_FOCALTECH=y +CONFIG_MOUSE_PS2_VMMOUSE=y +CONFIG_MOUSE_PS2_SMBUS=y +CONFIG_MOUSE_SERIAL=y +CONFIG_MOUSE_APPLETOUCH=y +CONFIG_MOUSE_BCM5974=y +CONFIG_MOUSE_CYAPA=y +CONFIG_MOUSE_ELAN_I2C=y +CONFIG_MOUSE_ELAN_I2C_I2C=y +CONFIG_MOUSE_ELAN_I2C_SMBUS=y +CONFIG_MOUSE_VSXXXAA=y +CONFIG_MOUSE_GPIO=y +CONFIG_MOUSE_SYNAPTICS_I2C=y +CONFIG_MOUSE_SYNAPTICS_USB=y +CONFIG_INPUT_JOYSTICK=y +CONFIG_JOYSTICK_ANALOG=y +CONFIG_JOYSTICK_A3D=y +CONFIG_JOYSTICK_ADI=y +CONFIG_JOYSTICK_COBRA=y +CONFIG_JOYSTICK_GF2K=y +CONFIG_JOYSTICK_GRIP=y +CONFIG_JOYSTICK_GRIP_MP=y +CONFIG_JOYSTICK_GUILLEMOT=y +CONFIG_JOYSTICK_INTERACT=y +CONFIG_JOYSTICK_SIDEWINDER=y +CONFIG_JOYSTICK_TMDC=y +CONFIG_JOYSTICK_IFORCE=y +CONFIG_JOYSTICK_IFORCE_USB=y +CONFIG_JOYSTICK_IFORCE_232=y +CONFIG_JOYSTICK_WARRIOR=y +CONFIG_JOYSTICK_MAGELLAN=y +CONFIG_JOYSTICK_SPACEORB=y +CONFIG_JOYSTICK_SPACEBALL=y +CONFIG_JOYSTICK_STINGER=y +CONFIG_JOYSTICK_TWIDJOY=y +CONFIG_JOYSTICK_ZHENHUA=y +CONFIG_JOYSTICK_DB9=y +CONFIG_JOYSTICK_GAMECON=y +CONFIG_JOYSTICK_TURBOGRAFX=y +CONFIG_JOYSTICK_AS5011=y +CONFIG_JOYSTICK_JOYDUMP=y +CONFIG_JOYSTICK_XPAD=y +CONFIG_JOYSTICK_XPAD_FF=y +CONFIG_JOYSTICK_XPAD_LEDS=y +CONFIG_JOYSTICK_WALKERA0701=y +CONFIG_JOYSTICK_PSXPAD_SPI=y +CONFIG_JOYSTICK_PSXPAD_SPI_FF=y +CONFIG_INPUT_TABLET=y +CONFIG_TABLET_USB_ACECAD=y +CONFIG_TABLET_USB_AIPTEK=y +CONFIG_TABLET_USB_GTCO=y +CONFIG_TABLET_USB_HANWANG=y +CONFIG_TABLET_USB_KBTAB=y +CONFIG_TABLET_USB_PEGASUS=y +CONFIG_TABLET_SERIAL_WACOM4=y +CONFIG_INPUT_TOUCHSCREEN=y +CONFIG_TOUCHSCREEN_PROPERTIES=y +CONFIG_TOUCHSCREEN_88PM860X=y +CONFIG_TOUCHSCREEN_ADS7846=y +CONFIG_TOUCHSCREEN_AD7877=y +CONFIG_TOUCHSCREEN_AD7879=y +CONFIG_TOUCHSCREEN_AD7879_I2C=y +CONFIG_TOUCHSCREEN_AD7879_SPI=y +CONFIG_TOUCHSCREEN_AR1021_I2C=y +CONFIG_TOUCHSCREEN_ATMEL_MXT=y +CONFIG_TOUCHSCREEN_ATMEL_MXT_T37=y +CONFIG_TOUCHSCREEN_AUO_PIXCIR=y +CONFIG_TOUCHSCREEN_BU21013=y +CONFIG_TOUCHSCREEN_CHIPONE_ICN8318=y +CONFIG_TOUCHSCREEN_CY8CTMG110=y +CONFIG_TOUCHSCREEN_CYTTSP_CORE=y +CONFIG_TOUCHSCREEN_CYTTSP_I2C=y +CONFIG_TOUCHSCREEN_CYTTSP_SPI=y +CONFIG_TOUCHSCREEN_CYTTSP4_CORE=y +CONFIG_TOUCHSCREEN_CYTTSP4_I2C=y +CONFIG_TOUCHSCREEN_CYTTSP4_SPI=y +CONFIG_TOUCHSCREEN_DA9034=y +CONFIG_TOUCHSCREEN_DA9052=y +CONFIG_TOUCHSCREEN_DYNAPRO=y +CONFIG_TOUCHSCREEN_HAMPSHIRE=y +CONFIG_TOUCHSCREEN_EETI=y +CONFIG_TOUCHSCREEN_EGALAX=y +CONFIG_TOUCHSCREEN_EGALAX_SERIAL=y +CONFIG_TOUCHSCREEN_EXC3000=y +CONFIG_TOUCHSCREEN_FUJITSU=y +CONFIG_TOUCHSCREEN_GOODIX=y +CONFIG_TOUCHSCREEN_HIDEEP=y +CONFIG_TOUCHSCREEN_ILI210X=y +CONFIG_TOUCHSCREEN_IPROC=y +CONFIG_TOUCHSCREEN_S6SY761=y +CONFIG_TOUCHSCREEN_GUNZE=y +CONFIG_TOUCHSCREEN_EKTF2127=y +CONFIG_TOUCHSCREEN_ELAN=y +CONFIG_TOUCHSCREEN_ELO=y +CONFIG_TOUCHSCREEN_WACOM_W8001=y +CONFIG_TOUCHSCREEN_WACOM_I2C=y +CONFIG_TOUCHSCREEN_MAX11801=y +CONFIG_TOUCHSCREEN_MCS5000=y +CONFIG_TOUCHSCREEN_MMS114=y +CONFIG_TOUCHSCREEN_MELFAS_MIP4=y +CONFIG_TOUCHSCREEN_MTOUCH=y +CONFIG_TOUCHSCREEN_IMX6UL_TSC=y +CONFIG_TOUCHSCREEN_INEXIO=y +CONFIG_TOUCHSCREEN_MK712=y +CONFIG_TOUCHSCREEN_PENMOUNT=y +CONFIG_TOUCHSCREEN_EDT_FT5X06=y +CONFIG_TOUCHSCREEN_MIGOR=y +CONFIG_TOUCHSCREEN_TOUCHRIGHT=y +CONFIG_TOUCHSCREEN_TOUCHWIN=y +CONFIG_TOUCHSCREEN_TI_AM335X_TSC=y +CONFIG_TOUCHSCREEN_UCB1400=y +CONFIG_TOUCHSCREEN_PIXCIR=y +CONFIG_TOUCHSCREEN_WDT87XX_I2C=y +CONFIG_TOUCHSCREEN_WM831X=y +CONFIG_TOUCHSCREEN_WM97XX=y +CONFIG_TOUCHSCREEN_WM9705=y +CONFIG_TOUCHSCREEN_WM9712=y +CONFIG_TOUCHSCREEN_WM9713=y +CONFIG_TOUCHSCREEN_USB_COMPOSITE=y +CONFIG_TOUCHSCREEN_MXS_LRADC=y +CONFIG_TOUCHSCREEN_MX25=y +CONFIG_TOUCHSCREEN_MC13783=y +CONFIG_TOUCHSCREEN_USB_EGALAX=y +CONFIG_TOUCHSCREEN_USB_PANJIT=y +CONFIG_TOUCHSCREEN_USB_3M=y +CONFIG_TOUCHSCREEN_USB_ITM=y +CONFIG_TOUCHSCREEN_USB_ETURBO=y +CONFIG_TOUCHSCREEN_USB_GUNZE=y +CONFIG_TOUCHSCREEN_USB_DMC_TSC10=y +CONFIG_TOUCHSCREEN_USB_IRTOUCH=y +CONFIG_TOUCHSCREEN_USB_IDEALTEK=y +CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH=y +CONFIG_TOUCHSCREEN_USB_GOTOP=y +CONFIG_TOUCHSCREEN_USB_JASTEC=y +CONFIG_TOUCHSCREEN_USB_ELO=y +CONFIG_TOUCHSCREEN_USB_E2I=y +CONFIG_TOUCHSCREEN_USB_ZYTRONIC=y +CONFIG_TOUCHSCREEN_USB_ETT_TC45USB=y +CONFIG_TOUCHSCREEN_USB_NEXIO=y +CONFIG_TOUCHSCREEN_USB_EASYTOUCH=y +CONFIG_TOUCHSCREEN_TOUCHIT213=y +CONFIG_TOUCHSCREEN_TS4800=y +CONFIG_TOUCHSCREEN_TSC_SERIO=y +CONFIG_TOUCHSCREEN_TSC200X_CORE=y +CONFIG_TOUCHSCREEN_TSC2004=y +CONFIG_TOUCHSCREEN_TSC2005=y +CONFIG_TOUCHSCREEN_TSC2007=y +CONFIG_TOUCHSCREEN_TSC2007_IIO=y +CONFIG_TOUCHSCREEN_PCAP=y +CONFIG_TOUCHSCREEN_RM_TS=y +CONFIG_TOUCHSCREEN_SILEAD=y +CONFIG_TOUCHSCREEN_SIS_I2C=y +CONFIG_TOUCHSCREEN_ST1232=y +CONFIG_TOUCHSCREEN_STMFTS=y +CONFIG_TOUCHSCREEN_STMPE=y +CONFIG_TOUCHSCREEN_SUN4I=y +CONFIG_TOUCHSCREEN_SUR40=y +CONFIG_TOUCHSCREEN_SURFACE3_SPI=y +CONFIG_TOUCHSCREEN_SX8654=y +CONFIG_TOUCHSCREEN_TPS6507X=y +CONFIG_TOUCHSCREEN_ZET6223=y +CONFIG_TOUCHSCREEN_ZFORCE=y +CONFIG_TOUCHSCREEN_COLIBRI_VF50=y +CONFIG_TOUCHSCREEN_ROHM_BU21023=y +CONFIG_INPUT_MISC=y +CONFIG_INPUT_88PM860X_ONKEY=y +CONFIG_INPUT_88PM80X_ONKEY=y +CONFIG_INPUT_AD714X=y +CONFIG_INPUT_AD714X_I2C=y +CONFIG_INPUT_AD714X_SPI=y +CONFIG_INPUT_ARIZONA_HAPTICS=y +CONFIG_INPUT_ATMEL_CAPTOUCH=y +CONFIG_INPUT_BMA150=y +CONFIG_INPUT_E3X0_BUTTON=y +CONFIG_INPUT_PCSPKR=y +CONFIG_INPUT_PM8941_PWRKEY=y +CONFIG_INPUT_PM8XXX_VIBRATOR=y +CONFIG_INPUT_PMIC8XXX_PWRKEY=y +CONFIG_INPUT_MAX77693_HAPTIC=y +CONFIG_INPUT_MAX8925_ONKEY=y +CONFIG_INPUT_MAX8997_HAPTIC=y +CONFIG_INPUT_MC13783_PWRBUTTON=y +CONFIG_INPUT_MMA8450=y +CONFIG_INPUT_APANEL=y +CONFIG_INPUT_GP2A=y +CONFIG_INPUT_GPIO_BEEPER=y +CONFIG_INPUT_GPIO_DECODER=y +CONFIG_INPUT_CPCAP_PWRBUTTON=y +CONFIG_INPUT_ATLAS_BTNS=y +CONFIG_INPUT_ATI_REMOTE2=y +CONFIG_INPUT_KEYSPAN_REMOTE=y +CONFIG_INPUT_KXTJ9=y +CONFIG_INPUT_KXTJ9_POLLED_MODE=y +CONFIG_INPUT_POWERMATE=y +CONFIG_INPUT_YEALINK=y +CONFIG_INPUT_CM109=y +CONFIG_INPUT_REGULATOR_HAPTIC=y +CONFIG_INPUT_RETU_PWRBUTTON=y +CONFIG_INPUT_TPS65218_PWRBUTTON=y +CONFIG_INPUT_AXP20X_PEK=y +CONFIG_INPUT_TWL4030_PWRBUTTON=y +CONFIG_INPUT_TWL4030_VIBRA=y +CONFIG_INPUT_TWL6040_VIBRA=y +CONFIG_INPUT_UINPUT=y +CONFIG_INPUT_PALMAS_PWRBUTTON=y +CONFIG_INPUT_PCF50633_PMU=y +CONFIG_INPUT_PCF8574=y +CONFIG_INPUT_PWM_BEEPER=y +CONFIG_INPUT_PWM_VIBRA=y +CONFIG_INPUT_RK805_PWRKEY=y +CONFIG_INPUT_GPIO_ROTARY_ENCODER=y +CONFIG_INPUT_DA9052_ONKEY=y +CONFIG_INPUT_DA9055_ONKEY=y +CONFIG_INPUT_DA9063_ONKEY=y +CONFIG_INPUT_WM831X_ON=y +CONFIG_INPUT_PCAP=y +CONFIG_INPUT_ADXL34X=y +CONFIG_INPUT_ADXL34X_I2C=y +CONFIG_INPUT_ADXL34X_SPI=y +CONFIG_INPUT_IMS_PCU=y +CONFIG_INPUT_CMA3000=y +CONFIG_INPUT_CMA3000_I2C=y +CONFIG_INPUT_XEN_KBDDEV_FRONTEND=y +CONFIG_INPUT_IDEAPAD_SLIDEBAR=y +CONFIG_INPUT_SOC_BUTTON_ARRAY=y +CONFIG_INPUT_DRV260X_HAPTICS=y +CONFIG_INPUT_DRV2665_HAPTICS=y +CONFIG_INPUT_DRV2667_HAPTICS=y +CONFIG_INPUT_HISI_POWERKEY=y +CONFIG_RMI4_CORE=y +CONFIG_RMI4_I2C=y +CONFIG_RMI4_SPI=y +CONFIG_RMI4_SMB=y +CONFIG_RMI4_F03=y +CONFIG_RMI4_F03_SERIO=y +CONFIG_RMI4_2D_SENSOR=y +CONFIG_RMI4_F11=y +CONFIG_RMI4_F12=y +CONFIG_RMI4_F30=y +CONFIG_RMI4_F34=y +CONFIG_RMI4_F54=y +CONFIG_RMI4_F55=y + +# +# Hardware I/O ports +# +CONFIG_SERIO=y +CONFIG_ARCH_MIGHT_HAVE_PC_SERIO=y +CONFIG_SERIO_I8042=y +CONFIG_SERIO_SERPORT=y +CONFIG_SERIO_CT82C710=y +CONFIG_SERIO_PARKBD=y +CONFIG_SERIO_PCIPS2=y +CONFIG_SERIO_LIBPS2=y +CONFIG_SERIO_RAW=y +CONFIG_SERIO_ALTERA_PS2=y +CONFIG_SERIO_PS2MULT=y +CONFIG_SERIO_ARC_PS2=y +CONFIG_SERIO_APBPS2=y +CONFIG_SERIO_OLPC_APSP=y +CONFIG_HYPERV_KEYBOARD=y +CONFIG_SERIO_SUN4I_PS2=y +CONFIG_SERIO_GPIO_PS2=y +CONFIG_USERIO=y +CONFIG_GAMEPORT=y +CONFIG_GAMEPORT_NS558=y +CONFIG_GAMEPORT_L4=y +CONFIG_GAMEPORT_EMU10K1=y +CONFIG_GAMEPORT_FM801=y + +# +# Character devices +# +CONFIG_TTY=y +CONFIG_VT=y +CONFIG_CONSOLE_TRANSLATIONS=y +CONFIG_VT_CONSOLE=y +CONFIG_VT_CONSOLE_SLEEP=y +CONFIG_HW_CONSOLE=y +CONFIG_VT_HW_CONSOLE_BINDING=y +CONFIG_UNIX98_PTYS=y +CONFIG_LEGACY_PTYS=y +CONFIG_LEGACY_PTY_COUNT=256 +CONFIG_SERIAL_NONSTANDARD=y +CONFIG_ROCKETPORT=y +CONFIG_CYCLADES=y +CONFIG_CYZ_INTR=y +CONFIG_MOXA_INTELLIO=y +CONFIG_MOXA_SMARTIO=y +CONFIG_SYNCLINK=y +CONFIG_SYNCLINKMP=y +CONFIG_SYNCLINK_GT=y +CONFIG_NOZOMI=y +CONFIG_ISI=y +CONFIG_N_HDLC=y +CONFIG_N_GSM=y +CONFIG_TRACE_ROUTER=y +CONFIG_TRACE_SINK=y +CONFIG_GOLDFISH_TTY=y +CONFIG_GOLDFISH_TTY_EARLY_CONSOLE=y +CONFIG_DEVMEM=y +CONFIG_DEVKMEM=y + +# +# Serial drivers +# +CONFIG_SERIAL_EARLYCON=y +CONFIG_SERIAL_8250=y +CONFIG_SERIAL_8250_DEPRECATED_OPTIONS=y +CONFIG_SERIAL_8250_PNP=y +CONFIG_SERIAL_8250_FINTEK=y +CONFIG_SERIAL_8250_CONSOLE=y +CONFIG_SERIAL_8250_DMA=y +CONFIG_SERIAL_8250_PCI=y +CONFIG_SERIAL_8250_EXAR=y +CONFIG_SERIAL_8250_CS=y +CONFIG_SERIAL_8250_MEN_MCB=y +CONFIG_SERIAL_8250_NR_UARTS=4 +CONFIG_SERIAL_8250_RUNTIME_UARTS=4 +CONFIG_SERIAL_8250_EXTENDED=y +CONFIG_SERIAL_8250_MANY_PORTS=y +CONFIG_SERIAL_8250_ASPEED_VUART=y +CONFIG_SERIAL_8250_SHARE_IRQ=y +CONFIG_SERIAL_8250_DETECT_IRQ=y +CONFIG_SERIAL_8250_RSA=y +CONFIG_SERIAL_8250_BCM2835AUX=y +# CONFIG_SERIAL_8250_FSL is not set +CONFIG_SERIAL_8250_DW=y +CONFIG_SERIAL_8250_RT288X=y +CONFIG_SERIAL_8250_LPC18XX=y +CONFIG_SERIAL_8250_UNIPHIER=y +CONFIG_SERIAL_8250_INGENIC=y +CONFIG_SERIAL_8250_LPSS=y +CONFIG_SERIAL_8250_MID=y +CONFIG_SERIAL_8250_MOXA=y +CONFIG_SERIAL_OF_PLATFORM=y + +# +# Non-8250 serial port support +# +CONFIG_SERIAL_ATMEL=y +CONFIG_SERIAL_ATMEL_CONSOLE=y +CONFIG_SERIAL_ATMEL_PDC=y +CONFIG_SERIAL_ATMEL_TTYAT=y +CONFIG_SERIAL_KGDB_NMI=y +CONFIG_SERIAL_CLPS711X=y +CONFIG_SERIAL_CLPS711X_CONSOLE=y +CONFIG_SERIAL_MAX3100=y +CONFIG_SERIAL_MAX310X=y +CONFIG_SERIAL_IMX=y +CONFIG_SERIAL_IMX_CONSOLE=y +CONFIG_SERIAL_UARTLITE=y +CONFIG_SERIAL_UARTLITE_CONSOLE=y +CONFIG_SERIAL_UARTLITE_NR_UARTS=1 +CONFIG_SERIAL_SH_SCI=y +CONFIG_SERIAL_SH_SCI_NR_UARTS=2 +CONFIG_SERIAL_SH_SCI_CONSOLE=y +CONFIG_SERIAL_SH_SCI_EARLYCON=y +CONFIG_SERIAL_SH_SCI_DMA=y +CONFIG_SERIAL_CORE=y +CONFIG_SERIAL_CORE_CONSOLE=y +CONFIG_CONSOLE_POLL=y +CONFIG_SERIAL_JSM=y +CONFIG_SERIAL_SCCNXP=y +CONFIG_SERIAL_SCCNXP_CONSOLE=y +CONFIG_SERIAL_SC16IS7XX_CORE=y +CONFIG_SERIAL_SC16IS7XX=y +CONFIG_SERIAL_SC16IS7XX_I2C=y +CONFIG_SERIAL_SC16IS7XX_SPI=y +CONFIG_SERIAL_TIMBERDALE=y +CONFIG_SERIAL_BCM63XX=y +CONFIG_SERIAL_BCM63XX_CONSOLE=y +CONFIG_SERIAL_ALTERA_JTAGUART=y +CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE=y +CONFIG_SERIAL_ALTERA_JTAGUART_CONSOLE_BYPASS=y +CONFIG_SERIAL_ALTERA_UART=y +CONFIG_SERIAL_ALTERA_UART_MAXPORTS=4 +CONFIG_SERIAL_ALTERA_UART_BAUDRATE=115200 +CONFIG_SERIAL_ALTERA_UART_CONSOLE=y +CONFIG_SERIAL_IFX6X60=y +CONFIG_SERIAL_PCH_UART=y +CONFIG_SERIAL_PCH_UART_CONSOLE=y +CONFIG_SERIAL_MXS_AUART=y +CONFIG_SERIAL_MXS_AUART_CONSOLE=y +CONFIG_SERIAL_XILINX_PS_UART=y +CONFIG_SERIAL_XILINX_PS_UART_CONSOLE=y +CONFIG_SERIAL_MPS2_UART_CONSOLE=y +CONFIG_SERIAL_MPS2_UART=y +CONFIG_SERIAL_ARC=y +CONFIG_SERIAL_ARC_CONSOLE=y +CONFIG_SERIAL_ARC_NR_PORTS=1 +CONFIG_SERIAL_RP2=y +CONFIG_SERIAL_RP2_NR_UARTS=32 +CONFIG_SERIAL_FSL_LPUART=y +CONFIG_SERIAL_FSL_LPUART_CONSOLE=y +CONFIG_SERIAL_CONEXANT_DIGICOLOR=y +CONFIG_SERIAL_CONEXANT_DIGICOLOR_CONSOLE=y +CONFIG_SERIAL_ST_ASC=y +CONFIG_SERIAL_ST_ASC_CONSOLE=y +CONFIG_SERIAL_MEN_Z135=y +CONFIG_SERIAL_STM32=y +CONFIG_SERIAL_STM32_CONSOLE=y +CONFIG_SERIAL_MVEBU_UART=y +CONFIG_SERIAL_MVEBU_CONSOLE=y +CONFIG_SERIAL_OWL=y +CONFIG_SERIAL_OWL_CONSOLE=y +CONFIG_SERIAL_MCTRL_GPIO=y +CONFIG_SERIAL_DEV_BUS=y +CONFIG_SERIAL_DEV_CTRL_TTYPORT=y +CONFIG_TTY_PRINTK=y +CONFIG_PRINTER=y +CONFIG_LP_CONSOLE=y +CONFIG_PPDEV=y +CONFIG_HVC_DRIVER=y +CONFIG_HVC_IRQ=y +CONFIG_HVC_XEN=y +CONFIG_HVC_XEN_FRONTEND=y +CONFIG_VIRTIO_CONSOLE=y +CONFIG_IPMI_HANDLER=y +CONFIG_IPMI_DMI_DECODE=y +CONFIG_IPMI_PROC_INTERFACE=y +CONFIG_IPMI_PANIC_EVENT=y +CONFIG_IPMI_PANIC_STRING=y +CONFIG_IPMI_DEVICE_INTERFACE=y +CONFIG_IPMI_SI=y +CONFIG_IPMI_SSIF=y +CONFIG_IPMI_WATCHDOG=y +CONFIG_IPMI_POWEROFF=y +CONFIG_ASPEED_BT_IPMI_BMC=y +CONFIG_HW_RANDOM=y +CONFIG_HW_RANDOM_TIMERIOMEM=y +CONFIG_HW_RANDOM_INTEL=y +CONFIG_HW_RANDOM_AMD=y +CONFIG_HW_RANDOM_VIA=y +CONFIG_HW_RANDOM_VIRTIO=y +CONFIG_HW_RANDOM_STM32=y +CONFIG_HW_RANDOM_MESON=y +CONFIG_HW_RANDOM_CAVIUM=y +CONFIG_HW_RANDOM_MTK=y +CONFIG_HW_RANDOM_EXYNOS=y +CONFIG_NVRAM=y +CONFIG_R3964=y +CONFIG_APPLICOM=y + +# +# PCMCIA character devices +# +CONFIG_SYNCLINK_CS=y +CONFIG_CARDMAN_4000=y +CONFIG_CARDMAN_4040=y +CONFIG_SCR24X=y +CONFIG_IPWIRELESS=y +CONFIG_MWAVE=y +CONFIG_RAW_DRIVER=y +CONFIG_MAX_RAW_DEVS=256 +CONFIG_HPET=y +CONFIG_HPET_MMAP=y +CONFIG_HPET_MMAP_DEFAULT=y +CONFIG_HANGCHECK_TIMER=y +CONFIG_UV_MMTIMER=y +CONFIG_TCG_TPM=y +CONFIG_HW_RANDOM_TPM=y +CONFIG_TCG_TIS_CORE=y +CONFIG_TCG_TIS=y +CONFIG_TCG_TIS_SPI=y +CONFIG_TCG_TIS_I2C_ATMEL=y +CONFIG_TCG_TIS_I2C_INFINEON=y +CONFIG_TCG_TIS_I2C_NUVOTON=y +CONFIG_TCG_NSC=y +CONFIG_TCG_ATMEL=y +CONFIG_TCG_INFINEON=y +CONFIG_TCG_XEN=y +CONFIG_TCG_CRB=y +CONFIG_TCG_VTPM_PROXY=y +CONFIG_TCG_TIS_ST33ZP24=y +CONFIG_TCG_TIS_ST33ZP24_I2C=y +CONFIG_TCG_TIS_ST33ZP24_SPI=y +CONFIG_TELCLOCK=y +CONFIG_DEVPORT=y +CONFIG_XILLYBUS=y +CONFIG_XILLYBUS_PCIE=y +CONFIG_XILLYBUS_OF=y + +# +# I2C support +# +CONFIG_I2C=y +CONFIG_ACPI_I2C_OPREGION=y +CONFIG_I2C_BOARDINFO=y +CONFIG_I2C_COMPAT=y +CONFIG_I2C_CHARDEV=y +CONFIG_I2C_MUX=y + +# +# Multiplexer I2C Chip support +# +CONFIG_I2C_ARB_GPIO_CHALLENGE=y +CONFIG_I2C_MUX_GPIO=y +CONFIG_I2C_MUX_GPMUX=y +CONFIG_I2C_MUX_LTC4306=y +CONFIG_I2C_MUX_PCA9541=y +CONFIG_I2C_MUX_PCA954x=y +CONFIG_I2C_MUX_PINCTRL=y +CONFIG_I2C_MUX_REG=y +CONFIG_I2C_DEMUX_PINCTRL=y +CONFIG_I2C_MUX_MLXCPLD=y +CONFIG_I2C_HELPER_AUTO=y +CONFIG_I2C_SMBUS=y +CONFIG_I2C_ALGOBIT=y +CONFIG_I2C_ALGOPCA=y + +# +# I2C Hardware Bus support +# + +# +# PC SMBus host controller drivers +# +CONFIG_I2C_ALI1535=y +CONFIG_I2C_ALI1563=y +CONFIG_I2C_ALI15X3=y +CONFIG_I2C_AMD756=y +CONFIG_I2C_AMD756_S4882=y +CONFIG_I2C_AMD8111=y +CONFIG_I2C_HIX5HD2=y +CONFIG_I2C_I801=y +CONFIG_I2C_ISCH=y +CONFIG_I2C_ISMT=y +CONFIG_I2C_PIIX4=y +CONFIG_I2C_CHT_WC=y +CONFIG_I2C_NFORCE2=y +CONFIG_I2C_NFORCE2_S4985=y +CONFIG_I2C_SIS5595=y +CONFIG_I2C_SIS630=y +CONFIG_I2C_SIS96X=y +CONFIG_I2C_VIA=y +CONFIG_I2C_VIAPRO=y + +# +# ACPI drivers +# +CONFIG_I2C_SCMI=y + +# +# I2C system bus drivers (mostly embedded / system-on-chip) +# +CONFIG_I2C_ASPEED=y +CONFIG_I2C_AXXIA=y +CONFIG_I2C_BCM_IPROC=y +CONFIG_I2C_BRCMSTB=y +CONFIG_I2C_CBUS_GPIO=y +CONFIG_I2C_DESIGNWARE_CORE=y +CONFIG_I2C_DESIGNWARE_PLATFORM=y +CONFIG_I2C_DESIGNWARE_SLAVE=y +CONFIG_I2C_DESIGNWARE_PCI=y +CONFIG_I2C_DESIGNWARE_BAYTRAIL=y +CONFIG_I2C_EFM32=y +CONFIG_I2C_EG20T=y +CONFIG_I2C_EMEV2=y +CONFIG_I2C_GPIO=y +CONFIG_I2C_GPIO_FAULT_INJECTOR=y +CONFIG_I2C_IMG=y +CONFIG_I2C_IMX_LPI2C=y +CONFIG_I2C_JZ4780=y +CONFIG_I2C_KEMPLD=y +CONFIG_I2C_LPC2K=y +CONFIG_I2C_MESON=y +CONFIG_I2C_MT65XX=y +CONFIG_I2C_OCORES=y +CONFIG_I2C_PCA_PLATFORM=y +# CONFIG_I2C_PXA_PCI is not set +CONFIG_I2C_RIIC=y +CONFIG_I2C_RK3X=y +CONFIG_I2C_SH_MOBILE=y +CONFIG_I2C_SIMTEC=y +CONFIG_I2C_STM32F4=y +CONFIG_I2C_STM32F7=y +CONFIG_I2C_SUN6I_P2WI=y +CONFIG_I2C_UNIPHIER=y +CONFIG_I2C_UNIPHIER_F=y +CONFIG_I2C_VERSATILE=y +CONFIG_I2C_THUNDERX=y +CONFIG_I2C_XILINX=y +CONFIG_I2C_XLP9XX=y +CONFIG_I2C_RCAR=y + +# +# External I2C/SMBus adapter drivers +# +CONFIG_I2C_DIOLAN_U2C=y +CONFIG_I2C_DLN2=y +CONFIG_I2C_PARPORT=y +CONFIG_I2C_PARPORT_LIGHT=y +CONFIG_I2C_ROBOTFUZZ_OSIF=y +CONFIG_I2C_TAOS_EVM=y +CONFIG_I2C_TINY_USB=y +CONFIG_I2C_VIPERBOARD=y + +# +# Other I2C/SMBus bus drivers +# +CONFIG_I2C_MLXCPLD=y +CONFIG_I2C_CROS_EC_TUNNEL=y +CONFIG_I2C_STUB=m +CONFIG_I2C_SLAVE=y +CONFIG_I2C_SLAVE_EEPROM=y +CONFIG_I2C_DEBUG_CORE=y +CONFIG_I2C_DEBUG_ALGO=y +CONFIG_I2C_DEBUG_BUS=y +CONFIG_SPI=y +CONFIG_SPI_DEBUG=y +CONFIG_SPI_MASTER=y + +# +# SPI Master Controller Drivers +# +CONFIG_SPI_ALTERA=y +CONFIG_SPI_ARMADA_3700=y +CONFIG_SPI_ATMEL=y +CONFIG_SPI_AXI_SPI_ENGINE=y +CONFIG_SPI_BCM2835=y +CONFIG_SPI_BCM2835AUX=y +CONFIG_SPI_BCM63XX=y +CONFIG_SPI_BCM63XX_HSSPI=y +CONFIG_SPI_BCM_QSPI=y +CONFIG_SPI_BITBANG=y +CONFIG_SPI_BUTTERFLY=y +CONFIG_SPI_CADENCE=y +CONFIG_SPI_CLPS711X=y +CONFIG_SPI_DESIGNWARE=y +CONFIG_SPI_DW_PCI=y +CONFIG_SPI_DW_MID_DMA=y +CONFIG_SPI_DW_MMIO=y +CONFIG_SPI_DLN2=y +CONFIG_SPI_EP93XX=y +CONFIG_SPI_FSL_LPSPI=y +CONFIG_SPI_GPIO=y +CONFIG_SPI_IMG_SPFI=y +CONFIG_SPI_IMX=y +CONFIG_SPI_JCORE=y +CONFIG_SPI_LM70_LLP=y +CONFIG_SPI_LP8841_RTC=y +CONFIG_SPI_FSL_LIB=y +CONFIG_SPI_FSL_SPI=y +CONFIG_SPI_FSL_DSPI=y +CONFIG_SPI_MESON_SPICC=y +CONFIG_SPI_MESON_SPIFC=y +CONFIG_SPI_MT65XX=y +CONFIG_SPI_LANTIQ_SSC=y +CONFIG_SPI_OC_TINY=y +CONFIG_SPI_OMAP24XX=y +CONFIG_SPI_TI_QSPI=y +CONFIG_SPI_OMAP_100K=y +CONFIG_SPI_ORION=y +CONFIG_SPI_PIC32=y +CONFIG_SPI_PIC32_SQI=y +CONFIG_SPI_PXA2XX=y +CONFIG_SPI_PXA2XX_PCI=y +CONFIG_SPI_ROCKCHIP=y +CONFIG_SPI_RSPI=y +CONFIG_SPI_S3C64XX=y +CONFIG_SPI_SC18IS602=y +CONFIG_SPI_SH_MSIOF=y +CONFIG_SPI_SH=y +CONFIG_SPI_SH_HSPI=y +CONFIG_SPI_SPRD_ADI=y +CONFIG_SPI_STM32=y +CONFIG_SPI_ST_SSC4=y +CONFIG_SPI_SUN4I=y +CONFIG_SPI_SUN6I=y +CONFIG_SPI_TEGRA114=y +CONFIG_SPI_TEGRA20_SFLASH=y +CONFIG_SPI_TEGRA20_SLINK=y +CONFIG_SPI_THUNDERX=y +CONFIG_SPI_TOPCLIFF_PCH=y +CONFIG_SPI_TXX9=y +CONFIG_SPI_XCOMM=y +CONFIG_SPI_XILINX=y +CONFIG_SPI_XLP=y +CONFIG_SPI_XTENSA_XTFPGA=y +CONFIG_SPI_ZYNQMP_GQSPI=y + +# +# SPI Protocol Masters +# +CONFIG_SPI_SPIDEV=y +CONFIG_SPI_LOOPBACK_TEST=m +CONFIG_SPI_TLE62X0=y +CONFIG_SPI_SLAVE=y +CONFIG_SPI_SLAVE_TIME=y +CONFIG_SPI_SLAVE_SYSTEM_CONTROL=y +CONFIG_SPMI=y +CONFIG_SPMI_MSM_PMIC_ARB=y +CONFIG_HSI=y +CONFIG_HSI_BOARDINFO=y + +# +# HSI controllers +# + +# +# HSI clients +# +CONFIG_HSI_CHAR=y +CONFIG_PPS=y +CONFIG_PPS_DEBUG=y + +# +# PPS clients support +# +CONFIG_PPS_CLIENT_KTIMER=y +CONFIG_PPS_CLIENT_LDISC=y +CONFIG_PPS_CLIENT_PARPORT=y +CONFIG_PPS_CLIENT_GPIO=y + +# +# PPS generators support +# + +# +# PTP clock support +# +CONFIG_PTP_1588_CLOCK=y +CONFIG_PTP_1588_CLOCK_DTE=y +CONFIG_PTP_1588_CLOCK_GIANFAR=y +CONFIG_DP83640_PHY=y +CONFIG_PTP_1588_CLOCK_PCH=y +CONFIG_PTP_1588_CLOCK_KVM=y +CONFIG_PINCTRL=y +CONFIG_GENERIC_PINCTRL_GROUPS=y +CONFIG_PINMUX=y +CONFIG_GENERIC_PINMUX_FUNCTIONS=y +CONFIG_PINCONF=y +CONFIG_GENERIC_PINCONF=y +CONFIG_DEBUG_PINCTRL=y +CONFIG_PINCTRL_AS3722=y +CONFIG_PINCTRL_AXP209=y +CONFIG_PINCTRL_AMD=y +CONFIG_PINCTRL_DA850_PUPD=y +CONFIG_PINCTRL_LPC18XX=y +CONFIG_PINCTRL_MCP23S08=y +CONFIG_PINCTRL_RZA1=y +CONFIG_PINCTRL_SINGLE=y +CONFIG_PINCTRL_SX150X=y +CONFIG_PINCTRL_MAX77620=y +CONFIG_PINCTRL_PALMAS=y +CONFIG_PINCTRL_INGENIC=y +CONFIG_PINCTRL_RK805=y +CONFIG_PINCTRL_OCELOT=y +CONFIG_PINCTRL_ASPEED=y +CONFIG_PINCTRL_ASPEED_G4=y +CONFIG_PINCTRL_ASPEED_G5=y +CONFIG_PINCTRL_BCM281XX=y +CONFIG_PINCTRL_IPROC_GPIO=y +CONFIG_PINCTRL_CYGNUS_MUX=y +CONFIG_PINCTRL_NSP_GPIO=y +CONFIG_PINCTRL_NS2_MUX=y +CONFIG_PINCTRL_NSP_MUX=y +CONFIG_PINCTRL_BERLIN=y +# CONFIG_PINCTRL_BERLIN_BG2 is not set +# CONFIG_PINCTRL_BERLIN_BG2CD is not set +# CONFIG_PINCTRL_BERLIN_BG2Q is not set +CONFIG_PINCTRL_BERLIN_BG4CT=y +CONFIG_PINCTRL_BAYTRAIL=y +CONFIG_PINCTRL_CHERRYVIEW=y +CONFIG_PINCTRL_MERRIFIELD=y +CONFIG_PINCTRL_INTEL=y +CONFIG_PINCTRL_BROXTON=y +CONFIG_PINCTRL_CANNONLAKE=y +CONFIG_PINCTRL_CEDARFORK=y +CONFIG_PINCTRL_DENVERTON=y +CONFIG_PINCTRL_GEMINILAKE=y +CONFIG_PINCTRL_LEWISBURG=y +CONFIG_PINCTRL_SUNRISEPOINT=y +CONFIG_PINCTRL_PXA=y +CONFIG_PINCTRL_PXA25X=y +CONFIG_PINCTRL_PXA27X=y +CONFIG_PINCTRL_MSM=y +CONFIG_PINCTRL_APQ8064=y +CONFIG_PINCTRL_APQ8084=y +CONFIG_PINCTRL_IPQ4019=y +CONFIG_PINCTRL_IPQ8064=y +CONFIG_PINCTRL_IPQ8074=y +CONFIG_PINCTRL_MSM8660=y +CONFIG_PINCTRL_MSM8960=y +CONFIG_PINCTRL_MDM9615=y +CONFIG_PINCTRL_MSM8X74=y +CONFIG_PINCTRL_MSM8916=y +CONFIG_PINCTRL_MSM8994=y +CONFIG_PINCTRL_MSM8996=y +CONFIG_PINCTRL_MSM8998=y +CONFIG_PINCTRL_QDF2XXX=y +CONFIG_PINCTRL_QCOM_SPMI_PMIC=y +CONFIG_PINCTRL_QCOM_SSBI_PMIC=y +CONFIG_PINCTRL_SPRD=y +CONFIG_PINCTRL_SPRD_SC9860=y +CONFIG_PINCTRL_STM32=y +CONFIG_PINCTRL_STM32F429=y +CONFIG_PINCTRL_STM32F469=y +CONFIG_PINCTRL_STM32F746=y +CONFIG_PINCTRL_STM32F769=y +CONFIG_PINCTRL_STM32H743=y +CONFIG_PINCTRL_STM32MP157=y +CONFIG_PINCTRL_TI_IODELAY=y +CONFIG_PINCTRL_UNIPHIER=y +CONFIG_PINCTRL_UNIPHIER_LD4=y +CONFIG_PINCTRL_UNIPHIER_PRO4=y +CONFIG_PINCTRL_UNIPHIER_SLD8=y +CONFIG_PINCTRL_UNIPHIER_PRO5=y +CONFIG_PINCTRL_UNIPHIER_PXS2=y +CONFIG_PINCTRL_UNIPHIER_LD6B=y +CONFIG_PINCTRL_UNIPHIER_LD11=y +CONFIG_PINCTRL_UNIPHIER_LD20=y +CONFIG_PINCTRL_UNIPHIER_PXS3=y + +# +# MediaTek pinctrl drivers +# +CONFIG_PINCTRL_MTK=y +CONFIG_PINCTRL_MT2701=y +CONFIG_PINCTRL_MT8135=y +CONFIG_PINCTRL_MT8127=y +CONFIG_PINCTRL_MT7622=y +CONFIG_PINCTRL_MT8173=y +CONFIG_PINCTRL_MT6397=y +CONFIG_GPIOLIB=y +CONFIG_OF_GPIO=y +CONFIG_GPIO_ACPI=y +CONFIG_GPIOLIB_IRQCHIP=y +CONFIG_DEBUG_GPIO=y +CONFIG_GPIO_SYSFS=y +CONFIG_GPIO_GENERIC=y +CONFIG_GPIO_MAX730X=y + +# +# Memory mapped GPIO drivers +# +CONFIG_GPIO_74XX_MMIO=y +CONFIG_GPIO_ALTERA=y +CONFIG_GPIO_AMDPT=y +CONFIG_GPIO_ASPEED=y +CONFIG_GPIO_ATH79=y +CONFIG_GPIO_BCM_KONA=y +CONFIG_GPIO_BRCMSTB=y +CONFIG_GPIO_CLPS711X=y +CONFIG_GPIO_DWAPB=y +CONFIG_GPIO_EM=y +CONFIG_GPIO_ETRAXFS=y +CONFIG_GPIO_EXAR=y +CONFIG_GPIO_FTGPIO010=y +CONFIG_GPIO_GENERIC_PLATFORM=y +CONFIG_GPIO_GRGPIO=y +CONFIG_GPIO_ICH=y +CONFIG_GPIO_INGENIC=y +CONFIG_GPIO_IOP=y +CONFIG_GPIO_LPC18XX=y +CONFIG_GPIO_LYNXPOINT=y +CONFIG_GPIO_MB86S7X=y +CONFIG_GPIO_MENZ127=y +CONFIG_GPIO_MOCKUP=y +CONFIG_GPIO_MPC8XXX=y +CONFIG_GPIO_RCAR=y +CONFIG_GPIO_SYSCON=y +CONFIG_GPIO_TEGRA=y +CONFIG_GPIO_TEGRA186=y +CONFIG_GPIO_TS4800=y +CONFIG_GPIO_THUNDERX=y +CONFIG_GPIO_UNIPHIER=y +CONFIG_GPIO_VX855=y +CONFIG_GPIO_XILINX=y +CONFIG_GPIO_XLP=y +CONFIG_GPIO_ZX=y + +# +# Port-mapped I/O GPIO drivers +# +CONFIG_GPIO_104_DIO_48E=y +CONFIG_GPIO_104_IDIO_16=y +CONFIG_GPIO_104_IDI_48=y +CONFIG_GPIO_F7188X=y +CONFIG_GPIO_GPIO_MM=y +CONFIG_GPIO_IT87=y +CONFIG_GPIO_SCH=y +CONFIG_GPIO_SCH311X=y +CONFIG_GPIO_TS5500=y +CONFIG_GPIO_WINBOND=y +CONFIG_GPIO_WS16C48=y + +# +# I2C GPIO expanders +# +CONFIG_GPIO_ADP5588=y +CONFIG_GPIO_ADP5588_IRQ=y +CONFIG_GPIO_ADNP=y +CONFIG_GPIO_MAX7300=y +CONFIG_GPIO_MAX732X=y +CONFIG_GPIO_MAX732X_IRQ=y +CONFIG_GPIO_PCA953X=y +CONFIG_GPIO_PCA953X_IRQ=y +CONFIG_GPIO_PCF857X=y +CONFIG_GPIO_TPIC2810=y +CONFIG_GPIO_TS4900=y + +# +# MFD GPIO expanders +# +CONFIG_GPIO_ADP5520=y +CONFIG_GPIO_ARIZONA=y +CONFIG_GPIO_BD9571MWV=y +CONFIG_GPIO_CRYSTAL_COVE=y +CONFIG_GPIO_CS5535=y +CONFIG_GPIO_DA9052=y +CONFIG_GPIO_DA9055=y +CONFIG_GPIO_DLN2=y +CONFIG_GPIO_JANZ_TTL=y +CONFIG_GPIO_KEMPLD=y +CONFIG_GPIO_LP3943=y +CONFIG_GPIO_LP873X=y +CONFIG_GPIO_LP87565=y +CONFIG_GPIO_MAX77620=y +CONFIG_GPIO_MSIC=y +CONFIG_GPIO_PALMAS=y +CONFIG_GPIO_RC5T583=y +CONFIG_GPIO_STMPE=y +CONFIG_GPIO_TC3589X=y +CONFIG_GPIO_TIMBERDALE=y +CONFIG_GPIO_TPS65086=y +CONFIG_GPIO_TPS65218=y +CONFIG_GPIO_TPS6586X=y +CONFIG_GPIO_TPS65910=y +CONFIG_GPIO_TPS65912=y +CONFIG_GPIO_TPS68470=y +CONFIG_GPIO_TWL4030=y +CONFIG_GPIO_TWL6040=y +CONFIG_GPIO_UCB1400=y +CONFIG_GPIO_WHISKEY_COVE=y +CONFIG_GPIO_WM831X=y +CONFIG_GPIO_WM8350=y +CONFIG_GPIO_WM8994=y + +# +# PCI GPIO expanders +# +CONFIG_GPIO_AMD8111=y +CONFIG_GPIO_INTEL_MID=y +CONFIG_GPIO_MERRIFIELD=y +CONFIG_GPIO_ML_IOH=y +CONFIG_GPIO_PCH=y +CONFIG_GPIO_PCI_IDIO_16=y +CONFIG_GPIO_PCIE_IDIO_24=y +CONFIG_GPIO_RDC321X=y +CONFIG_GPIO_SODAVILLE=y + +# +# SPI GPIO expanders +# +CONFIG_GPIO_74X164=y +CONFIG_GPIO_MAX3191X=y +CONFIG_GPIO_MAX7301=y +CONFIG_GPIO_MC33880=y +CONFIG_GPIO_PISOSR=y +CONFIG_GPIO_XRA1403=y + +# +# USB GPIO expanders +# +CONFIG_GPIO_VIPERBOARD=y +CONFIG_W1=y +CONFIG_W1_CON=y + +# +# 1-wire Bus Masters +# +CONFIG_W1_MASTER_MATROX=y +CONFIG_W1_MASTER_DS2490=y +CONFIG_W1_MASTER_DS2482=y +CONFIG_W1_MASTER_MXC=y +CONFIG_W1_MASTER_DS1WM=y +CONFIG_W1_MASTER_GPIO=y + +# +# 1-wire Slaves +# +CONFIG_W1_SLAVE_THERM=y +CONFIG_W1_SLAVE_SMEM=y +CONFIG_W1_SLAVE_DS2405=y +CONFIG_W1_SLAVE_DS2408=y +CONFIG_W1_SLAVE_DS2408_READBACK=y +CONFIG_W1_SLAVE_DS2413=y +CONFIG_W1_SLAVE_DS2406=y +CONFIG_W1_SLAVE_DS2423=y +CONFIG_W1_SLAVE_DS2805=y +CONFIG_W1_SLAVE_DS2431=y +CONFIG_W1_SLAVE_DS2433=y +CONFIG_W1_SLAVE_DS2433_CRC=y +CONFIG_W1_SLAVE_DS2438=y +CONFIG_W1_SLAVE_DS2760=y +CONFIG_W1_SLAVE_DS2780=y +CONFIG_W1_SLAVE_DS2781=y +CONFIG_W1_SLAVE_DS28E04=y +CONFIG_W1_SLAVE_DS28E17=y +CONFIG_POWER_AVS=y +CONFIG_POWER_RESET=y +CONFIG_POWER_RESET_AS3722=y +CONFIG_POWER_RESET_BRCMKONA=y +CONFIG_POWER_RESET_BRCMSTB=y +CONFIG_POWER_RESET_GEMINI_POWEROFF=y +CONFIG_POWER_RESET_GPIO=y +CONFIG_POWER_RESET_GPIO_RESTART=y +CONFIG_POWER_RESET_PIIX4_POWEROFF=y +CONFIG_POWER_RESET_LTC2952=y +CONFIG_POWER_RESET_RESTART=y +CONFIG_POWER_RESET_KEYSTONE=y +CONFIG_POWER_RESET_SYSCON=y +CONFIG_POWER_RESET_SYSCON_POWEROFF=y +CONFIG_POWER_RESET_RMOBILE=y +CONFIG_POWER_RESET_ZX=y +CONFIG_REBOOT_MODE=y +CONFIG_SYSCON_REBOOT_MODE=y +CONFIG_POWER_SUPPLY=y +CONFIG_POWER_SUPPLY_DEBUG=y +CONFIG_PDA_POWER=y +CONFIG_GENERIC_ADC_BATTERY=y +CONFIG_MAX8925_POWER=y +CONFIG_WM831X_BACKUP=y +CONFIG_WM831X_POWER=y +CONFIG_WM8350_POWER=y +CONFIG_TEST_POWER=y +CONFIG_BATTERY_88PM860X=y +CONFIG_BATTERY_ACT8945A=y +CONFIG_BATTERY_CPCAP=y +CONFIG_BATTERY_DS2760=y +CONFIG_BATTERY_DS2780=y +CONFIG_BATTERY_DS2781=y +CONFIG_BATTERY_DS2782=y +CONFIG_BATTERY_LEGO_EV3=y +CONFIG_BATTERY_WM97XX=y +CONFIG_BATTERY_SBS=y +CONFIG_CHARGER_SBS=y +CONFIG_MANAGER_SBS=y +CONFIG_BATTERY_BQ27XXX=y +CONFIG_BATTERY_BQ27XXX_I2C=y +CONFIG_BATTERY_BQ27XXX_HDQ=y +CONFIG_BATTERY_BQ27XXX_DT_UPDATES_NVM=y +CONFIG_BATTERY_DA9030=y +CONFIG_BATTERY_DA9052=y +CONFIG_CHARGER_DA9150=y +CONFIG_BATTERY_DA9150=y +CONFIG_CHARGER_AXP20X=y +CONFIG_BATTERY_AXP20X=y +CONFIG_AXP20X_POWER=y +CONFIG_AXP288_CHARGER=y +CONFIG_AXP288_FUEL_GAUGE=y +CONFIG_BATTERY_MAX17040=y +CONFIG_BATTERY_MAX17042=y +CONFIG_BATTERY_MAX1721X=y +CONFIG_BATTERY_TWL4030_MADC=y +CONFIG_CHARGER_88PM860X=y +CONFIG_CHARGER_PCF50633=y +CONFIG_BATTERY_RX51=y +CONFIG_CHARGER_CPCAP=y +CONFIG_CHARGER_ISP1704=y +CONFIG_CHARGER_MAX8903=y +CONFIG_CHARGER_TWL4030=y +CONFIG_CHARGER_LP8727=y +CONFIG_CHARGER_LP8788=y +CONFIG_CHARGER_GPIO=y +CONFIG_CHARGER_MANAGER=y +CONFIG_CHARGER_LTC3651=y +CONFIG_CHARGER_MAX14577=y +CONFIG_CHARGER_DETECTOR_MAX14656=y +CONFIG_CHARGER_MAX77693=y +CONFIG_CHARGER_MAX8997=y +CONFIG_CHARGER_MAX8998=y +CONFIG_CHARGER_QCOM_SMBB=y +CONFIG_CHARGER_BQ2415X=y +CONFIG_CHARGER_BQ24190=y +CONFIG_CHARGER_BQ24257=y +CONFIG_CHARGER_BQ24735=y +CONFIG_CHARGER_BQ25890=y +CONFIG_CHARGER_SMB347=y +CONFIG_CHARGER_TPS65090=y +CONFIG_CHARGER_TPS65217=y +CONFIG_BATTERY_GAUGE_LTC2941=y +CONFIG_BATTERY_GOLDFISH=y +CONFIG_BATTERY_RT5033=y +CONFIG_CHARGER_RT9455=y +CONFIG_HWMON=y +CONFIG_HWMON_VID=y +CONFIG_HWMON_DEBUG_CHIP=y + +# +# Native drivers +# +CONFIG_SENSORS_ABITUGURU=y +CONFIG_SENSORS_ABITUGURU3=y +CONFIG_SENSORS_AD7314=y +CONFIG_SENSORS_AD7414=y +CONFIG_SENSORS_AD7418=y +CONFIG_SENSORS_ADM1021=y +CONFIG_SENSORS_ADM1025=y +CONFIG_SENSORS_ADM1026=y +CONFIG_SENSORS_ADM1029=y +CONFIG_SENSORS_ADM1031=y +CONFIG_SENSORS_ADM9240=y +CONFIG_SENSORS_ADT7X10=y +CONFIG_SENSORS_ADT7310=y +CONFIG_SENSORS_ADT7410=y +CONFIG_SENSORS_ADT7411=y +CONFIG_SENSORS_ADT7462=y +CONFIG_SENSORS_ADT7470=y +CONFIG_SENSORS_ADT7475=y +CONFIG_SENSORS_ASC7621=y +CONFIG_SENSORS_K8TEMP=y +CONFIG_SENSORS_K10TEMP=y +CONFIG_SENSORS_FAM15H_POWER=y +CONFIG_SENSORS_APPLESMC=y +CONFIG_SENSORS_ARM_SCPI=y +CONFIG_SENSORS_ASB100=y +CONFIG_SENSORS_ASPEED=y +CONFIG_SENSORS_ATXP1=y +CONFIG_SENSORS_DS620=y +CONFIG_SENSORS_DS1621=y +CONFIG_SENSORS_DELL_SMM=y +CONFIG_SENSORS_DA9052_ADC=y +CONFIG_SENSORS_DA9055=y +CONFIG_SENSORS_I5K_AMB=y +CONFIG_SENSORS_F71805F=y +CONFIG_SENSORS_F71882FG=y +CONFIG_SENSORS_F75375S=y +CONFIG_SENSORS_MC13783_ADC=y +CONFIG_SENSORS_FSCHMD=y +CONFIG_SENSORS_FTSTEUTATES=y +CONFIG_SENSORS_GL518SM=y +CONFIG_SENSORS_GL520SM=y +CONFIG_SENSORS_G760A=y +CONFIG_SENSORS_G762=y +CONFIG_SENSORS_GPIO_FAN=y +CONFIG_SENSORS_HIH6130=y +CONFIG_SENSORS_IBMAEM=y +CONFIG_SENSORS_IBMPEX=y +CONFIG_SENSORS_IIO_HWMON=y +CONFIG_SENSORS_I5500=y +CONFIG_SENSORS_CORETEMP=y +CONFIG_SENSORS_IT87=y +CONFIG_SENSORS_JC42=y +CONFIG_SENSORS_POWR1220=y +CONFIG_SENSORS_LINEAGE=y +CONFIG_SENSORS_LTC2945=y +CONFIG_SENSORS_LTC2990=y +CONFIG_SENSORS_LTC4151=y +CONFIG_SENSORS_LTC4215=y +CONFIG_SENSORS_LTC4222=y +CONFIG_SENSORS_LTC4245=y +CONFIG_SENSORS_LTC4260=y +CONFIG_SENSORS_LTC4261=y +CONFIG_SENSORS_MAX1111=y +CONFIG_SENSORS_MAX16065=y +CONFIG_SENSORS_MAX1619=y +CONFIG_SENSORS_MAX1668=y +CONFIG_SENSORS_MAX197=y +CONFIG_SENSORS_MAX31722=y +CONFIG_SENSORS_MAX6621=y +CONFIG_SENSORS_MAX6639=y +CONFIG_SENSORS_MAX6642=y +CONFIG_SENSORS_MAX6650=y +CONFIG_SENSORS_MAX6697=y +CONFIG_SENSORS_MAX31790=y +CONFIG_SENSORS_MCP3021=y +CONFIG_SENSORS_TC654=y +CONFIG_SENSORS_MENF21BMC_HWMON=y +CONFIG_SENSORS_ADCXX=y +CONFIG_SENSORS_LM63=y +CONFIG_SENSORS_LM70=y +CONFIG_SENSORS_LM73=y +CONFIG_SENSORS_LM75=y +CONFIG_SENSORS_LM77=y +CONFIG_SENSORS_LM78=y +CONFIG_SENSORS_LM80=y +CONFIG_SENSORS_LM83=y +CONFIG_SENSORS_LM85=y +CONFIG_SENSORS_LM87=y +CONFIG_SENSORS_LM90=y +CONFIG_SENSORS_LM92=y +CONFIG_SENSORS_LM93=y +CONFIG_SENSORS_LM95234=y +CONFIG_SENSORS_LM95241=y +CONFIG_SENSORS_LM95245=y +CONFIG_SENSORS_PC87360=y +CONFIG_SENSORS_PC87427=y +CONFIG_SENSORS_NTC_THERMISTOR=y +CONFIG_SENSORS_NCT6683=y +CONFIG_SENSORS_NCT6775=y +CONFIG_SENSORS_NCT7802=y +CONFIG_SENSORS_NCT7904=y +CONFIG_SENSORS_NSA320=y +CONFIG_SENSORS_PCF8591=y +CONFIG_PMBUS=y +CONFIG_SENSORS_PMBUS=y +CONFIG_SENSORS_ADM1275=y +CONFIG_SENSORS_IBM_CFFPS=y +CONFIG_SENSORS_IR35221=y +CONFIG_SENSORS_LM25066=y +CONFIG_SENSORS_LTC2978=y +CONFIG_SENSORS_LTC2978_REGULATOR=y +CONFIG_SENSORS_LTC3815=y +CONFIG_SENSORS_MAX16064=y +CONFIG_SENSORS_MAX20751=y +CONFIG_SENSORS_MAX31785=y +CONFIG_SENSORS_MAX34440=y +CONFIG_SENSORS_MAX8688=y +CONFIG_SENSORS_TPS40422=y +CONFIG_SENSORS_TPS53679=y +CONFIG_SENSORS_UCD9000=y +CONFIG_SENSORS_UCD9200=y +CONFIG_SENSORS_ZL6100=y +CONFIG_SENSORS_PWM_FAN=y +CONFIG_SENSORS_SHT15=y +CONFIG_SENSORS_SHT21=y +CONFIG_SENSORS_SHT3x=y +CONFIG_SENSORS_SHTC1=y +CONFIG_SENSORS_SIS5595=y +CONFIG_SENSORS_DME1737=y +CONFIG_SENSORS_EMC1403=y +CONFIG_SENSORS_EMC2103=y +CONFIG_SENSORS_EMC6W201=y +CONFIG_SENSORS_SMSC47M1=y +CONFIG_SENSORS_SMSC47M192=y +CONFIG_SENSORS_SMSC47B397=y +CONFIG_SENSORS_SCH56XX_COMMON=y +CONFIG_SENSORS_SCH5627=y +CONFIG_SENSORS_SCH5636=y +CONFIG_SENSORS_STTS751=y +CONFIG_SENSORS_SMM665=y +CONFIG_SENSORS_ADC128D818=y +CONFIG_SENSORS_ADS1015=y +CONFIG_SENSORS_ADS7828=y +CONFIG_SENSORS_ADS7871=y +CONFIG_SENSORS_AMC6821=y +CONFIG_SENSORS_INA209=y +CONFIG_SENSORS_INA2XX=y +CONFIG_SENSORS_INA3221=y +CONFIG_SENSORS_TC74=y +CONFIG_SENSORS_THMC50=y +CONFIG_SENSORS_TMP102=y +CONFIG_SENSORS_TMP103=y +CONFIG_SENSORS_TMP108=y +CONFIG_SENSORS_TMP401=y +CONFIG_SENSORS_TMP421=y +CONFIG_SENSORS_VIA_CPUTEMP=y +CONFIG_SENSORS_VIA686A=y +CONFIG_SENSORS_VT1211=y +CONFIG_SENSORS_VT8231=y +CONFIG_SENSORS_W83773G=y +CONFIG_SENSORS_W83781D=y +CONFIG_SENSORS_W83791D=y +CONFIG_SENSORS_W83792D=y +CONFIG_SENSORS_W83793=y +CONFIG_SENSORS_W83795=y +CONFIG_SENSORS_W83795_FANCTRL=y +CONFIG_SENSORS_W83L785TS=y +CONFIG_SENSORS_W83L786NG=y +CONFIG_SENSORS_W83627HF=y +CONFIG_SENSORS_W83627EHF=y +CONFIG_SENSORS_WM831X=y +CONFIG_SENSORS_WM8350=y +CONFIG_SENSORS_XGENE=y + +# +# ACPI drivers +# +CONFIG_SENSORS_ACPI_POWER=y +CONFIG_SENSORS_ATK0110=y +CONFIG_THERMAL=y +CONFIG_THERMAL_EMERGENCY_POWEROFF_DELAY_MS=0 +CONFIG_THERMAL_HWMON=y +CONFIG_THERMAL_OF=y +CONFIG_THERMAL_WRITABLE_TRIPS=y +CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE=y +# CONFIG_THERMAL_DEFAULT_GOV_FAIR_SHARE is not set +# CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE is not set +# CONFIG_THERMAL_DEFAULT_GOV_POWER_ALLOCATOR is not set +CONFIG_THERMAL_GOV_FAIR_SHARE=y +CONFIG_THERMAL_GOV_STEP_WISE=y +CONFIG_THERMAL_GOV_BANG_BANG=y +CONFIG_THERMAL_GOV_USER_SPACE=y +CONFIG_THERMAL_GOV_POWER_ALLOCATOR=y +CONFIG_CPU_THERMAL=y +CONFIG_CLOCK_THERMAL=y +CONFIG_DEVFREQ_THERMAL=y +CONFIG_THERMAL_EMULATION=y +CONFIG_HISI_THERMAL=y +CONFIG_IMX_THERMAL=y +CONFIG_MAX77620_THERMAL=y +CONFIG_QORIQ_THERMAL=y +CONFIG_SPEAR_THERMAL=y +CONFIG_ROCKCHIP_THERMAL=y +CONFIG_RCAR_THERMAL=y +CONFIG_RCAR_GEN3_THERMAL=y +CONFIG_KIRKWOOD_THERMAL=y +CONFIG_DOVE_THERMAL=y +CONFIG_ARMADA_THERMAL=y +CONFIG_DA9062_THERMAL=y +CONFIG_INTEL_POWERCLAMP=y +CONFIG_X86_PKG_TEMP_THERMAL=y +CONFIG_INTEL_SOC_DTS_IOSF_CORE=y +CONFIG_INTEL_SOC_DTS_THERMAL=y + +# +# ACPI INT340X thermal drivers +# +CONFIG_INT340X_THERMAL=y +CONFIG_ACPI_THERMAL_REL=y +CONFIG_INT3406_THERMAL=y +CONFIG_INTEL_BXT_PMIC_THERMAL=y +CONFIG_INTEL_PCH_THERMAL=y +CONFIG_MTK_THERMAL=y + +# +# Broadcom thermal drivers +# +CONFIG_BCM2835_THERMAL=y +CONFIG_BRCMSTB_THERMAL=y +CONFIG_BCM_NS_THERMAL=y + +# +# Texas Instruments thermal drivers +# +CONFIG_TI_SOC_THERMAL=y +CONFIG_TI_THERMAL=y +CONFIG_OMAP3_THERMAL=y +CONFIG_OMAP4_THERMAL=y +CONFIG_OMAP5_THERMAL=y +CONFIG_DRA752_THERMAL=y + +# +# Samsung thermal drivers +# +CONFIG_EXYNOS_THERMAL=y +CONFIG_TANGO_THERMAL=y +CONFIG_QCOM_SPMI_TEMP_ALARM=y +CONFIG_GENERIC_ADC_THERMAL=y + +# +# Qualcomm thermal drivers +# +CONFIG_QCOM_TSENS=y +CONFIG_ZX2967_THERMAL=y +CONFIG_UNIPHIER_THERMAL=y +CONFIG_WATCHDOG=y +CONFIG_WATCHDOG_CORE=y +CONFIG_WATCHDOG_NOWAYOUT=y +CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED=y +CONFIG_WATCHDOG_SYSFS=y + +# +# Watchdog Device Drivers +# +CONFIG_SOFT_WATCHDOG=y +CONFIG_SOFT_WATCHDOG_PRETIMEOUT=y +CONFIG_DA9052_WATCHDOG=y +CONFIG_DA9055_WATCHDOG=y +CONFIG_DA9063_WATCHDOG=y +CONFIG_DA9062_WATCHDOG=y +CONFIG_GPIO_WATCHDOG=y +CONFIG_GPIO_WATCHDOG_ARCH_INITCALL=y +CONFIG_MENF21BMC_WATCHDOG=y +CONFIG_TANGOX_WATCHDOG=y +CONFIG_WDAT_WDT=y +CONFIG_WM831X_WATCHDOG=y +CONFIG_WM8350_WATCHDOG=y +CONFIG_XILINX_WATCHDOG=y +CONFIG_ZIIRAVE_WATCHDOG=y +CONFIG_RAVE_SP_WATCHDOG=y +CONFIG_ASM9260_WATCHDOG=y +CONFIG_AT91RM9200_WATCHDOG=y +CONFIG_AT91SAM9X_WATCHDOG=y +CONFIG_SAMA5D4_WATCHDOG=y +CONFIG_CADENCE_WATCHDOG=y +CONFIG_FTWDT010_WATCHDOG=y +CONFIG_S3C2410_WATCHDOG=y +CONFIG_DW_WATCHDOG=y +CONFIG_EP93XX_WATCHDOG=y +CONFIG_OMAP_WATCHDOG=y +CONFIG_DAVINCI_WATCHDOG=y +CONFIG_RN5T618_WATCHDOG=y +CONFIG_SUNXI_WATCHDOG=y +CONFIG_TWL4030_WATCHDOG=y +CONFIG_STMP3XXX_RTC_WATCHDOG=y +CONFIG_NUC900_WATCHDOG=y +CONFIG_TS4800_WATCHDOG=y +CONFIG_TS72XX_WATCHDOG=y +CONFIG_MAX63XX_WATCHDOG=y +CONFIG_MAX77620_WATCHDOG=y +CONFIG_IMX2_WDT=y +CONFIG_RETU_WATCHDOG=y +CONFIG_MOXART_WDT=y +CONFIG_SIRFSOC_WATCHDOG=y +CONFIG_ST_LPC_WATCHDOG=y +CONFIG_TEGRA_WATCHDOG=y +CONFIG_QCOM_WDT=y +CONFIG_MESON_GXBB_WATCHDOG=y +CONFIG_MESON_WATCHDOG=y +CONFIG_MEDIATEK_WATCHDOG=y +CONFIG_DIGICOLOR_WATCHDOG=y +CONFIG_LPC18XX_WATCHDOG=y +CONFIG_ATLAS7_WATCHDOG=y +CONFIG_RENESAS_WDT=y +CONFIG_RENESAS_RZAWDT=y +CONFIG_ASPEED_WATCHDOG=y +CONFIG_UNIPHIER_WATCHDOG=y +CONFIG_RTD119X_WATCHDOG=y +CONFIG_SPRD_WATCHDOG=y +CONFIG_ACQUIRE_WDT=y +CONFIG_ADVANTECH_WDT=y +CONFIG_ALIM1535_WDT=y +CONFIG_ALIM7101_WDT=y +CONFIG_EBC_C384_WDT=y +CONFIG_F71808E_WDT=y +CONFIG_SP5100_TCO=y +CONFIG_GEODE_WDT=y +CONFIG_SC520_WDT=y +CONFIG_SBC_FITPC2_WATCHDOG=y +CONFIG_EUROTECH_WDT=y +CONFIG_IB700_WDT=y +CONFIG_IBMASR=y +CONFIG_WAFER_WDT=y +CONFIG_I6300ESB_WDT=y +CONFIG_IE6XX_WDT=y +CONFIG_INTEL_SCU_WATCHDOG=y +CONFIG_INTEL_MID_WATCHDOG=y +CONFIG_ITCO_WDT=y +CONFIG_ITCO_VENDOR_SUPPORT=y +CONFIG_IT8712F_WDT=y +CONFIG_IT87_WDT=y +CONFIG_HP_WATCHDOG=y +CONFIG_KEMPLD_WDT=y +CONFIG_HPWDT_NMI_DECODING=y +CONFIG_SC1200_WDT=y +CONFIG_PC87413_WDT=y +CONFIG_NV_TCO=y +CONFIG_RDC321X_WDT=y +CONFIG_60XX_WDT=y +CONFIG_CPU5_WDT=y +CONFIG_SMSC_SCH311X_WDT=y +CONFIG_SMSC37B787_WDT=y +CONFIG_VIA_WDT=y +CONFIG_W83627HF_WDT=y +CONFIG_W83877F_WDT=y +CONFIG_W83977F_WDT=y +CONFIG_MACHZ_WDT=y +CONFIG_SBC_EPX_C3_WATCHDOG=y +CONFIG_INTEL_MEI_WDT=y +CONFIG_NI903X_WDT=y +CONFIG_NIC7018_WDT=y +CONFIG_BCM47XX_WDT=y +CONFIG_BCM2835_WDT=y +CONFIG_BCM_KONA_WDT=y +CONFIG_BCM_KONA_WDT_DEBUG=y +CONFIG_BCM7038_WDT=y +CONFIG_IMGPDC_WDT=y +CONFIG_MPC5200_WDT=y +CONFIG_MV64X60_WDT=y +CONFIG_MEN_A21_WDT=y +CONFIG_XEN_WDT=y +CONFIG_UML_WATCHDOG=y + +# +# PCI-based Watchdog Cards +# +CONFIG_PCIPCWATCHDOG=y +CONFIG_WDTPCI=y + +# +# USB-based Watchdog Cards +# +CONFIG_USBPCWATCHDOG=y + +# +# Watchdog Pretimeout Governors +# +CONFIG_WATCHDOG_PRETIMEOUT_GOV=y +# CONFIG_WATCHDOG_PRETIMEOUT_DEFAULT_GOV_NOOP is not set +CONFIG_WATCHDOG_PRETIMEOUT_DEFAULT_GOV_PANIC=y +CONFIG_WATCHDOG_PRETIMEOUT_GOV_NOOP=y +CONFIG_WATCHDOG_PRETIMEOUT_GOV_PANIC=y +CONFIG_SSB_POSSIBLE=y +CONFIG_SSB=y +CONFIG_SSB_SPROM=y +CONFIG_SSB_BLOCKIO=y +CONFIG_SSB_PCIHOST_POSSIBLE=y +CONFIG_SSB_PCIHOST=y +CONFIG_SSB_B43_PCI_BRIDGE=y +CONFIG_SSB_PCMCIAHOST_POSSIBLE=y +CONFIG_SSB_PCMCIAHOST=y +CONFIG_SSB_SDIOHOST_POSSIBLE=y +CONFIG_SSB_SDIOHOST=y +CONFIG_SSB_SILENT=y +CONFIG_SSB_DRIVER_PCICORE_POSSIBLE=y +CONFIG_SSB_DRIVER_PCICORE=y +CONFIG_SSB_DRIVER_GPIO=y +CONFIG_BCMA_POSSIBLE=y +CONFIG_BCMA=y +CONFIG_BCMA_BLOCKIO=y +CONFIG_BCMA_HOST_PCI_POSSIBLE=y +CONFIG_BCMA_HOST_PCI=y +CONFIG_BCMA_HOST_SOC=y +CONFIG_BCMA_DRIVER_PCI=y +CONFIG_BCMA_SFLASH=y +CONFIG_BCMA_DRIVER_GMAC_CMN=y +CONFIG_BCMA_DRIVER_GPIO=y +CONFIG_BCMA_DEBUG=y + +# +# Multifunction device drivers +# +CONFIG_MFD_CORE=y +CONFIG_MFD_CS5535=y +CONFIG_MFD_ACT8945A=y +CONFIG_MFD_AS3711=y +CONFIG_MFD_AS3722=y +CONFIG_PMIC_ADP5520=y +CONFIG_MFD_AAT2870_CORE=y +CONFIG_MFD_ATMEL_FLEXCOM=y +CONFIG_MFD_ATMEL_HLCDC=y +CONFIG_MFD_BCM590XX=y +CONFIG_MFD_BD9571MWV=y +CONFIG_MFD_AXP20X=y +CONFIG_MFD_AXP20X_I2C=y +CONFIG_MFD_CROS_EC=y +CONFIG_MFD_CROS_EC_I2C=y +CONFIG_MFD_CROS_EC_SPI=y +CONFIG_MFD_CROS_EC_CHARDEV=y +CONFIG_PMIC_DA903X=y +CONFIG_PMIC_DA9052=y +CONFIG_MFD_DA9052_SPI=y +CONFIG_MFD_DA9052_I2C=y +CONFIG_MFD_DA9055=y +CONFIG_MFD_DA9062=y +CONFIG_MFD_DA9063=y +CONFIG_MFD_DA9150=y +CONFIG_MFD_DLN2=y +CONFIG_MFD_EXYNOS_LPASS=y +CONFIG_MFD_MC13XXX=y +CONFIG_MFD_MC13XXX_SPI=y +CONFIG_MFD_MC13XXX_I2C=y +CONFIG_MFD_MXS_LRADC=y +CONFIG_MFD_MX25_TSADC=y +CONFIG_MFD_HI6421_PMIC=y +CONFIG_MFD_HI655X_PMIC=y +CONFIG_HTC_PASIC3=y +CONFIG_HTC_I2CPLD=y +CONFIG_MFD_INTEL_QUARK_I2C_GPIO=y +CONFIG_LPC_ICH=y +CONFIG_LPC_SCH=y +CONFIG_INTEL_SOC_PMIC=y +CONFIG_INTEL_SOC_PMIC_BXTWC=y +CONFIG_INTEL_SOC_PMIC_CHTWC=y +CONFIG_INTEL_SOC_PMIC_CHTDC_TI=y +CONFIG_MFD_INTEL_LPSS=y +CONFIG_MFD_INTEL_LPSS_ACPI=y +CONFIG_MFD_INTEL_LPSS_PCI=y +CONFIG_MFD_INTEL_MSIC=y +CONFIG_MFD_JANZ_CMODIO=y +CONFIG_MFD_KEMPLD=y +CONFIG_MFD_88PM800=y +CONFIG_MFD_88PM805=y +CONFIG_MFD_88PM860X=y +CONFIG_MFD_MAX14577=y +CONFIG_MFD_MAX77620=y +CONFIG_MFD_MAX77686=y +CONFIG_MFD_MAX77693=y +CONFIG_MFD_MAX77843=y +CONFIG_MFD_MAX8907=y +CONFIG_MFD_MAX8925=y +CONFIG_MFD_MAX8997=y +CONFIG_MFD_MAX8998=y +CONFIG_MFD_MT6397=y +CONFIG_MFD_MENF21BMC=y +CONFIG_EZX_PCAP=y +CONFIG_MFD_CPCAP=y +CONFIG_MFD_VIPERBOARD=y +CONFIG_MFD_RETU=y +CONFIG_MFD_PCF50633=y +CONFIG_PCF50633_ADC=y +CONFIG_PCF50633_GPIO=y +CONFIG_UCB1400_CORE=y +CONFIG_MFD_PM8XXX=y +CONFIG_MFD_SPMI_PMIC=y +CONFIG_MFD_RDC321X=y +CONFIG_MFD_RT5033=y +CONFIG_MFD_RC5T583=y +CONFIG_MFD_RK808=y +CONFIG_MFD_RN5T618=y +CONFIG_MFD_SEC_CORE=y +CONFIG_MFD_SI476X_CORE=y +CONFIG_MFD_SM501=y +CONFIG_MFD_SM501_GPIO=y +CONFIG_MFD_SKY81452=y +CONFIG_MFD_SMSC=y +CONFIG_MFD_SC27XX_PMIC=y +CONFIG_ABX500_CORE=y +CONFIG_AB3100_CORE=y +CONFIG_AB3100_OTP=y +CONFIG_MFD_STMPE=y + +# +# STMicroelectronics STMPE Interface Drivers +# +CONFIG_STMPE_I2C=y +CONFIG_STMPE_SPI=y +CONFIG_MFD_SYSCON=y +CONFIG_MFD_TI_AM335X_TSCADC=y +CONFIG_MFD_LP3943=y +CONFIG_MFD_LP8788=y +CONFIG_MFD_TI_LMU=y +CONFIG_MFD_PALMAS=y +CONFIG_TPS6105X=y +CONFIG_TPS65010=y +CONFIG_TPS6507X=y +CONFIG_MFD_TPS65086=y +CONFIG_MFD_TPS65090=y +CONFIG_MFD_TPS65217=y +CONFIG_MFD_TPS68470=y +CONFIG_MFD_TI_LP873X=y +CONFIG_MFD_TI_LP87565=y +CONFIG_MFD_TPS65218=y +CONFIG_MFD_TPS6586X=y +CONFIG_MFD_TPS65910=y +CONFIG_MFD_TPS65912=y +CONFIG_MFD_TPS65912_I2C=y +CONFIG_MFD_TPS65912_SPI=y +CONFIG_MFD_TPS80031=y +CONFIG_TWL4030_CORE=y +CONFIG_MFD_TWL4030_AUDIO=y +CONFIG_TWL6040_CORE=y +CONFIG_MFD_WL1273_CORE=y +CONFIG_MFD_LM3533=y +CONFIG_MFD_TIMBERDALE=y +CONFIG_MFD_TC3589X=y +# CONFIG_MFD_TMIO is not set +CONFIG_MFD_VX855=y +CONFIG_MFD_ARIZONA=y +CONFIG_MFD_ARIZONA_I2C=y +CONFIG_MFD_ARIZONA_SPI=y +CONFIG_MFD_CS47L24=y +CONFIG_MFD_WM5102=y +CONFIG_MFD_WM5110=y +CONFIG_MFD_WM8997=y +CONFIG_MFD_WM8998=y +CONFIG_MFD_WM8400=y +CONFIG_MFD_WM831X=y +CONFIG_MFD_WM831X_I2C=y +CONFIG_MFD_WM831X_SPI=y +CONFIG_MFD_WM8350=y +CONFIG_MFD_WM8350_I2C=y +CONFIG_MFD_WM8994=y +CONFIG_MFD_STW481X=y +CONFIG_MFD_STM32_LPTIMER=y +CONFIG_MFD_STM32_TIMERS=y +CONFIG_RAVE_SP_CORE=y +CONFIG_REGULATOR=y +CONFIG_REGULATOR_DEBUG=y +CONFIG_REGULATOR_FIXED_VOLTAGE=y +CONFIG_REGULATOR_VIRTUAL_CONSUMER=y +CONFIG_REGULATOR_USERSPACE_CONSUMER=y +CONFIG_REGULATOR_88PM800=y +CONFIG_REGULATOR_88PM8607=y +CONFIG_REGULATOR_ACT8865=y +CONFIG_REGULATOR_ACT8945A=y +CONFIG_REGULATOR_AD5398=y +CONFIG_REGULATOR_ANATOP=y +CONFIG_REGULATOR_AAT2870=y +CONFIG_REGULATOR_AB3100=y +CONFIG_REGULATOR_ARIZONA_LDO1=y +CONFIG_REGULATOR_ARIZONA_MICSUPP=y +CONFIG_REGULATOR_AS3711=y +CONFIG_REGULATOR_AS3722=y +CONFIG_REGULATOR_AXP20X=y +CONFIG_REGULATOR_BCM590XX=y +CONFIG_REGULATOR_BD9571MWV=y +CONFIG_REGULATOR_CPCAP=y +CONFIG_REGULATOR_DA903X=y +CONFIG_REGULATOR_DA9052=y +CONFIG_REGULATOR_DA9055=y +CONFIG_REGULATOR_DA9062=y +CONFIG_REGULATOR_DA9063=y +CONFIG_REGULATOR_DA9210=y +CONFIG_REGULATOR_DA9211=y +CONFIG_REGULATOR_FAN53555=y +CONFIG_REGULATOR_GPIO=y +CONFIG_REGULATOR_HI6421=y +CONFIG_REGULATOR_HI6421V530=y +CONFIG_REGULATOR_HI655X=y +CONFIG_REGULATOR_ISL9305=y +CONFIG_REGULATOR_ISL6271A=y +CONFIG_REGULATOR_LM363X=y +CONFIG_REGULATOR_LP3971=y +CONFIG_REGULATOR_LP3972=y +CONFIG_REGULATOR_LP872X=y +CONFIG_REGULATOR_LP873X=y +CONFIG_REGULATOR_LP8755=y +CONFIG_REGULATOR_LP87565=y +CONFIG_REGULATOR_LP8788=y +CONFIG_REGULATOR_LTC3589=y +CONFIG_REGULATOR_LTC3676=y +CONFIG_REGULATOR_MAX14577=y +CONFIG_REGULATOR_MAX1586=y +CONFIG_REGULATOR_MAX77620=y +CONFIG_REGULATOR_MAX8649=y +CONFIG_REGULATOR_MAX8660=y +CONFIG_REGULATOR_MAX8907=y +CONFIG_REGULATOR_MAX8925=y +CONFIG_REGULATOR_MAX8952=y +CONFIG_REGULATOR_MAX8973=y +CONFIG_REGULATOR_MAX8997=y +CONFIG_REGULATOR_MAX8998=y +CONFIG_REGULATOR_MAX77686=y +CONFIG_REGULATOR_MAX77693=y +CONFIG_REGULATOR_MAX77802=y +CONFIG_REGULATOR_MC13XXX_CORE=y +CONFIG_REGULATOR_MC13783=y +CONFIG_REGULATOR_MC13892=y +CONFIG_REGULATOR_MT6311=y +CONFIG_REGULATOR_MT6323=y +CONFIG_REGULATOR_MT6380=y +CONFIG_REGULATOR_MT6397=y +CONFIG_REGULATOR_PALMAS=y +CONFIG_REGULATOR_PBIAS=y +CONFIG_REGULATOR_PCAP=y +CONFIG_REGULATOR_PCF50633=y +CONFIG_REGULATOR_PFUZE100=y +CONFIG_REGULATOR_PV88060=y +CONFIG_REGULATOR_PV88080=y +CONFIG_REGULATOR_PV88090=y +CONFIG_REGULATOR_PWM=y +CONFIG_REGULATOR_QCOM_SPMI=y +CONFIG_REGULATOR_RC5T583=y +CONFIG_REGULATOR_RK808=y +CONFIG_REGULATOR_RN5T618=y +CONFIG_REGULATOR_RT5033=y +CONFIG_REGULATOR_S2MPA01=y +CONFIG_REGULATOR_S2MPS11=y +CONFIG_REGULATOR_S5M8767=y +CONFIG_REGULATOR_SC2731=y +CONFIG_REGULATOR_SKY81452=y +CONFIG_REGULATOR_STM32_VREFBUF=y +CONFIG_REGULATOR_STW481X_VMMC=y +CONFIG_REGULATOR_TPS51632=y +CONFIG_REGULATOR_TPS6105X=y +CONFIG_REGULATOR_TPS62360=y +CONFIG_REGULATOR_TPS65023=y +CONFIG_REGULATOR_TPS6507X=y +CONFIG_REGULATOR_TPS65086=y +CONFIG_REGULATOR_TPS65090=y +CONFIG_REGULATOR_TPS65132=y +CONFIG_REGULATOR_TPS65217=y +CONFIG_REGULATOR_TPS65218=y +CONFIG_REGULATOR_TPS6524X=y +CONFIG_REGULATOR_TPS6586X=y +CONFIG_REGULATOR_TPS65910=y +CONFIG_REGULATOR_TPS65912=y +CONFIG_REGULATOR_TPS80031=y +CONFIG_REGULATOR_TWL4030=y +CONFIG_REGULATOR_VCTRL=y +CONFIG_REGULATOR_WM831X=y +CONFIG_REGULATOR_WM8350=y +CONFIG_REGULATOR_WM8400=y +CONFIG_REGULATOR_WM8994=y +CONFIG_CEC_CORE=y +CONFIG_CEC_NOTIFIER=y +CONFIG_RC_CORE=y +CONFIG_RC_MAP=y +CONFIG_LIRC=y +CONFIG_RC_DECODERS=y +CONFIG_IR_NEC_DECODER=y +CONFIG_IR_RC5_DECODER=y +CONFIG_IR_RC6_DECODER=y +CONFIG_IR_JVC_DECODER=y +CONFIG_IR_SONY_DECODER=y +CONFIG_IR_SANYO_DECODER=y +CONFIG_IR_SHARP_DECODER=y +CONFIG_IR_MCE_KBD_DECODER=y +CONFIG_IR_XMP_DECODER=y +CONFIG_RC_DEVICES=y +CONFIG_RC_ATI_REMOTE=y +CONFIG_IR_ENE=y +CONFIG_IR_HIX5HD2=y +CONFIG_IR_IMON=y +CONFIG_IR_MCEUSB=y +CONFIG_IR_ITE_CIR=y +CONFIG_IR_FINTEK=y +CONFIG_IR_MESON=y +CONFIG_IR_MTK=y +CONFIG_IR_NUVOTON=y +CONFIG_IR_REDRAT3=y +CONFIG_IR_SPI=y +CONFIG_IR_STREAMZAP=y +CONFIG_IR_WINBOND_CIR=y +CONFIG_IR_IGORPLUGUSB=y +CONFIG_IR_IGUANA=y +CONFIG_IR_TTUSBIR=y +CONFIG_IR_RX51=y +CONFIG_IR_IMG=y +CONFIG_IR_IMG_RAW=y +CONFIG_IR_IMG_HW=y +CONFIG_IR_IMG_NEC=y +CONFIG_IR_IMG_JVC=y +CONFIG_IR_IMG_SONY=y +CONFIG_IR_IMG_SHARP=y +CONFIG_IR_IMG_SANYO=y +CONFIG_IR_IMG_RC5=y +CONFIG_IR_IMG_RC6=y +CONFIG_RC_LOOPBACK=y +CONFIG_IR_GPIO_CIR=y +CONFIG_IR_GPIO_TX=y +CONFIG_IR_PWM_TX=y +CONFIG_RC_ST=y +CONFIG_IR_SUNXI=y +CONFIG_IR_SERIAL=y +CONFIG_IR_SERIAL_TRANSMITTER=y +CONFIG_IR_SIR=y +CONFIG_IR_TANGO=y +CONFIG_IR_ZX=y +CONFIG_MEDIA_SUPPORT=y + +# +# Multimedia core support +# +CONFIG_MEDIA_CAMERA_SUPPORT=y +CONFIG_MEDIA_ANALOG_TV_SUPPORT=y +CONFIG_MEDIA_DIGITAL_TV_SUPPORT=y +CONFIG_MEDIA_RADIO_SUPPORT=y +CONFIG_MEDIA_SDR_SUPPORT=y +CONFIG_MEDIA_CEC_SUPPORT=y +CONFIG_MEDIA_CEC_RC=y +CONFIG_MEDIA_CONTROLLER=y +CONFIG_MEDIA_CONTROLLER_DVB=y +CONFIG_VIDEO_DEV=y +CONFIG_VIDEO_V4L2_SUBDEV_API=y +CONFIG_VIDEO_V4L2=y +CONFIG_VIDEO_ADV_DEBUG=y +CONFIG_VIDEO_FIXED_MINOR_RANGES=y +CONFIG_VIDEO_PCI_SKELETON=y +CONFIG_VIDEO_TUNER=y +CONFIG_V4L2_MEM2MEM_DEV=y +CONFIG_V4L2_FLASH_LED_CLASS=y +CONFIG_V4L2_FWNODE=y +CONFIG_VIDEOBUF_GEN=y +CONFIG_VIDEOBUF_DMA_SG=y +CONFIG_VIDEOBUF_VMALLOC=y +CONFIG_VIDEOBUF_DMA_CONTIG=y +CONFIG_VIDEOBUF_DVB=y +CONFIG_DVB_CORE=y +CONFIG_DVB_MMAP=y +CONFIG_DVB_NET=y +CONFIG_TTPCI_EEPROM=y +CONFIG_DVB_MAX_ADAPTERS=16 +CONFIG_DVB_DYNAMIC_MINORS=y +CONFIG_DVB_DEMUX_SECTION_LOSS_LOG=y +CONFIG_DVB_ULE_DEBUG=y + +# +# Media drivers +# +CONFIG_MEDIA_USB_SUPPORT=y + +# +# Webcam devices +# +CONFIG_USB_VIDEO_CLASS=y +CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y +CONFIG_USB_GSPCA=y +CONFIG_USB_M5602=y +CONFIG_USB_STV06XX=y +CONFIG_USB_GL860=y +CONFIG_USB_GSPCA_BENQ=y +CONFIG_USB_GSPCA_CONEX=y +CONFIG_USB_GSPCA_CPIA1=y +CONFIG_USB_GSPCA_DTCS033=y +CONFIG_USB_GSPCA_ETOMS=y +CONFIG_USB_GSPCA_FINEPIX=y +CONFIG_USB_GSPCA_JEILINJ=y +CONFIG_USB_GSPCA_JL2005BCD=y +CONFIG_USB_GSPCA_KINECT=y +CONFIG_USB_GSPCA_KONICA=y +CONFIG_USB_GSPCA_MARS=y +CONFIG_USB_GSPCA_MR97310A=y +CONFIG_USB_GSPCA_NW80X=y +CONFIG_USB_GSPCA_OV519=y +CONFIG_USB_GSPCA_OV534=y +CONFIG_USB_GSPCA_OV534_9=y +CONFIG_USB_GSPCA_PAC207=y +CONFIG_USB_GSPCA_PAC7302=y +CONFIG_USB_GSPCA_PAC7311=y +CONFIG_USB_GSPCA_SE401=y +CONFIG_USB_GSPCA_SN9C2028=y +CONFIG_USB_GSPCA_SN9C20X=y +CONFIG_USB_GSPCA_SONIXB=y +CONFIG_USB_GSPCA_SONIXJ=y +CONFIG_USB_GSPCA_SPCA500=y +CONFIG_USB_GSPCA_SPCA501=y +CONFIG_USB_GSPCA_SPCA505=y +CONFIG_USB_GSPCA_SPCA506=y +CONFIG_USB_GSPCA_SPCA508=y +CONFIG_USB_GSPCA_SPCA561=y +CONFIG_USB_GSPCA_SPCA1528=y +CONFIG_USB_GSPCA_SQ905=y +CONFIG_USB_GSPCA_SQ905C=y +CONFIG_USB_GSPCA_SQ930X=y +CONFIG_USB_GSPCA_STK014=y +CONFIG_USB_GSPCA_STK1135=y +CONFIG_USB_GSPCA_STV0680=y +CONFIG_USB_GSPCA_SUNPLUS=y +CONFIG_USB_GSPCA_T613=y +CONFIG_USB_GSPCA_TOPRO=y +CONFIG_USB_GSPCA_TOUPTEK=y +CONFIG_USB_GSPCA_TV8532=y +CONFIG_USB_GSPCA_VC032X=y +CONFIG_USB_GSPCA_VICAM=y +CONFIG_USB_GSPCA_XIRLINK_CIT=y +CONFIG_USB_GSPCA_ZC3XX=y +CONFIG_USB_PWC=y +CONFIG_USB_PWC_DEBUG=y +CONFIG_USB_PWC_INPUT_EVDEV=y +CONFIG_VIDEO_CPIA2=y +CONFIG_USB_ZR364XX=y +CONFIG_USB_STKWEBCAM=y +CONFIG_USB_S2255=y +CONFIG_VIDEO_USBTV=y + +# +# Analog TV USB devices +# +CONFIG_VIDEO_PVRUSB2=y +CONFIG_VIDEO_PVRUSB2_SYSFS=y +CONFIG_VIDEO_PVRUSB2_DVB=y +CONFIG_VIDEO_PVRUSB2_DEBUGIFC=y +CONFIG_VIDEO_HDPVR=y +CONFIG_VIDEO_USBVISION=y +CONFIG_VIDEO_STK1160_COMMON=y +CONFIG_VIDEO_STK1160=y +CONFIG_VIDEO_GO7007=y +CONFIG_VIDEO_GO7007_USB=y +CONFIG_VIDEO_GO7007_LOADER=y +CONFIG_VIDEO_GO7007_USB_S2250_BOARD=y + +# +# Analog/digital TV USB devices +# +CONFIG_VIDEO_AU0828=y +CONFIG_VIDEO_AU0828_V4L2=y +CONFIG_VIDEO_AU0828_RC=y +CONFIG_VIDEO_CX231XX=y +CONFIG_VIDEO_CX231XX_RC=y +CONFIG_VIDEO_CX231XX_ALSA=y +CONFIG_VIDEO_CX231XX_DVB=y +CONFIG_VIDEO_TM6000=y +CONFIG_VIDEO_TM6000_ALSA=y +CONFIG_VIDEO_TM6000_DVB=y + +# +# Digital TV USB devices +# +CONFIG_DVB_USB=y +CONFIG_DVB_USB_DEBUG=y +CONFIG_DVB_USB_DIB3000MC=y +CONFIG_DVB_USB_A800=y +CONFIG_DVB_USB_DIBUSB_MB=y +CONFIG_DVB_USB_DIBUSB_MB_FAULTY=y +CONFIG_DVB_USB_DIBUSB_MC=y +CONFIG_DVB_USB_DIB0700=y +CONFIG_DVB_USB_UMT_010=y +CONFIG_DVB_USB_CXUSB=y +CONFIG_DVB_USB_M920X=y +CONFIG_DVB_USB_DIGITV=y +CONFIG_DVB_USB_VP7045=y +CONFIG_DVB_USB_VP702X=y +CONFIG_DVB_USB_GP8PSK=y +CONFIG_DVB_USB_NOVA_T_USB2=y +CONFIG_DVB_USB_TTUSB2=y +CONFIG_DVB_USB_DTT200U=y +CONFIG_DVB_USB_OPERA1=y +CONFIG_DVB_USB_AF9005=y +CONFIG_DVB_USB_AF9005_REMOTE=y +CONFIG_DVB_USB_PCTV452E=y +CONFIG_DVB_USB_DW2102=y +CONFIG_DVB_USB_CINERGY_T2=y +CONFIG_DVB_USB_DTV5100=y +CONFIG_DVB_USB_FRIIO=y +CONFIG_DVB_USB_AZ6027=y +CONFIG_DVB_USB_TECHNISAT_USB2=y +CONFIG_DVB_USB_V2=y +CONFIG_DVB_USB_AF9015=y +CONFIG_DVB_USB_AF9035=y +CONFIG_DVB_USB_ANYSEE=y +CONFIG_DVB_USB_AU6610=y +CONFIG_DVB_USB_AZ6007=y +CONFIG_DVB_USB_CE6230=y +CONFIG_DVB_USB_EC168=y +CONFIG_DVB_USB_GL861=y +CONFIG_DVB_USB_LME2510=y +CONFIG_DVB_USB_MXL111SF=y +CONFIG_DVB_USB_RTL28XXU=y +CONFIG_DVB_USB_DVBSKY=y +CONFIG_DVB_USB_ZD1301=y +CONFIG_DVB_TTUSB_BUDGET=y +CONFIG_DVB_TTUSB_DEC=y +CONFIG_SMS_USB_DRV=y +CONFIG_DVB_B2C2_FLEXCOP_USB=y +CONFIG_DVB_B2C2_FLEXCOP_USB_DEBUG=y +CONFIG_DVB_AS102=y + +# +# Webcam, TV (analog/digital) USB devices +# +CONFIG_VIDEO_EM28XX=y +CONFIG_VIDEO_EM28XX_V4L2=y +CONFIG_VIDEO_EM28XX_ALSA=y +CONFIG_VIDEO_EM28XX_DVB=y +CONFIG_VIDEO_EM28XX_RC=y + +# +# Software defined radio USB devices +# +CONFIG_USB_AIRSPY=y +CONFIG_USB_HACKRF=y +CONFIG_USB_MSI2500=y + +# +# USB HDMI CEC adapters +# +CONFIG_USB_PULSE8_CEC=y +CONFIG_USB_RAINSHADOW_CEC=y +CONFIG_MEDIA_PCI_SUPPORT=y + +# +# Media capture support +# +CONFIG_VIDEO_MEYE=y +CONFIG_VIDEO_SOLO6X10=y +CONFIG_VIDEO_TW5864=y +CONFIG_VIDEO_TW68=y +CONFIG_VIDEO_TW686X=y +CONFIG_VIDEO_ZORAN=y +CONFIG_VIDEO_ZORAN_DC30=y +CONFIG_VIDEO_ZORAN_ZR36060=y +CONFIG_VIDEO_ZORAN_BUZ=y +CONFIG_VIDEO_ZORAN_DC10=y +CONFIG_VIDEO_ZORAN_LML33=y +CONFIG_VIDEO_ZORAN_LML33R10=y +CONFIG_VIDEO_ZORAN_AVS6EYES=y + +# +# Media capture/analog TV support +# +CONFIG_VIDEO_IVTV=y +CONFIG_VIDEO_IVTV_DEPRECATED_IOCTLS=y +CONFIG_VIDEO_IVTV_ALSA=y +CONFIG_VIDEO_FB_IVTV=y +CONFIG_VIDEO_HEXIUM_GEMINI=y +CONFIG_VIDEO_HEXIUM_ORION=y +CONFIG_VIDEO_MXB=y +CONFIG_VIDEO_DT3155=y + +# +# Media capture/analog/hybrid TV support +# +CONFIG_VIDEO_CX18=y +CONFIG_VIDEO_CX18_ALSA=y +CONFIG_VIDEO_CX23885=y +CONFIG_MEDIA_ALTERA_CI=y +CONFIG_VIDEO_CX25821=y +CONFIG_VIDEO_CX25821_ALSA=y +CONFIG_VIDEO_CX88=y +CONFIG_VIDEO_CX88_ALSA=y +CONFIG_VIDEO_CX88_BLACKBIRD=y +CONFIG_VIDEO_CX88_DVB=y +CONFIG_VIDEO_CX88_ENABLE_VP3054=y +CONFIG_VIDEO_CX88_VP3054=y +CONFIG_VIDEO_CX88_MPEG=y +CONFIG_VIDEO_BT848=y +CONFIG_DVB_BT8XX=y +CONFIG_VIDEO_SAA7134=y +CONFIG_VIDEO_SAA7134_ALSA=y +CONFIG_VIDEO_SAA7134_RC=y +CONFIG_VIDEO_SAA7134_DVB=y +CONFIG_VIDEO_SAA7134_GO7007=y +CONFIG_VIDEO_SAA7164=y +CONFIG_VIDEO_COBALT=y + +# +# Media digital TV PCI Adapters +# +CONFIG_DVB_AV7110_IR=y +CONFIG_DVB_AV7110=y +CONFIG_DVB_AV7110_OSD=y +CONFIG_DVB_BUDGET_CORE=y +CONFIG_DVB_BUDGET=y +CONFIG_DVB_BUDGET_CI=y +CONFIG_DVB_BUDGET_AV=y +CONFIG_DVB_BUDGET_PATCH=y +CONFIG_DVB_B2C2_FLEXCOP_PCI=y +CONFIG_DVB_B2C2_FLEXCOP_PCI_DEBUG=y +CONFIG_DVB_PLUTO2=y +CONFIG_DVB_DM1105=y +CONFIG_DVB_PT1=y +CONFIG_DVB_PT3=y +CONFIG_MANTIS_CORE=y +CONFIG_DVB_MANTIS=y +CONFIG_DVB_HOPPER=y +CONFIG_DVB_NGENE=y +CONFIG_DVB_DDBRIDGE=y +CONFIG_DVB_DDBRIDGE_MSIENABLE=y +CONFIG_DVB_SMIPCIE=y +CONFIG_DVB_NETUP_UNIDVB=y +CONFIG_VIDEO_IPU3_CIO2=y +CONFIG_V4L_PLATFORM_DRIVERS=y +CONFIG_VIDEO_CAFE_CCIC=y +CONFIG_VIDEO_VIA_CAMERA=y +CONFIG_VIDEO_DAVINCI_VPIF_DISPLAY=y +CONFIG_VIDEO_DAVINCI_VPIF_CAPTURE=y +CONFIG_VIDEO_DM6446_CCDC=y +CONFIG_VIDEO_DM355_CCDC=y +CONFIG_VIDEO_SH_VOU=y +CONFIG_VIDEO_M32R_AR=y +CONFIG_VIDEO_MUX=y +CONFIG_VIDEO_PXA27x=y +CONFIG_VIDEO_QCOM_CAMSS=y +CONFIG_VIDEO_S3C_CAMIF=y +CONFIG_VIDEO_STM32_DCMI=y +CONFIG_SOC_CAMERA=y +CONFIG_SOC_CAMERA_SCALE_CROP=y +CONFIG_SOC_CAMERA_PLATFORM=y +CONFIG_VIDEO_SH_MOBILE_CEU=y +CONFIG_VIDEO_SAMSUNG_EXYNOS4_IS=y +CONFIG_VIDEO_EXYNOS4_IS_COMMON=y +CONFIG_VIDEO_S5P_FIMC=y +CONFIG_VIDEO_S5P_MIPI_CSIS=y +CONFIG_VIDEO_EXYNOS4_FIMC_IS=y +CONFIG_VIDEO_EXYNOS4_ISP_DMA_CAPTURE=y +CONFIG_VIDEO_AM437X_VPFE=y +CONFIG_VIDEO_XILINX=y +CONFIG_VIDEO_XILINX_TPG=y +CONFIG_VIDEO_XILINX_VTC=y +CONFIG_VIDEO_RCAR_VIN=y +CONFIG_VIDEO_ATMEL_ISC=y +CONFIG_VIDEO_ATMEL_ISI=y +CONFIG_VIDEO_TI_CAL=y +CONFIG_V4L_MEM2MEM_DRIVERS=y +CONFIG_VIDEO_CODA=y +CONFIG_VIDEO_IMX_VDOA=y +CONFIG_VIDEO_MEDIATEK_JPEG=y +CONFIG_VIDEO_MEDIATEK_VPU=y +CONFIG_VIDEO_MEDIATEK_MDP=y +CONFIG_VIDEO_MEDIATEK_VCODEC=y +CONFIG_VIDEO_MEM2MEM_DEINTERLACE=y +CONFIG_VIDEO_SAMSUNG_S5P_G2D=y +CONFIG_VIDEO_SAMSUNG_S5P_JPEG=y +CONFIG_VIDEO_SAMSUNG_S5P_MFC=y +CONFIG_VIDEO_MX2_EMMAPRP=y +CONFIG_VIDEO_SAMSUNG_EXYNOS_GSC=y +CONFIG_VIDEO_STI_BDISP=y +CONFIG_VIDEO_STI_HVA=y +CONFIG_VIDEO_STI_HVA_DEBUGFS=y +CONFIG_VIDEO_STI_DELTA=y +CONFIG_VIDEO_STI_DELTA_MJPEG=y +CONFIG_VIDEO_STI_DELTA_DRIVER=y +CONFIG_VIDEO_SH_VEU=y +CONFIG_VIDEO_RENESAS_FDP1=y +CONFIG_VIDEO_RENESAS_JPU=y +CONFIG_VIDEO_RENESAS_FCP=y +CONFIG_VIDEO_RENESAS_VSP1=y +CONFIG_VIDEO_ROCKCHIP_RGA=y +CONFIG_VIDEO_TI_VPE=y +CONFIG_VIDEO_TI_VPE_DEBUG=y +CONFIG_VIDEO_QCOM_VENUS=y +CONFIG_VIDEO_TI_VPDMA=y +CONFIG_VIDEO_TI_SC=y +CONFIG_VIDEO_TI_CSC=y +CONFIG_V4L_TEST_DRIVERS=y +CONFIG_VIDEO_VIMC=y +CONFIG_VIDEO_VIVID=y +CONFIG_VIDEO_VIVID_CEC=y +CONFIG_VIDEO_VIVID_MAX_DEVS=64 +CONFIG_VIDEO_VIM2M=y +CONFIG_DVB_PLATFORM_DRIVERS=y +CONFIG_DVB_C8SECTPFE=y +CONFIG_CEC_PLATFORM_DRIVERS=y +CONFIG_VIDEO_MESON_AO_CEC=y +CONFIG_VIDEO_SAMSUNG_S5P_CEC=y +CONFIG_VIDEO_STI_HDMI_CEC=y +CONFIG_VIDEO_STM32_HDMI_CEC=y +CONFIG_VIDEO_TEGRA_HDMI_CEC=y +CONFIG_SDR_PLATFORM_DRIVERS=y +CONFIG_VIDEO_RCAR_DRIF=y + +# +# Supported MMC/SDIO adapters +# +CONFIG_SMS_SDIO_DRV=y +CONFIG_RADIO_ADAPTERS=y +CONFIG_RADIO_TEA575X=y +CONFIG_RADIO_SI470X=y +CONFIG_USB_SI470X=y +CONFIG_RADIO_SI4713=y +CONFIG_USB_SI4713=y +CONFIG_PLATFORM_SI4713=y +CONFIG_I2C_SI4713=y +CONFIG_RADIO_SI476X=y +CONFIG_USB_MR800=y +CONFIG_USB_DSBR=y +CONFIG_RADIO_MAXIRADIO=y +CONFIG_RADIO_SHARK=y +CONFIG_RADIO_SHARK2=y +CONFIG_USB_KEENE=y +CONFIG_USB_RAREMONO=y +CONFIG_USB_MA901=y +CONFIG_RADIO_TEA5764=y +CONFIG_RADIO_TEA5764_XTAL=y +CONFIG_RADIO_SAA7706H=y +CONFIG_RADIO_TEF6862=y +CONFIG_RADIO_TIMBERDALE=y +CONFIG_RADIO_WL1273=y + +# +# Texas Instruments WL128x FM driver (ST based) +# +CONFIG_RADIO_WL128X=y + +# +# Supported FireWire (IEEE 1394) Adapters +# +CONFIG_DVB_FIREDTV=y +CONFIG_DVB_FIREDTV_INPUT=y +CONFIG_MEDIA_COMMON_OPTIONS=y + +# +# common driver options +# +CONFIG_VIDEO_CX2341X=y +CONFIG_VIDEO_TVEEPROM=y +CONFIG_CYPRESS_FIRMWARE=y +CONFIG_VIDEOBUF2_CORE=y +CONFIG_VIDEOBUF2_V4L2=y +CONFIG_VIDEOBUF2_MEMOPS=y +CONFIG_VIDEOBUF2_DMA_CONTIG=y +CONFIG_VIDEOBUF2_VMALLOC=y +CONFIG_VIDEOBUF2_DMA_SG=y +CONFIG_VIDEOBUF2_DVB=y +CONFIG_DVB_B2C2_FLEXCOP=y +CONFIG_DVB_B2C2_FLEXCOP_DEBUG=y +CONFIG_VIDEO_SAA7146=y +CONFIG_VIDEO_SAA7146_VV=y +CONFIG_SMS_SIANO_MDTV=y +CONFIG_SMS_SIANO_RC=y +CONFIG_SMS_SIANO_DEBUGFS=y +CONFIG_VIDEO_V4L2_TPG=y + +# +# Media ancillary drivers (tuners, sensors, i2c, spi, frontends) +# +CONFIG_MEDIA_SUBDRV_AUTOSELECT=y +CONFIG_MEDIA_ATTACH=y +CONFIG_VIDEO_IR_I2C=y + +# +# I2C Encoders, decoders, sensors and other helper chips +# + +# +# Audio decoders, processors and mixers +# +CONFIG_VIDEO_TVAUDIO=y +CONFIG_VIDEO_TDA7432=y +CONFIG_VIDEO_TDA9840=y +CONFIG_VIDEO_TEA6415C=y +CONFIG_VIDEO_TEA6420=y +CONFIG_VIDEO_MSP3400=y +CONFIG_VIDEO_CS3308=y +CONFIG_VIDEO_CS5345=y +CONFIG_VIDEO_CS53L32A=y +CONFIG_VIDEO_TLV320AIC23B=y +CONFIG_VIDEO_UDA1342=y +CONFIG_VIDEO_WM8775=y +CONFIG_VIDEO_WM8739=y +CONFIG_VIDEO_VP27SMPX=y +CONFIG_VIDEO_SONY_BTF_MPX=y + +# +# RDS decoders +# +CONFIG_VIDEO_SAA6588=y + +# +# Video decoders +# +CONFIG_VIDEO_ADV7180=y +CONFIG_VIDEO_ADV7183=y +CONFIG_VIDEO_ADV748X=y +CONFIG_VIDEO_ADV7604=y +CONFIG_VIDEO_ADV7604_CEC=y +CONFIG_VIDEO_ADV7842=y +CONFIG_VIDEO_ADV7842_CEC=y +CONFIG_VIDEO_BT819=y +CONFIG_VIDEO_BT856=y +CONFIG_VIDEO_BT866=y +CONFIG_VIDEO_KS0127=y +CONFIG_VIDEO_ML86V7667=y +CONFIG_VIDEO_AD5820=y +CONFIG_VIDEO_DW9714=y +CONFIG_VIDEO_SAA7110=y +CONFIG_VIDEO_SAA711X=y +CONFIG_VIDEO_TC358743=y +CONFIG_VIDEO_TC358743_CEC=y +CONFIG_VIDEO_TVP514X=y +CONFIG_VIDEO_TVP5150=y +CONFIG_VIDEO_TVP7002=y +CONFIG_VIDEO_TW2804=y +CONFIG_VIDEO_TW9903=y +CONFIG_VIDEO_TW9906=y +CONFIG_VIDEO_VPX3220=y + +# +# Video and audio decoders +# +CONFIG_VIDEO_SAA717X=y +CONFIG_VIDEO_CX25840=y + +# +# Video encoders +# +CONFIG_VIDEO_SAA7127=y +CONFIG_VIDEO_SAA7185=y +CONFIG_VIDEO_ADV7170=y +CONFIG_VIDEO_ADV7175=y +CONFIG_VIDEO_ADV7343=y +CONFIG_VIDEO_ADV7393=y +CONFIG_VIDEO_ADV7511=y +CONFIG_VIDEO_ADV7511_CEC=y +CONFIG_VIDEO_AD9389B=y +CONFIG_VIDEO_AK881X=y +CONFIG_VIDEO_THS8200=y + +# +# Camera sensor devices +# +CONFIG_VIDEO_APTINA_PLL=y +CONFIG_VIDEO_SMIAPP_PLL=y +CONFIG_VIDEO_IMX274=y +CONFIG_VIDEO_OV2640=y +CONFIG_VIDEO_OV2659=y +CONFIG_VIDEO_OV5640=y +CONFIG_VIDEO_OV5645=y +CONFIG_VIDEO_OV5647=y +CONFIG_VIDEO_OV6650=y +CONFIG_VIDEO_OV5670=y +CONFIG_VIDEO_OV7640=y +CONFIG_VIDEO_OV7670=y +CONFIG_VIDEO_OV7740=y +CONFIG_VIDEO_OV9650=y +CONFIG_VIDEO_OV13858=y +CONFIG_VIDEO_VS6624=y +CONFIG_VIDEO_MT9M032=y +CONFIG_VIDEO_MT9M111=y +CONFIG_VIDEO_MT9P031=y +CONFIG_VIDEO_MT9T001=y +CONFIG_VIDEO_MT9V011=y +CONFIG_VIDEO_MT9V032=y +CONFIG_VIDEO_SR030PC30=y +CONFIG_VIDEO_NOON010PC30=y +CONFIG_VIDEO_M5MOLS=y +CONFIG_VIDEO_S5K6AA=y +CONFIG_VIDEO_S5K6A3=y +CONFIG_VIDEO_S5K4ECGX=y +CONFIG_VIDEO_S5K5BAF=y +CONFIG_VIDEO_SMIAPP=y +CONFIG_VIDEO_ET8EK8=y +CONFIG_VIDEO_S5C73M3=y + +# +# Flash devices +# +CONFIG_VIDEO_ADP1653=y +CONFIG_VIDEO_LM3560=y +CONFIG_VIDEO_LM3646=y + +# +# Video improvement chips +# +CONFIG_VIDEO_UPD64031A=y +CONFIG_VIDEO_UPD64083=y + +# +# Audio/Video compression chips +# +CONFIG_VIDEO_SAA6752HS=y + +# +# SDR tuner chips +# +CONFIG_SDR_MAX2175=y + +# +# Miscellaneous helper chips +# +CONFIG_VIDEO_THS7303=y +CONFIG_VIDEO_M52790=y + +# +# Sensors used on soc_camera driver +# + +# +# soc_camera sensor drivers +# +CONFIG_SOC_CAMERA_IMX074=y +CONFIG_SOC_CAMERA_MT9M001=y +CONFIG_SOC_CAMERA_MT9M111=y +CONFIG_SOC_CAMERA_MT9T031=y +CONFIG_SOC_CAMERA_MT9T112=y +CONFIG_SOC_CAMERA_MT9V022=y +CONFIG_SOC_CAMERA_OV5642=y +CONFIG_SOC_CAMERA_OV772X=y +CONFIG_SOC_CAMERA_OV9640=y +CONFIG_SOC_CAMERA_OV9740=y +CONFIG_SOC_CAMERA_RJ54N1=y +CONFIG_SOC_CAMERA_TW9910=y + +# +# SPI helper chips +# +CONFIG_VIDEO_GS1662=y +CONFIG_MEDIA_TUNER=y + +# +# Customize TV tuners +# +CONFIG_MEDIA_TUNER_SIMPLE=y +CONFIG_MEDIA_TUNER_TDA18250=y +CONFIG_MEDIA_TUNER_TDA8290=y +CONFIG_MEDIA_TUNER_TDA827X=y +CONFIG_MEDIA_TUNER_TDA18271=y +CONFIG_MEDIA_TUNER_TDA9887=y +CONFIG_MEDIA_TUNER_TEA5761=y +CONFIG_MEDIA_TUNER_TEA5767=y +CONFIG_MEDIA_TUNER_MSI001=y +CONFIG_MEDIA_TUNER_MT20XX=y +CONFIG_MEDIA_TUNER_MT2060=y +CONFIG_MEDIA_TUNER_MT2063=y +CONFIG_MEDIA_TUNER_MT2266=y +CONFIG_MEDIA_TUNER_MT2131=y +CONFIG_MEDIA_TUNER_QT1010=y +CONFIG_MEDIA_TUNER_XC2028=y +CONFIG_MEDIA_TUNER_XC5000=y +CONFIG_MEDIA_TUNER_XC4000=y +CONFIG_MEDIA_TUNER_MXL5005S=y +CONFIG_MEDIA_TUNER_MXL5007T=y +CONFIG_MEDIA_TUNER_MC44S803=y +CONFIG_MEDIA_TUNER_MAX2165=y +CONFIG_MEDIA_TUNER_TDA18218=y +CONFIG_MEDIA_TUNER_FC0011=y +CONFIG_MEDIA_TUNER_FC0012=y +CONFIG_MEDIA_TUNER_FC0013=y +CONFIG_MEDIA_TUNER_TDA18212=y +CONFIG_MEDIA_TUNER_E4000=y +CONFIG_MEDIA_TUNER_FC2580=y +CONFIG_MEDIA_TUNER_M88RS6000T=y +CONFIG_MEDIA_TUNER_TUA9001=y +CONFIG_MEDIA_TUNER_SI2157=y +CONFIG_MEDIA_TUNER_IT913X=y +CONFIG_MEDIA_TUNER_R820T=y +CONFIG_MEDIA_TUNER_MXL301RF=y +CONFIG_MEDIA_TUNER_QM1D1C0042=y + +# +# Customise DVB Frontends +# + +# +# Multistandard (satellite) frontends +# +CONFIG_DVB_STB0899=y +CONFIG_DVB_STB6100=y +CONFIG_DVB_STV090x=y +CONFIG_DVB_STV0910=y +CONFIG_DVB_STV6110x=y +CONFIG_DVB_STV6111=y +CONFIG_DVB_MXL5XX=y +CONFIG_DVB_M88DS3103=y + +# +# Multistandard (cable + terrestrial) frontends +# +CONFIG_DVB_DRXK=y +CONFIG_DVB_TDA18271C2DD=y +CONFIG_DVB_SI2165=y +CONFIG_DVB_MN88472=y +CONFIG_DVB_MN88473=y + +# +# DVB-S (satellite) frontends +# +CONFIG_DVB_CX24110=y +CONFIG_DVB_CX24123=y +CONFIG_DVB_MT312=y +CONFIG_DVB_ZL10036=y +CONFIG_DVB_ZL10039=y +CONFIG_DVB_S5H1420=y +CONFIG_DVB_STV0288=y +CONFIG_DVB_STB6000=y +CONFIG_DVB_STV0299=y +CONFIG_DVB_STV6110=y +CONFIG_DVB_STV0900=y +CONFIG_DVB_TDA8083=y +CONFIG_DVB_TDA10086=y +CONFIG_DVB_TDA8261=y +CONFIG_DVB_VES1X93=y +CONFIG_DVB_TUNER_ITD1000=y +CONFIG_DVB_TUNER_CX24113=y +CONFIG_DVB_TDA826X=y +CONFIG_DVB_TUA6100=y +CONFIG_DVB_CX24116=y +CONFIG_DVB_CX24117=y +CONFIG_DVB_CX24120=y +CONFIG_DVB_SI21XX=y +CONFIG_DVB_TS2020=y +CONFIG_DVB_DS3000=y +CONFIG_DVB_MB86A16=y +CONFIG_DVB_TDA10071=y + +# +# DVB-T (terrestrial) frontends +# +CONFIG_DVB_SP8870=y +CONFIG_DVB_SP887X=y +CONFIG_DVB_CX22700=y +CONFIG_DVB_CX22702=y +CONFIG_DVB_S5H1432=y +CONFIG_DVB_DRXD=y +CONFIG_DVB_L64781=y +CONFIG_DVB_TDA1004X=y +CONFIG_DVB_NXT6000=y +CONFIG_DVB_MT352=y +CONFIG_DVB_ZL10353=y +CONFIG_DVB_DIB3000MB=y +CONFIG_DVB_DIB3000MC=y +CONFIG_DVB_DIB7000M=y +CONFIG_DVB_DIB7000P=y +CONFIG_DVB_DIB9000=y +CONFIG_DVB_TDA10048=y +CONFIG_DVB_AF9013=y +CONFIG_DVB_EC100=y +CONFIG_DVB_STV0367=y +CONFIG_DVB_CXD2820R=y +CONFIG_DVB_CXD2841ER=y +CONFIG_DVB_RTL2830=y +CONFIG_DVB_RTL2832=y +CONFIG_DVB_RTL2832_SDR=y +CONFIG_DVB_SI2168=y +CONFIG_DVB_AS102_FE=y +CONFIG_DVB_ZD1301_DEMOD=y +CONFIG_DVB_GP8PSK_FE=y + +# +# DVB-C (cable) frontends +# +CONFIG_DVB_VES1820=y +CONFIG_DVB_TDA10021=y +CONFIG_DVB_TDA10023=y +CONFIG_DVB_STV0297=y + +# +# ATSC (North American/Korean Terrestrial/Cable DTV) frontends +# +CONFIG_DVB_NXT200X=y +CONFIG_DVB_OR51211=y +CONFIG_DVB_OR51132=y +CONFIG_DVB_BCM3510=y +CONFIG_DVB_LGDT330X=y +CONFIG_DVB_LGDT3305=y +CONFIG_DVB_LGDT3306A=y +CONFIG_DVB_LG2160=y +CONFIG_DVB_S5H1409=y +CONFIG_DVB_AU8522=y +CONFIG_DVB_AU8522_DTV=y +CONFIG_DVB_AU8522_V4L=y +CONFIG_DVB_S5H1411=y + +# +# ISDB-T (terrestrial) frontends +# +CONFIG_DVB_S921=y +CONFIG_DVB_DIB8000=y +CONFIG_DVB_MB86A20S=y + +# +# ISDB-S (satellite) & ISDB-T (terrestrial) frontends +# +CONFIG_DVB_TC90522=y + +# +# Digital terrestrial only tuners/PLL +# +CONFIG_DVB_PLL=y +CONFIG_DVB_TUNER_DIB0070=y +CONFIG_DVB_TUNER_DIB0090=y + +# +# SEC control devices for DVB-S +# +CONFIG_DVB_DRX39XYJ=y +CONFIG_DVB_LNBH25=y +CONFIG_DVB_LNBP21=y +CONFIG_DVB_LNBP22=y +CONFIG_DVB_ISL6405=y +CONFIG_DVB_ISL6421=y +CONFIG_DVB_ISL6423=y +CONFIG_DVB_A8293=y +CONFIG_DVB_SP2=y +CONFIG_DVB_LGS8GL5=y +CONFIG_DVB_LGS8GXX=y +CONFIG_DVB_ATBM8830=y +CONFIG_DVB_TDA665x=y +CONFIG_DVB_IX2505V=y +CONFIG_DVB_M88RS2000=y +CONFIG_DVB_AF9033=y +CONFIG_DVB_HORUS3A=y +CONFIG_DVB_ASCOT2E=y +CONFIG_DVB_HELENE=y + +# +# Tools to develop new frontends +# +CONFIG_DVB_DUMMY_FE=y + +# +# Graphics support +# +CONFIG_AGP=y +CONFIG_AGP_AMD64=y +CONFIG_AGP_INTEL=y +CONFIG_AGP_SIS=y +CONFIG_AGP_VIA=y +CONFIG_INTEL_GTT=y +CONFIG_VGA_ARB=y +CONFIG_VGA_ARB_MAX_GPUS=16 +CONFIG_VGA_SWITCHEROO=y +CONFIG_IMX_IPUV3_CORE=y +CONFIG_DRM=y +CONFIG_DRM_MIPI_DSI=y +CONFIG_DRM_DP_AUX_CHARDEV=y +CONFIG_DRM_DEBUG_MM=y +CONFIG_DRM_DEBUG_MM_SELFTEST=y +CONFIG_DRM_KMS_HELPER=y +CONFIG_DRM_KMS_FB_HELPER=y +CONFIG_DRM_FBDEV_EMULATION=y +CONFIG_DRM_FBDEV_OVERALLOC=100 +CONFIG_DRM_LOAD_EDID_FIRMWARE=y +CONFIG_DRM_TTM=y +CONFIG_DRM_GEM_CMA_HELPER=y +CONFIG_DRM_KMS_CMA_HELPER=y +CONFIG_DRM_VM=y +CONFIG_DRM_SCHED=y + +# +# I2C encoder or helper chips +# +CONFIG_DRM_I2C_CH7006=y +CONFIG_DRM_I2C_SIL164=y +CONFIG_DRM_I2C_NXP_TDA998X=y +CONFIG_DRM_RADEON=y +CONFIG_DRM_RADEON_USERPTR=y +CONFIG_DRM_AMDGPU=y +CONFIG_DRM_AMDGPU_SI=y +CONFIG_DRM_AMDGPU_CIK=y +CONFIG_DRM_AMDGPU_USERPTR=y +CONFIG_DRM_AMDGPU_GART_DEBUGFS=y + +# +# ACP (Audio CoProcessor) Configuration +# +CONFIG_DRM_AMD_ACP=y + +# +# Display Engine Configuration +# +CONFIG_DRM_AMD_DC=y +CONFIG_DRM_AMD_DC_PRE_VEGA=y +CONFIG_DRM_AMD_DC_FBC=y +# CONFIG_DRM_AMD_DC_DCN1_0 is not set +CONFIG_DEBUG_KERNEL_DC=y + +# +# AMD Library routines +# +CONFIG_CHASH=y +CONFIG_CHASH_STATS=y +CONFIG_CHASH_SELFTEST=y +CONFIG_DRM_NOUVEAU=y +CONFIG_NOUVEAU_DEBUG=5 +CONFIG_NOUVEAU_DEBUG_DEFAULT=3 +CONFIG_NOUVEAU_DEBUG_MMU=y +CONFIG_DRM_NOUVEAU_BACKLIGHT=y +CONFIG_DRM_I915=y +CONFIG_DRM_I915_ALPHA_SUPPORT=y +CONFIG_DRM_I915_CAPTURE_ERROR=y +CONFIG_DRM_I915_COMPRESS_ERROR=y +CONFIG_DRM_I915_USERPTR=y +CONFIG_DRM_I915_GVT=y +CONFIG_DRM_I915_GVT_KVMGT=y + +# +# drm/i915 Debugging +# +CONFIG_DRM_I915_DEBUG=y +CONFIG_DRM_I915_SW_FENCE_DEBUG_OBJECTS=y +CONFIG_DRM_I915_SW_FENCE_CHECK_DAG=y +CONFIG_DRM_I915_SELFTEST=y +CONFIG_DRM_I915_LOW_LEVEL_TRACEPOINTS=y +CONFIG_DRM_I915_DEBUG_VBLANK_EVADE=y +CONFIG_DRM_VGEM=y +CONFIG_DRM_VMWGFX=y +CONFIG_DRM_VMWGFX_FBCON=y +CONFIG_DRM_GMA500=y +CONFIG_DRM_GMA600=y +CONFIG_DRM_GMA3600=y +CONFIG_DRM_MEDFIELD=y +CONFIG_DRM_UDL=y +CONFIG_DRM_AST=y +CONFIG_DRM_MGAG200=y +CONFIG_DRM_CIRRUS_QEMU=y +CONFIG_DRM_RCAR_DW_HDMI=y +CONFIG_DRM_QXL=y +CONFIG_DRM_BOCHS=y +CONFIG_DRM_VIRTIO_GPU=y +CONFIG_DRM_PANEL=y + +# +# Display Panels +# +CONFIG_DRM_PANEL_LVDS=y +CONFIG_DRM_PANEL_SIMPLE=y +CONFIG_DRM_PANEL_ILITEK_IL9322=y +CONFIG_DRM_PANEL_INNOLUX_P079ZCA=y +CONFIG_DRM_PANEL_JDI_LT070ME05000=y +CONFIG_DRM_PANEL_SAMSUNG_LD9040=y +CONFIG_DRM_PANEL_LG_LG4573=y +CONFIG_DRM_PANEL_ORISETECH_OTM8009A=y +CONFIG_DRM_PANEL_PANASONIC_VVX10F034N00=y +CONFIG_DRM_PANEL_RASPBERRYPI_TOUCHSCREEN=y +CONFIG_DRM_PANEL_SAMSUNG_S6E3HA2=y +CONFIG_DRM_PANEL_SAMSUNG_S6E63J0X03=y +CONFIG_DRM_PANEL_SAMSUNG_S6E8AA0=y +CONFIG_DRM_PANEL_SEIKO_43WVF1G=y +CONFIG_DRM_PANEL_SHARP_LQ101R1SX01=y +CONFIG_DRM_PANEL_SHARP_LS043T1LE01=y +CONFIG_DRM_PANEL_SITRONIX_ST7789V=y +CONFIG_DRM_BRIDGE=y +CONFIG_DRM_PANEL_BRIDGE=y + +# +# Display Interface Bridges +# +CONFIG_DRM_ANALOGIX_ANX78XX=y +CONFIG_DRM_DUMB_VGA_DAC=y +CONFIG_DRM_LVDS_ENCODER=y +CONFIG_DRM_MEGACHIPS_STDPXXXX_GE_B850V3_FW=y +CONFIG_DRM_NXP_PTN3460=y +CONFIG_DRM_PARADE_PS8622=y +CONFIG_DRM_SIL_SII8620=y +CONFIG_DRM_SII902X=y +CONFIG_DRM_SII9234=y +CONFIG_DRM_TOSHIBA_TC358767=y +CONFIG_DRM_TI_TFP410=y +CONFIG_DRM_I2C_ADV7511=y +CONFIG_DRM_I2C_ADV7511_AUDIO=y +CONFIG_DRM_I2C_ADV7533=y +CONFIG_DRM_I2C_ADV7511_CEC=y +CONFIG_DRM_DW_HDMI=y +CONFIG_DRM_DW_HDMI_AHB_AUDIO=y +CONFIG_DRM_DW_HDMI_I2S_AUDIO=y +CONFIG_DRM_DW_HDMI_CEC=y +CONFIG_HSA_AMD=y +CONFIG_DRM_VC4=y +CONFIG_DRM_VC4_HDMI_CEC=y +CONFIG_DRM_ARCPGU=y +CONFIG_DRM_HISI_HIBMC=y +CONFIG_DRM_MXS=y +CONFIG_DRM_MXSFB=y +CONFIG_DRM_TINYDRM=y +CONFIG_TINYDRM_MIPI_DBI=y +CONFIG_TINYDRM_ILI9225=y +CONFIG_TINYDRM_MI0283QT=y +CONFIG_TINYDRM_REPAPER=y +CONFIG_TINYDRM_ST7586=y +CONFIG_TINYDRM_ST7735R=y +CONFIG_DRM_PL111=y +CONFIG_DRM_TVE200=y +CONFIG_DRM_LEGACY=y +CONFIG_DRM_TDFX=y +CONFIG_DRM_R128=y +CONFIG_DRM_I810=y +CONFIG_DRM_MGA=y +CONFIG_DRM_SIS=y +CONFIG_DRM_VIA=y +CONFIG_DRM_SAVAGE=y +CONFIG_DRM_PANEL_ORIENTATION_QUIRKS=y +CONFIG_DRM_LIB_RANDOM=y + +# +# Frame buffer Devices +# +CONFIG_FB=y +CONFIG_FIRMWARE_EDID=y +CONFIG_FB_CMDLINE=y +CONFIG_FB_NOTIFY=y +CONFIG_FB_DDC=y +CONFIG_FB_BOOT_VESA_SUPPORT=y +CONFIG_FB_CFB_FILLRECT=y +CONFIG_FB_CFB_COPYAREA=y +CONFIG_FB_CFB_IMAGEBLIT=y +# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set +CONFIG_FB_SYS_FILLRECT=y +CONFIG_FB_SYS_COPYAREA=y +CONFIG_FB_SYS_IMAGEBLIT=y +# CONFIG_FB_PROVIDE_GET_FB_UNMAPPED_AREA is not set +CONFIG_FB_FOREIGN_ENDIAN=y +CONFIG_FB_BOTH_ENDIAN=y +# CONFIG_FB_BIG_ENDIAN is not set +# CONFIG_FB_LITTLE_ENDIAN is not set +CONFIG_FB_SYS_FOPS=y +CONFIG_FB_DEFERRED_IO=y +CONFIG_FB_HECUBA=y +CONFIG_FB_SVGALIB=y +# CONFIG_FB_MACMODES is not set +CONFIG_FB_BACKLIGHT=y +CONFIG_FB_MODE_HELPERS=y +CONFIG_FB_TILEBLITTING=y + +# +# Frame buffer hardware drivers +# +CONFIG_FB_CIRRUS=y +CONFIG_FB_PM2=y +CONFIG_FB_PM2_FIFO_DISCONNECT=y +CONFIG_FB_CLPS711X=y +CONFIG_FB_CYBER2000=y +CONFIG_FB_CYBER2000_DDC=y +CONFIG_FB_ARC=y +CONFIG_FB_ASILIANT=y +CONFIG_FB_IMSTT=y +CONFIG_FB_VGA16=y +CONFIG_FB_UVESA=y +CONFIG_FB_VESA=y +CONFIG_FB_EFI=y +CONFIG_FB_N411=y +CONFIG_FB_HGA=y +CONFIG_FB_OPENCORES=y +CONFIG_FB_S1D13XXX=y +CONFIG_FB_NVIDIA=y +CONFIG_FB_NVIDIA_I2C=y +CONFIG_FB_NVIDIA_DEBUG=y +CONFIG_FB_NVIDIA_BACKLIGHT=y +CONFIG_FB_RIVA=y +CONFIG_FB_RIVA_I2C=y +CONFIG_FB_RIVA_DEBUG=y +CONFIG_FB_RIVA_BACKLIGHT=y +CONFIG_FB_I740=y +CONFIG_FB_LE80578=y +CONFIG_FB_CARILLO_RANCH=y +CONFIG_FB_MATROX=y +CONFIG_FB_MATROX_MILLENIUM=y +CONFIG_FB_MATROX_MYSTIQUE=y +CONFIG_FB_MATROX_G=y +CONFIG_FB_MATROX_I2C=y +CONFIG_FB_MATROX_MAVEN=y +CONFIG_FB_RADEON=y +CONFIG_FB_RADEON_I2C=y +CONFIG_FB_RADEON_BACKLIGHT=y +CONFIG_FB_RADEON_DEBUG=y +CONFIG_FB_ATY128=y +CONFIG_FB_ATY128_BACKLIGHT=y +CONFIG_FB_ATY=y +CONFIG_FB_ATY_CT=y +CONFIG_FB_ATY_GENERIC_LCD=y +CONFIG_FB_ATY_GX=y +CONFIG_FB_ATY_BACKLIGHT=y +CONFIG_FB_S3=y +CONFIG_FB_S3_DDC=y +CONFIG_FB_SAVAGE=y +CONFIG_FB_SAVAGE_I2C=y +CONFIG_FB_SAVAGE_ACCEL=y +CONFIG_FB_SIS=y +CONFIG_FB_SIS_300=y +CONFIG_FB_SIS_315=y +CONFIG_FB_VIA=y +CONFIG_FB_VIA_DIRECT_PROCFS=y +CONFIG_FB_VIA_X_COMPATIBILITY=y +CONFIG_FB_NEOMAGIC=y +CONFIG_FB_KYRO=y +CONFIG_FB_3DFX=y +CONFIG_FB_3DFX_ACCEL=y +CONFIG_FB_3DFX_I2C=y +CONFIG_FB_VOODOO1=y +CONFIG_FB_VT8623=y +CONFIG_FB_TRIDENT=y +CONFIG_FB_ARK=y +CONFIG_FB_PM3=y +CONFIG_FB_CARMINE=y +CONFIG_FB_CARMINE_DRAM_EVAL=y +# CONFIG_CARMINE_DRAM_CUSTOM is not set +CONFIG_FB_GEODE=y +CONFIG_FB_GEODE_LX=y +CONFIG_FB_GEODE_GX=y +CONFIG_FB_GEODE_GX1=y +CONFIG_FB_TMIO=y +CONFIG_FB_TMIO_ACCELL=y +CONFIG_FB_SM501=y +CONFIG_FB_SMSCUFX=y +CONFIG_FB_UDL=y +CONFIG_FB_IBM_GXT4500=y +CONFIG_FB_GOLDFISH=y +CONFIG_FB_VIRTUAL=y +CONFIG_XEN_FBDEV_FRONTEND=y +CONFIG_FB_METRONOME=y +CONFIG_FB_MB862XX=y +CONFIG_FB_MB862XX_PCI_GDC=y +CONFIG_FB_MB862XX_I2C=y +CONFIG_FB_BROADSHEET=y +CONFIG_FB_AUO_K190X=y +CONFIG_FB_AUO_K1900=y +CONFIG_FB_AUO_K1901=y +CONFIG_FB_HYPERV=y +CONFIG_FB_SIMPLE=y +CONFIG_FB_SSD1307=y +CONFIG_FB_SM712=y +CONFIG_BACKLIGHT_LCD_SUPPORT=y +CONFIG_LCD_CLASS_DEVICE=y +CONFIG_LCD_L4F00242T03=y +CONFIG_LCD_LMS283GF05=y +CONFIG_LCD_LTV350QV=y +CONFIG_LCD_ILI922X=y +CONFIG_LCD_ILI9320=y +CONFIG_LCD_TDO24M=y +CONFIG_LCD_VGG2432A4=y +CONFIG_LCD_PLATFORM=y +CONFIG_LCD_S6E63M0=y +CONFIG_LCD_LD9040=y +CONFIG_LCD_AMS369FG06=y +CONFIG_LCD_LMS501KF03=y +CONFIG_LCD_HX8357=y +CONFIG_BACKLIGHT_CLASS_DEVICE=y +CONFIG_BACKLIGHT_GENERIC=y +CONFIG_BACKLIGHT_LM3533=y +CONFIG_BACKLIGHT_CARILLO_RANCH=y +CONFIG_BACKLIGHT_PWM=y +CONFIG_BACKLIGHT_DA903X=y +CONFIG_BACKLIGHT_DA9052=y +CONFIG_BACKLIGHT_MAX8925=y +CONFIG_BACKLIGHT_APPLE=y +CONFIG_BACKLIGHT_PM8941_WLED=y +CONFIG_BACKLIGHT_SAHARA=y +CONFIG_BACKLIGHT_WM831X=y +CONFIG_BACKLIGHT_ADP5520=y +CONFIG_BACKLIGHT_ADP8860=y +CONFIG_BACKLIGHT_ADP8870=y +CONFIG_BACKLIGHT_88PM860X=y +CONFIG_BACKLIGHT_PCF50633=y +CONFIG_BACKLIGHT_AAT2870=y +CONFIG_BACKLIGHT_LM3630A=y +CONFIG_BACKLIGHT_LM3639=y +CONFIG_BACKLIGHT_LP855X=y +CONFIG_BACKLIGHT_LP8788=y +CONFIG_BACKLIGHT_OT200=y +CONFIG_BACKLIGHT_PANDORA=y +CONFIG_BACKLIGHT_SKY81452=y +CONFIG_BACKLIGHT_TPS65217=y +CONFIG_BACKLIGHT_AS3711=y +CONFIG_BACKLIGHT_GPIO=y +CONFIG_BACKLIGHT_LV5207LP=y +CONFIG_BACKLIGHT_BD6107=y +CONFIG_BACKLIGHT_ARCXCNN=y +CONFIG_VGASTATE=y +CONFIG_VIDEOMODE_HELPERS=y +CONFIG_HDMI=y + +# +# Console display driver support +# +CONFIG_VGA_CONSOLE=y +CONFIG_VGACON_SOFT_SCROLLBACK=y +CONFIG_VGACON_SOFT_SCROLLBACK_SIZE=64 +CONFIG_VGACON_SOFT_SCROLLBACK_PERSISTENT_ENABLE_BY_DEFAULT=y +CONFIG_DUMMY_CONSOLE=y +CONFIG_DUMMY_CONSOLE_COLUMNS=80 +CONFIG_DUMMY_CONSOLE_ROWS=25 +CONFIG_FRAMEBUFFER_CONSOLE=y +CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y +CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y +CONFIG_LOGO=y +CONFIG_LOGO_LINUX_MONO=y +CONFIG_LOGO_LINUX_VGA16=y +CONFIG_LOGO_LINUX_CLUT224=y +CONFIG_SOUND=y +CONFIG_SOUND_OSS_CORE=y +CONFIG_SOUND_OSS_CORE_PRECLAIM=y +CONFIG_SND=y +CONFIG_SND_TIMER=y +CONFIG_SND_PCM=y +CONFIG_SND_PCM_ELD=y +CONFIG_SND_PCM_IEC958=y +CONFIG_SND_DMAENGINE_PCM=y +CONFIG_SND_HWDEP=y +CONFIG_SND_SEQ_DEVICE=y +CONFIG_SND_RAWMIDI=y +CONFIG_SND_COMPRESS_OFFLOAD=y +CONFIG_SND_JACK=y +CONFIG_SND_JACK_INPUT_DEV=y +CONFIG_SND_OSSEMUL=y +CONFIG_SND_MIXER_OSS=y +CONFIG_SND_PCM_OSS=y +CONFIG_SND_PCM_OSS_PLUGINS=y +CONFIG_SND_PCM_TIMER=y +CONFIG_SND_HRTIMER=y +CONFIG_SND_DYNAMIC_MINORS=y +CONFIG_SND_MAX_CARDS=32 +CONFIG_SND_SUPPORT_OLD_API=y +CONFIG_SND_PROC_FS=y +CONFIG_SND_VERBOSE_PROCFS=y +CONFIG_SND_VERBOSE_PRINTK=y +CONFIG_SND_DEBUG=y +CONFIG_SND_DEBUG_VERBOSE=y +CONFIG_SND_PCM_XRUN_DEBUG=y +CONFIG_SND_VMASTER=y +CONFIG_SND_DMA_SGBUF=y +CONFIG_SND_SEQUENCER=y +CONFIG_SND_SEQ_DUMMY=y +CONFIG_SND_SEQUENCER_OSS=y +CONFIG_SND_SEQ_HRTIMER_DEFAULT=y +CONFIG_SND_SEQ_MIDI_EVENT=y +CONFIG_SND_SEQ_MIDI=y +CONFIG_SND_SEQ_MIDI_EMUL=y +CONFIG_SND_SEQ_VIRMIDI=y +CONFIG_SND_MPU401_UART=y +CONFIG_SND_OPL3_LIB=y +CONFIG_SND_OPL3_LIB_SEQ=y +# CONFIG_SND_OPL4_LIB_SEQ is not set +CONFIG_SND_VX_LIB=y +CONFIG_SND_AC97_CODEC=y +CONFIG_SND_DRIVERS=y +CONFIG_SND_PCSP=y +CONFIG_SND_DUMMY=y +CONFIG_SND_ALOOP=y +CONFIG_SND_VIRMIDI=y +CONFIG_SND_MTPAV=y +CONFIG_SND_MTS64=y +CONFIG_SND_SERIAL_U16550=y +CONFIG_SND_MPU401=y +CONFIG_SND_PORTMAN2X4=y +CONFIG_SND_AC97_POWER_SAVE=y +CONFIG_SND_AC97_POWER_SAVE_DEFAULT=0 +CONFIG_SND_SB_COMMON=y +CONFIG_SND_SB16_DSP=y +CONFIG_SND_PCI=y +CONFIG_SND_AD1889=y +CONFIG_SND_ALS300=y +CONFIG_SND_ALS4000=y +CONFIG_SND_ALI5451=y +CONFIG_SND_ASIHPI=y +CONFIG_SND_ATIIXP=y +CONFIG_SND_ATIIXP_MODEM=y +CONFIG_SND_AU8810=y +CONFIG_SND_AU8820=y +CONFIG_SND_AU8830=y +CONFIG_SND_AW2=y +CONFIG_SND_AZT3328=y +CONFIG_SND_BT87X=y +CONFIG_SND_BT87X_OVERCLOCK=y +CONFIG_SND_CA0106=y +CONFIG_SND_CMIPCI=y +CONFIG_SND_OXYGEN_LIB=y +CONFIG_SND_OXYGEN=y +CONFIG_SND_CS4281=y +CONFIG_SND_CS46XX=y +CONFIG_SND_CS46XX_NEW_DSP=y +CONFIG_SND_CS5530=y +CONFIG_SND_CS5535AUDIO=y +CONFIG_SND_CTXFI=y +CONFIG_SND_DARLA20=y +CONFIG_SND_GINA20=y +CONFIG_SND_LAYLA20=y +CONFIG_SND_DARLA24=y +CONFIG_SND_GINA24=y +CONFIG_SND_LAYLA24=y +CONFIG_SND_MONA=y +CONFIG_SND_MIA=y +CONFIG_SND_ECHO3G=y +CONFIG_SND_INDIGO=y +CONFIG_SND_INDIGOIO=y +CONFIG_SND_INDIGODJ=y +CONFIG_SND_INDIGOIOX=y +CONFIG_SND_INDIGODJX=y +CONFIG_SND_EMU10K1=y +CONFIG_SND_EMU10K1_SEQ=y +CONFIG_SND_EMU10K1X=y +CONFIG_SND_ENS1370=y +CONFIG_SND_ENS1371=y +CONFIG_SND_ES1938=y +CONFIG_SND_ES1968=y +CONFIG_SND_ES1968_INPUT=y +CONFIG_SND_ES1968_RADIO=y +CONFIG_SND_FM801=y +CONFIG_SND_FM801_TEA575X_BOOL=y +CONFIG_SND_HDSP=y + +# +# Don't forget to add built-in firmwares for HDSP driver +# +CONFIG_SND_HDSPM=y +CONFIG_SND_ICE1712=y +CONFIG_SND_ICE1724=y +CONFIG_SND_INTEL8X0=y +CONFIG_SND_INTEL8X0M=y +CONFIG_SND_KORG1212=y +CONFIG_SND_LOLA=y +CONFIG_SND_LX6464ES=y +CONFIG_SND_MAESTRO3=y +CONFIG_SND_MAESTRO3_INPUT=y +CONFIG_SND_MIXART=y +CONFIG_SND_NM256=y +CONFIG_SND_PCXHR=y +CONFIG_SND_RIPTIDE=y +CONFIG_SND_RME32=y +CONFIG_SND_RME96=y +CONFIG_SND_RME9652=y +CONFIG_SND_SONICVIBES=y +CONFIG_SND_TRIDENT=y +CONFIG_SND_VIA82XX=y +CONFIG_SND_VIA82XX_MODEM=y +CONFIG_SND_VIRTUOSO=y +CONFIG_SND_VX222=y +CONFIG_SND_YMFPCI=y + +# +# HD-Audio +# +CONFIG_SND_HDA=y +CONFIG_SND_HDA_INTEL=y +CONFIG_SND_HDA_HWDEP=y +CONFIG_SND_HDA_RECONFIG=y +CONFIG_SND_HDA_INPUT_BEEP=y +CONFIG_SND_HDA_INPUT_BEEP_MODE=1 +CONFIG_SND_HDA_PATCH_LOADER=y +CONFIG_SND_HDA_CODEC_REALTEK=y +CONFIG_SND_HDA_CODEC_ANALOG=y +CONFIG_SND_HDA_CODEC_SIGMATEL=y +CONFIG_SND_HDA_CODEC_VIA=y +CONFIG_SND_HDA_CODEC_HDMI=y +CONFIG_SND_HDA_CODEC_CIRRUS=y +CONFIG_SND_HDA_CODEC_CONEXANT=y +CONFIG_SND_HDA_CODEC_CA0110=y +CONFIG_SND_HDA_CODEC_CA0132=y +CONFIG_SND_HDA_CODEC_CA0132_DSP=y +CONFIG_SND_HDA_CODEC_CMEDIA=y +CONFIG_SND_HDA_CODEC_SI3054=y +CONFIG_SND_HDA_GENERIC=y +CONFIG_SND_HDA_POWER_SAVE_DEFAULT=0 +CONFIG_SND_HDA_CORE=y +CONFIG_SND_HDA_DSP_LOADER=y +CONFIG_SND_HDA_I915=y +CONFIG_SND_HDA_EXT_CORE=y +CONFIG_SND_HDA_PREALLOC_SIZE=64 +CONFIG_SND_PXA2XX_LIB=y +CONFIG_SND_SPI=y +CONFIG_SND_AT73C213=y +CONFIG_SND_AT73C213_TARGET_BITRATE=48000 +CONFIG_SND_USB=y +CONFIG_SND_USB_AUDIO=y +CONFIG_SND_USB_UA101=y +CONFIG_SND_USB_USX2Y=y +CONFIG_SND_USB_CAIAQ=y +CONFIG_SND_USB_CAIAQ_INPUT=y +CONFIG_SND_USB_US122L=y +CONFIG_SND_USB_6FIRE=y +CONFIG_SND_USB_HIFACE=y +CONFIG_SND_BCD2000=y +CONFIG_SND_USB_LINE6=y +CONFIG_SND_USB_POD=y +CONFIG_SND_USB_PODHD=y +CONFIG_SND_USB_TONEPORT=y +CONFIG_SND_USB_VARIAX=y +CONFIG_SND_FIREWIRE=y +CONFIG_SND_FIREWIRE_LIB=y +CONFIG_SND_DICE=y +CONFIG_SND_OXFW=y +CONFIG_SND_ISIGHT=y +CONFIG_SND_FIREWORKS=y +CONFIG_SND_BEBOB=y +CONFIG_SND_FIREWIRE_DIGI00X=y +CONFIG_SND_FIREWIRE_TASCAM=y +CONFIG_SND_FIREWIRE_MOTU=y +CONFIG_SND_FIREFACE=y +CONFIG_SND_PCMCIA=y +CONFIG_SND_VXPOCKET=y +CONFIG_SND_PDAUDIOCF=y +CONFIG_SND_SOC=y +CONFIG_SND_SOC_AC97_BUS=y +CONFIG_SND_SOC_GENERIC_DMAENGINE_PCM=y +CONFIG_SND_SOC_COMPRESS=y +CONFIG_SND_SOC_TOPOLOGY=y +CONFIG_SND_SOC_ACPI=y +CONFIG_SND_SOC_ADI=y +CONFIG_SND_SOC_ADI_AXI_I2S=y +CONFIG_SND_SOC_ADI_AXI_SPDIF=y +CONFIG_SND_SOC_AMD_ACP=y +CONFIG_SND_SOC_AMD_CZ_RT5645_MACH=y +CONFIG_SND_ATMEL_SOC=y +CONFIG_SND_ATMEL_SOC_PDC=y +CONFIG_SND_ATMEL_SOC_SSC_PDC=y +CONFIG_SND_ATMEL_SOC_DMA=y +CONFIG_SND_ATMEL_SOC_SSC_DMA=y +CONFIG_SND_ATMEL_SOC_SSC=y +CONFIG_SND_AT91_SOC_SAM9G20_WM8731=y +CONFIG_SND_ATMEL_SOC_WM8904=y +CONFIG_SND_AT91_SOC_SAM9X5_WM8731=y +CONFIG_SND_ATMEL_SOC_CLASSD=y +CONFIG_SND_ATMEL_SOC_PDMIC=y +CONFIG_SND_BCM2835_SOC_I2S=y +CONFIG_SND_SOC_CYGNUS=y +CONFIG_SND_EP93XX_SOC=y +CONFIG_SND_EDMA_SOC=y +CONFIG_SND_DAVINCI_SOC_I2S=y +CONFIG_SND_DAVINCI_SOC_MCASP=y +CONFIG_SND_DESIGNWARE_I2S=y +CONFIG_SND_DESIGNWARE_PCM=y + +# +# SoC Audio for Freescale CPUs +# + +# +# Common SoC Audio options for Freescale CPUs: +# +CONFIG_SND_SOC_FSL_ASRC=y +CONFIG_SND_SOC_FSL_SAI=y +CONFIG_SND_SOC_FSL_SSI=y +CONFIG_SND_SOC_FSL_SPDIF=y +CONFIG_SND_SOC_FSL_ESAI=y +CONFIG_SND_SOC_IMX_PCM_DMA=y +CONFIG_SND_SOC_IMX_AUDMUX=y +CONFIG_SND_IMX_SOC=y + +# +# SoC Audio support for Freescale i.MX boards: +# +CONFIG_SND_SOC_IMX_WM8962=y +CONFIG_SND_SOC_IMX_ES8328=y +CONFIG_SND_SOC_IMX_SGTL5000=y +CONFIG_SND_SOC_IMX_SPDIF=y +CONFIG_SND_SOC_FSL_ASOC_CARD=y +CONFIG_SND_I2S_HI6210_I2S=y +CONFIG_SND_JZ4740_SOC=y +CONFIG_SND_JZ4740_SOC_I2S=y +CONFIG_SND_JZ4740_SOC_QI_LB60=y +CONFIG_SND_KIRKWOOD_SOC=y +CONFIG_SND_KIRKWOOD_SOC_ARMADA370_DB=y +CONFIG_SND_SOC_IMG=y +CONFIG_SND_SOC_IMG_I2S_IN=y +CONFIG_SND_SOC_IMG_I2S_OUT=y +CONFIG_SND_SOC_IMG_PARALLEL_OUT=y +CONFIG_SND_SOC_IMG_SPDIF_IN=y +CONFIG_SND_SOC_IMG_SPDIF_OUT=y +CONFIG_SND_SOC_IMG_PISTACHIO_INTERNAL_DAC=y +CONFIG_SND_SOC_INTEL_SST_TOPLEVEL=y +CONFIG_SND_SST_IPC=y +CONFIG_SND_SST_IPC_PCI=y +CONFIG_SND_SST_IPC_ACPI=y +CONFIG_SND_SOC_INTEL_SST_ACPI=y +CONFIG_SND_SOC_INTEL_SST=y +CONFIG_SND_SOC_INTEL_SST_FIRMWARE=y +CONFIG_SND_SOC_INTEL_HASWELL=y +CONFIG_SND_SOC_INTEL_BAYTRAIL=y +CONFIG_SND_SST_ATOM_HIFI2_PLATFORM_PCI=y +CONFIG_SND_SST_ATOM_HIFI2_PLATFORM=y +CONFIG_SND_SOC_INTEL_SKYLAKE_SSP_CLK=y +CONFIG_SND_SOC_INTEL_SKYLAKE=y +CONFIG_SND_SOC_ACPI_INTEL_MATCH=y +CONFIG_SND_SOC_INTEL_MACH=y +CONFIG_SND_SOC_INTEL_HASWELL_MACH=y +CONFIG_SND_SOC_INTEL_BDW_RT5677_MACH=y +CONFIG_SND_SOC_INTEL_BROADWELL_MACH=y +CONFIG_SND_SOC_INTEL_BYT_MAX98090_MACH=y +CONFIG_SND_SOC_INTEL_BYT_RT5640_MACH=y +CONFIG_SND_SOC_INTEL_BYTCR_RT5640_MACH=y +CONFIG_SND_SOC_INTEL_BYTCR_RT5651_MACH=y +CONFIG_SND_SOC_INTEL_CHT_BSW_RT5672_MACH=y +CONFIG_SND_SOC_INTEL_CHT_BSW_RT5645_MACH=y +CONFIG_SND_SOC_INTEL_CHT_BSW_MAX98090_TI_MACH=y +CONFIG_SND_SOC_INTEL_BYT_CHT_DA7213_MACH=y +CONFIG_SND_SOC_INTEL_BYT_CHT_ES8316_MACH=y +CONFIG_SND_SOC_INTEL_BYT_CHT_NOCODEC_MACH=y +CONFIG_SND_SOC_INTEL_SKL_RT286_MACH=y +CONFIG_SND_SOC_INTEL_SKL_NAU88L25_SSM4567_MACH=y +CONFIG_SND_SOC_INTEL_SKL_NAU88L25_MAX98357A_MACH=y +CONFIG_SND_SOC_INTEL_BXT_DA7219_MAX98357A_MACH=y +CONFIG_SND_SOC_INTEL_BXT_RT298_MACH=y +CONFIG_SND_SOC_INTEL_KBL_RT5663_MAX98927_MACH=y +CONFIG_SND_SOC_INTEL_KBL_RT5663_RT5514_MAX98927_MACH=y +CONFIG_SND_MXS_SOC=y +CONFIG_SND_SOC_MXS_SGTL5000=y +CONFIG_SND_PXA2XX_SOC=y +CONFIG_SND_SOC_QCOM=y +CONFIG_SND_SOC_LPASS_CPU=y +CONFIG_SND_SOC_LPASS_PLATFORM=y +CONFIG_SND_SOC_LPASS_IPQ806X=y +CONFIG_SND_SOC_LPASS_APQ8016=y +CONFIG_SND_SOC_STORM=y +CONFIG_SND_SOC_APQ8016_SBC=y +CONFIG_SND_SOC_ROCKCHIP=y +CONFIG_SND_SOC_ROCKCHIP_I2S=y +CONFIG_SND_SOC_ROCKCHIP_PDM=y +CONFIG_SND_SOC_ROCKCHIP_SPDIF=y +CONFIG_SND_SOC_ROCKCHIP_MAX98090=y +CONFIG_SND_SOC_ROCKCHIP_RT5645=y +CONFIG_SND_SOC_RK3288_HDMI_ANALOG=y +CONFIG_SND_SOC_RK3399_GRU_SOUND=y +CONFIG_SND_SOC_SAMSUNG=y +CONFIG_SND_SAMSUNG_PCM=y +CONFIG_SND_SAMSUNG_SPDIF=y +CONFIG_SND_SAMSUNG_I2S=y +CONFIG_SND_SOC_SAMSUNG_SMDK_WM8580=y +CONFIG_SND_SOC_SAMSUNG_SMDK_WM8994=y +CONFIG_SND_SOC_SMARTQ=y +CONFIG_SND_SOC_SAMSUNG_SMDK_SPDIF=y +CONFIG_SND_SOC_SMDK_WM8994_PCM=y +CONFIG_SND_SOC_SPEYSIDE=y +CONFIG_SND_SOC_TOBERMORY=y +CONFIG_SND_SOC_BELLS=y +CONFIG_SND_SOC_LOWLAND=y +CONFIG_SND_SOC_LITTLEMILL=y +CONFIG_SND_SOC_SNOW=y +CONFIG_SND_SOC_ODROID=y +CONFIG_SND_SOC_ARNDALE_RT5631_ALC5631=y +CONFIG_SND_SOC_SAMSUNG_TM2_WM5110=y + +# +# SoC Audio support for SuperH +# +CONFIG_SND_SOC_SH4_FSI=y +CONFIG_SND_SOC_RCAR=y +CONFIG_SND_SOC_SIRF=y +CONFIG_SND_SOC_SIRF_AUDIO=y +CONFIG_SND_SOC_SIRF_AUDIO_PORT=y +CONFIG_SND_SOC_SIRF_USP=y +CONFIG_SND_SOC_STI=y + +# +# STMicroelectronics STM32 SOC audio support +# +CONFIG_SND_SOC_STM32_SAI=y +CONFIG_SND_SOC_STM32_I2S=y +CONFIG_SND_SOC_STM32_SPDIFRX=y +CONFIG_SND_SOC_STM32_DFSDM=y + +# +# Allwinner SoC Audio support +# +CONFIG_SND_SUN4I_CODEC=y +CONFIG_SND_SUN8I_CODEC=y +CONFIG_SND_SUN8I_CODEC_ANALOG=y +CONFIG_SND_SUN4I_I2S=y +CONFIG_SND_SUN4I_SPDIF=y +CONFIG_SND_SOC_TEGRA=y +CONFIG_SND_SOC_TEGRA20_AC97=y +CONFIG_SND_SOC_TEGRA20_DAS=y +CONFIG_SND_SOC_TEGRA20_I2S=y +CONFIG_SND_SOC_TEGRA20_SPDIF=y +CONFIG_SND_SOC_TEGRA30_AHUB=y +CONFIG_SND_SOC_TEGRA30_I2S=y +CONFIG_SND_SOC_TEGRA_RT5640=y +CONFIG_SND_SOC_TEGRA_WM8753=y +CONFIG_SND_SOC_TEGRA_WM8903=y +CONFIG_SND_SOC_TEGRA_WM9712=y +CONFIG_SND_SOC_TEGRA_TRIMSLICE=y +CONFIG_SND_SOC_TEGRA_ALC5632=y +CONFIG_SND_SOC_TEGRA_MAX98090=y +CONFIG_SND_SOC_TEGRA_RT5677=y +CONFIG_SND_SOC_TEGRA_SGTL5000=y +CONFIG_SND_SOC_UNIPHIER=y +CONFIG_SND_SOC_UNIPHIER_EVEA_CODEC=y +CONFIG_SND_SOC_XTFPGA_I2S=y +CONFIG_ZX_SPDIF=y +CONFIG_ZX_I2S=y +CONFIG_ZX_TDM=y +CONFIG_SND_SOC_I2C_AND_SPI=y + +# +# CODEC drivers +# +CONFIG_SND_SOC_ALL_CODECS=y +CONFIG_SND_SOC_88PM860X=y +CONFIG_SND_SOC_ARIZONA=y +CONFIG_SND_SOC_WM_HUBS=y +CONFIG_SND_SOC_WM_ADSP=y +CONFIG_SND_SOC_AB8500_CODEC=y +CONFIG_SND_SOC_AC97_CODEC=y +CONFIG_SND_SOC_AD1836=y +CONFIG_SND_SOC_AD193X=y +CONFIG_SND_SOC_AD193X_SPI=y +CONFIG_SND_SOC_AD193X_I2C=y +CONFIG_SND_SOC_AD1980=y +CONFIG_SND_SOC_AD73311=y +CONFIG_SND_SOC_ADAU_UTILS=y +CONFIG_SND_SOC_ADAU1373=y +CONFIG_SND_SOC_ADAU1701=y +CONFIG_SND_SOC_ADAU17X1=y +CONFIG_SND_SOC_ADAU1761=y +CONFIG_SND_SOC_ADAU1761_I2C=y +CONFIG_SND_SOC_ADAU1761_SPI=y +CONFIG_SND_SOC_ADAU1781=y +CONFIG_SND_SOC_ADAU1781_I2C=y +CONFIG_SND_SOC_ADAU1781_SPI=y +CONFIG_SND_SOC_ADAU1977=y +CONFIG_SND_SOC_ADAU1977_SPI=y +CONFIG_SND_SOC_ADAU1977_I2C=y +CONFIG_SND_SOC_ADAU7002=y +CONFIG_SND_SOC_ADAV80X=y +CONFIG_SND_SOC_ADAV801=y +CONFIG_SND_SOC_ADAV803=y +CONFIG_SND_SOC_ADS117X=y +CONFIG_SND_SOC_AK4104=y +CONFIG_SND_SOC_AK4535=y +CONFIG_SND_SOC_AK4554=y +CONFIG_SND_SOC_AK4613=y +CONFIG_SND_SOC_AK4641=y +CONFIG_SND_SOC_AK4642=y +CONFIG_SND_SOC_AK4671=y +CONFIG_SND_SOC_AK5386=y +CONFIG_SND_SOC_ALC5623=y +CONFIG_SND_SOC_ALC5632=y +CONFIG_SND_SOC_BT_SCO=y +CONFIG_SND_SOC_CQ0093VC=y +CONFIG_SND_SOC_CS35L32=y +CONFIG_SND_SOC_CS35L33=y +CONFIG_SND_SOC_CS35L34=y +CONFIG_SND_SOC_CS35L35=y +CONFIG_SND_SOC_CS42L42=y +CONFIG_SND_SOC_CS42L51=y +CONFIG_SND_SOC_CS42L51_I2C=y +CONFIG_SND_SOC_CS42L52=y +CONFIG_SND_SOC_CS42L56=y +CONFIG_SND_SOC_CS42L73=y +CONFIG_SND_SOC_CS4265=y +CONFIG_SND_SOC_CS4270=y +CONFIG_SND_SOC_CS4271=y +CONFIG_SND_SOC_CS4271_I2C=y +CONFIG_SND_SOC_CS4271_SPI=y +CONFIG_SND_SOC_CS42XX8=y +CONFIG_SND_SOC_CS42XX8_I2C=y +CONFIG_SND_SOC_CS43130=y +CONFIG_SND_SOC_CS4349=y +CONFIG_SND_SOC_CS47L24=y +CONFIG_SND_SOC_CS53L30=y +CONFIG_SND_SOC_CX20442=y +CONFIG_SND_SOC_JZ4740_CODEC=y +CONFIG_SND_SOC_L3=y +CONFIG_SND_SOC_DA7210=y +CONFIG_SND_SOC_DA7213=y +CONFIG_SND_SOC_DA7218=y +CONFIG_SND_SOC_DA7219=y +CONFIG_SND_SOC_DA732X=y +CONFIG_SND_SOC_DA9055=y +CONFIG_SND_SOC_DIO2125=y +CONFIG_SND_SOC_DMIC=y +CONFIG_SND_SOC_HDMI_CODEC=y +CONFIG_SND_SOC_ES7134=y +CONFIG_SND_SOC_ES8316=y +CONFIG_SND_SOC_ES8328=y +CONFIG_SND_SOC_ES8328_I2C=y +CONFIG_SND_SOC_ES8328_SPI=y +CONFIG_SND_SOC_GTM601=y +CONFIG_SND_SOC_HDAC_HDMI=y +CONFIG_SND_SOC_ICS43432=y +CONFIG_SND_SOC_INNO_RK3036=y +CONFIG_SND_SOC_ISABELLE=y +CONFIG_SND_SOC_LM49453=y +CONFIG_SND_SOC_MAX98088=y +CONFIG_SND_SOC_MAX98090=y +CONFIG_SND_SOC_MAX98095=y +CONFIG_SND_SOC_MAX98357A=y +CONFIG_SND_SOC_MAX98371=y +CONFIG_SND_SOC_MAX98504=y +CONFIG_SND_SOC_MAX9867=y +CONFIG_SND_SOC_MAX98925=y +CONFIG_SND_SOC_MAX98926=y +CONFIG_SND_SOC_MAX98927=y +CONFIG_SND_SOC_MAX98373=y +CONFIG_SND_SOC_MAX9850=y +CONFIG_SND_SOC_MAX9860=y +CONFIG_SND_SOC_MSM8916_WCD_ANALOG=y +CONFIG_SND_SOC_MSM8916_WCD_DIGITAL=y +CONFIG_SND_SOC_PCM1681=y +CONFIG_SND_SOC_PCM179X=y +CONFIG_SND_SOC_PCM179X_I2C=y +CONFIG_SND_SOC_PCM179X_SPI=y +CONFIG_SND_SOC_PCM186X=y +CONFIG_SND_SOC_PCM186X_I2C=y +CONFIG_SND_SOC_PCM186X_SPI=y +CONFIG_SND_SOC_PCM3008=y +CONFIG_SND_SOC_PCM3168A=y +CONFIG_SND_SOC_PCM3168A_I2C=y +CONFIG_SND_SOC_PCM3168A_SPI=y +CONFIG_SND_SOC_PCM5102A=y +CONFIG_SND_SOC_PCM512x=y +CONFIG_SND_SOC_PCM512x_I2C=y +CONFIG_SND_SOC_PCM512x_SPI=y +CONFIG_SND_SOC_RL6231=y +CONFIG_SND_SOC_RL6347A=y +CONFIG_SND_SOC_RT274=y +CONFIG_SND_SOC_RT286=y +CONFIG_SND_SOC_RT298=y +CONFIG_SND_SOC_RT5514=y +CONFIG_SND_SOC_RT5514_SPI=y +# CONFIG_SND_SOC_RT5514_SPI_BUILTIN is not set +CONFIG_SND_SOC_RT5616=y +CONFIG_SND_SOC_RT5631=y +CONFIG_SND_SOC_RT5640=y +CONFIG_SND_SOC_RT5645=y +CONFIG_SND_SOC_RT5651=y +CONFIG_SND_SOC_RT5659=y +CONFIG_SND_SOC_RT5660=y +CONFIG_SND_SOC_RT5663=y +CONFIG_SND_SOC_RT5665=y +CONFIG_SND_SOC_RT5670=y +CONFIG_SND_SOC_RT5677=y +CONFIG_SND_SOC_RT5677_SPI=y +CONFIG_SND_SOC_SGTL5000=y +CONFIG_SND_SOC_SI476X=y +CONFIG_SND_SOC_SIGMADSP=y +CONFIG_SND_SOC_SIGMADSP_I2C=y +CONFIG_SND_SOC_SIGMADSP_REGMAP=y +CONFIG_SND_SOC_SIRF_AUDIO_CODEC=y +CONFIG_SND_SOC_SPDIF=y +CONFIG_SND_SOC_SSM2518=y +CONFIG_SND_SOC_SSM2602=y +CONFIG_SND_SOC_SSM2602_SPI=y +CONFIG_SND_SOC_SSM2602_I2C=y +CONFIG_SND_SOC_SSM4567=y +CONFIG_SND_SOC_STA32X=y +CONFIG_SND_SOC_STA350=y +CONFIG_SND_SOC_STA529=y +CONFIG_SND_SOC_STAC9766=y +CONFIG_SND_SOC_STI_SAS=y +CONFIG_SND_SOC_TAS2552=y +CONFIG_SND_SOC_TAS5086=y +CONFIG_SND_SOC_TAS571X=y +CONFIG_SND_SOC_TAS5720=y +CONFIG_SND_SOC_TAS6424=y +CONFIG_SND_SOC_TFA9879=y +CONFIG_SND_SOC_TLV320AIC23=y +CONFIG_SND_SOC_TLV320AIC23_I2C=y +CONFIG_SND_SOC_TLV320AIC23_SPI=y +CONFIG_SND_SOC_TLV320AIC26=y +CONFIG_SND_SOC_TLV320AIC31XX=y +CONFIG_SND_SOC_TLV320AIC32X4=y +CONFIG_SND_SOC_TLV320AIC32X4_I2C=y +CONFIG_SND_SOC_TLV320AIC32X4_SPI=y +CONFIG_SND_SOC_TLV320AIC3X=y +CONFIG_SND_SOC_TLV320DAC33=y +CONFIG_SND_SOC_TS3A227E=y +CONFIG_SND_SOC_TSCS42XX=y +CONFIG_SND_SOC_TWL4030=y +CONFIG_SND_SOC_TWL6040=y +CONFIG_SND_SOC_UDA134X=y +CONFIG_SND_SOC_UDA1380=y +CONFIG_SND_SOC_WL1273=y +CONFIG_SND_SOC_WM0010=y +CONFIG_SND_SOC_WM1250_EV1=y +CONFIG_SND_SOC_WM2000=y +CONFIG_SND_SOC_WM2200=y +CONFIG_SND_SOC_WM5100=y +CONFIG_SND_SOC_WM5102=y +CONFIG_SND_SOC_WM5110=y +CONFIG_SND_SOC_WM8350=y +CONFIG_SND_SOC_WM8400=y +CONFIG_SND_SOC_WM8510=y +CONFIG_SND_SOC_WM8523=y +CONFIG_SND_SOC_WM8524=y +CONFIG_SND_SOC_WM8580=y +CONFIG_SND_SOC_WM8711=y +CONFIG_SND_SOC_WM8727=y +CONFIG_SND_SOC_WM8728=y +CONFIG_SND_SOC_WM8731=y +CONFIG_SND_SOC_WM8737=y +CONFIG_SND_SOC_WM8741=y +CONFIG_SND_SOC_WM8750=y +CONFIG_SND_SOC_WM8753=y +CONFIG_SND_SOC_WM8770=y +CONFIG_SND_SOC_WM8776=y +CONFIG_SND_SOC_WM8782=y +CONFIG_SND_SOC_WM8804=y +CONFIG_SND_SOC_WM8804_I2C=y +CONFIG_SND_SOC_WM8804_SPI=y +CONFIG_SND_SOC_WM8900=y +CONFIG_SND_SOC_WM8903=y +CONFIG_SND_SOC_WM8904=y +CONFIG_SND_SOC_WM8940=y +CONFIG_SND_SOC_WM8955=y +CONFIG_SND_SOC_WM8960=y +CONFIG_SND_SOC_WM8961=y +CONFIG_SND_SOC_WM8962=y +CONFIG_SND_SOC_WM8971=y +CONFIG_SND_SOC_WM8974=y +CONFIG_SND_SOC_WM8978=y +CONFIG_SND_SOC_WM8983=y +CONFIG_SND_SOC_WM8985=y +CONFIG_SND_SOC_WM8988=y +CONFIG_SND_SOC_WM8990=y +CONFIG_SND_SOC_WM8991=y +CONFIG_SND_SOC_WM8993=y +CONFIG_SND_SOC_WM8994=y +CONFIG_SND_SOC_WM8995=y +CONFIG_SND_SOC_WM8996=y +CONFIG_SND_SOC_WM8997=y +CONFIG_SND_SOC_WM8998=y +CONFIG_SND_SOC_WM9081=y +CONFIG_SND_SOC_WM9090=y +CONFIG_SND_SOC_WM9705=y +CONFIG_SND_SOC_WM9712=y +CONFIG_SND_SOC_WM9713=y +CONFIG_SND_SOC_ZX_AUD96P22=y +CONFIG_SND_SOC_LM4857=y +CONFIG_SND_SOC_MAX9768=y +CONFIG_SND_SOC_MAX9877=y +CONFIG_SND_SOC_MC13783=y +CONFIG_SND_SOC_ML26124=y +CONFIG_SND_SOC_NAU8540=y +CONFIG_SND_SOC_NAU8810=y +CONFIG_SND_SOC_NAU8824=y +CONFIG_SND_SOC_NAU8825=y +CONFIG_SND_SOC_TPA6130A2=y +CONFIG_SND_SIMPLE_CARD_UTILS=y +CONFIG_SND_SIMPLE_CARD=y +CONFIG_SND_SIMPLE_SCU_CARD=y +CONFIG_SND_AUDIO_GRAPH_CARD=y +CONFIG_SND_AUDIO_GRAPH_SCU_CARD=y +CONFIG_SND_X86=y +CONFIG_HDMI_LPE_AUDIO=y +CONFIG_SND_SYNTH_EMUX=y +CONFIG_AC97_BUS=y + +# +# HID support +# +CONFIG_HID=y +CONFIG_HID_BATTERY_STRENGTH=y +CONFIG_HIDRAW=y +CONFIG_UHID=y +CONFIG_HID_GENERIC=y + +# +# Special HID drivers +# +CONFIG_HID_A4TECH=y +CONFIG_HID_ACCUTOUCH=y +CONFIG_HID_ACRUX=y +CONFIG_HID_ACRUX_FF=y +CONFIG_HID_APPLE=y +CONFIG_HID_APPLEIR=y +CONFIG_HID_ASUS=y +CONFIG_HID_AUREAL=y +CONFIG_HID_BELKIN=y +CONFIG_HID_BETOP_FF=y +CONFIG_HID_CHERRY=y +CONFIG_HID_CHICONY=y +CONFIG_HID_CORSAIR=y +CONFIG_HID_PRODIKEYS=y +CONFIG_HID_CMEDIA=y +CONFIG_HID_CP2112=y +CONFIG_HID_CYPRESS=y +CONFIG_HID_DRAGONRISE=y +CONFIG_DRAGONRISE_FF=y +CONFIG_HID_EMS_FF=y +CONFIG_HID_ELECOM=y +CONFIG_HID_ELO=y +CONFIG_HID_EZKEY=y +CONFIG_HID_GEMBIRD=y +CONFIG_HID_GFRM=y +CONFIG_HID_HOLTEK=y +CONFIG_HOLTEK_FF=y +CONFIG_HID_GT683R=y +CONFIG_HID_KEYTOUCH=y +CONFIG_HID_KYE=y +CONFIG_HID_UCLOGIC=y +CONFIG_HID_WALTOP=y +CONFIG_HID_GYRATION=y +CONFIG_HID_ICADE=y +CONFIG_HID_ITE=y +CONFIG_HID_JABRA=y +CONFIG_HID_TWINHAN=y +CONFIG_HID_KENSINGTON=y +CONFIG_HID_LCPOWER=y +CONFIG_HID_LED=y +CONFIG_HID_LENOVO=y +CONFIG_HID_LOGITECH=y +CONFIG_HID_LOGITECH_DJ=y +CONFIG_HID_LOGITECH_HIDPP=y +CONFIG_LOGITECH_FF=y +CONFIG_LOGIRUMBLEPAD2_FF=y +CONFIG_LOGIG940_FF=y +CONFIG_LOGIWHEELS_FF=y +CONFIG_HID_MAGICMOUSE=y +CONFIG_HID_MAYFLASH=y +CONFIG_HID_MICROSOFT=y +CONFIG_HID_MONTEREY=y +CONFIG_HID_MULTITOUCH=y +CONFIG_HID_NTI=y +CONFIG_HID_NTRIG=y +CONFIG_HID_ORTEK=y +CONFIG_HID_PANTHERLORD=y +CONFIG_PANTHERLORD_FF=y +CONFIG_HID_PENMOUNT=y +CONFIG_HID_PETALYNX=y +CONFIG_HID_PICOLCD=y +CONFIG_HID_PICOLCD_FB=y +CONFIG_HID_PICOLCD_BACKLIGHT=y +CONFIG_HID_PICOLCD_LCD=y +CONFIG_HID_PICOLCD_LEDS=y +CONFIG_HID_PICOLCD_CIR=y +CONFIG_HID_PLANTRONICS=y +CONFIG_HID_PRIMAX=y +CONFIG_HID_RETRODE=y +CONFIG_HID_ROCCAT=y +CONFIG_HID_SAITEK=y +CONFIG_HID_SAMSUNG=y +CONFIG_HID_SONY=y +CONFIG_SONY_FF=y +CONFIG_HID_SPEEDLINK=y +CONFIG_HID_STEELSERIES=y +CONFIG_HID_SUNPLUS=y +CONFIG_HID_RMI=y +CONFIG_HID_GREENASIA=y +CONFIG_GREENASIA_FF=y +CONFIG_HID_HYPERV_MOUSE=y +CONFIG_HID_SMARTJOYPLUS=y +CONFIG_SMARTJOYPLUS_FF=y +CONFIG_HID_TIVO=y +CONFIG_HID_TOPSEED=y +CONFIG_HID_THINGM=y +CONFIG_HID_THRUSTMASTER=y +CONFIG_THRUSTMASTER_FF=y +CONFIG_HID_UDRAW_PS3=y +CONFIG_HID_WACOM=y +CONFIG_HID_WIIMOTE=y +CONFIG_HID_XINMO=y +CONFIG_HID_ZEROPLUS=y +CONFIG_ZEROPLUS_FF=y +CONFIG_HID_ZYDACRON=y +CONFIG_HID_SENSOR_HUB=y +CONFIG_HID_SENSOR_CUSTOM_SENSOR=y +CONFIG_HID_ALPS=y + +# +# USB HID support +# +CONFIG_USB_HID=y +CONFIG_HID_PID=y +CONFIG_USB_HIDDEV=y + +# +# I2C HID support +# +CONFIG_I2C_HID=y + +# +# Intel ISH HID support +# +CONFIG_INTEL_ISH_HID=y +CONFIG_USB_OHCI_LITTLE_ENDIAN=y +CONFIG_USB_SUPPORT=y +CONFIG_USB_COMMON=y +CONFIG_USB_ARCH_HAS_HCD=y +CONFIG_USB=y +CONFIG_USB_PCI=y +CONFIG_USB_ANNOUNCE_NEW_DEVICES=y + +# +# Miscellaneous USB options +# +CONFIG_USB_DEFAULT_PERSIST=y +CONFIG_USB_DYNAMIC_MINORS=y +CONFIG_USB_OTG=y +CONFIG_USB_OTG_WHITELIST=y +CONFIG_USB_OTG_BLACKLIST_HUB=y +CONFIG_USB_OTG_FSM=y +CONFIG_USB_LEDS_TRIGGER_USBPORT=y +CONFIG_USB_MON=y +CONFIG_USB_WUSB=y +CONFIG_USB_WUSB_CBAF=y +CONFIG_USB_WUSB_CBAF_DEBUG=y + +# +# USB Host Controller Drivers +# +CONFIG_USB_C67X00_HCD=y +CONFIG_USB_XHCI_HCD=y +CONFIG_USB_XHCI_DBGCAP=y +CONFIG_USB_XHCI_PCI=y +CONFIG_USB_XHCI_PLATFORM=y +CONFIG_USB_XHCI_MTK=y +CONFIG_USB_XHCI_MVEBU=y +CONFIG_USB_XHCI_RCAR=y +CONFIG_USB_EHCI_HCD=y +CONFIG_USB_EHCI_ROOT_HUB_TT=y +CONFIG_USB_EHCI_TT_NEWSCHED=y +CONFIG_USB_EHCI_PCI=y +CONFIG_USB_EHCI_HCD_PLATFORM=y +CONFIG_USB_OXU210HP_HCD=y +CONFIG_USB_ISP116X_HCD=y +CONFIG_USB_ISP1362_HCD=y +CONFIG_USB_FOTG210_HCD=y +CONFIG_USB_MAX3421_HCD=y +CONFIG_USB_OHCI_HCD=y +CONFIG_USB_OHCI_HCD_PCI=y +CONFIG_USB_OHCI_HCD_SSB=y +CONFIG_USB_OHCI_HCD_PLATFORM=y +CONFIG_USB_UHCI_HCD=y +CONFIG_USB_U132_HCD=y +CONFIG_USB_SL811_HCD=y +CONFIG_USB_SL811_HCD_ISO=y +CONFIG_USB_SL811_CS=y +CONFIG_USB_R8A66597_HCD=y +CONFIG_USB_RENESAS_USBHS_HCD=y +CONFIG_USB_WHCI_HCD=y +CONFIG_USB_HWA_HCD=y +CONFIG_USB_HCD_BCMA=y +CONFIG_USB_HCD_SSB=y +CONFIG_USB_HCD_TEST_MODE=y +CONFIG_USB_RENESAS_USBHS=y + +# +# USB Device Class drivers +# +CONFIG_USB_ACM=y +CONFIG_USB_PRINTER=y +CONFIG_USB_WDM=y +CONFIG_USB_TMC=y + +# +# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may +# + +# +# also be needed; see USB_STORAGE Help for more info +# +CONFIG_USB_STORAGE=y +CONFIG_USB_STORAGE_DEBUG=y +CONFIG_USB_STORAGE_REALTEK=y +CONFIG_REALTEK_AUTOPM=y +CONFIG_USB_STORAGE_DATAFAB=y +CONFIG_USB_STORAGE_FREECOM=y +CONFIG_USB_STORAGE_ISD200=y +CONFIG_USB_STORAGE_USBAT=y +CONFIG_USB_STORAGE_SDDR09=y +CONFIG_USB_STORAGE_SDDR55=y +CONFIG_USB_STORAGE_JUMPSHOT=y +CONFIG_USB_STORAGE_ALAUDA=y +CONFIG_USB_STORAGE_ONETOUCH=y +CONFIG_USB_STORAGE_KARMA=y +CONFIG_USB_STORAGE_CYPRESS_ATACB=y +CONFIG_USB_STORAGE_ENE_UB6250=y +CONFIG_USB_UAS=y + +# +# USB Imaging devices +# +CONFIG_USB_MDC800=y +CONFIG_USB_MICROTEK=y +CONFIG_USBIP_CORE=y +CONFIG_USBIP_VHCI_HCD=y +CONFIG_USBIP_VHCI_HC_PORTS=8 +CONFIG_USBIP_VHCI_NR_HCS=1 +CONFIG_USBIP_HOST=y +CONFIG_USBIP_VUDC=y +CONFIG_USBIP_DEBUG=y +CONFIG_USB_MTU3=y +# CONFIG_USB_MTU3_HOST is not set +# CONFIG_USB_MTU3_GADGET is not set +CONFIG_USB_MTU3_DUAL_ROLE=y +CONFIG_USB_MTU3_DEBUG=y +CONFIG_USB_MUSB_HDRC=y +# CONFIG_USB_MUSB_HOST is not set +# CONFIG_USB_MUSB_GADGET is not set +CONFIG_USB_MUSB_DUAL_ROLE=y + +# +# Platform Glue Layer +# +CONFIG_USB_MUSB_TUSB6010=y +CONFIG_USB_MUSB_DSPS=y +CONFIG_USB_MUSB_UX500=y +CONFIG_USB_MUSB_AM335X_CHILD=y + +# +# MUSB DMA mode +# +CONFIG_MUSB_PIO_ONLY=y +CONFIG_USB_DWC3=y +CONFIG_USB_DWC3_ULPI=y +# CONFIG_USB_DWC3_HOST is not set +# CONFIG_USB_DWC3_GADGET is not set +CONFIG_USB_DWC3_DUAL_ROLE=y + +# +# Platform Glue Driver Support +# +CONFIG_USB_DWC3_OMAP=y +CONFIG_USB_DWC3_EXYNOS=y +CONFIG_USB_DWC3_PCI=y +CONFIG_USB_DWC3_KEYSTONE=y +CONFIG_USB_DWC3_OF_SIMPLE=y +CONFIG_USB_DWC3_ST=y +CONFIG_USB_DWC2=y +# CONFIG_USB_DWC2_HOST is not set + +# +# Gadget/Dual-role mode requires USB Gadget support to be enabled +# +# CONFIG_USB_DWC2_PERIPHERAL is not set +CONFIG_USB_DWC2_DUAL_ROLE=y +CONFIG_USB_DWC2_PCI=y +CONFIG_USB_DWC2_DEBUG=y +CONFIG_USB_DWC2_VERBOSE=y +CONFIG_USB_DWC2_TRACK_MISSED_SOFS=y +CONFIG_USB_DWC2_DEBUG_PERIODIC=y +CONFIG_USB_CHIPIDEA=y +CONFIG_USB_CHIPIDEA_OF=y +CONFIG_USB_CHIPIDEA_PCI=y +CONFIG_USB_CHIPIDEA_UDC=y +CONFIG_USB_CHIPIDEA_HOST=y +CONFIG_USB_CHIPIDEA_ULPI=y +CONFIG_USB_ISP1760=y +CONFIG_USB_ISP1760_HCD=y +CONFIG_USB_ISP1761_UDC=y +# CONFIG_USB_ISP1760_HOST_ROLE is not set +# CONFIG_USB_ISP1760_GADGET_ROLE is not set +CONFIG_USB_ISP1760_DUAL_ROLE=y + +# +# USB port drivers +# +CONFIG_USB_USS720=y +CONFIG_USB_SERIAL=y +CONFIG_USB_SERIAL_CONSOLE=y +CONFIG_USB_SERIAL_GENERIC=y +CONFIG_USB_SERIAL_SIMPLE=y +CONFIG_USB_SERIAL_AIRCABLE=y +CONFIG_USB_SERIAL_ARK3116=y +CONFIG_USB_SERIAL_BELKIN=y +CONFIG_USB_SERIAL_CH341=y +CONFIG_USB_SERIAL_WHITEHEAT=y +CONFIG_USB_SERIAL_DIGI_ACCELEPORT=y +CONFIG_USB_SERIAL_CP210X=y +CONFIG_USB_SERIAL_CYPRESS_M8=y +CONFIG_USB_SERIAL_EMPEG=y +CONFIG_USB_SERIAL_FTDI_SIO=y +CONFIG_USB_SERIAL_VISOR=y +CONFIG_USB_SERIAL_IPAQ=y +CONFIG_USB_SERIAL_IR=y +CONFIG_USB_SERIAL_EDGEPORT=y +CONFIG_USB_SERIAL_EDGEPORT_TI=y +CONFIG_USB_SERIAL_F81232=y +CONFIG_USB_SERIAL_F8153X=y +CONFIG_USB_SERIAL_GARMIN=y +CONFIG_USB_SERIAL_IPW=y +CONFIG_USB_SERIAL_IUU=y +CONFIG_USB_SERIAL_KEYSPAN_PDA=y +CONFIG_USB_SERIAL_KEYSPAN=y +CONFIG_USB_SERIAL_KLSI=y +CONFIG_USB_SERIAL_KOBIL_SCT=y +CONFIG_USB_SERIAL_MCT_U232=y +CONFIG_USB_SERIAL_METRO=y +CONFIG_USB_SERIAL_MOS7720=y +CONFIG_USB_SERIAL_MOS7715_PARPORT=y +CONFIG_USB_SERIAL_MOS7840=y +CONFIG_USB_SERIAL_MXUPORT=y +CONFIG_USB_SERIAL_NAVMAN=y +CONFIG_USB_SERIAL_PL2303=y +CONFIG_USB_SERIAL_OTI6858=y +CONFIG_USB_SERIAL_QCAUX=y +CONFIG_USB_SERIAL_QUALCOMM=y +CONFIG_USB_SERIAL_SPCP8X5=y +CONFIG_USB_SERIAL_SAFE=y +CONFIG_USB_SERIAL_SAFE_PADDED=y +CONFIG_USB_SERIAL_SIERRAWIRELESS=y +CONFIG_USB_SERIAL_SYMBOL=y +CONFIG_USB_SERIAL_TI=y +CONFIG_USB_SERIAL_CYBERJACK=y +CONFIG_USB_SERIAL_XIRCOM=y +CONFIG_USB_SERIAL_WWAN=y +CONFIG_USB_SERIAL_OPTION=y +CONFIG_USB_SERIAL_OMNINET=y +CONFIG_USB_SERIAL_OPTICON=y +CONFIG_USB_SERIAL_XSENS_MT=y +CONFIG_USB_SERIAL_WISHBONE=y +CONFIG_USB_SERIAL_SSU100=y +CONFIG_USB_SERIAL_QT2=y +CONFIG_USB_SERIAL_UPD78F0730=y +CONFIG_USB_SERIAL_DEBUG=y + +# +# USB Miscellaneous drivers +# +CONFIG_USB_EMI62=y +CONFIG_USB_EMI26=y +CONFIG_USB_ADUTUX=y +CONFIG_USB_SEVSEG=y +CONFIG_USB_RIO500=y +CONFIG_USB_LEGOTOWER=y +CONFIG_USB_LCD=y +CONFIG_USB_CYPRESS_CY7C63=y +CONFIG_USB_CYTHERM=y +CONFIG_USB_IDMOUSE=y +CONFIG_USB_FTDI_ELAN=y +CONFIG_USB_APPLEDISPLAY=y +CONFIG_USB_SISUSBVGA=y +CONFIG_USB_SISUSBVGA_CON=y +CONFIG_USB_LD=y +CONFIG_USB_TRANCEVIBRATOR=y +CONFIG_USB_IOWARRIOR=y +CONFIG_USB_TEST=y +CONFIG_USB_EHSET_TEST_FIXTURE=y +CONFIG_USB_ISIGHTFW=y +CONFIG_USB_YUREX=y +CONFIG_USB_EZUSB_FX2=y +CONFIG_USB_HUB_USB251XB=y +CONFIG_USB_HSIC_USB3503=y +CONFIG_USB_HSIC_USB4604=y +CONFIG_USB_LINK_LAYER_TEST=y +CONFIG_USB_CHAOSKEY=y +CONFIG_USB_ATM=y +CONFIG_USB_SPEEDTOUCH=y +CONFIG_USB_CXACRU=y +CONFIG_USB_UEAGLEATM=y +CONFIG_USB_XUSBATM=y + +# +# USB Physical Layer drivers +# +CONFIG_USB_PHY=y +CONFIG_KEYSTONE_USB_PHY=y +CONFIG_NOP_USB_XCEIV=y +CONFIG_AM335X_CONTROL_USB=y +CONFIG_AM335X_PHY_USB=y +CONFIG_USB_GPIO_VBUS=y +CONFIG_TAHVO_USB=y +CONFIG_TAHVO_USB_HOST_BY_DEFAULT=y +CONFIG_USB_ISP1301=y +CONFIG_USB_GADGET=y +CONFIG_USB_GADGET_DEBUG=y +CONFIG_USB_GADGET_VERBOSE=y +CONFIG_USB_GADGET_DEBUG_FILES=y +CONFIG_USB_GADGET_DEBUG_FS=y +CONFIG_USB_GADGET_VBUS_DRAW=2 +CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS=2 +CONFIG_U_SERIAL_CONSOLE=y + +# +# USB Peripheral Controller +# +CONFIG_USB_FOTG210_UDC=y +CONFIG_USB_GR_UDC=y +CONFIG_USB_R8A66597=y +CONFIG_USB_RENESAS_USBHS_UDC=y +CONFIG_USB_RENESAS_USB3=y +CONFIG_USB_PXA27X=y +CONFIG_USB_MV_UDC=y +CONFIG_USB_MV_U3D=y +CONFIG_USB_SNP_CORE=y +CONFIG_USB_SNP_UDC_PLAT=y +CONFIG_USB_M66592=y +CONFIG_USB_BDC_UDC=y + +# +# Platform Support +# +CONFIG_USB_BDC_PCI=y +CONFIG_USB_AMD5536UDC=y +CONFIG_USB_NET2272=y +CONFIG_USB_NET2272_DMA=y +CONFIG_USB_NET2280=y +CONFIG_USB_GOKU=y +CONFIG_USB_EG20T=y +CONFIG_USB_GADGET_XILINX=y +CONFIG_USB_DUMMY_HCD=y +CONFIG_USB_LIBCOMPOSITE=y +CONFIG_USB_F_ACM=y +CONFIG_USB_F_SS_LB=y +CONFIG_USB_U_SERIAL=y +CONFIG_USB_U_ETHER=y +CONFIG_USB_U_AUDIO=y +CONFIG_USB_F_SERIAL=y +CONFIG_USB_F_OBEX=y +CONFIG_USB_F_NCM=y +CONFIG_USB_F_ECM=y +CONFIG_USB_F_PHONET=y +CONFIG_USB_F_EEM=y +CONFIG_USB_F_SUBSET=y +CONFIG_USB_F_RNDIS=y +CONFIG_USB_F_MASS_STORAGE=y +CONFIG_USB_F_FS=y +CONFIG_USB_F_UAC1=y +CONFIG_USB_F_UAC1_LEGACY=y +CONFIG_USB_F_UAC2=y +CONFIG_USB_F_UVC=y +CONFIG_USB_F_MIDI=y +CONFIG_USB_F_HID=y +CONFIG_USB_F_PRINTER=y +CONFIG_USB_F_TCM=y +CONFIG_USB_CONFIGFS=y +CONFIG_USB_CONFIGFS_SERIAL=y +CONFIG_USB_CONFIGFS_ACM=y +CONFIG_USB_CONFIGFS_OBEX=y +CONFIG_USB_CONFIGFS_NCM=y +CONFIG_USB_CONFIGFS_ECM=y +CONFIG_USB_CONFIGFS_ECM_SUBSET=y +CONFIG_USB_CONFIGFS_RNDIS=y +CONFIG_USB_CONFIGFS_EEM=y +CONFIG_USB_CONFIGFS_PHONET=y +CONFIG_USB_CONFIGFS_MASS_STORAGE=y +CONFIG_USB_CONFIGFS_F_LB_SS=y +CONFIG_USB_CONFIGFS_F_FS=y +CONFIG_USB_CONFIGFS_F_UAC1=y +CONFIG_USB_CONFIGFS_F_UAC1_LEGACY=y +CONFIG_USB_CONFIGFS_F_UAC2=y +CONFIG_USB_CONFIGFS_F_MIDI=y +CONFIG_USB_CONFIGFS_F_HID=y +CONFIG_USB_CONFIGFS_F_UVC=y +CONFIG_USB_CONFIGFS_F_PRINTER=y +CONFIG_USB_CONFIGFS_F_TCM=y +# CONFIG_USB_ZERO is not set +# CONFIG_USB_AUDIO is not set +CONFIG_USB_ETH=y +CONFIG_USB_ETH_RNDIS=y +CONFIG_USB_ETH_EEM=y +# CONFIG_USB_G_NCM is not set +# CONFIG_USB_GADGETFS is not set +# CONFIG_USB_FUNCTIONFS is not set +# CONFIG_USB_MASS_STORAGE is not set +# CONFIG_USB_GADGET_TARGET is not set +# CONFIG_USB_G_SERIAL is not set +# CONFIG_USB_MIDI_GADGET is not set +# CONFIG_USB_G_PRINTER is not set +# CONFIG_USB_CDC_COMPOSITE is not set +# CONFIG_USB_G_NOKIA is not set +# CONFIG_USB_G_ACM_MS is not set +# CONFIG_USB_G_MULTI is not set +# CONFIG_USB_G_HID is not set +# CONFIG_USB_G_DBGP is not set +# CONFIG_USB_G_WEBCAM is not set +CONFIG_TYPEC=y +CONFIG_TYPEC_TCPM=y +CONFIG_TYPEC_FUSB302=y +CONFIG_TYPEC_WCOVE=y +CONFIG_TYPEC_UCSI=y +CONFIG_UCSI_ACPI=y +CONFIG_TYPEC_TPS6598X=y +CONFIG_USB_LED_TRIG=y +CONFIG_USB_ULPI_BUS=y +CONFIG_UWB=y +CONFIG_UWB_HWA=y +CONFIG_UWB_WHCI=y +CONFIG_UWB_I1480U=y +CONFIG_MMC=y +CONFIG_PWRSEQ_EMMC=y +CONFIG_PWRSEQ_SD8787=y +CONFIG_PWRSEQ_SIMPLE=y +CONFIG_MMC_BLOCK=y +CONFIG_MMC_BLOCK_MINORS=8 +CONFIG_SDIO_UART=y +CONFIG_MMC_TEST=y + +# +# MMC/SD/SDIO Host Controller Drivers +# +CONFIG_MMC_DEBUG=y +CONFIG_MMC_SDHCI=y +CONFIG_MMC_SDHCI_IO_ACCESSORS=y +CONFIG_MMC_SDHCI_PCI=y +CONFIG_MMC_RICOH_MMC=y +CONFIG_MMC_SDHCI_ACPI=y +CONFIG_MMC_SDHCI_PLTFM=y +CONFIG_MMC_SDHCI_OF_ARASAN=y +CONFIG_MMC_SDHCI_OF_AT91=y +CONFIG_MMC_SDHCI_CADENCE=y +CONFIG_MMC_SDHCI_PXAV3=y +CONFIG_MMC_SDHCI_PXAV2=y +CONFIG_MMC_SDHCI_F_SDH30=y +CONFIG_MMC_SDHCI_IPROC=y +CONFIG_MMC_MESON_MX_SDIO=y +CONFIG_MMC_OMAP_HS=y +CONFIG_MMC_WBSD=y +CONFIG_MMC_TIFM_SD=y +CONFIG_MMC_GOLDFISH=y +CONFIG_MMC_SPI=y +CONFIG_MMC_SDRICOH_CS=y +CONFIG_MMC_TMIO_CORE=y +CONFIG_MMC_SDHI=y +CONFIG_MMC_SDHI_SYS_DMAC=y +CONFIG_MMC_SDHI_INTERNAL_DMAC=y +CONFIG_MMC_CB710=y +CONFIG_MMC_VIA_SDMMC=y +CONFIG_MMC_CAVIUM_THUNDERX=y +CONFIG_MMC_DW=y +CONFIG_MMC_DW_PLTFM=y +CONFIG_MMC_DW_EXYNOS=y +CONFIG_MMC_DW_K3=y +CONFIG_MMC_DW_PCI=y +CONFIG_MMC_SH_MMCIF=y +CONFIG_MMC_VUB300=y +CONFIG_MMC_USHC=y +CONFIG_MMC_USDHI6ROL0=y +CONFIG_MMC_REALTEK_PCI=y +CONFIG_MMC_REALTEK_USB=y +CONFIG_MMC_CQHCI=y +CONFIG_MMC_TOSHIBA_PCI=y +CONFIG_MMC_BCM2835=y +CONFIG_MMC_MTK=y +CONFIG_MMC_SDHCI_XENON=y +CONFIG_MMC_SDHCI_OMAP=y +CONFIG_MEMSTICK=y +CONFIG_MEMSTICK_DEBUG=y + +# +# MemoryStick drivers +# +CONFIG_MEMSTICK_UNSAFE_RESUME=y +CONFIG_MSPRO_BLOCK=y +CONFIG_MS_BLOCK=y + +# +# MemoryStick Host Controller Drivers +# +CONFIG_MEMSTICK_TIFM_MS=y +CONFIG_MEMSTICK_JMICRON_38X=y +CONFIG_MEMSTICK_R592=y +CONFIG_MEMSTICK_REALTEK_PCI=y +CONFIG_MEMSTICK_REALTEK_USB=y +CONFIG_NEW_LEDS=y +CONFIG_LEDS_CLASS=y +CONFIG_LEDS_CLASS_FLASH=y +CONFIG_LEDS_BRIGHTNESS_HW_CHANGED=y + +# +# LED drivers +# +CONFIG_LEDS_88PM860X=y +CONFIG_LEDS_AAT1290=y +CONFIG_LEDS_APU=y +CONFIG_LEDS_AS3645A=y +CONFIG_LEDS_BCM6328=y +CONFIG_LEDS_BCM6358=y +CONFIG_LEDS_CPCAP=y +CONFIG_LEDS_LM3530=y +CONFIG_LEDS_LM3533=y +CONFIG_LEDS_LM3642=y +CONFIG_LEDS_LM3692X=y +CONFIG_LEDS_MT6323=y +CONFIG_LEDS_PCA9532=y +CONFIG_LEDS_PCA9532_GPIO=y +CONFIG_LEDS_GPIO=y +CONFIG_LEDS_LP3944=y +CONFIG_LEDS_LP3952=y +CONFIG_LEDS_LP55XX_COMMON=y +CONFIG_LEDS_LP5521=y +CONFIG_LEDS_LP5523=y +CONFIG_LEDS_LP5562=y +CONFIG_LEDS_LP8501=y +CONFIG_LEDS_LP8788=y +CONFIG_LEDS_LP8860=y +CONFIG_LEDS_CLEVO_MAIL=y +CONFIG_LEDS_PCA955X=y +CONFIG_LEDS_PCA955X_GPIO=y +CONFIG_LEDS_PCA963X=y +CONFIG_LEDS_WM831X_STATUS=y +CONFIG_LEDS_WM8350=y +CONFIG_LEDS_DA903X=y +CONFIG_LEDS_DA9052=y +CONFIG_LEDS_DAC124S085=y +CONFIG_LEDS_PWM=y +CONFIG_LEDS_REGULATOR=y +CONFIG_LEDS_BD2802=y +CONFIG_LEDS_INTEL_SS4200=y +CONFIG_LEDS_LT3593=y +CONFIG_LEDS_ADP5520=y +CONFIG_LEDS_MC13783=y +CONFIG_LEDS_TCA6507=y +CONFIG_LEDS_TLC591XX=y +CONFIG_LEDS_MAX77693=y +CONFIG_LEDS_MAX8997=y +CONFIG_LEDS_LM355x=y +CONFIG_LEDS_OT200=y +CONFIG_LEDS_MENF21BMC=y +CONFIG_LEDS_KTD2692=y +CONFIG_LEDS_IS31FL319X=y +CONFIG_LEDS_IS31FL32XX=y + +# +# LED driver for blink(1) USB RGB LED is under Special HID drivers (HID_THINGM) +# +CONFIG_LEDS_BLINKM=y +CONFIG_LEDS_SYSCON=y +CONFIG_LEDS_PM8058=y +CONFIG_LEDS_MLXCPLD=y +CONFIG_LEDS_USER=y +CONFIG_LEDS_NIC78BX=y + +# +# LED Triggers +# +CONFIG_LEDS_TRIGGERS=y +CONFIG_LEDS_TRIGGER_TIMER=y +CONFIG_LEDS_TRIGGER_ONESHOT=y +CONFIG_LEDS_TRIGGER_DISK=y +CONFIG_LEDS_TRIGGER_MTD=y +CONFIG_LEDS_TRIGGER_HEARTBEAT=y +CONFIG_LEDS_TRIGGER_BACKLIGHT=y +CONFIG_LEDS_TRIGGER_CPU=y +CONFIG_LEDS_TRIGGER_ACTIVITY=y +CONFIG_LEDS_TRIGGER_GPIO=y +CONFIG_LEDS_TRIGGER_DEFAULT_ON=y + +# +# iptables trigger is under Netfilter config (LED target) +# +CONFIG_LEDS_TRIGGER_TRANSIENT=y +CONFIG_LEDS_TRIGGER_CAMERA=y +CONFIG_LEDS_TRIGGER_PANIC=y +CONFIG_LEDS_TRIGGER_NETDEV=y +CONFIG_ACCESSIBILITY=y +CONFIG_A11Y_BRAILLE_CONSOLE=y +CONFIG_INFINIBAND=y +CONFIG_INFINIBAND_USER_MAD=y +CONFIG_INFINIBAND_USER_ACCESS=y +CONFIG_INFINIBAND_EXP_USER_ACCESS=y +CONFIG_INFINIBAND_USER_MEM=y +CONFIG_INFINIBAND_ON_DEMAND_PAGING=y +CONFIG_INFINIBAND_ADDR_TRANS=y +CONFIG_INFINIBAND_ADDR_TRANS_CONFIGFS=y +CONFIG_INFINIBAND_MTHCA=y +CONFIG_INFINIBAND_MTHCA_DEBUG=y +CONFIG_INFINIBAND_QIB=y +CONFIG_INFINIBAND_QIB_DCA=y +CONFIG_INFINIBAND_CXGB3=y +CONFIG_INFINIBAND_CXGB3_DEBUG=y +CONFIG_INFINIBAND_CXGB4=y +CONFIG_INFINIBAND_I40IW=y +CONFIG_MLX4_INFINIBAND=y +CONFIG_MLX5_INFINIBAND=y +CONFIG_INFINIBAND_NES=y +CONFIG_INFINIBAND_NES_DEBUG=y +CONFIG_INFINIBAND_OCRDMA=y +CONFIG_INFINIBAND_VMWARE_PVRDMA=y +CONFIG_INFINIBAND_USNIC=y +CONFIG_INFINIBAND_HNS=y +CONFIG_INFINIBAND_HNS_HIP06=y +CONFIG_INFINIBAND_HNS_HIP08=y +CONFIG_INFINIBAND_IPOIB=y +CONFIG_INFINIBAND_IPOIB_CM=y +CONFIG_INFINIBAND_IPOIB_DEBUG=y +CONFIG_INFINIBAND_IPOIB_DEBUG_DATA=y +CONFIG_INFINIBAND_SRP=y +CONFIG_INFINIBAND_SRPT=y +CONFIG_INFINIBAND_ISER=y +CONFIG_INFINIBAND_ISERT=y +CONFIG_INFINIBAND_OPA_VNIC=y +CONFIG_INFINIBAND_RDMAVT=y +CONFIG_RDMA_RXE=y +CONFIG_INFINIBAND_HFI1=y +CONFIG_HFI1_DEBUG_SDMA_ORDER=y +CONFIG_SDMA_VERBOSITY=y +CONFIG_INFINIBAND_QEDR=y +CONFIG_INFINIBAND_BNXT_RE=y +CONFIG_EDAC_ATOMIC_SCRUB=y +CONFIG_EDAC_SUPPORT=y +CONFIG_EDAC=y +CONFIG_EDAC_LEGACY_SYSFS=y +CONFIG_EDAC_DEBUG=y +CONFIG_EDAC_DECODE_MCE=y +CONFIG_EDAC_GHES=y +CONFIG_EDAC_AMD64=y +CONFIG_EDAC_AMD64_ERROR_INJECTION=y +CONFIG_EDAC_E752X=y +CONFIG_EDAC_I82975X=y +CONFIG_EDAC_I3000=y +CONFIG_EDAC_I3200=y +CONFIG_EDAC_IE31200=y +CONFIG_EDAC_X38=y +CONFIG_EDAC_I5400=y +CONFIG_EDAC_I7CORE=y +CONFIG_EDAC_I5000=y +CONFIG_EDAC_I5100=y +CONFIG_EDAC_I7300=y +CONFIG_EDAC_SBRIDGE=y +CONFIG_EDAC_SKX=y +CONFIG_EDAC_PND2=y +CONFIG_EDAC_XGENE=y +CONFIG_RTC_LIB=y +CONFIG_RTC_MC146818_LIB=y +CONFIG_RTC_CLASS=y +CONFIG_RTC_HCTOSYS=y +CONFIG_RTC_HCTOSYS_DEVICE="rtc0" +CONFIG_RTC_SYSTOHC=y +CONFIG_RTC_SYSTOHC_DEVICE="rtc0" +CONFIG_RTC_DEBUG=y +CONFIG_RTC_NVMEM=y + +# +# RTC interfaces +# +CONFIG_RTC_INTF_SYSFS=y +CONFIG_RTC_INTF_PROC=y +CONFIG_RTC_INTF_DEV=y +CONFIG_RTC_INTF_DEV_UIE_EMUL=y +CONFIG_RTC_DRV_TEST=y + +# +# I2C RTC drivers +# +CONFIG_RTC_DRV_88PM860X=y +CONFIG_RTC_DRV_88PM80X=y +CONFIG_RTC_DRV_ABB5ZES3=y +CONFIG_RTC_DRV_ABX80X=y +CONFIG_RTC_DRV_BRCMSTB=y +CONFIG_RTC_DRV_AS3722=y +CONFIG_RTC_DRV_DS1307=y +CONFIG_RTC_DRV_DS1307_HWMON=y +CONFIG_RTC_DRV_DS1307_CENTURY=y +CONFIG_RTC_DRV_DS1374=y +CONFIG_RTC_DRV_DS1374_WDT=y +CONFIG_RTC_DRV_DS1672=y +CONFIG_RTC_DRV_HYM8563=y +CONFIG_RTC_DRV_LP8788=y +CONFIG_RTC_DRV_MAX6900=y +CONFIG_RTC_DRV_MAX8907=y +CONFIG_RTC_DRV_MAX8925=y +CONFIG_RTC_DRV_MAX8998=y +CONFIG_RTC_DRV_MAX8997=y +CONFIG_RTC_DRV_MAX77686=y +CONFIG_RTC_DRV_RK808=y +CONFIG_RTC_DRV_RS5C372=y +CONFIG_RTC_DRV_ISL1208=y +CONFIG_RTC_DRV_ISL12022=y +CONFIG_RTC_DRV_X1205=y +CONFIG_RTC_DRV_PCF8523=y +CONFIG_RTC_DRV_PCF85063=y +CONFIG_RTC_DRV_PCF85363=y +CONFIG_RTC_DRV_PCF8563=y +CONFIG_RTC_DRV_PCF8583=y +CONFIG_RTC_DRV_M41T80=y +CONFIG_RTC_DRV_M41T80_WDT=y +CONFIG_RTC_DRV_BQ32K=y +CONFIG_RTC_DRV_TWL4030=y +CONFIG_RTC_DRV_PALMAS=y +CONFIG_RTC_DRV_TPS6586X=y +CONFIG_RTC_DRV_TPS65910=y +CONFIG_RTC_DRV_TPS80031=y +CONFIG_RTC_DRV_RC5T583=y +CONFIG_RTC_DRV_S35390A=y +CONFIG_RTC_DRV_FM3130=y +CONFIG_RTC_DRV_RX8010=y +CONFIG_RTC_DRV_RX8581=y +CONFIG_RTC_DRV_RX8025=y +CONFIG_RTC_DRV_EM3027=y +CONFIG_RTC_DRV_RV8803=y +CONFIG_RTC_DRV_S5M=y + +# +# SPI RTC drivers +# +CONFIG_RTC_DRV_M41T93=y +CONFIG_RTC_DRV_M41T94=y +CONFIG_RTC_DRV_DS1302=y +CONFIG_RTC_DRV_DS1305=y +CONFIG_RTC_DRV_DS1343=y +CONFIG_RTC_DRV_DS1347=y +CONFIG_RTC_DRV_DS1390=y +CONFIG_RTC_DRV_MAX6916=y +CONFIG_RTC_DRV_R9701=y +CONFIG_RTC_DRV_RX4581=y +CONFIG_RTC_DRV_RX6110=y +CONFIG_RTC_DRV_RS5C348=y +CONFIG_RTC_DRV_MAX6902=y +CONFIG_RTC_DRV_PCF2123=y +CONFIG_RTC_DRV_MCP795=y +CONFIG_RTC_I2C_AND_SPI=y + +# +# SPI and I2C RTC drivers +# +CONFIG_RTC_DRV_DS3232=y +CONFIG_RTC_DRV_DS3232_HWMON=y +CONFIG_RTC_DRV_PCF2127=y +CONFIG_RTC_DRV_RV3029C2=y +CONFIG_RTC_DRV_RV3029_HWMON=y + +# +# Platform RTC drivers +# +CONFIG_RTC_DRV_CMOS=y +CONFIG_RTC_DRV_VRTC=y +CONFIG_RTC_DRV_DS1286=y +CONFIG_RTC_DRV_DS1511=y +CONFIG_RTC_DRV_DS1553=y +CONFIG_RTC_DRV_DS1685_FAMILY=y +CONFIG_RTC_DRV_DS1685=y +# CONFIG_RTC_DRV_DS1689 is not set +# CONFIG_RTC_DRV_DS17285 is not set +# CONFIG_RTC_DRV_DS17485 is not set +# CONFIG_RTC_DRV_DS17885 is not set +CONFIG_RTC_DS1685_PROC_REGS=y +CONFIG_RTC_DS1685_SYSFS_REGS=y +CONFIG_RTC_DRV_DS1742=y +CONFIG_RTC_DRV_DS2404=y +CONFIG_RTC_DRV_DA9052=y +CONFIG_RTC_DRV_DA9055=y +CONFIG_RTC_DRV_DA9063=y +CONFIG_RTC_DRV_STK17TA8=y +CONFIG_RTC_DRV_M48T86=y +CONFIG_RTC_DRV_M48T35=y +CONFIG_RTC_DRV_M48T59=y +CONFIG_RTC_DRV_MSM6242=y +CONFIG_RTC_DRV_BQ4802=y +CONFIG_RTC_DRV_RP5C01=y +CONFIG_RTC_DRV_V3020=y +CONFIG_RTC_DRV_WM831X=y +CONFIG_RTC_DRV_WM8350=y +CONFIG_RTC_DRV_SC27XX=y +CONFIG_RTC_DRV_SPEAR=y +CONFIG_RTC_DRV_PCF50633=y +CONFIG_RTC_DRV_AB3100=y +CONFIG_RTC_DRV_NUC900=y +CONFIG_RTC_DRV_ZYNQMP=y +CONFIG_RTC_DRV_CROS_EC=y + +# +# on-CPU RTC drivers +# +CONFIG_RTC_DRV_ASM9260=y +CONFIG_RTC_DRV_DAVINCI=y +CONFIG_RTC_DRV_DIGICOLOR=y +CONFIG_RTC_DRV_OMAP=y +CONFIG_RTC_DRV_S3C=y +CONFIG_RTC_DRV_EP93XX=y +CONFIG_RTC_DRV_VR41XX=y +CONFIG_RTC_DRV_AT91RM9200=y +CONFIG_RTC_DRV_AT91SAM9=y +CONFIG_RTC_DRV_GENERIC=y +CONFIG_RTC_DRV_VT8500=y +CONFIG_RTC_DRV_SUN6I=y +CONFIG_RTC_DRV_SUNXI=y +CONFIG_RTC_DRV_MV=y +CONFIG_RTC_DRV_ARMADA38X=y +CONFIG_RTC_DRV_FTRTC010=y +CONFIG_RTC_DRV_COH901331=y +CONFIG_RTC_DRV_STMP=y +CONFIG_RTC_DRV_PCAP=y +CONFIG_RTC_DRV_MC13XXX=y +CONFIG_RTC_DRV_JZ4740=y +CONFIG_RTC_DRV_LPC24XX=y +CONFIG_RTC_DRV_LPC32XX=y +CONFIG_RTC_DRV_PM8XXX=y +CONFIG_RTC_DRV_TEGRA=y +CONFIG_RTC_DRV_SNVS=y +CONFIG_RTC_DRV_MOXART=y +CONFIG_RTC_DRV_MT6397=y +CONFIG_RTC_DRV_MT7622=y +CONFIG_RTC_DRV_XGENE=y +CONFIG_RTC_DRV_R7301=y +CONFIG_RTC_DRV_STM32=y +CONFIG_RTC_DRV_CPCAP=y +CONFIG_RTC_DRV_RTD119X=y + +# +# HID Sensor RTC drivers +# +CONFIG_RTC_DRV_HID_SENSOR_TIME=y +CONFIG_DMADEVICES=y +CONFIG_DMADEVICES_DEBUG=y +CONFIG_DMADEVICES_VDEBUG=y + +# +# DMA Devices +# +CONFIG_ASYNC_TX_ENABLE_CHANNEL_SWITCH=y +CONFIG_DMA_ENGINE=y +CONFIG_DMA_VIRTUAL_CHANNELS=y +CONFIG_DMA_ACPI=y +CONFIG_DMA_OF=y +CONFIG_ALTERA_MSGDMA=y +CONFIG_AXI_DMAC=y +CONFIG_BCM_SBA_RAID=y +CONFIG_COH901318=y +CONFIG_DMA_JZ4740=y +CONFIG_DMA_JZ4780=y +CONFIG_DMA_OMAP=y +CONFIG_DMA_SA11X0=y +CONFIG_DMA_SUN6I=y +CONFIG_EP93XX_DMA=y +CONFIG_FSL_EDMA=y +CONFIG_IMG_MDC_DMA=y +CONFIG_INTEL_IDMA64=y +CONFIG_INTEL_IOATDMA=y +CONFIG_INTEL_MIC_X100_DMA=y +CONFIG_K3_DMA=y +CONFIG_MMP_PDMA=y +CONFIG_MMP_TDMA=y +CONFIG_MV_XOR=y +CONFIG_MXS_DMA=y +CONFIG_NBPFAXI_DMA=y +CONFIG_PCH_DMA=y +CONFIG_STM32_DMA=y +CONFIG_STM32_DMAMUX=y +CONFIG_STM32_MDMA=y +CONFIG_SPRD_DMA=y +CONFIG_S3C24XX_DMAC=y +CONFIG_TEGRA210_ADMA=y +CONFIG_TIMB_DMA=y +CONFIG_TI_DMA_CROSSBAR=y +CONFIG_TI_EDMA=y +CONFIG_XGENE_DMA=y +CONFIG_ZX_DMA=y +CONFIG_QCOM_HIDMA_MGMT=y +CONFIG_QCOM_HIDMA=y +CONFIG_DW_DMAC_CORE=y +CONFIG_DW_DMAC=y +CONFIG_DW_DMAC_PCI=y +CONFIG_HSU_DMA=y +CONFIG_HSU_DMA_PCI=y +CONFIG_RENESAS_DMA=y +CONFIG_SH_DMAE_BASE=y +CONFIG_SH_DMAE=y +CONFIG_RCAR_DMAC=y +CONFIG_RENESAS_USB_DMAC=y +CONFIG_SUDMAC=y + +# +# DMA Clients +# +CONFIG_ASYNC_TX_DMA=y +CONFIG_DMATEST=y +CONFIG_DMA_ENGINE_RAID=y + +# +# DMABUF options +# +CONFIG_SYNC_FILE=y +CONFIG_SW_SYNC=y +CONFIG_DCA=y +CONFIG_AUXDISPLAY=y +CONFIG_CHARLCD=y +CONFIG_HD44780=y +CONFIG_KS0108=y +CONFIG_KS0108_PORT=0x378 +CONFIG_KS0108_DELAY=2 +CONFIG_CFAG12864B=y +CONFIG_CFAG12864B_RATE=20 +CONFIG_IMG_ASCII_LCD=y +CONFIG_HT16K33=y +CONFIG_PANEL=y +CONFIG_PANEL_PARPORT=0 +CONFIG_PANEL_PROFILE=5 +CONFIG_PANEL_CHANGE_MESSAGE=y +CONFIG_PANEL_BOOT_MESSAGE="" +CONFIG_UIO=y +CONFIG_UIO_CIF=y +CONFIG_UIO_PDRV_GENIRQ=y +CONFIG_UIO_DMEM_GENIRQ=y +CONFIG_UIO_AEC=y +CONFIG_UIO_SERCOS3=y +CONFIG_UIO_PCI_GENERIC=y +CONFIG_UIO_NETX=y +CONFIG_UIO_PRUSS=y +CONFIG_UIO_MF624=y +CONFIG_UIO_HV_GENERIC=y +CONFIG_VFIO_IOMMU_TYPE1=y +CONFIG_VFIO_VIRQFD=y +CONFIG_VFIO=y +CONFIG_VFIO_NOIOMMU=y +CONFIG_VFIO_PCI=y +CONFIG_VFIO_PCI_VGA=y +CONFIG_VFIO_PCI_MMAP=y +CONFIG_VFIO_PCI_INTX=y +CONFIG_VFIO_PCI_IGD=y +CONFIG_VFIO_MDEV=y +CONFIG_VFIO_MDEV_DEVICE=y +CONFIG_IRQ_BYPASS_MANAGER=y +CONFIG_VIRT_DRIVERS=y +CONFIG_VBOXGUEST=y +CONFIG_VIRTIO=y +CONFIG_VIRTIO_MENU=y +CONFIG_VIRTIO_PCI=y +CONFIG_VIRTIO_PCI_LEGACY=y +CONFIG_VIRTIO_BALLOON=y +CONFIG_VIRTIO_INPUT=y +CONFIG_VIRTIO_MMIO=y +CONFIG_VIRTIO_MMIO_CMDLINE_DEVICES=y + +# +# Microsoft Hyper-V guest support +# +CONFIG_HYPERV=y +CONFIG_HYPERV_TSCPAGE=y +CONFIG_HYPERV_UTILS=y +CONFIG_HYPERV_BALLOON=y + +# +# Xen driver support +# +CONFIG_XEN_BALLOON=y +CONFIG_XEN_SELFBALLOONING=y +CONFIG_XEN_BALLOON_MEMORY_HOTPLUG=y +CONFIG_XEN_SCRUB_PAGES=y +CONFIG_XEN_DEV_EVTCHN=y +CONFIG_XENFS=y +CONFIG_XEN_COMPAT_XENFS=y +CONFIG_XEN_SYS_HYPERVISOR=y +CONFIG_XEN_XENBUS_FRONTEND=y +CONFIG_XEN_GNTDEV=y +CONFIG_XEN_GRANT_DEV_ALLOC=y +CONFIG_SWIOTLB_XEN=y +CONFIG_XEN_TMEM=m +CONFIG_XEN_PVCALLS_FRONTEND=y +CONFIG_XEN_PRIVCMD=y +CONFIG_XEN_EFI=y +CONFIG_XEN_AUTO_XLATE=y +CONFIG_XEN_ACPI=y +CONFIG_STAGING=y +CONFIG_IRDA=y + +# +# IrDA protocols +# +CONFIG_IRLAN=y +CONFIG_IRNET=y +CONFIG_IRCOMM=y +CONFIG_IRDA_ULTRA=y + +# +# IrDA options +# +CONFIG_IRDA_CACHE_LAST_LSAP=y +CONFIG_IRDA_FAST_RR=y +CONFIG_IRDA_DEBUG=y + +# +# Infrared-port device drivers +# + +# +# SIR device drivers +# +CONFIG_IRTTY_SIR=y + +# +# Dongle support +# +CONFIG_DONGLE=y +CONFIG_ESI_DONGLE=y +CONFIG_ACTISYS_DONGLE=y +CONFIG_TEKRAM_DONGLE=y +CONFIG_TOIM3232_DONGLE=y +CONFIG_LITELINK_DONGLE=y +CONFIG_MA600_DONGLE=y +CONFIG_GIRBIL_DONGLE=y +CONFIG_MCP2120_DONGLE=y +CONFIG_OLD_BELKIN_DONGLE=y +CONFIG_ACT200L_DONGLE=y +CONFIG_KINGSUN_DONGLE=y +CONFIG_KSDAZZLE_DONGLE=y +CONFIG_KS959_DONGLE=y + +# +# FIR device drivers +# +CONFIG_USB_IRDA=y +CONFIG_SIGMATEL_FIR=y +CONFIG_NSC_FIR=y +CONFIG_WINBOND_FIR=y +CONFIG_SMC_IRCC_FIR=y +CONFIG_ALI_FIR=y +CONFIG_VLSI_FIR=y +CONFIG_VIA_FIR=y +CONFIG_MCS_FIR=y +CONFIG_IPX=y +CONFIG_IPX_INTERN=y +CONFIG_NCP_FS=y +CONFIG_NCPFS_PACKET_SIGNING=y +CONFIG_NCPFS_IOCTL_LOCKING=y +CONFIG_NCPFS_STRONG=y +CONFIG_NCPFS_NFS_NS=y +CONFIG_NCPFS_OS2_NS=y +CONFIG_NCPFS_SMALLDOS=y +CONFIG_NCPFS_NLS=y +CONFIG_NCPFS_EXTRAS=y +CONFIG_PRISM2_USB=y +CONFIG_COMEDI=y +CONFIG_COMEDI_DEBUG=y +CONFIG_COMEDI_DEFAULT_BUF_SIZE_KB=2048 +CONFIG_COMEDI_DEFAULT_BUF_MAXSIZE_KB=20480 +CONFIG_COMEDI_MISC_DRIVERS=y +CONFIG_COMEDI_BOND=y +CONFIG_COMEDI_TEST=y +CONFIG_COMEDI_PARPORT=y +CONFIG_COMEDI_SERIAL2002=y +CONFIG_COMEDI_SSV_DNP=y +CONFIG_COMEDI_ISA_DRIVERS=y +CONFIG_COMEDI_PCL711=y +CONFIG_COMEDI_PCL724=y +CONFIG_COMEDI_PCL726=y +CONFIG_COMEDI_PCL730=y +CONFIG_COMEDI_PCL812=y +CONFIG_COMEDI_PCL816=y +CONFIG_COMEDI_PCL818=y +CONFIG_COMEDI_PCM3724=y +CONFIG_COMEDI_AMPLC_DIO200_ISA=y +CONFIG_COMEDI_AMPLC_PC236_ISA=y +CONFIG_COMEDI_AMPLC_PC263_ISA=y +CONFIG_COMEDI_RTI800=y +CONFIG_COMEDI_RTI802=y +CONFIG_COMEDI_DAC02=y +CONFIG_COMEDI_DAS16M1=y +CONFIG_COMEDI_DAS08_ISA=y +CONFIG_COMEDI_DAS16=y +CONFIG_COMEDI_DAS800=y +CONFIG_COMEDI_DAS1800=y +CONFIG_COMEDI_DAS6402=y +CONFIG_COMEDI_DT2801=y +CONFIG_COMEDI_DT2811=y +CONFIG_COMEDI_DT2814=y +CONFIG_COMEDI_DT2815=y +CONFIG_COMEDI_DT2817=y +CONFIG_COMEDI_DT282X=y +CONFIG_COMEDI_DMM32AT=y +CONFIG_COMEDI_FL512=y +CONFIG_COMEDI_AIO_AIO12_8=y +CONFIG_COMEDI_AIO_IIRO_16=y +CONFIG_COMEDI_II_PCI20KC=y +CONFIG_COMEDI_C6XDIGIO=y +CONFIG_COMEDI_MPC624=y +CONFIG_COMEDI_ADQ12B=y +CONFIG_COMEDI_NI_AT_A2150=y +CONFIG_COMEDI_NI_AT_AO=y +CONFIG_COMEDI_NI_ATMIO=y +CONFIG_COMEDI_NI_ATMIO16D=y +CONFIG_COMEDI_NI_LABPC_ISA=y +CONFIG_COMEDI_PCMAD=y +CONFIG_COMEDI_PCMDA12=y +CONFIG_COMEDI_PCMMIO=y +CONFIG_COMEDI_PCMUIO=y +CONFIG_COMEDI_MULTIQ3=y +CONFIG_COMEDI_S526=y +CONFIG_COMEDI_PCI_DRIVERS=y +CONFIG_COMEDI_8255_PCI=y +CONFIG_COMEDI_ADDI_WATCHDOG=y +CONFIG_COMEDI_ADDI_APCI_1032=y +CONFIG_COMEDI_ADDI_APCI_1500=y +CONFIG_COMEDI_ADDI_APCI_1516=y +CONFIG_COMEDI_ADDI_APCI_1564=y +CONFIG_COMEDI_ADDI_APCI_16XX=y +CONFIG_COMEDI_ADDI_APCI_2032=y +CONFIG_COMEDI_ADDI_APCI_2200=y +CONFIG_COMEDI_ADDI_APCI_3120=y +CONFIG_COMEDI_ADDI_APCI_3501=y +CONFIG_COMEDI_ADDI_APCI_3XXX=y +CONFIG_COMEDI_ADL_PCI6208=y +CONFIG_COMEDI_ADL_PCI7X3X=y +CONFIG_COMEDI_ADL_PCI8164=y +CONFIG_COMEDI_ADL_PCI9111=y +CONFIG_COMEDI_ADL_PCI9118=y +CONFIG_COMEDI_ADV_PCI1710=y +CONFIG_COMEDI_ADV_PCI1720=y +CONFIG_COMEDI_ADV_PCI1723=y +CONFIG_COMEDI_ADV_PCI1724=y +CONFIG_COMEDI_ADV_PCI1760=y +CONFIG_COMEDI_ADV_PCI_DIO=y +CONFIG_COMEDI_AMPLC_DIO200_PCI=y +CONFIG_COMEDI_AMPLC_PC236_PCI=y +CONFIG_COMEDI_AMPLC_PC263_PCI=y +CONFIG_COMEDI_AMPLC_PCI224=y +CONFIG_COMEDI_AMPLC_PCI230=y +CONFIG_COMEDI_CONTEC_PCI_DIO=y +CONFIG_COMEDI_DAS08_PCI=y +CONFIG_COMEDI_DT3000=y +CONFIG_COMEDI_DYNA_PCI10XX=y +CONFIG_COMEDI_GSC_HPDI=y +CONFIG_COMEDI_MF6X4=y +CONFIG_COMEDI_ICP_MULTI=y +CONFIG_COMEDI_DAQBOARD2000=y +CONFIG_COMEDI_JR3_PCI=y +CONFIG_COMEDI_KE_COUNTER=y +CONFIG_COMEDI_CB_PCIDAS64=y +CONFIG_COMEDI_CB_PCIDAS=y +CONFIG_COMEDI_CB_PCIDDA=y +CONFIG_COMEDI_CB_PCIMDAS=y +CONFIG_COMEDI_CB_PCIMDDA=y +CONFIG_COMEDI_ME4000=y +CONFIG_COMEDI_ME_DAQ=y +CONFIG_COMEDI_NI_6527=y +CONFIG_COMEDI_NI_65XX=y +CONFIG_COMEDI_NI_660X=y +CONFIG_COMEDI_NI_670X=y +CONFIG_COMEDI_NI_LABPC_PCI=y +CONFIG_COMEDI_NI_PCIDIO=y +CONFIG_COMEDI_NI_PCIMIO=y +CONFIG_COMEDI_RTD520=y +CONFIG_COMEDI_S626=y +CONFIG_COMEDI_MITE=y +CONFIG_COMEDI_NI_TIOCMD=y +CONFIG_COMEDI_PCMCIA_DRIVERS=y +CONFIG_COMEDI_CB_DAS16_CS=y +CONFIG_COMEDI_DAS08_CS=y +CONFIG_COMEDI_NI_DAQ_700_CS=y +CONFIG_COMEDI_NI_DAQ_DIO24_CS=y +CONFIG_COMEDI_NI_LABPC_CS=y +CONFIG_COMEDI_NI_MIO_CS=y +CONFIG_COMEDI_QUATECH_DAQP_CS=y +CONFIG_COMEDI_USB_DRIVERS=y +CONFIG_COMEDI_DT9812=y +CONFIG_COMEDI_NI_USB6501=y +CONFIG_COMEDI_USBDUX=y +CONFIG_COMEDI_USBDUXFAST=y +CONFIG_COMEDI_USBDUXSIGMA=y +CONFIG_COMEDI_VMK80XX=y +CONFIG_COMEDI_8254=y +CONFIG_COMEDI_8255=y +CONFIG_COMEDI_8255_SA=y +CONFIG_COMEDI_KCOMEDILIB=y +CONFIG_COMEDI_AMPLC_DIO200=y +CONFIG_COMEDI_AMPLC_PC236=y +CONFIG_COMEDI_DAS08=y +CONFIG_COMEDI_ISADMA=y +CONFIG_COMEDI_NI_LABPC=y +CONFIG_COMEDI_NI_LABPC_ISADMA=y +CONFIG_COMEDI_NI_TIO=y +CONFIG_RTL8192U=m +CONFIG_RTLLIB=m +CONFIG_RTLLIB_CRYPTO_CCMP=m +CONFIG_RTLLIB_CRYPTO_TKIP=m +CONFIG_RTLLIB_CRYPTO_WEP=m +CONFIG_RTL8192E=m +CONFIG_RTL8723BS=m +CONFIG_R8712U=y +CONFIG_R8188EU=m +CONFIG_88EU_AP_MODE=y +CONFIG_R8822BE=m +CONFIG_RTLWIFI_DEBUG_ST=y +CONFIG_RTS5208=y +CONFIG_VT6655=m +CONFIG_VT6656=m + +# +# IIO staging drivers +# + +# +# Accelerometers +# +CONFIG_ADIS16201=y +CONFIG_ADIS16203=y +CONFIG_ADIS16209=y +CONFIG_ADIS16240=y + +# +# Analog to digital converters +# +CONFIG_AD7606=y +CONFIG_AD7606_IFACE_PARALLEL=y +CONFIG_AD7606_IFACE_SPI=y +CONFIG_AD7780=y +CONFIG_AD7816=y +CONFIG_AD7192=y +CONFIG_AD7280=y + +# +# Analog digital bi-direction converters +# +CONFIG_ADT7316=y +CONFIG_ADT7316_SPI=y +CONFIG_ADT7316_I2C=y + +# +# Capacitance to digital converters +# +CONFIG_AD7150=y +CONFIG_AD7152=y +CONFIG_AD7746=y + +# +# Direct Digital Synthesis +# +CONFIG_AD9832=y +CONFIG_AD9834=y + +# +# Digital gyroscope sensors +# +CONFIG_ADIS16060=y + +# +# Network Analyzer, Impedance Converters +# +CONFIG_AD5933=y + +# +# Light sensors +# +CONFIG_TSL2x7x=y + +# +# Active energy metering IC +# +CONFIG_ADE7753=y +CONFIG_ADE7754=y +CONFIG_ADE7758=y +CONFIG_ADE7759=y +CONFIG_ADE7854=y +CONFIG_ADE7854_I2C=y +CONFIG_ADE7854_SPI=y + +# +# Resolver to digital converters +# +CONFIG_AD2S90=y +CONFIG_AD2S1200=y +CONFIG_AD2S1210=y + +# +# Triggers - standalone +# +CONFIG_FB_SM750=y +CONFIG_FB_XGI=y + +# +# Speakup console speech +# +CONFIG_SPEAKUP=y +CONFIG_SPEAKUP_SYNTH_ACNTSA=y +CONFIG_SPEAKUP_SYNTH_ACNTPC=y +CONFIG_SPEAKUP_SYNTH_APOLLO=y +CONFIG_SPEAKUP_SYNTH_AUDPTR=y +CONFIG_SPEAKUP_SYNTH_BNS=y +CONFIG_SPEAKUP_SYNTH_DECTLK=y +CONFIG_SPEAKUP_SYNTH_DECEXT=y +CONFIG_SPEAKUP_SYNTH_DECPC=m +CONFIG_SPEAKUP_SYNTH_DTLK=y +CONFIG_SPEAKUP_SYNTH_KEYPC=y +CONFIG_SPEAKUP_SYNTH_LTLK=y +CONFIG_SPEAKUP_SYNTH_SOFT=y +CONFIG_SPEAKUP_SYNTH_SPKOUT=y +CONFIG_SPEAKUP_SYNTH_TXPRT=y +CONFIG_SPEAKUP_SYNTH_DUMMY=y +CONFIG_STAGING_MEDIA=y +CONFIG_INTEL_ATOMISP=y +CONFIG_VIDEO_ATOMISP=y +CONFIG_VIDEO_ATOMISP_OV5693=y +CONFIG_VIDEO_ATOMISP_OV2722=y +CONFIG_VIDEO_ATOMISP_GC2235=y +CONFIG_VIDEO_ATOMISP_OV8858=y +CONFIG_VIDEO_ATOMISP_MSRLIST_HELPER=y +CONFIG_VIDEO_ATOMISP_MT9M114=y +CONFIG_VIDEO_ATOMISP_GC0310=y +CONFIG_VIDEO_ATOMISP_OV2680=y +CONFIG_VIDEO_ATOMISP_LM3554=y +CONFIG_I2C_BCM2048=y +CONFIG_DVB_CXD2099=y +CONFIG_TEGRA_VDE=y + +# +# Android +# +CONFIG_ASHMEM=y +CONFIG_ION=y +CONFIG_ION_SYSTEM_HEAP=y +CONFIG_ION_CARVEOUT_HEAP=y +CONFIG_ION_CHUNK_HEAP=y +CONFIG_ION_CMA_HEAP=y +CONFIG_STAGING_BOARD=y +CONFIG_LTE_GDM724X=m +CONFIG_FIREWIRE_SERIAL=y +CONFIG_FWTTY_MAX_TOTAL_PORTS=64 +CONFIG_FWTTY_MAX_CARD_PORTS=32 +CONFIG_GOLDFISH_AUDIO=y +CONFIG_MTD_GOLDFISH_NAND=y +CONFIG_MTD_SPINAND_MT29F=y +CONFIG_MTD_SPINAND_ONDIEECC=y +CONFIG_LNET=m +CONFIG_LNET_MAX_PAYLOAD=1048576 +CONFIG_LNET_SELFTEST=m +CONFIG_LNET_XPRT_IB=m +CONFIG_LUSTRE_FS=m +CONFIG_LUSTRE_DEBUG_EXPENSIVE_CHECK=y +CONFIG_DGNC=y +CONFIG_GS_FPGABOOT=y +CONFIG_CRYPTO_SKEIN=y +CONFIG_UNISYSSPAR=y +CONFIG_UNISYS_VISORNIC=y +CONFIG_UNISYS_VISORINPUT=y +CONFIG_UNISYS_VISORHBA=y +CONFIG_COMMON_CLK_XLNX_CLKWZRD=y +CONFIG_FB_TFT=y +CONFIG_FB_TFT_AGM1264K_FL=y +CONFIG_FB_TFT_BD663474=y +CONFIG_FB_TFT_HX8340BN=y +CONFIG_FB_TFT_HX8347D=y +CONFIG_FB_TFT_HX8353D=y +CONFIG_FB_TFT_HX8357D=y +CONFIG_FB_TFT_ILI9163=y +CONFIG_FB_TFT_ILI9320=y +CONFIG_FB_TFT_ILI9325=y +CONFIG_FB_TFT_ILI9340=y +CONFIG_FB_TFT_ILI9341=y +CONFIG_FB_TFT_ILI9481=y +CONFIG_FB_TFT_ILI9486=y +CONFIG_FB_TFT_PCD8544=y +CONFIG_FB_TFT_RA8875=y +CONFIG_FB_TFT_S6D02A1=y +CONFIG_FB_TFT_S6D1121=y +CONFIG_FB_TFT_SH1106=y +CONFIG_FB_TFT_SSD1289=y +CONFIG_FB_TFT_SSD1305=y +CONFIG_FB_TFT_SSD1306=y +CONFIG_FB_TFT_SSD1331=y +CONFIG_FB_TFT_SSD1351=y +CONFIG_FB_TFT_ST7735R=y +CONFIG_FB_TFT_ST7789V=y +CONFIG_FB_TFT_TINYLCD=y +CONFIG_FB_TFT_TLS8204=y +CONFIG_FB_TFT_UC1611=y +CONFIG_FB_TFT_UC1701=y +CONFIG_FB_TFT_UPD161704=y +CONFIG_FB_TFT_WATTEROTT=y +CONFIG_FB_FLEX=y +CONFIG_FB_TFT_FBTFT_DEVICE=y +CONFIG_FSL_MC_BUS=y +CONFIG_WILC1000=y +CONFIG_WILC1000_SDIO=y +CONFIG_WILC1000_SPI=y +CONFIG_WILC1000_HW_OOB_INTR=y +CONFIG_MOST=y +CONFIG_MOST_CDEV=y +CONFIG_MOST_NET=y +CONFIG_MOST_SOUND=y +CONFIG_MOST_VIDEO=y +CONFIG_MOST_DIM2=y +CONFIG_MOST_I2C=y +CONFIG_MOST_USB=y +CONFIG_KS7010=y +CONFIG_GREYBUS=y +CONFIG_GREYBUS_ES2=y +CONFIG_GREYBUS_AUDIO=y +CONFIG_GREYBUS_BOOTROM=y +CONFIG_GREYBUS_FIRMWARE=y +CONFIG_GREYBUS_HID=y +CONFIG_GREYBUS_LIGHT=y +CONFIG_GREYBUS_LOG=y +CONFIG_GREYBUS_LOOPBACK=y +CONFIG_GREYBUS_POWER=y +CONFIG_GREYBUS_RAW=y +CONFIG_GREYBUS_VIBRATOR=y +CONFIG_GREYBUS_BRIDGED_PHY=y +CONFIG_GREYBUS_GPIO=y +CONFIG_GREYBUS_I2C=y +CONFIG_GREYBUS_PWM=y +CONFIG_GREYBUS_SDIO=y +CONFIG_GREYBUS_SPI=y +CONFIG_GREYBUS_UART=y +CONFIG_GREYBUS_USB=y +CONFIG_GREYBUS_ARCHE=y +CONFIG_BCM_VIDEOCORE=y +CONFIG_BCM2835_VCHIQ=y +CONFIG_VIDEO_BCM2835=y +CONFIG_CRYPTO_DEV_CCREE=y + +# +# USB Power Delivery and Type-C drivers +# +CONFIG_TYPEC_TCPCI=y +CONFIG_DRM_VBOXVIDEO=y +CONFIG_PI433=y +CONFIG_X86_PLATFORM_DEVICES=y +CONFIG_ACER_WMI=y +CONFIG_ACER_WIRELESS=y +CONFIG_ACERHDF=y +CONFIG_ALIENWARE_WMI=y +CONFIG_ASUS_LAPTOP=y +CONFIG_DELL_SMBIOS=y +CONFIG_DELL_SMBIOS_WMI=y +CONFIG_DELL_SMBIOS_SMM=y +CONFIG_DELL_LAPTOP=y +CONFIG_DELL_WMI=y +CONFIG_DELL_WMI_DESCRIPTOR=y +CONFIG_DELL_WMI_AIO=y +CONFIG_DELL_WMI_LED=y +CONFIG_DELL_SMO8800=y +CONFIG_DELL_RBTN=y +CONFIG_FUJITSU_LAPTOP=y +CONFIG_FUJITSU_TABLET=y +CONFIG_AMILO_RFKILL=y +CONFIG_GPD_POCKET_FAN=y +CONFIG_HP_ACCEL=y +CONFIG_HP_WIRELESS=y +CONFIG_HP_WMI=y +CONFIG_MSI_LAPTOP=y +CONFIG_PANASONIC_LAPTOP=y +CONFIG_COMPAL_LAPTOP=y +CONFIG_SONY_LAPTOP=y +CONFIG_SONYPI_COMPAT=y +CONFIG_IDEAPAD_LAPTOP=y +CONFIG_SURFACE3_WMI=y +CONFIG_THINKPAD_ACPI=y +CONFIG_THINKPAD_ACPI_ALSA_SUPPORT=y +CONFIG_THINKPAD_ACPI_DEBUGFACILITIES=y +CONFIG_THINKPAD_ACPI_DEBUG=y +CONFIG_THINKPAD_ACPI_UNSAFE_LEDS=y +CONFIG_THINKPAD_ACPI_VIDEO=y +CONFIG_THINKPAD_ACPI_HOTKEY_POLL=y +CONFIG_SENSORS_HDAPS=y +CONFIG_INTEL_MENLOW=y +CONFIG_EEEPC_LAPTOP=y +CONFIG_ASUS_WMI=y +CONFIG_ASUS_NB_WMI=y +CONFIG_EEEPC_WMI=y +CONFIG_ASUS_WIRELESS=y +CONFIG_ACPI_WMI=y +CONFIG_WMI_BMOF=y +CONFIG_INTEL_WMI_THUNDERBOLT=y +CONFIG_MSI_WMI=y +CONFIG_PEAQ_WMI=y +CONFIG_TOPSTAR_LAPTOP=y +CONFIG_ACPI_TOSHIBA=y +CONFIG_TOSHIBA_BT_RFKILL=y +CONFIG_TOSHIBA_HAPS=y +CONFIG_TOSHIBA_WMI=y +CONFIG_ACPI_CMPC=y +CONFIG_INTEL_CHT_INT33FE=y +CONFIG_INTEL_INT0002_VGPIO=y +CONFIG_INTEL_HID_EVENT=y +CONFIG_INTEL_VBTN=y +CONFIG_INTEL_SCU_IPC=y +CONFIG_INTEL_SCU_IPC_UTIL=y +CONFIG_INTEL_MID_POWER_BUTTON=y +CONFIG_INTEL_MFLD_THERMAL=y +CONFIG_INTEL_IPS=y +CONFIG_INTEL_PMC_CORE=y +CONFIG_IBM_RTL=y +CONFIG_XO1_RFKILL=y +CONFIG_XO15_EBOOK=y +CONFIG_SAMSUNG_LAPTOP=y +CONFIG_MXM_WMI=y +CONFIG_INTEL_OAKTRAIL=y +CONFIG_SAMSUNG_Q10=y +CONFIG_APPLE_GMUX=y +CONFIG_INTEL_RST=y +CONFIG_INTEL_SMARTCONNECT=y +CONFIG_PVPANIC=y +CONFIG_INTEL_PMC_IPC=y +CONFIG_INTEL_BXTWC_PMIC_TMU=y +CONFIG_SURFACE_PRO3_BUTTON=y +CONFIG_SURFACE_3_BUTTON=y +CONFIG_INTEL_PUNIT_IPC=y +CONFIG_INTEL_TELEMETRY=y +CONFIG_MLX_PLATFORM=y +CONFIG_INTEL_TURBO_MAX_3=y +CONFIG_SILEAD_DMI=y +CONFIG_INTEL_CHTDC_TI_PWRBTN=y +CONFIG_PMC_ATOM=y +CONFIG_GOLDFISH_BUS=y +CONFIG_GOLDFISH_PIPE=y +CONFIG_CHROME_PLATFORMS=y +CONFIG_CHROMEOS_LAPTOP=y +CONFIG_CHROMEOS_PSTORE=y +CONFIG_CROS_EC_CTL=y +CONFIG_CROS_EC_LPC=y +CONFIG_CROS_EC_LPC_MEC=y +CONFIG_CROS_EC_PROTO=y +CONFIG_CROS_KBD_LED_BACKLIGHT=y +CONFIG_MELLANOX_PLATFORM=y +CONFIG_MLXREG_HOTPLUG=y +CONFIG_CLKDEV_LOOKUP=y +CONFIG_HAVE_CLK_PREPARE=y +CONFIG_COMMON_CLK=y + +# +# Common Clock Framework +# +CONFIG_COMMON_CLK_WM831X=y +CONFIG_COMMON_CLK_VERSATILE=y +CONFIG_CLK_SP810=y +CONFIG_CLK_HSDK=y +CONFIG_COMMON_CLK_MAX77686=y +CONFIG_COMMON_CLK_RK808=y +CONFIG_COMMON_CLK_HI655X=y +CONFIG_COMMON_CLK_SCPI=y +CONFIG_COMMON_CLK_SI5351=y +CONFIG_COMMON_CLK_SI514=y +CONFIG_COMMON_CLK_SI570=y +CONFIG_COMMON_CLK_CDCE706=y +CONFIG_COMMON_CLK_CDCE925=y +CONFIG_COMMON_CLK_CS2000_CP=y +CONFIG_COMMON_CLK_GEMINI=y +CONFIG_COMMON_CLK_ASPEED=y +CONFIG_COMMON_CLK_S2MPS11=y +CONFIG_CLK_TWL6040=y +CONFIG_COMMON_CLK_AXI_CLKGEN=y +CONFIG_CLK_QORIQ=y +CONFIG_COMMON_CLK_XGENE=y +# CONFIG_COMMON_CLK_NXP is not set +CONFIG_COMMON_CLK_PALMAS=y +CONFIG_COMMON_CLK_PWM=y +# CONFIG_COMMON_CLK_PXA is not set +# CONFIG_COMMON_CLK_PIC32 is not set +CONFIG_COMMON_CLK_OXNAS=y +CONFIG_COMMON_CLK_VC5=y +CONFIG_CLK_BCM_63XX=y +CONFIG_CLK_BCM_KONA=y +CONFIG_COMMON_CLK_IPROC=y +CONFIG_CLK_BCM_CYGNUS=y +CONFIG_CLK_BCM_HR2=y +CONFIG_CLK_BCM_NSP=y +CONFIG_CLK_BCM_NS2=y +CONFIG_CLK_BCM_SR=y +CONFIG_COMMON_CLK_HI3516CV300=y +CONFIG_COMMON_CLK_HI3519=y +CONFIG_COMMON_CLK_HI3660=y +CONFIG_COMMON_CLK_HI3798CV200=y +CONFIG_COMMON_CLK_HI6220=y +CONFIG_RESET_HISI=y +CONFIG_STUB_CLK_HI6220=y +CONFIG_STUB_CLK_HI3660=y +CONFIG_COMMON_CLK_BOSTON=y +CONFIG_COMMON_CLK_KEYSTONE=y + +# +# Clock driver for MediaTek SoC +# +CONFIG_COMMON_CLK_MEDIATEK=y +CONFIG_COMMON_CLK_MT2701=y +CONFIG_COMMON_CLK_MT2701_MMSYS=y +CONFIG_COMMON_CLK_MT2701_IMGSYS=y +CONFIG_COMMON_CLK_MT2701_VDECSYS=y +CONFIG_COMMON_CLK_MT2701_HIFSYS=y +CONFIG_COMMON_CLK_MT2701_ETHSYS=y +CONFIG_COMMON_CLK_MT2701_BDPSYS=y +CONFIG_COMMON_CLK_MT2712=y +CONFIG_COMMON_CLK_MT2712_BDPSYS=y +CONFIG_COMMON_CLK_MT2712_IMGSYS=y +CONFIG_COMMON_CLK_MT2712_JPGDECSYS=y +CONFIG_COMMON_CLK_MT2712_MFGCFG=y +CONFIG_COMMON_CLK_MT2712_MMSYS=y +CONFIG_COMMON_CLK_MT2712_VDECSYS=y +CONFIG_COMMON_CLK_MT2712_VENCSYS=y +CONFIG_COMMON_CLK_MT6797=y +CONFIG_COMMON_CLK_MT6797_MMSYS=y +CONFIG_COMMON_CLK_MT6797_IMGSYS=y +CONFIG_COMMON_CLK_MT6797_VDECSYS=y +CONFIG_COMMON_CLK_MT6797_VENCSYS=y +CONFIG_COMMON_CLK_MT7622=y +CONFIG_COMMON_CLK_MT7622_ETHSYS=y +CONFIG_COMMON_CLK_MT7622_HIFSYS=y +CONFIG_COMMON_CLK_MT7622_AUDSYS=y +CONFIG_COMMON_CLK_MT8135=y +CONFIG_COMMON_CLK_MT8173=y +CONFIG_QCOM_GDSC=y +CONFIG_COMMON_CLK_QCOM=y +CONFIG_QCOM_A53PLL=y +CONFIG_QCOM_CLK_APCS_MSM8916=y +CONFIG_APQ_GCC_8084=y +CONFIG_APQ_MMCC_8084=y +CONFIG_IPQ_GCC_4019=y +CONFIG_IPQ_GCC_806X=y +CONFIG_IPQ_LCC_806X=y +CONFIG_IPQ_GCC_8074=y +CONFIG_MSM_GCC_8660=y +CONFIG_MSM_GCC_8916=y +CONFIG_MSM_GCC_8960=y +CONFIG_MSM_LCC_8960=y +CONFIG_MDM_GCC_9615=y +CONFIG_MDM_LCC_9615=y +CONFIG_MSM_MMCC_8960=y +CONFIG_MSM_GCC_8974=y +CONFIG_MSM_MMCC_8974=y +CONFIG_MSM_GCC_8994=y +CONFIG_MSM_GCC_8996=y +CONFIG_MSM_MMCC_8996=y +CONFIG_SPMI_PMIC_CLKDIV=y +CONFIG_CLK_RENESAS=y +CONFIG_CLK_RENESAS_LEGACY=y +CONFIG_CLK_EMEV2=y +CONFIG_CLK_RZA1=y +CONFIG_CLK_R8A73A4=y +CONFIG_CLK_R8A7740=y +CONFIG_CLK_R8A7743=y +CONFIG_CLK_R8A7745=y +CONFIG_CLK_R8A7778=y +CONFIG_CLK_R8A7779=y +CONFIG_CLK_R8A7790=y +CONFIG_CLK_R8A7791=y +CONFIG_CLK_R8A7792=y +CONFIG_CLK_R8A7794=y +CONFIG_CLK_R8A7795=y +CONFIG_CLK_R8A7796=y +CONFIG_CLK_R8A77970=y +CONFIG_CLK_R8A77995=y +CONFIG_CLK_SH73A0=y +CONFIG_CLK_RCAR_GEN2=y +CONFIG_CLK_RCAR_GEN2_CPG=y +CONFIG_CLK_RCAR_GEN3_CPG=y +CONFIG_CLK_RCAR_USB2_CLOCK_SEL=y +CONFIG_CLK_RENESAS_CPG_MSSR=y +CONFIG_CLK_RENESAS_CPG_MSTP=y +CONFIG_CLK_RENESAS_DIV6=y +CONFIG_COMMON_CLK_SAMSUNG=y +CONFIG_EXYNOS_ARM64_COMMON_CLK=y +CONFIG_EXYNOS_AUDSS_CLK_CON=y +CONFIG_S3C2410_COMMON_CLK=y +CONFIG_S3C2412_COMMON_CLK=y +CONFIG_S3C2443_COMMON_CLK=y +CONFIG_SPRD_COMMON_CLK=y +CONFIG_SPRD_SC9860_CLK=y +CONFIG_SUNXI_CCU=y +CONFIG_SUN50I_A64_CCU=y +CONFIG_SUN4I_A10_CCU=y +CONFIG_SUN5I_CCU=y +CONFIG_SUN6I_A31_CCU=y +CONFIG_SUN8I_A23_CCU=y +CONFIG_SUN8I_A33_CCU=y +CONFIG_SUN8I_A83T_CCU=y +CONFIG_SUN8I_H3_CCU=y +CONFIG_SUN8I_V3S_CCU=y +CONFIG_SUN8I_DE2_CCU=y +CONFIG_SUN8I_R40_CCU=y +CONFIG_SUN9I_A80_CCU=y +CONFIG_SUN8I_R_CCU=y +CONFIG_COMMON_CLK_TI_ADPLL=y +CONFIG_CLK_UNIPHIER=y +CONFIG_HWSPINLOCK=y + +# +# Clock Source drivers +# +CONFIG_TIMER_OF=y +CONFIG_TIMER_PROBE=y +CONFIG_CLKEVT_I8253=y +CONFIG_I8253_LOCK=y +CONFIG_CLKBLD_I8253=y +CONFIG_CLKSRC_MMIO=y +CONFIG_BCM2835_TIMER=y +CONFIG_BCM_KONA_TIMER=y +CONFIG_DIGICOLOR_TIMER=y +CONFIG_DW_APB_TIMER=y +CONFIG_FTTMR010_TIMER=y +CONFIG_MESON6_TIMER=y +CONFIG_OWL_TIMER=y +CONFIG_SUN4I_TIMER=y +CONFIG_SUN5I_HSTIMER=y +CONFIG_VT8500_TIMER=y +CONFIG_CADENCE_TTC_TIMER=y +CONFIG_ASM9260_TIMER=y +CONFIG_CLKSRC_DBX500_PRCMU=y +CONFIG_CLPS711X_TIMER=y +CONFIG_ATLAS7_TIMER=y +CONFIG_MXS_TIMER=y +CONFIG_PRIMA2_TIMER=y +CONFIG_NSPIRE_TIMER=y +CONFIG_INTEGRATOR_AP_TIMER=y +CONFIG_CLKSRC_DBX500_PRCMU_SCHED_CLOCK=y +CONFIG_CLKSRC_PISTACHIO=y +CONFIG_ARC_TIMERS=y +CONFIG_ARC_TIMERS_64BIT=y +CONFIG_ARMV7M_SYSTICK=y +# CONFIG_ATMEL_PIT is not set +CONFIG_ATMEL_ST=y +CONFIG_CLKSRC_SAMSUNG_PWM=y +CONFIG_FSL_FTM_TIMER=y +CONFIG_OXNAS_RPS_TIMER=y +CONFIG_MTK_TIMER=y +CONFIG_SPRD_TIMER=y +CONFIG_CLKSRC_JCORE_PIT=y +CONFIG_SH_TIMER_CMT=y +CONFIG_SH_TIMER_MTU2=y +CONFIG_RENESAS_OSTM=y +CONFIG_SH_TIMER_TMU=y +CONFIG_EM_TIMER_STI=y +CONFIG_CLKSRC_PXA=y +CONFIG_H8300_TMR8=y +CONFIG_H8300_TMR16=y +CONFIG_H8300_TPU=y +CONFIG_CLKSRC_ST_LPC=y +CONFIG_MAILBOX=y +CONFIG_PLATFORM_MHU=y +CONFIG_ROCKCHIP_MBOX=y +CONFIG_PCC=y +CONFIG_ALTERA_MBOX=y +CONFIG_MAILBOX_TEST=y +CONFIG_QCOM_APCS_IPC=y +CONFIG_BCM_PDC_MBOX=y +CONFIG_IOMMU_API=y +CONFIG_IOMMU_SUPPORT=y + +# +# Generic IOMMU Pagetable Support +# +CONFIG_IOMMU_IO_PGTABLE=y +CONFIG_IOMMU_IO_PGTABLE_LPAE=y +CONFIG_IOMMU_IO_PGTABLE_LPAE_SELFTEST=y +CONFIG_IOMMU_IO_PGTABLE_ARMV7S=y +CONFIG_IOMMU_IO_PGTABLE_ARMV7S_SELFTEST=y +CONFIG_IOMMU_IOVA=y +CONFIG_OF_IOMMU=y +CONFIG_AMD_IOMMU=y +CONFIG_AMD_IOMMU_V2=y +CONFIG_DMAR_TABLE=y +CONFIG_INTEL_IOMMU=y +CONFIG_INTEL_IOMMU_SVM=y +CONFIG_INTEL_IOMMU_DEFAULT_ON=y +CONFIG_INTEL_IOMMU_FLOPPY_WA=y +CONFIG_IRQ_REMAP=y +CONFIG_QCOM_IOMMU=y + +# +# Remoteproc drivers +# +CONFIG_REMOTEPROC=y + +# +# Rpmsg drivers +# +CONFIG_RPMSG=y +CONFIG_RPMSG_CHAR=y +CONFIG_RPMSG_QCOM_GLINK_NATIVE=y +CONFIG_RPMSG_QCOM_GLINK_RPM=y +CONFIG_RPMSG_VIRTIO=y +CONFIG_SOUNDWIRE=y + +# +# SoundWire Devices +# +CONFIG_SOUNDWIRE_BUS=y +CONFIG_SOUNDWIRE_CADENCE=y +CONFIG_SOUNDWIRE_INTEL=y + +# +# SOC (System On Chip) specific Drivers +# +CONFIG_OWL_PM_DOMAINS_HELPER=y +CONFIG_OWL_PM_DOMAINS=y + +# +# Amlogic SoC drivers +# +CONFIG_MESON_GX_SOCINFO=y +CONFIG_MESON_GX_PM_DOMAINS=y +CONFIG_MESON_MX_SOCINFO=y +CONFIG_AT91_SOC_ID=y + +# +# Broadcom SoC drivers +# +CONFIG_SOC_BRCMSTB=y + +# +# i.MX SoC drivers +# +CONFIG_IMX7_PM_DOMAINS=y + +# +# MediaTek SoC drivers +# +CONFIG_MTK_INFRACFG=y +CONFIG_MTK_PMIC_WRAP=y +CONFIG_MTK_SCPSYS=y + +# +# Qualcomm SoC drivers +# +CONFIG_SOC_RENESAS=y +CONFIG_SYSC_R8A7743=y +CONFIG_SYSC_R8A7745=y +CONFIG_SYSC_R8A7779=y +CONFIG_SYSC_R8A7790=y +CONFIG_SYSC_R8A7791=y +CONFIG_SYSC_R8A7792=y +CONFIG_SYSC_R8A7794=y +CONFIG_SYSC_R8A7795=y +CONFIG_SYSC_R8A7796=y +CONFIG_SYSC_R8A77970=y +CONFIG_SYSC_R8A77995=y +CONFIG_RST_RCAR=y +CONFIG_SYSC_RCAR=y +CONFIG_ROCKCHIP_GRF=y +CONFIG_ROCKCHIP_PM_DOMAINS=y +CONFIG_SOC_SAMSUNG=y +CONFIG_EXYNOS_PM_DOMAINS=y +# CONFIG_SUNXI_SRAM is not set +CONFIG_SOC_TI=y +CONFIG_UX500_SOC_ID=y + +# +# Xilinx SoC drivers +# +CONFIG_XILINX_VCU=y +CONFIG_SOC_ZTE=y +CONFIG_ZX2967_PM_DOMAINS=y +CONFIG_PM_DEVFREQ=y + +# +# DEVFREQ Governors +# +CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND=y +CONFIG_DEVFREQ_GOV_PERFORMANCE=y +CONFIG_DEVFREQ_GOV_POWERSAVE=y +CONFIG_DEVFREQ_GOV_USERSPACE=y +CONFIG_DEVFREQ_GOV_PASSIVE=y + +# +# DEVFREQ Drivers +# +CONFIG_ARM_EXYNOS_BUS_DEVFREQ=y +CONFIG_PM_DEVFREQ_EVENT=y +CONFIG_DEVFREQ_EVENT_EXYNOS_NOCP=y +CONFIG_DEVFREQ_EVENT_EXYNOS_PPMU=y +CONFIG_EXTCON=y + +# +# Extcon Device Drivers +# +CONFIG_EXTCON_ADC_JACK=y +CONFIG_EXTCON_ARIZONA=y +CONFIG_EXTCON_AXP288=y +CONFIG_EXTCON_GPIO=y +CONFIG_EXTCON_INTEL_INT3496=y +CONFIG_EXTCON_INTEL_CHT_WC=y +CONFIG_EXTCON_MAX14577=y +CONFIG_EXTCON_MAX3355=y +CONFIG_EXTCON_MAX77693=y +CONFIG_EXTCON_MAX77843=y +CONFIG_EXTCON_MAX8997=y +CONFIG_EXTCON_PALMAS=y +CONFIG_EXTCON_QCOM_SPMI_MISC=y +CONFIG_EXTCON_RT8973A=y +CONFIG_EXTCON_SM5502=y +CONFIG_EXTCON_USB_GPIO=y +CONFIG_EXTCON_USBC_CROS_EC=y +CONFIG_MEMORY=y +CONFIG_SAMSUNG_MC=y +CONFIG_EXYNOS_SROM=y +CONFIG_IIO=y +CONFIG_IIO_BUFFER=y +CONFIG_IIO_BUFFER_CB=y +CONFIG_IIO_BUFFER_HW_CONSUMER=y +CONFIG_IIO_KFIFO_BUF=y +CONFIG_IIO_TRIGGERED_BUFFER=y +CONFIG_IIO_CONFIGFS=y +CONFIG_IIO_TRIGGER=y +CONFIG_IIO_CONSUMERS_PER_TRIGGER=2 +CONFIG_IIO_SW_DEVICE=y +CONFIG_IIO_SW_TRIGGER=y +CONFIG_IIO_TRIGGERED_EVENT=y + +# +# Accelerometers +# +CONFIG_BMA180=y +CONFIG_BMA220=y +CONFIG_BMC150_ACCEL=y +CONFIG_BMC150_ACCEL_I2C=y +CONFIG_BMC150_ACCEL_SPI=y +CONFIG_DA280=y +CONFIG_DA311=y +CONFIG_DMARD06=y +CONFIG_DMARD09=y +CONFIG_DMARD10=y +CONFIG_HID_SENSOR_ACCEL_3D=y +CONFIG_IIO_CROS_EC_ACCEL_LEGACY=y +CONFIG_KXSD9=y +CONFIG_KXSD9_SPI=y +CONFIG_KXSD9_I2C=y +CONFIG_KXCJK1013=y +CONFIG_MC3230=y +CONFIG_MMA7455=y +CONFIG_MMA7455_I2C=y +CONFIG_MMA7455_SPI=y +CONFIG_MMA7660=y +CONFIG_MMA8452=y +CONFIG_MMA9551_CORE=y +CONFIG_MMA9551=y +CONFIG_MMA9553=y +CONFIG_MXC4005=y +CONFIG_MXC6255=y +CONFIG_SCA3000=y +CONFIG_STK8312=y +CONFIG_STK8BA50=y + +# +# Analog to digital converters +# +CONFIG_AD_SIGMA_DELTA=y +CONFIG_AD7266=y +CONFIG_AD7291=y +CONFIG_AD7298=y +CONFIG_AD7476=y +CONFIG_AD7766=y +CONFIG_AD7791=y +CONFIG_AD7793=y +CONFIG_AD7887=y +CONFIG_AD7923=y +CONFIG_AD799X=y +CONFIG_ASPEED_ADC=y +CONFIG_AT91_SAMA5D2_ADC=y +CONFIG_AXP20X_ADC=y +CONFIG_AXP288_ADC=y +CONFIG_BCM_IPROC_ADC=y +CONFIG_CC10001_ADC=y +CONFIG_CPCAP_ADC=y +CONFIG_DA9150_GPADC=y +CONFIG_DLN2_ADC=y +CONFIG_ENVELOPE_DETECTOR=y +CONFIG_EXYNOS_ADC=y +CONFIG_MXS_LRADC_ADC=y +CONFIG_FSL_MX25_ADC=y +CONFIG_HI8435=y +CONFIG_HX711=y +CONFIG_IMX7D_ADC=y +CONFIG_LP8788_ADC=y +CONFIG_LPC18XX_ADC=y +CONFIG_LPC32XX_ADC=y +CONFIG_LTC2471=y +CONFIG_LTC2485=y +CONFIG_LTC2497=y +CONFIG_MAX1027=y +CONFIG_MAX11100=y +CONFIG_MAX1118=y +CONFIG_MAX1363=y +CONFIG_MAX9611=y +CONFIG_MCP320X=y +CONFIG_MCP3422=y +CONFIG_MEDIATEK_MT6577_AUXADC=y +CONFIG_MEN_Z188_ADC=y +CONFIG_MESON_SARADC=y +CONFIG_NAU7802=y +CONFIG_PALMAS_GPADC=y +CONFIG_QCOM_VADC_COMMON=y +CONFIG_QCOM_PM8XXX_XOADC=y +CONFIG_QCOM_SPMI_IADC=y +CONFIG_QCOM_SPMI_VADC=y +CONFIG_RCAR_GYRO_ADC=y +CONFIG_SPEAR_ADC=y +CONFIG_SD_ADC_MODULATOR=y +CONFIG_STM32_ADC_CORE=y +CONFIG_STM32_ADC=y +CONFIG_STM32_DFSDM_CORE=y +CONFIG_STM32_DFSDM_ADC=y +CONFIG_STX104=y +CONFIG_TI_ADC081C=y +CONFIG_TI_ADC0832=y +CONFIG_TI_ADC084S021=y +CONFIG_TI_ADC12138=y +CONFIG_TI_ADC108S102=y +CONFIG_TI_ADC128S052=y +CONFIG_TI_ADC161S626=y +CONFIG_TI_ADS7950=y +CONFIG_TI_ADS8688=y +CONFIG_TI_AM335X_ADC=y +CONFIG_TI_TLC4541=y +CONFIG_TWL4030_MADC=y +CONFIG_TWL6030_GPADC=y +CONFIG_VF610_ADC=y +CONFIG_VIPERBOARD_ADC=y +CONFIG_XILINX_XADC=y + +# +# Amplifiers +# +CONFIG_AD8366=y + +# +# Chemical Sensors +# +CONFIG_ATLAS_PH_SENSOR=y +CONFIG_CCS811=y +CONFIG_IAQCORE=y +CONFIG_VZ89X=y +CONFIG_IIO_CROS_EC_SENSORS_CORE=y +CONFIG_IIO_CROS_EC_SENSORS=y + +# +# Hid Sensor IIO Common +# +CONFIG_HID_SENSOR_IIO_COMMON=y +CONFIG_HID_SENSOR_IIO_TRIGGER=y +CONFIG_IIO_MS_SENSORS_I2C=y + +# +# SSP Sensor Common +# +CONFIG_IIO_SSP_SENSORS_COMMONS=y +CONFIG_IIO_SSP_SENSORHUB=y +CONFIG_IIO_ST_SENSORS_I2C=y +CONFIG_IIO_ST_SENSORS_SPI=y +CONFIG_IIO_ST_SENSORS_CORE=y + +# +# Counters +# +CONFIG_104_QUAD_8=y +CONFIG_STM32_LPTIMER_CNT=y + +# +# Digital to analog converters +# +CONFIG_AD5064=y +CONFIG_AD5360=y +CONFIG_AD5380=y +CONFIG_AD5421=y +CONFIG_AD5446=y +CONFIG_AD5449=y +CONFIG_AD5592R_BASE=y +CONFIG_AD5592R=y +CONFIG_AD5593R=y +CONFIG_AD5504=y +CONFIG_AD5624R_SPI=y +CONFIG_LTC2632=y +CONFIG_AD5686=y +CONFIG_AD5755=y +CONFIG_AD5761=y +CONFIG_AD5764=y +CONFIG_AD5791=y +CONFIG_AD7303=y +CONFIG_CIO_DAC=y +CONFIG_AD8801=y +CONFIG_DPOT_DAC=y +CONFIG_DS4424=y +CONFIG_LPC18XX_DAC=y +CONFIG_M62332=y +CONFIG_MAX517=y +CONFIG_MAX5821=y +CONFIG_MCP4725=y +CONFIG_MCP4922=y +CONFIG_STM32_DAC=y +CONFIG_STM32_DAC_CORE=y +CONFIG_TI_DAC082S085=y +CONFIG_VF610_DAC=y + +# +# IIO dummy driver +# +CONFIG_IIO_DUMMY_EVGEN=y +CONFIG_IIO_SIMPLE_DUMMY=y +CONFIG_IIO_SIMPLE_DUMMY_EVENTS=y +CONFIG_IIO_SIMPLE_DUMMY_BUFFER=y + +# +# Frequency Synthesizers DDS/PLL +# + +# +# Clock Generator/Distribution +# +CONFIG_AD9523=y + +# +# Phase-Locked Loop (PLL) frequency synthesizers +# +CONFIG_ADF4350=y + +# +# Digital gyroscope sensors +# +CONFIG_ADIS16080=y +CONFIG_ADIS16130=y +CONFIG_ADIS16136=y +CONFIG_ADIS16260=y +CONFIG_ADXRS450=y +CONFIG_BMG160=y +CONFIG_BMG160_I2C=y +CONFIG_BMG160_SPI=y +CONFIG_HID_SENSOR_GYRO_3D=y +CONFIG_MPU3050=y +CONFIG_MPU3050_I2C=y +CONFIG_IIO_ST_GYRO_3AXIS=y +CONFIG_IIO_ST_GYRO_I2C_3AXIS=y +CONFIG_IIO_ST_GYRO_SPI_3AXIS=y +CONFIG_ITG3200=y + +# +# Health Sensors +# + +# +# Heart Rate Monitors +# +CONFIG_AFE4403=y +CONFIG_AFE4404=y +CONFIG_MAX30100=y +CONFIG_MAX30102=y + +# +# Humidity sensors +# +CONFIG_AM2315=y +CONFIG_DHT11=y +CONFIG_HDC100X=y +CONFIG_HID_SENSOR_HUMIDITY=y +CONFIG_HTS221=y +CONFIG_HTS221_I2C=y +CONFIG_HTS221_SPI=y +CONFIG_HTU21=y +CONFIG_SI7005=y +CONFIG_SI7020=y + +# +# Inertial measurement units +# +CONFIG_ADIS16400=y +CONFIG_ADIS16480=y +CONFIG_BMI160=y +CONFIG_BMI160_I2C=y +CONFIG_BMI160_SPI=y +CONFIG_KMX61=y +CONFIG_INV_MPU6050_IIO=y +CONFIG_INV_MPU6050_I2C=y +CONFIG_INV_MPU6050_SPI=y +CONFIG_IIO_ST_LSM6DSX=y +CONFIG_IIO_ST_LSM6DSX_I2C=y +CONFIG_IIO_ST_LSM6DSX_SPI=y +CONFIG_IIO_ADIS_LIB=y +CONFIG_IIO_ADIS_LIB_BUFFER=y + +# +# Light sensors +# +CONFIG_ACPI_ALS=y +CONFIG_ADJD_S311=y +CONFIG_AL3320A=y +CONFIG_APDS9300=y +CONFIG_APDS9960=y +CONFIG_BH1750=y +CONFIG_BH1780=y +CONFIG_CM32181=y +CONFIG_CM3232=y +CONFIG_CM3323=y +CONFIG_CM3605=y +CONFIG_CM36651=y +CONFIG_IIO_CROS_EC_LIGHT_PROX=y +CONFIG_GP2AP020A00F=y +CONFIG_SENSORS_ISL29018=y +CONFIG_SENSORS_ISL29028=y +CONFIG_ISL29125=y +CONFIG_HID_SENSOR_ALS=y +CONFIG_HID_SENSOR_PROX=y +CONFIG_JSA1212=y +CONFIG_RPR0521=y +CONFIG_SENSORS_LM3533=y +CONFIG_LTR501=y +CONFIG_MAX44000=y +CONFIG_OPT3001=y +CONFIG_PA12203001=y +CONFIG_SI1145=y +CONFIG_STK3310=y +CONFIG_ST_UVIS25=y +CONFIG_ST_UVIS25_I2C=y +CONFIG_ST_UVIS25_SPI=y +CONFIG_TCS3414=y +CONFIG_TCS3472=y +CONFIG_SENSORS_TSL2563=y +CONFIG_TSL2583=y +CONFIG_TSL4531=y +CONFIG_US5182D=y +CONFIG_VCNL4000=y +CONFIG_VEML6070=y +CONFIG_VL6180=y +CONFIG_ZOPT2201=y + +# +# Magnetometer sensors +# +CONFIG_AK8974=y +CONFIG_AK8975=y +CONFIG_AK09911=y +CONFIG_BMC150_MAGN=y +CONFIG_BMC150_MAGN_I2C=y +CONFIG_BMC150_MAGN_SPI=y +CONFIG_MAG3110=y +CONFIG_HID_SENSOR_MAGNETOMETER_3D=y +CONFIG_MMC35240=y +CONFIG_IIO_ST_MAGN_3AXIS=y +CONFIG_IIO_ST_MAGN_I2C_3AXIS=y +CONFIG_IIO_ST_MAGN_SPI_3AXIS=y +CONFIG_SENSORS_HMC5843=y +CONFIG_SENSORS_HMC5843_I2C=y +CONFIG_SENSORS_HMC5843_SPI=y + +# +# Multiplexers +# +CONFIG_IIO_MUX=y + +# +# Inclinometer sensors +# +CONFIG_HID_SENSOR_INCLINOMETER_3D=y +CONFIG_HID_SENSOR_DEVICE_ROTATION=y + +# +# Triggers - standalone +# +CONFIG_IIO_HRTIMER_TRIGGER=y +CONFIG_IIO_INTERRUPT_TRIGGER=y +CONFIG_IIO_STM32_LPTIMER_TRIGGER=y +CONFIG_IIO_STM32_TIMER_TRIGGER=y +CONFIG_IIO_TIGHTLOOP_TRIGGER=y +CONFIG_IIO_SYSFS_TRIGGER=y + +# +# Digital potentiometers +# +CONFIG_DS1803=y +CONFIG_MAX5481=y +CONFIG_MAX5487=y +CONFIG_MCP4131=y +CONFIG_MCP4531=y +CONFIG_TPL0102=y + +# +# Digital potentiostats +# +CONFIG_LMP91000=y + +# +# Pressure sensors +# +CONFIG_ABP060MG=y +CONFIG_BMP280=y +CONFIG_BMP280_I2C=y +CONFIG_BMP280_SPI=y +CONFIG_IIO_CROS_EC_BARO=y +CONFIG_HID_SENSOR_PRESS=y +CONFIG_HP03=y +CONFIG_MPL115=y +CONFIG_MPL115_I2C=y +CONFIG_MPL115_SPI=y +CONFIG_MPL3115=y +CONFIG_MS5611=y +CONFIG_MS5611_I2C=y +CONFIG_MS5611_SPI=y +CONFIG_MS5637=y +CONFIG_IIO_ST_PRESS=y +CONFIG_IIO_ST_PRESS_I2C=y +CONFIG_IIO_ST_PRESS_SPI=y +CONFIG_T5403=y +CONFIG_HP206C=y +CONFIG_ZPA2326=y +CONFIG_ZPA2326_I2C=y +CONFIG_ZPA2326_SPI=y + +# +# Lightning sensors +# +CONFIG_AS3935=y + +# +# Proximity and distance sensors +# +CONFIG_LIDAR_LITE_V2=y +CONFIG_RFD77402=y +CONFIG_SRF04=y +CONFIG_SX9500=y +CONFIG_SRF08=y + +# +# Temperature sensors +# +CONFIG_MAXIM_THERMOCOUPLE=y +CONFIG_HID_SENSOR_TEMP=y +CONFIG_MLX90614=y +CONFIG_TMP006=y +CONFIG_TMP007=y +CONFIG_TSYS01=y +CONFIG_TSYS02D=y +CONFIG_NTB=y +CONFIG_NTB_AMD=y +CONFIG_NTB_IDT=y +CONFIG_NTB_INTEL=y +CONFIG_NTB_SWITCHTEC=y +CONFIG_NTB_PINGPONG=y +CONFIG_NTB_TOOL=y +CONFIG_NTB_PERF=y +CONFIG_NTB_TRANSPORT=y +CONFIG_VME_BUS=y + +# +# VME Bridge Drivers +# +CONFIG_VME_CA91CX42=y +CONFIG_VME_TSI148=y +CONFIG_VME_FAKE=y + +# +# VME Board Drivers +# +CONFIG_VMIVME_7805=y + +# +# VME Device Drivers +# +CONFIG_VME_USER=y +CONFIG_PWM=y +CONFIG_PWM_SYSFS=y +CONFIG_PWM_ATMEL_HLCDC_PWM=y +CONFIG_PWM_BCM_IPROC=y +CONFIG_PWM_CLPS711X=y +CONFIG_PWM_CRC=y +CONFIG_PWM_CROS_EC=y +CONFIG_PWM_FSL_FTM=y +CONFIG_PWM_HIBVT=y +CONFIG_PWM_IMG=y +CONFIG_PWM_LP3943=y +CONFIG_PWM_LPSS=y +CONFIG_PWM_LPSS_PCI=y +CONFIG_PWM_LPSS_PLATFORM=y +CONFIG_PWM_MTK_DISP=y +CONFIG_PWM_MEDIATEK=y +CONFIG_PWM_PCA9685=y +CONFIG_PWM_RCAR=y +CONFIG_PWM_RENESAS_TPU=y +CONFIG_PWM_STM32=y +CONFIG_PWM_STM32_LP=y +CONFIG_PWM_STMPE=y +CONFIG_PWM_SUN4I=y +CONFIG_PWM_TWL=y +CONFIG_PWM_TWL_LED=y + +# +# IRQ chip support +# +CONFIG_IRQCHIP=y +CONFIG_ARM_GIC_MAX_NR=1 +# CONFIG_ARM_GIC_V3_ITS is not set +CONFIG_JCORE_AIC=y +CONFIG_TS4800_IRQ=y +CONFIG_IRQ_UNIPHIER_AIDET=y +CONFIG_IPACK_BUS=y +CONFIG_BOARD_TPCI200=y +CONFIG_SERIAL_IPOCTAL=y +CONFIG_RESET_CONTROLLER=y +CONFIG_RESET_ATH79=y +CONFIG_RESET_AXS10X=y +CONFIG_RESET_BERLIN=y +CONFIG_RESET_HSDK=y +CONFIG_RESET_IMX7=y +CONFIG_RESET_LANTIQ=y +CONFIG_RESET_LPC18XX=y +CONFIG_RESET_MESON=y +CONFIG_RESET_PISTACHIO=y +CONFIG_RESET_SIMPLE=y +CONFIG_RESET_SUNXI=y +CONFIG_RESET_TI_SYSCON=y +CONFIG_RESET_UNIPHIER=y +CONFIG_RESET_ZYNQ=y +CONFIG_COMMON_RESET_HI3660=y +CONFIG_COMMON_RESET_HI6220=y +# CONFIG_RESET_TEGRA_BPMP is not set +CONFIG_FMC=y +CONFIG_FMC_FAKEDEV=y +CONFIG_FMC_TRIVIAL=y +CONFIG_FMC_WRITE_EEPROM=y +CONFIG_FMC_CHARDEV=y + +# +# PHY Subsystem +# +CONFIG_GENERIC_PHY=y +CONFIG_PHY_LPC18XX_USB_OTG=y +CONFIG_PHY_XGENE=y +CONFIG_PHY_MESON8B_USB2=y +CONFIG_PHY_MESON_GXL_USB2=y +CONFIG_PHY_CYGNUS_PCIE=y +CONFIG_BCM_KONA_USB2_PHY=y +CONFIG_PHY_BCM_NS_USB2=y +CONFIG_PHY_BCM_NS_USB3=y +CONFIG_PHY_NS2_PCIE=y +CONFIG_PHY_NS2_USB_DRD=y +CONFIG_PHY_BRCM_SATA=y +CONFIG_PHY_HI6220_USB=y +CONFIG_PHY_LANTIQ_RCU_USB2=y +CONFIG_ARMADA375_USBCLUSTER_PHY=y +CONFIG_PHY_MVEBU_CP110_COMPHY=y +CONFIG_PHY_PXA_28NM_HSIC=y +CONFIG_PHY_PXA_28NM_USB2=y +CONFIG_PHY_CPCAP_USB=y +CONFIG_PHY_QCOM_QMP=y +CONFIG_PHY_QCOM_QUSB2=y +CONFIG_PHY_QCOM_USB_HS=y +CONFIG_PHY_QCOM_USB_HSIC=y +CONFIG_PHY_RALINK_USB=y +CONFIG_PHY_RCAR_GEN3_USB3=y +CONFIG_PHY_ROCKCHIP_INNO_USB2=y +CONFIG_PHY_ROCKCHIP_PCIE=y +CONFIG_PHY_ROCKCHIP_TYPEC=y +CONFIG_PHY_EXYNOS_DP_VIDEO=y +CONFIG_PHY_EXYNOS_MIPI_VIDEO=y +CONFIG_PHY_EXYNOS_PCIE=y +CONFIG_PHY_SAMSUNG_USB2=y +# CONFIG_PHY_EXYNOS4210_USB2 is not set +# CONFIG_PHY_EXYNOS4X12_USB2 is not set +# CONFIG_PHY_EXYNOS5250_USB2 is not set +CONFIG_PHY_ST_SPEAR1310_MIPHY=y +CONFIG_PHY_ST_SPEAR1340_MIPHY=y +CONFIG_PHY_STIH407_USB=y +CONFIG_OMAP_CONTROL_PHY=y +CONFIG_PHY_TUSB1210=y +CONFIG_POWERCAP=y +CONFIG_INTEL_RAPL=y +CONFIG_MCB=y +CONFIG_MCB_PCI=y +CONFIG_MCB_LPC=y + +# +# Performance monitor support +# +CONFIG_RAS=y +CONFIG_RAS_CEC=y +CONFIG_THUNDERBOLT=y + +# +# Android +# +CONFIG_ANDROID=y +CONFIG_ANDROID_BINDER_IPC=y +CONFIG_ANDROID_BINDER_DEVICES="binder,hwbinder,vndbinder" +CONFIG_ANDROID_BINDER_IPC_SELFTEST=y +CONFIG_LIBNVDIMM=y +CONFIG_BLK_DEV_PMEM=y +CONFIG_ND_BLK=y +CONFIG_ND_CLAIM=y +CONFIG_ND_BTT=y +CONFIG_BTT=y +CONFIG_ND_PFN=y +CONFIG_NVDIMM_PFN=y +CONFIG_NVDIMM_DAX=y +CONFIG_DAX=y +CONFIG_DEV_DAX=y +CONFIG_DEV_DAX_PMEM=y +CONFIG_NVMEM=y +CONFIG_NVMEM_IMX_IIM=y +CONFIG_NVMEM_IMX_OCOTP=y +CONFIG_NVMEM_LPC18XX_EEPROM=y +CONFIG_NVMEM_LPC18XX_OTP=y +CONFIG_NVMEM_MXS_OCOTP=y +CONFIG_MTK_EFUSE=y +CONFIG_QCOM_QFPROM=y +CONFIG_ROCKCHIP_EFUSE=y +CONFIG_NVMEM_BCM_OCOTP=y +CONFIG_UNIPHIER_EFUSE=y +CONFIG_NVMEM_VF610_OCOTP=y +CONFIG_MESON_MX_EFUSE=y +CONFIG_NVMEM_SNVS_LPGPR=y +CONFIG_STM=y +CONFIG_STM_DUMMY=y +CONFIG_STM_SOURCE_CONSOLE=y +CONFIG_STM_SOURCE_HEARTBEAT=y +CONFIG_STM_SOURCE_FTRACE=y +CONFIG_INTEL_TH=y +CONFIG_INTEL_TH_PCI=y +CONFIG_INTEL_TH_GTH=y +CONFIG_INTEL_TH_STH=y +CONFIG_INTEL_TH_MSU=y +CONFIG_INTEL_TH_PTI=y +CONFIG_INTEL_TH_DEBUG=y +CONFIG_FPGA=y +CONFIG_FPGA_MGR_SOCFPGA=y +CONFIG_FPGA_MGR_SOCFPGA_A10=y +CONFIG_ALTERA_PR_IP_CORE=y +CONFIG_ALTERA_PR_IP_CORE_PLAT=y +CONFIG_FPGA_MGR_ALTERA_PS_SPI=y +CONFIG_FPGA_MGR_ALTERA_CVP=y +CONFIG_FPGA_MGR_ZYNQ_FPGA=y +CONFIG_FPGA_MGR_XILINX_SPI=y +CONFIG_FPGA_MGR_ICE40_SPI=y +CONFIG_FPGA_BRIDGE=y +CONFIG_XILINX_PR_DECOUPLER=y +CONFIG_FPGA_REGION=y +CONFIG_OF_FPGA_REGION=y +CONFIG_FSI=y +CONFIG_FSI_MASTER_GPIO=y +CONFIG_FSI_MASTER_HUB=y +CONFIG_FSI_SCOM=y +CONFIG_TEE=y + +# +# TEE drivers +# +CONFIG_MULTIPLEXER=y + +# +# Multiplexer drivers +# +CONFIG_MUX_ADG792A=y +CONFIG_MUX_GPIO=y +CONFIG_MUX_MMIO=y +CONFIG_PM_OPP=y +CONFIG_UNISYS_VISORBUS=y +CONFIG_SIOX=y +CONFIG_SIOX_BUS_GPIO=y +CONFIG_SLIMBUS=y +CONFIG_SLIM_QCOM_CTRL=y + +# +# Firmware Drivers +# +CONFIG_ARM_SCPI_PROTOCOL=y +CONFIG_ARM_SCPI_POWER_DOMAIN=y +CONFIG_EDD=y +CONFIG_EDD_OFF=y +CONFIG_FIRMWARE_MEMMAP=y +CONFIG_DELL_RBU=y +CONFIG_DCDBAS=y +CONFIG_DMIID=y +CONFIG_DMI_SYSFS=y +CONFIG_DMI_SCAN_MACHINE_NON_EFI_FALLBACK=y +CONFIG_ISCSI_IBFT_FIND=y +CONFIG_ISCSI_IBFT=y +CONFIG_FW_CFG_SYSFS=y +CONFIG_FW_CFG_SYSFS_CMDLINE=y +CONFIG_GOOGLE_FIRMWARE=y +CONFIG_GOOGLE_SMI=y +CONFIG_GOOGLE_COREBOOT_TABLE=y +CONFIG_GOOGLE_COREBOOT_TABLE_ACPI=y +CONFIG_GOOGLE_COREBOOT_TABLE_OF=y +CONFIG_GOOGLE_MEMCONSOLE=y +CONFIG_GOOGLE_MEMCONSOLE_X86_LEGACY=y +CONFIG_GOOGLE_MEMCONSOLE_COREBOOT=y +CONFIG_GOOGLE_VPD=y + +# +# EFI (Extensible Firmware Interface) Support +# +CONFIG_EFI_VARS=y +CONFIG_EFI_ESRT=y +CONFIG_EFI_VARS_PSTORE=y +CONFIG_EFI_VARS_PSTORE_DEFAULT_DISABLE=y +CONFIG_EFI_RUNTIME_MAP=y +CONFIG_EFI_FAKE_MEMMAP=y +CONFIG_EFI_MAX_FAKE_MEM=8 +CONFIG_EFI_RUNTIME_WRAPPERS=y +CONFIG_EFI_BOOTLOADER_CONTROL=y +CONFIG_EFI_CAPSULE_LOADER=y +CONFIG_EFI_TEST=y +CONFIG_APPLE_PROPERTIES=y +CONFIG_RESET_ATTACK_MITIGATION=y +CONFIG_UEFI_CPER=y +CONFIG_EFI_DEV_PATH_PARSER=y + +# +# Tegra firmware driver +# + +# +# File systems +# +CONFIG_DCACHE_WORD_ACCESS=y +CONFIG_FS_IOMAP=y +CONFIG_EXT2_FS=y +CONFIG_EXT2_FS_XATTR=y +CONFIG_EXT2_FS_POSIX_ACL=y +CONFIG_EXT2_FS_SECURITY=y +CONFIG_EXT3_FS=y +CONFIG_EXT3_FS_POSIX_ACL=y +CONFIG_EXT3_FS_SECURITY=y +CONFIG_EXT4_FS=y +CONFIG_EXT4_FS_POSIX_ACL=y +CONFIG_EXT4_FS_SECURITY=y +CONFIG_EXT4_ENCRYPTION=y +CONFIG_EXT4_FS_ENCRYPTION=y +CONFIG_EXT4_DEBUG=y +CONFIG_JBD2=y +CONFIG_JBD2_DEBUG=y +CONFIG_FS_MBCACHE=y +CONFIG_REISERFS_FS=y +CONFIG_REISERFS_CHECK=y +CONFIG_REISERFS_PROC_INFO=y +CONFIG_REISERFS_FS_XATTR=y +CONFIG_REISERFS_FS_POSIX_ACL=y +CONFIG_REISERFS_FS_SECURITY=y +CONFIG_JFS_FS=y +CONFIG_JFS_POSIX_ACL=y +CONFIG_JFS_SECURITY=y +CONFIG_JFS_DEBUG=y +CONFIG_JFS_STATISTICS=y +CONFIG_XFS_FS=y +CONFIG_XFS_QUOTA=y +CONFIG_XFS_POSIX_ACL=y +CONFIG_XFS_RT=y +CONFIG_XFS_ONLINE_SCRUB=y +CONFIG_XFS_DEBUG=y +CONFIG_XFS_ASSERT_FATAL=y +CONFIG_GFS2_FS=y +CONFIG_GFS2_FS_LOCKING_DLM=y +CONFIG_OCFS2_FS=y +CONFIG_OCFS2_FS_O2CB=y +CONFIG_OCFS2_FS_USERSPACE_CLUSTER=y +CONFIG_OCFS2_FS_STATS=y +CONFIG_OCFS2_DEBUG_MASKLOG=y +CONFIG_OCFS2_DEBUG_FS=y +CONFIG_BTRFS_FS=y +CONFIG_BTRFS_FS_POSIX_ACL=y +CONFIG_BTRFS_FS_CHECK_INTEGRITY=y +CONFIG_BTRFS_FS_RUN_SANITY_TESTS=y +CONFIG_BTRFS_DEBUG=y +CONFIG_BTRFS_ASSERT=y +CONFIG_BTRFS_FS_REF_VERIFY=y +CONFIG_NILFS2_FS=y +CONFIG_F2FS_FS=y +CONFIG_F2FS_STAT_FS=y +CONFIG_F2FS_FS_XATTR=y +CONFIG_F2FS_FS_POSIX_ACL=y +CONFIG_F2FS_FS_SECURITY=y +CONFIG_F2FS_CHECK_FS=y +CONFIG_F2FS_FS_ENCRYPTION=y +CONFIG_F2FS_IO_TRACE=y +CONFIG_F2FS_FAULT_INJECTION=y +CONFIG_FS_DAX=y +CONFIG_FS_DAX_PMD=y +CONFIG_FS_POSIX_ACL=y +CONFIG_EXPORTFS=y +CONFIG_EXPORTFS_BLOCK_OPS=y +CONFIG_FILE_LOCKING=y +CONFIG_MANDATORY_FILE_LOCKING=y +CONFIG_FS_ENCRYPTION=y +CONFIG_FSNOTIFY=y +CONFIG_DNOTIFY=y +CONFIG_INOTIFY_USER=y +CONFIG_FANOTIFY=y +CONFIG_FANOTIFY_ACCESS_PERMISSIONS=y +CONFIG_QUOTA=y +CONFIG_QUOTA_NETLINK_INTERFACE=y +CONFIG_PRINT_QUOTA_WARNING=y +CONFIG_QUOTA_DEBUG=y +CONFIG_QUOTA_TREE=y +CONFIG_QFMT_V1=y +CONFIG_QFMT_V2=y +CONFIG_QUOTACTL=y +CONFIG_QUOTACTL_COMPAT=y +CONFIG_AUTOFS4_FS=y +CONFIG_FUSE_FS=y +CONFIG_CUSE=y +CONFIG_OVERLAY_FS=y +CONFIG_OVERLAY_FS_REDIRECT_DIR=y +CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW=y +CONFIG_OVERLAY_FS_INDEX=y +CONFIG_OVERLAY_FS_NFS_EXPORT=y + +# +# Caches +# +CONFIG_FSCACHE=y +CONFIG_FSCACHE_STATS=y +CONFIG_FSCACHE_HISTOGRAM=y +CONFIG_FSCACHE_DEBUG=y +CONFIG_FSCACHE_OBJECT_LIST=y +CONFIG_CACHEFILES=y +CONFIG_CACHEFILES_DEBUG=y +CONFIG_CACHEFILES_HISTOGRAM=y + +# +# CD-ROM/DVD Filesystems +# +CONFIG_ISO9660_FS=y +CONFIG_JOLIET=y +CONFIG_ZISOFS=y +CONFIG_UDF_FS=y +CONFIG_UDF_NLS=y + +# +# DOS/FAT/NT Filesystems +# +CONFIG_FAT_FS=y +CONFIG_MSDOS_FS=y +CONFIG_VFAT_FS=y +CONFIG_FAT_DEFAULT_CODEPAGE=437 +CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" +CONFIG_FAT_DEFAULT_UTF8=y +CONFIG_NTFS_FS=y +CONFIG_NTFS_DEBUG=y +CONFIG_NTFS_RW=y + +# +# Pseudo filesystems +# +CONFIG_PROC_FS=y +CONFIG_PROC_KCORE=y +CONFIG_PROC_VMCORE=y +CONFIG_PROC_SYSCTL=y +CONFIG_PROC_PAGE_MONITOR=y +CONFIG_PROC_CHILDREN=y +CONFIG_KERNFS=y +CONFIG_SYSFS=y +CONFIG_TMPFS=y +CONFIG_TMPFS_POSIX_ACL=y +CONFIG_TMPFS_XATTR=y +CONFIG_HUGETLBFS=y +CONFIG_HUGETLB_PAGE=y +CONFIG_ARCH_HAS_GIGANTIC_PAGE=y +CONFIG_CONFIGFS_FS=y +CONFIG_EFIVAR_FS=y +CONFIG_MISC_FILESYSTEMS=y +CONFIG_ORANGEFS_FS=y +CONFIG_ADFS_FS=y +CONFIG_ADFS_FS_RW=y +CONFIG_AFFS_FS=y +CONFIG_ECRYPT_FS=y +CONFIG_ECRYPT_FS_MESSAGING=y +CONFIG_HFS_FS=y +CONFIG_HFSPLUS_FS=y +CONFIG_HFSPLUS_FS_POSIX_ACL=y +CONFIG_BEFS_FS=y +CONFIG_BEFS_DEBUG=y +CONFIG_BFS_FS=y +CONFIG_EFS_FS=y +CONFIG_JFFS2_FS=y +CONFIG_JFFS2_FS_DEBUG=0 +CONFIG_JFFS2_FS_WRITEBUFFER=y +CONFIG_JFFS2_FS_WBUF_VERIFY=y +CONFIG_JFFS2_SUMMARY=y +CONFIG_JFFS2_FS_XATTR=y +CONFIG_JFFS2_FS_POSIX_ACL=y +CONFIG_JFFS2_FS_SECURITY=y +CONFIG_JFFS2_COMPRESSION_OPTIONS=y +CONFIG_JFFS2_ZLIB=y +CONFIG_JFFS2_LZO=y +CONFIG_JFFS2_RTIME=y +CONFIG_JFFS2_RUBIN=y +# CONFIG_JFFS2_CMODE_NONE is not set +CONFIG_JFFS2_CMODE_PRIORITY=y +# CONFIG_JFFS2_CMODE_SIZE is not set +# CONFIG_JFFS2_CMODE_FAVOURLZO is not set +CONFIG_UBIFS_FS=y +CONFIG_UBIFS_FS_ADVANCED_COMPR=y +CONFIG_UBIFS_FS_LZO=y +CONFIG_UBIFS_FS_ZLIB=y +CONFIG_UBIFS_ATIME_SUPPORT=y +CONFIG_UBIFS_FS_ENCRYPTION=y +CONFIG_UBIFS_FS_SECURITY=y +CONFIG_CRAMFS=y +CONFIG_CRAMFS_BLOCKDEV=y +CONFIG_CRAMFS_MTD=y +CONFIG_SQUASHFS=y +CONFIG_SQUASHFS_FILE_CACHE=y +# CONFIG_SQUASHFS_FILE_DIRECT is not set +CONFIG_SQUASHFS_DECOMP_SINGLE=y +# CONFIG_SQUASHFS_DECOMP_MULTI is not set +# CONFIG_SQUASHFS_DECOMP_MULTI_PERCPU is not set +CONFIG_SQUASHFS_XATTR=y +CONFIG_SQUASHFS_ZLIB=y +CONFIG_SQUASHFS_LZ4=y +CONFIG_SQUASHFS_LZO=y +CONFIG_SQUASHFS_XZ=y +CONFIG_SQUASHFS_ZSTD=y +CONFIG_SQUASHFS_4K_DEVBLK_SIZE=y +CONFIG_SQUASHFS_EMBEDDED=y +CONFIG_SQUASHFS_FRAGMENT_CACHE_SIZE=3 +CONFIG_VXFS_FS=y +CONFIG_MINIX_FS=y +CONFIG_OMFS_FS=y +CONFIG_HPFS_FS=y +CONFIG_QNX4FS_FS=y +CONFIG_QNX6FS_FS=y +CONFIG_QNX6FS_DEBUG=y +CONFIG_ROMFS_FS=y +CONFIG_ROMFS_BACKED_BY_BLOCK=y +# CONFIG_ROMFS_BACKED_BY_MTD is not set +# CONFIG_ROMFS_BACKED_BY_BOTH is not set +CONFIG_ROMFS_ON_BLOCK=y +CONFIG_PSTORE=y +CONFIG_PSTORE_ZLIB_COMPRESS=y +# CONFIG_PSTORE_LZO_COMPRESS is not set +# CONFIG_PSTORE_LZ4_COMPRESS is not set +CONFIG_PSTORE_CONSOLE=y +CONFIG_PSTORE_PMSG=y +CONFIG_PSTORE_FTRACE=y +CONFIG_PSTORE_RAM=y +CONFIG_SYSV_FS=y +CONFIG_UFS_FS=y +CONFIG_UFS_FS_WRITE=y +CONFIG_UFS_DEBUG=y +CONFIG_EXOFS_FS=y +CONFIG_EXOFS_DEBUG=y +CONFIG_ORE=y +CONFIG_NETWORK_FILESYSTEMS=y +CONFIG_NFS_FS=y +CONFIG_NFS_V2=y +CONFIG_NFS_V3=y +CONFIG_NFS_V3_ACL=y +CONFIG_NFS_V4=y +CONFIG_NFS_SWAP=y +CONFIG_NFS_V4_1=y +CONFIG_NFS_V4_2=y +CONFIG_PNFS_FILE_LAYOUT=y +CONFIG_PNFS_BLOCK=y +CONFIG_PNFS_FLEXFILE_LAYOUT=m +CONFIG_NFS_V4_1_IMPLEMENTATION_ID_DOMAIN="kernel.org" +CONFIG_NFS_V4_1_MIGRATION=y +CONFIG_NFS_V4_SECURITY_LABEL=y +CONFIG_ROOT_NFS=y +CONFIG_NFS_FSCACHE=y +CONFIG_NFS_USE_LEGACY_DNS=y +CONFIG_NFS_DEBUG=y +CONFIG_NFSD=y +CONFIG_NFSD_V2_ACL=y +CONFIG_NFSD_V3=y +CONFIG_NFSD_V3_ACL=y +CONFIG_NFSD_V4=y +CONFIG_NFSD_PNFS=y +CONFIG_NFSD_BLOCKLAYOUT=y +CONFIG_NFSD_SCSILAYOUT=y +CONFIG_NFSD_FLEXFILELAYOUT=y +CONFIG_NFSD_V4_SECURITY_LABEL=y +CONFIG_NFSD_FAULT_INJECTION=y +CONFIG_GRACE_PERIOD=y +CONFIG_LOCKD=y +CONFIG_LOCKD_V4=y +CONFIG_NFS_ACL_SUPPORT=y +CONFIG_NFS_COMMON=y +CONFIG_SUNRPC=y +CONFIG_SUNRPC_GSS=y +CONFIG_SUNRPC_BACKCHANNEL=y +CONFIG_SUNRPC_SWAP=y +CONFIG_RPCSEC_GSS_KRB5=y +CONFIG_SUNRPC_DEBUG=y +CONFIG_SUNRPC_XPRT_RDMA=y +CONFIG_CEPH_FS=y +CONFIG_CEPH_FSCACHE=y +CONFIG_CEPH_FS_POSIX_ACL=y +CONFIG_CIFS=y +CONFIG_CIFS_STATS=y +CONFIG_CIFS_STATS2=y +CONFIG_CIFS_WEAK_PW_HASH=y +CONFIG_CIFS_UPCALL=y +CONFIG_CIFS_XATTR=y +CONFIG_CIFS_POSIX=y +CONFIG_CIFS_ACL=y +CONFIG_CIFS_DEBUG=y +CONFIG_CIFS_DEBUG2=y +CONFIG_CIFS_DEBUG_DUMP_KEYS=y +CONFIG_CIFS_DFS_UPCALL=y +CONFIG_CIFS_SMB311=y +CONFIG_CIFS_SMB_DIRECT=y +CONFIG_CIFS_FSCACHE=y +CONFIG_CODA_FS=y +CONFIG_AFS_FS=y +CONFIG_AFS_DEBUG=y +CONFIG_AFS_FSCACHE=y +CONFIG_9P_FS=y +CONFIG_9P_FSCACHE=y +CONFIG_9P_FS_POSIX_ACL=y +CONFIG_9P_FS_SECURITY=y +CONFIG_NLS=y +CONFIG_NLS_DEFAULT="iso8859-1" +CONFIG_NLS_CODEPAGE_437=y +CONFIG_NLS_CODEPAGE_737=y +CONFIG_NLS_CODEPAGE_775=y +CONFIG_NLS_CODEPAGE_850=y +CONFIG_NLS_CODEPAGE_852=y +CONFIG_NLS_CODEPAGE_855=y +CONFIG_NLS_CODEPAGE_857=y +CONFIG_NLS_CODEPAGE_860=y +CONFIG_NLS_CODEPAGE_861=y +CONFIG_NLS_CODEPAGE_862=y +CONFIG_NLS_CODEPAGE_863=y +CONFIG_NLS_CODEPAGE_864=y +CONFIG_NLS_CODEPAGE_865=y +CONFIG_NLS_CODEPAGE_866=y +CONFIG_NLS_CODEPAGE_869=y +CONFIG_NLS_CODEPAGE_936=y +CONFIG_NLS_CODEPAGE_950=y +CONFIG_NLS_CODEPAGE_932=y +CONFIG_NLS_CODEPAGE_949=y +CONFIG_NLS_CODEPAGE_874=y +CONFIG_NLS_ISO8859_8=y +CONFIG_NLS_CODEPAGE_1250=y +CONFIG_NLS_CODEPAGE_1251=y +CONFIG_NLS_ASCII=y +CONFIG_NLS_ISO8859_1=y +CONFIG_NLS_ISO8859_2=y +CONFIG_NLS_ISO8859_3=y +CONFIG_NLS_ISO8859_4=y +CONFIG_NLS_ISO8859_5=y +CONFIG_NLS_ISO8859_6=y +CONFIG_NLS_ISO8859_7=y +CONFIG_NLS_ISO8859_9=y +CONFIG_NLS_ISO8859_13=y +CONFIG_NLS_ISO8859_14=y +CONFIG_NLS_ISO8859_15=y +CONFIG_NLS_KOI8_R=y +CONFIG_NLS_KOI8_U=y +CONFIG_NLS_MAC_ROMAN=y +CONFIG_NLS_MAC_CELTIC=y +CONFIG_NLS_MAC_CENTEURO=y +CONFIG_NLS_MAC_CROATIAN=y +CONFIG_NLS_MAC_CYRILLIC=y +CONFIG_NLS_MAC_GAELIC=y +CONFIG_NLS_MAC_GREEK=y +CONFIG_NLS_MAC_ICELAND=y +CONFIG_NLS_MAC_INUIT=y +CONFIG_NLS_MAC_ROMANIAN=y +CONFIG_NLS_MAC_TURKISH=y +CONFIG_NLS_UTF8=y +CONFIG_DLM=y +CONFIG_DLM_DEBUG=y + +# +# Kernel hacking +# +CONFIG_TRACE_IRQFLAGS_SUPPORT=y + +# +# printk and dmesg options +# +CONFIG_PRINTK_TIME=y +CONFIG_CONSOLE_LOGLEVEL_DEFAULT=7 +CONFIG_MESSAGE_LOGLEVEL_DEFAULT=4 +CONFIG_BOOT_PRINTK_DELAY=y +CONFIG_DYNAMIC_DEBUG=y + +# +# Compile-time checks and compiler options +# +CONFIG_ENABLE_WARN_DEPRECATED=y +CONFIG_ENABLE_MUST_CHECK=y +CONFIG_FRAME_WARN=2048 +CONFIG_STRIP_ASM_SYMS=y +CONFIG_READABLE_ASM=y +CONFIG_UNUSED_SYMBOLS=y +CONFIG_PAGE_OWNER=y +CONFIG_DEBUG_FS=y +CONFIG_HEADERS_CHECK=y +CONFIG_DEBUG_SECTION_MISMATCH=y +CONFIG_SECTION_MISMATCH_WARN_ONLY=y +CONFIG_STACK_VALIDATION=y +CONFIG_DEBUG_FORCE_WEAK_PER_CPU=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE=0x1 +CONFIG_MAGIC_SYSRQ_SERIAL=y +CONFIG_DEBUG_KERNEL=y + +# +# Memory Debugging +# +CONFIG_PAGE_EXTENSION=y +CONFIG_DEBUG_PAGEALLOC=y +CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT=y +CONFIG_PAGE_POISONING=y +CONFIG_PAGE_POISONING_NO_SANITY=y +CONFIG_PAGE_POISONING_ZERO=y +CONFIG_DEBUG_PAGE_REF=y +CONFIG_DEBUG_RODATA_TEST=y +CONFIG_DEBUG_OBJECTS=y +CONFIG_DEBUG_OBJECTS_SELFTEST=y +CONFIG_DEBUG_OBJECTS_FREE=y +CONFIG_DEBUG_OBJECTS_TIMERS=y +CONFIG_DEBUG_OBJECTS_WORK=y +CONFIG_DEBUG_OBJECTS_RCU_HEAD=y +CONFIG_DEBUG_OBJECTS_PERCPU_COUNTER=y +CONFIG_DEBUG_OBJECTS_ENABLE_DEFAULT=1 +CONFIG_SLUB_DEBUG_ON=y +CONFIG_SLUB_STATS=y +CONFIG_HAVE_DEBUG_KMEMLEAK=y +CONFIG_DEBUG_KMEMLEAK=y +CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE=400 +CONFIG_DEBUG_KMEMLEAK_TEST=m +CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF=y +CONFIG_DEBUG_STACK_USAGE=y +CONFIG_DEBUG_VM=y +CONFIG_DEBUG_VM_VMACACHE=y +CONFIG_DEBUG_VM_RB=y +CONFIG_DEBUG_VM_PGFLAGS=y +CONFIG_ARCH_HAS_DEBUG_VIRTUAL=y +CONFIG_DEBUG_VIRTUAL=y +CONFIG_DEBUG_MEMORY_INIT=y +CONFIG_MEMORY_NOTIFIER_ERROR_INJECT=y +CONFIG_DEBUG_PER_CPU_MAPS=y +CONFIG_HAVE_DEBUG_STACKOVERFLOW=y +CONFIG_DEBUG_STACKOVERFLOW=y +CONFIG_HAVE_ARCH_KASAN=y +CONFIG_KASAN=y +CONFIG_KASAN_OUTLINE=y +# CONFIG_KASAN_INLINE is not set +CONFIG_TEST_KASAN=m +CONFIG_ARCH_HAS_KCOV=y +CONFIG_KCOV=y +CONFIG_KCOV_ENABLE_COMPARISONS=y +CONFIG_KCOV_INSTRUMENT_ALL=y +CONFIG_DEBUG_SHIRQ=y + +# +# Debug Lockups and Hangs +# +CONFIG_LOCKUP_DETECTOR=y +CONFIG_SOFTLOCKUP_DETECTOR=y +CONFIG_HARDLOCKUP_DETECTOR_PERF=y +CONFIG_HARDLOCKUP_CHECK_TIMESTAMP=y +CONFIG_HARDLOCKUP_DETECTOR=y +CONFIG_BOOTPARAM_HARDLOCKUP_PANIC=y +CONFIG_BOOTPARAM_HARDLOCKUP_PANIC_VALUE=1 +CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC=y +CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=1 +CONFIG_DETECT_HUNG_TASK=y +CONFIG_DEFAULT_HUNG_TASK_TIMEOUT=120 +CONFIG_BOOTPARAM_HUNG_TASK_PANIC=y +CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=1 +CONFIG_WQ_WATCHDOG=y +CONFIG_PANIC_ON_OOPS=y +CONFIG_PANIC_ON_OOPS_VALUE=1 +CONFIG_PANIC_TIMEOUT=0 +CONFIG_SCHED_DEBUG=y +CONFIG_SCHED_INFO=y +CONFIG_SCHEDSTATS=y +CONFIG_SCHED_STACK_END_CHECK=y +CONFIG_DEBUG_TIMEKEEPING=y + +# +# Lock Debugging (spinlocks, mutexes, etc...) +# +CONFIG_DEBUG_RT_MUTEXES=y +CONFIG_DEBUG_SPINLOCK=y +CONFIG_DEBUG_MUTEXES=y +CONFIG_DEBUG_WW_MUTEX_SLOWPATH=y +CONFIG_DEBUG_LOCK_ALLOC=y +CONFIG_PROVE_LOCKING=y +CONFIG_LOCKDEP=y +CONFIG_LOCK_STAT=y +CONFIG_DEBUG_LOCKDEP=y +CONFIG_DEBUG_ATOMIC_SLEEP=y +CONFIG_DEBUG_LOCKING_API_SELFTESTS=y +CONFIG_LOCK_TORTURE_TEST=y +CONFIG_WW_MUTEX_SELFTEST=y +CONFIG_TRACE_IRQFLAGS=y +CONFIG_STACKTRACE=y +CONFIG_WARN_ALL_UNSEEDED_RANDOM=y +CONFIG_DEBUG_KOBJECT=y +CONFIG_DEBUG_KOBJECT_RELEASE=y +CONFIG_DEBUG_BUGVERBOSE=y +CONFIG_DEBUG_LIST=y +CONFIG_DEBUG_PI_LIST=y +CONFIG_DEBUG_SG=y +CONFIG_DEBUG_NOTIFIERS=y +CONFIG_DEBUG_CREDENTIALS=y + +# +# RCU Debugging +# +CONFIG_PROVE_RCU=y +CONFIG_TORTURE_TEST=y +CONFIG_RCU_PERF_TEST=y +CONFIG_RCU_TORTURE_TEST=y +CONFIG_RCU_CPU_STALL_TIMEOUT=21 +CONFIG_RCU_TRACE=y +CONFIG_RCU_EQS_DEBUG=y +CONFIG_DEBUG_WQ_FORCE_RR_CPU=y +CONFIG_DEBUG_BLOCK_EXT_DEVT=y +CONFIG_CPU_HOTPLUG_STATE_CONTROL=y +CONFIG_NOTIFIER_ERROR_INJECTION=y +CONFIG_PM_NOTIFIER_ERROR_INJECT=y +CONFIG_OF_RECONFIG_NOTIFIER_ERROR_INJECT=y +CONFIG_NETDEV_NOTIFIER_ERROR_INJECT=y +CONFIG_FAULT_INJECTION=y +CONFIG_FUNCTION_ERROR_INJECTION=y +CONFIG_FAILSLAB=y +CONFIG_FAIL_PAGE_ALLOC=y +CONFIG_FAIL_MAKE_REQUEST=y +CONFIG_FAIL_IO_TIMEOUT=y +CONFIG_FAIL_MMC_REQUEST=y +CONFIG_FAIL_FUTEX=y +CONFIG_FAIL_FUNCTION=y +CONFIG_FAULT_INJECTION_DEBUG_FS=y +CONFIG_LATENCYTOP=y +CONFIG_USER_STACKTRACE_SUPPORT=y +CONFIG_NOP_TRACER=y +CONFIG_HAVE_FUNCTION_TRACER=y +CONFIG_HAVE_FUNCTION_GRAPH_TRACER=y +CONFIG_HAVE_DYNAMIC_FTRACE=y +CONFIG_HAVE_DYNAMIC_FTRACE_WITH_REGS=y +CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y +CONFIG_HAVE_SYSCALL_TRACEPOINTS=y +CONFIG_HAVE_FENTRY=y +CONFIG_HAVE_C_RECORDMCOUNT=y +CONFIG_TRACER_MAX_TRACE=y +CONFIG_TRACE_CLOCK=y +CONFIG_RING_BUFFER=y +CONFIG_EVENT_TRACING=y +CONFIG_CONTEXT_SWITCH_TRACER=y +CONFIG_RING_BUFFER_ALLOW_SWAP=y +CONFIG_TRACING=y +CONFIG_GENERIC_TRACER=y +CONFIG_TRACING_SUPPORT=y +CONFIG_FTRACE=y +CONFIG_FUNCTION_TRACER=y +CONFIG_FUNCTION_GRAPH_TRACER=y +CONFIG_IRQSOFF_TRACER=y +CONFIG_SCHED_TRACER=y +CONFIG_HWLAT_TRACER=y +CONFIG_FTRACE_SYSCALLS=y +CONFIG_TRACER_SNAPSHOT=y +CONFIG_TRACER_SNAPSHOT_PER_CPU_SWAP=y +CONFIG_BRANCH_PROFILE_NONE=y +# CONFIG_PROFILE_ANNOTATED_BRANCHES is not set +CONFIG_STACK_TRACER=y +CONFIG_BLK_DEV_IO_TRACE=y +CONFIG_KPROBE_EVENTS=y +CONFIG_UPROBE_EVENTS=y +CONFIG_BPF_EVENTS=y +CONFIG_PROBE_EVENTS=y +CONFIG_DYNAMIC_FTRACE=y +CONFIG_DYNAMIC_FTRACE_WITH_REGS=y +CONFIG_FUNCTION_PROFILER=y +CONFIG_BPF_KPROBE_OVERRIDE=y +CONFIG_FTRACE_MCOUNT_RECORD=y +CONFIG_FTRACE_SELFTEST=y +CONFIG_FTRACE_STARTUP_TEST=y +CONFIG_EVENT_TRACE_TEST_SYSCALLS=y +CONFIG_MMIOTRACE=y +CONFIG_TRACING_MAP=y +CONFIG_HIST_TRIGGERS=y +CONFIG_MMIOTRACE_TEST=m +CONFIG_TRACEPOINT_BENCHMARK=y +CONFIG_RING_BUFFER_BENCHMARK=y +CONFIG_RING_BUFFER_STARTUP_TEST=y +CONFIG_TRACE_EVAL_MAP_FILE=y +CONFIG_TRACING_EVENTS_GPIO=y +CONFIG_PROVIDE_OHCI1394_DMA_INIT=y +CONFIG_DMA_API_DEBUG=y +CONFIG_RUNTIME_TESTING_MENU=y +CONFIG_LKDTM=y +CONFIG_TEST_LIST_SORT=y +CONFIG_TEST_SORT=y +CONFIG_KPROBES_SANITY_TEST=y +CONFIG_BACKTRACE_SELF_TEST=y +CONFIG_RBTREE_TEST=y +CONFIG_INTERVAL_TREE_TEST=y +CONFIG_PERCPU_TEST=m +CONFIG_ATOMIC64_SELFTEST=y +CONFIG_ASYNC_RAID6_TEST=y +CONFIG_TEST_HEXDUMP=y +CONFIG_TEST_STRING_HELPERS=y +CONFIG_TEST_KSTRTOX=y +CONFIG_TEST_PRINTF=y +CONFIG_TEST_BITMAP=y +CONFIG_TEST_UUID=y +CONFIG_TEST_RHASHTABLE=y +CONFIG_TEST_HASH=y +CONFIG_TEST_PARMAN=y +CONFIG_TEST_LKM=m +CONFIG_TEST_USER_COPY=m +CONFIG_TEST_BPF=m +CONFIG_FIND_BIT_BENCHMARK=y +CONFIG_TEST_FIRMWARE=y +CONFIG_TEST_SYSCTL=y +CONFIG_TEST_UDELAY=y +CONFIG_TEST_STATIC_KEYS=m +CONFIG_TEST_KMOD=m +CONFIG_TEST_DEBUG_VIRTUAL=y +CONFIG_MEMTEST=y +CONFIG_BUG_ON_DATA_CORRUPTION=y +CONFIG_SAMPLES=y +CONFIG_SAMPLE_TRACE_EVENTS=m +CONFIG_SAMPLE_TRACE_PRINTK=m +CONFIG_SAMPLE_KOBJECT=m +CONFIG_SAMPLE_KPROBES=m +CONFIG_SAMPLE_KRETPROBES=m +CONFIG_SAMPLE_HW_BREAKPOINT=m +CONFIG_SAMPLE_KFIFO=m +CONFIG_SAMPLE_KDB=m +CONFIG_SAMPLE_RPMSG_CLIENT=m +CONFIG_SAMPLE_LIVEPATCH=m +CONFIG_SAMPLE_CONFIGFS=m +CONFIG_SAMPLE_CONNECTOR=m +CONFIG_SAMPLE_SECCOMP=m +CONFIG_SAMPLE_VFIO_MDEV_MTTY=m +CONFIG_HAVE_ARCH_KGDB=y +CONFIG_KGDB=y +CONFIG_KGDB_SERIAL_CONSOLE=y +CONFIG_KGDB_TESTS=y +CONFIG_KGDB_TESTS_ON_BOOT=y +CONFIG_KGDB_TESTS_BOOT_STRING="V1F100" +CONFIG_KGDB_LOW_LEVEL_TRAP=y +CONFIG_KGDB_KDB=y +CONFIG_KDB_DEFAULT_ENABLE=0x1 +CONFIG_KDB_KEYBOARD=y +CONFIG_KDB_CONTINUE_CATASTROPHIC=0 +CONFIG_ARCH_HAS_UBSAN_SANITIZE_ALL=y +# CONFIG_ARCH_WANTS_UBSAN_NO_NULL is not set +CONFIG_UBSAN=y +CONFIG_UBSAN_ALIGNMENT=y +CONFIG_UBSAN_NULL=y +CONFIG_ARCH_HAS_DEVMEM_IS_ALLOWED=y +CONFIG_STRICT_DEVMEM=y +CONFIG_IO_STRICT_DEVMEM=y +CONFIG_EARLY_PRINTK_USB=y +CONFIG_X86_VERBOSE_BOOTUP=y +CONFIG_EARLY_PRINTK=y +CONFIG_EARLY_PRINTK_DBGP=y +CONFIG_EARLY_PRINTK_EFI=y +CONFIG_EARLY_PRINTK_USB_XDBC=y +CONFIG_X86_PTDUMP_CORE=y +CONFIG_X86_PTDUMP=y +CONFIG_EFI_PGT_DUMP=y +CONFIG_DEBUG_WX=y +CONFIG_DOUBLEFAULT=y +CONFIG_DEBUG_TLBFLUSH=y +CONFIG_IOMMU_DEBUG=y +CONFIG_IOMMU_LEAK=y +CONFIG_HAVE_MMIOTRACE_SUPPORT=y +CONFIG_IO_DELAY_TYPE_0X80=0 +CONFIG_IO_DELAY_TYPE_0XED=1 +CONFIG_IO_DELAY_TYPE_UDELAY=2 +CONFIG_IO_DELAY_TYPE_NONE=3 +CONFIG_IO_DELAY_0X80=y +# CONFIG_IO_DELAY_0XED is not set +# CONFIG_IO_DELAY_UDELAY is not set +# CONFIG_IO_DELAY_NONE is not set +CONFIG_DEFAULT_IO_DELAY_TYPE=0 +CONFIG_DEBUG_BOOT_PARAMS=y +CONFIG_CPA_DEBUG=y +CONFIG_OPTIMIZE_INLINING=y +CONFIG_DEBUG_ENTRY=y +CONFIG_DEBUG_NMI_SELFTEST=y +CONFIG_X86_DEBUG_FPU=y +CONFIG_PUNIT_ATOM_DEBUG=y +CONFIG_UNWINDER_ORC=y +# CONFIG_UNWINDER_FRAME_POINTER is not set + +# +# Security options +# +CONFIG_KEYS=y +CONFIG_KEYS_COMPAT=y +CONFIG_PERSISTENT_KEYRINGS=y +CONFIG_BIG_KEYS=y +CONFIG_TRUSTED_KEYS=y +CONFIG_ENCRYPTED_KEYS=y +CONFIG_KEY_DH_OPERATIONS=y +CONFIG_SECURITY_DMESG_RESTRICT=y +CONFIG_SECURITY=y +CONFIG_SECURITY_WRITABLE_HOOKS=y +CONFIG_SECURITYFS=y +CONFIG_SECURITY_NETWORK=y +CONFIG_PAGE_TABLE_ISOLATION=y +CONFIG_SECURITY_INFINIBAND=y +CONFIG_SECURITY_NETWORK_XFRM=y +CONFIG_SECURITY_PATH=y +CONFIG_INTEL_TXT=y +CONFIG_LSM_MMAP_MIN_ADDR=65536 +CONFIG_HAVE_HARDENED_USERCOPY_ALLOCATOR=y +CONFIG_HARDENED_USERCOPY=y +CONFIG_HARDENED_USERCOPY_FALLBACK=y +CONFIG_HARDENED_USERCOPY_PAGESPAN=y +CONFIG_FORTIFY_SOURCE=y +CONFIG_STATIC_USERMODEHELPER=y +CONFIG_STATIC_USERMODEHELPER_PATH="/sbin/usermode-helper" +CONFIG_SECURITY_SELINUX=y +CONFIG_SECURITY_SELINUX_BOOTPARAM=y +CONFIG_SECURITY_SELINUX_BOOTPARAM_VALUE=1 +CONFIG_SECURITY_SELINUX_DISABLE=y +CONFIG_SECURITY_SELINUX_DEVELOP=y +CONFIG_SECURITY_SELINUX_AVC_STATS=y +CONFIG_SECURITY_SELINUX_CHECKREQPROT_VALUE=0 +CONFIG_SECURITY_SMACK=y +CONFIG_SECURITY_SMACK_BRINGUP=y +CONFIG_SECURITY_SMACK_NETFILTER=y +CONFIG_SECURITY_SMACK_APPEND_SIGNALS=y +CONFIG_SECURITY_TOMOYO=y +CONFIG_SECURITY_TOMOYO_MAX_ACCEPT_ENTRY=2048 +CONFIG_SECURITY_TOMOYO_MAX_AUDIT_LOG=1024 +CONFIG_SECURITY_TOMOYO_OMIT_USERSPACE_LOADER=y +CONFIG_SECURITY_APPARMOR=y +CONFIG_SECURITY_APPARMOR_BOOTPARAM_VALUE=1 +CONFIG_SECURITY_APPARMOR_HASH=y +CONFIG_SECURITY_APPARMOR_HASH_DEFAULT=y +CONFIG_SECURITY_APPARMOR_DEBUG=y +CONFIG_SECURITY_APPARMOR_DEBUG_ASSERTS=y +CONFIG_SECURITY_APPARMOR_DEBUG_MESSAGES=y +CONFIG_SECURITY_LOADPIN=y +CONFIG_SECURITY_LOADPIN_ENABLED=y +CONFIG_SECURITY_YAMA=y +CONFIG_INTEGRITY=y +CONFIG_INTEGRITY_SIGNATURE=y +CONFIG_INTEGRITY_ASYMMETRIC_KEYS=y +CONFIG_INTEGRITY_TRUSTED_KEYRING=y +CONFIG_INTEGRITY_AUDIT=y +CONFIG_IMA=y +CONFIG_IMA_MEASURE_PCR_IDX=10 +CONFIG_IMA_LSM_RULES=y +# CONFIG_IMA_TEMPLATE is not set +CONFIG_IMA_NG_TEMPLATE=y +# CONFIG_IMA_SIG_TEMPLATE is not set +CONFIG_IMA_DEFAULT_TEMPLATE="ima-ng" +CONFIG_IMA_DEFAULT_HASH_SHA1=y +# CONFIG_IMA_DEFAULT_HASH_SHA256 is not set +# CONFIG_IMA_DEFAULT_HASH_SHA512 is not set +# CONFIG_IMA_DEFAULT_HASH_WP512 is not set +CONFIG_IMA_DEFAULT_HASH="sha1" +CONFIG_IMA_WRITE_POLICY=y +CONFIG_IMA_READ_POLICY=y +CONFIG_IMA_APPRAISE=y +CONFIG_IMA_APPRAISE_BOOTPARAM=y +CONFIG_IMA_TRUSTED_KEYRING=y +CONFIG_IMA_KEYRINGS_PERMIT_SIGNED_BY_BUILTIN_OR_SECONDARY=y +CONFIG_IMA_BLACKLIST_KEYRING=y +CONFIG_IMA_LOAD_X509=y +CONFIG_IMA_X509_PATH="/etc/keys/x509_ima.der" +CONFIG_IMA_APPRAISE_SIGNED_INIT=y +CONFIG_EVM=y +CONFIG_EVM_ATTR_FSUUID=y +CONFIG_EVM_EXTRA_SMACK_XATTRS=y +CONFIG_EVM_LOAD_X509=y +CONFIG_EVM_X509_PATH="/etc/keys/x509_evm.der" +CONFIG_DEFAULT_SECURITY_SELINUX=y +# CONFIG_DEFAULT_SECURITY_SMACK is not set +# CONFIG_DEFAULT_SECURITY_TOMOYO is not set +# CONFIG_DEFAULT_SECURITY_APPARMOR is not set +# CONFIG_DEFAULT_SECURITY_DAC is not set +CONFIG_DEFAULT_SECURITY="selinux" +CONFIG_XOR_BLOCKS=y +CONFIG_ASYNC_CORE=y +CONFIG_ASYNC_MEMCPY=y +CONFIG_ASYNC_XOR=y +CONFIG_ASYNC_PQ=y +CONFIG_ASYNC_RAID6_RECOV=y +CONFIG_ASYNC_TX_DISABLE_PQ_VAL_DMA=y +CONFIG_ASYNC_TX_DISABLE_XOR_VAL_DMA=y +CONFIG_CRYPTO=y + +# +# Crypto core or helper +# +CONFIG_CRYPTO_ALGAPI=y +CONFIG_CRYPTO_ALGAPI2=y +CONFIG_CRYPTO_AEAD=y +CONFIG_CRYPTO_AEAD2=y +CONFIG_CRYPTO_BLKCIPHER=y +CONFIG_CRYPTO_BLKCIPHER2=y +CONFIG_CRYPTO_HASH=y +CONFIG_CRYPTO_HASH2=y +CONFIG_CRYPTO_RNG=y +CONFIG_CRYPTO_RNG2=y +CONFIG_CRYPTO_RNG_DEFAULT=y +CONFIG_CRYPTO_AKCIPHER2=y +CONFIG_CRYPTO_AKCIPHER=y +CONFIG_CRYPTO_KPP2=y +CONFIG_CRYPTO_KPP=y +CONFIG_CRYPTO_ACOMP2=y +CONFIG_CRYPTO_RSA=y +CONFIG_CRYPTO_DH=y +CONFIG_CRYPTO_ECDH=y +CONFIG_CRYPTO_MANAGER=y +CONFIG_CRYPTO_MANAGER2=y +CONFIG_CRYPTO_USER=y +CONFIG_CRYPTO_MANAGER_DISABLE_TESTS=y +CONFIG_CRYPTO_GF128MUL=y +CONFIG_CRYPTO_NULL=y +CONFIG_CRYPTO_NULL2=y +CONFIG_CRYPTO_PCRYPT=y +CONFIG_CRYPTO_WORKQUEUE=y +CONFIG_CRYPTO_CRYPTD=y +CONFIG_CRYPTO_MCRYPTD=y +CONFIG_CRYPTO_AUTHENC=y +CONFIG_CRYPTO_TEST=m +CONFIG_CRYPTO_ABLK_HELPER=y +CONFIG_CRYPTO_SIMD=y +CONFIG_CRYPTO_GLUE_HELPER_X86=y +CONFIG_CRYPTO_ENGINE=y + +# +# Authenticated Encryption with Associated Data +# +CONFIG_CRYPTO_CCM=y +CONFIG_CRYPTO_GCM=y +CONFIG_CRYPTO_CHACHA20POLY1305=y +CONFIG_CRYPTO_SEQIV=y +CONFIG_CRYPTO_ECHAINIV=y + +# +# Block modes +# +CONFIG_CRYPTO_CBC=y +CONFIG_CRYPTO_CTR=y +CONFIG_CRYPTO_CTS=y +CONFIG_CRYPTO_ECB=y +CONFIG_CRYPTO_LRW=y +CONFIG_CRYPTO_PCBC=y +CONFIG_CRYPTO_XTS=y +CONFIG_CRYPTO_KEYWRAP=y + +# +# Hash modes +# +CONFIG_CRYPTO_CMAC=y +CONFIG_CRYPTO_HMAC=y +CONFIG_CRYPTO_XCBC=y +CONFIG_CRYPTO_VMAC=y + +# +# Digest +# +CONFIG_CRYPTO_CRC32C=y +CONFIG_CRYPTO_CRC32C_INTEL=y +CONFIG_CRYPTO_CRC32=y +CONFIG_CRYPTO_CRC32_PCLMUL=y +CONFIG_CRYPTO_CRCT10DIF=y +CONFIG_CRYPTO_CRCT10DIF_PCLMUL=y +CONFIG_CRYPTO_GHASH=y +CONFIG_CRYPTO_POLY1305=y +CONFIG_CRYPTO_POLY1305_X86_64=y +CONFIG_CRYPTO_MD4=y +CONFIG_CRYPTO_MD5=y +CONFIG_CRYPTO_MICHAEL_MIC=y +CONFIG_CRYPTO_RMD128=y +CONFIG_CRYPTO_RMD160=y +CONFIG_CRYPTO_RMD256=y +CONFIG_CRYPTO_RMD320=y +CONFIG_CRYPTO_SHA1=y +CONFIG_CRYPTO_SHA1_SSSE3=y +CONFIG_CRYPTO_SHA256_SSSE3=y +CONFIG_CRYPTO_SHA512_SSSE3=y +CONFIG_CRYPTO_SHA1_MB=y +CONFIG_CRYPTO_SHA256_MB=y +CONFIG_CRYPTO_SHA512_MB=y +CONFIG_CRYPTO_SHA256=y +CONFIG_CRYPTO_SHA512=y +CONFIG_CRYPTO_SHA3=y +CONFIG_CRYPTO_SM3=y +CONFIG_CRYPTO_TGR192=y +CONFIG_CRYPTO_WP512=y +CONFIG_CRYPTO_GHASH_CLMUL_NI_INTEL=y + +# +# Ciphers +# +CONFIG_CRYPTO_AES=y +CONFIG_CRYPTO_AES_TI=y +CONFIG_CRYPTO_AES_X86_64=y +CONFIG_CRYPTO_AES_NI_INTEL=y +CONFIG_CRYPTO_ANUBIS=y +CONFIG_CRYPTO_ARC4=y +CONFIG_CRYPTO_BLOWFISH=y +CONFIG_CRYPTO_BLOWFISH_COMMON=y +CONFIG_CRYPTO_BLOWFISH_X86_64=y +CONFIG_CRYPTO_CAMELLIA=y +CONFIG_CRYPTO_CAMELLIA_X86_64=y +CONFIG_CRYPTO_CAMELLIA_AESNI_AVX_X86_64=y +CONFIG_CRYPTO_CAMELLIA_AESNI_AVX2_X86_64=y +CONFIG_CRYPTO_CAST_COMMON=y +CONFIG_CRYPTO_CAST5=y +CONFIG_CRYPTO_CAST5_AVX_X86_64=y +CONFIG_CRYPTO_CAST6=y +CONFIG_CRYPTO_CAST6_AVX_X86_64=y +CONFIG_CRYPTO_DES=y +CONFIG_CRYPTO_DES3_EDE_X86_64=y +CONFIG_CRYPTO_FCRYPT=y +CONFIG_CRYPTO_KHAZAD=y +CONFIG_CRYPTO_SALSA20=y +CONFIG_CRYPTO_SALSA20_X86_64=y +CONFIG_CRYPTO_CHACHA20=y +CONFIG_CRYPTO_CHACHA20_X86_64=y +CONFIG_CRYPTO_SEED=y +CONFIG_CRYPTO_SERPENT=y +CONFIG_CRYPTO_SERPENT_SSE2_X86_64=y +CONFIG_CRYPTO_SERPENT_AVX_X86_64=y +CONFIG_CRYPTO_SERPENT_AVX2_X86_64=y +CONFIG_CRYPTO_TEA=y +CONFIG_CRYPTO_TWOFISH=y +CONFIG_CRYPTO_TWOFISH_COMMON=y +CONFIG_CRYPTO_TWOFISH_X86_64=y +CONFIG_CRYPTO_TWOFISH_X86_64_3WAY=y +CONFIG_CRYPTO_TWOFISH_AVX_X86_64=y + +# +# Compression +# +CONFIG_CRYPTO_DEFLATE=y +CONFIG_CRYPTO_LZO=y +CONFIG_CRYPTO_842=y +CONFIG_CRYPTO_LZ4=y +CONFIG_CRYPTO_LZ4HC=y + +# +# Random Number Generation +# +CONFIG_CRYPTO_ANSI_CPRNG=y +CONFIG_CRYPTO_DRBG_MENU=y +CONFIG_CRYPTO_DRBG_HMAC=y +CONFIG_CRYPTO_DRBG_HASH=y +CONFIG_CRYPTO_DRBG_CTR=y +CONFIG_CRYPTO_DRBG=y +CONFIG_CRYPTO_JITTERENTROPY=y +CONFIG_CRYPTO_USER_API=y +CONFIG_CRYPTO_USER_API_HASH=y +CONFIG_CRYPTO_USER_API_SKCIPHER=y +CONFIG_CRYPTO_USER_API_RNG=y +CONFIG_CRYPTO_USER_API_AEAD=y +CONFIG_CRYPTO_HASH_INFO=y +CONFIG_CRYPTO_HW=y +CONFIG_CRYPTO_DEV_PADLOCK=y +CONFIG_CRYPTO_DEV_PADLOCK_AES=y +CONFIG_CRYPTO_DEV_PADLOCK_SHA=y +# CONFIG_CRYPTO_DEV_FSL_CAAM_CRYPTO_API_DESC is not set +CONFIG_CRYPTO_DEV_PICOXCELL=y +CONFIG_CRYPTO_DEV_EXYNOS_RNG=y +CONFIG_CRYPTO_DEV_S5P=y +CONFIG_CRYPTO_DEV_ATMEL_AUTHENC=y +CONFIG_CRYPTO_DEV_ATMEL_AES=y +CONFIG_CRYPTO_DEV_ATMEL_TDES=y +CONFIG_CRYPTO_DEV_ATMEL_SHA=y +CONFIG_CRYPTO_DEV_ATMEL_ECC=y +CONFIG_CRYPTO_DEV_CCP=y +CONFIG_CRYPTO_DEV_CCP_DD=y +CONFIG_CRYPTO_DEV_SP_CCP=y +CONFIG_CRYPTO_DEV_CCP_CRYPTO=y +CONFIG_CRYPTO_DEV_SP_PSP=y +CONFIG_CRYPTO_DEV_QAT=y +CONFIG_CRYPTO_DEV_QAT_DH895xCC=y +CONFIG_CRYPTO_DEV_QAT_C3XXX=y +CONFIG_CRYPTO_DEV_QAT_C62X=y +CONFIG_CRYPTO_DEV_QAT_DH895xCCVF=y +CONFIG_CRYPTO_DEV_QAT_C3XXXVF=y +CONFIG_CRYPTO_DEV_QAT_C62XVF=y +CONFIG_CRYPTO_DEV_CPT=y +CONFIG_CAVIUM_CPT=y +CONFIG_CRYPTO_DEV_NITROX=y +CONFIG_CRYPTO_DEV_NITROX_CNN55XX=y +CONFIG_CRYPTO_DEV_CAVIUM_ZIP=y +CONFIG_CRYPTO_DEV_QCE=y +CONFIG_CRYPTO_DEV_IMGTEC_HASH=y +CONFIG_CRYPTO_DEV_MEDIATEK=y +CONFIG_CRYPTO_DEV_CHELSIO=y +CONFIG_CHELSIO_IPSEC_INLINE=y +CONFIG_CRYPTO_DEV_VIRTIO=y +CONFIG_CRYPTO_DEV_SAFEXCEL=y +CONFIG_ASYMMETRIC_KEY_TYPE=y +CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y +CONFIG_X509_CERTIFICATE_PARSER=y +CONFIG_PKCS7_MESSAGE_PARSER=y +CONFIG_PKCS7_TEST_KEY=y +CONFIG_SIGNED_PE_FILE_VERIFICATION=y + +# +# Certificates for signature checking +# +CONFIG_MODULE_SIG_KEY="certs/signing_key.pem" +CONFIG_SYSTEM_TRUSTED_KEYRING=y +CONFIG_SYSTEM_TRUSTED_KEYS="" +CONFIG_SYSTEM_EXTRA_CERTIFICATE=y +CONFIG_SYSTEM_EXTRA_CERTIFICATE_SIZE=4096 +CONFIG_SECONDARY_TRUSTED_KEYRING=y +CONFIG_SYSTEM_BLACKLIST_KEYRING=y +CONFIG_SYSTEM_BLACKLIST_HASH_LIST="" +CONFIG_HAVE_KVM=y +CONFIG_HAVE_KVM_IRQCHIP=y +CONFIG_HAVE_KVM_IRQFD=y +CONFIG_HAVE_KVM_IRQ_ROUTING=y +CONFIG_HAVE_KVM_EVENTFD=y +CONFIG_KVM_MMIO=y +CONFIG_KVM_ASYNC_PF=y +CONFIG_HAVE_KVM_MSI=y +CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT=y +CONFIG_KVM_VFIO=y +CONFIG_KVM_GENERIC_DIRTYLOG_READ_PROTECT=y +CONFIG_KVM_COMPAT=y +CONFIG_HAVE_KVM_IRQ_BYPASS=y +CONFIG_VIRTUALIZATION=y +CONFIG_KVM=y +CONFIG_KVM_INTEL=y +CONFIG_KVM_AMD=y +CONFIG_KVM_AMD_SEV=y +CONFIG_KVM_MMU_AUDIT=y +CONFIG_VHOST_NET=y +CONFIG_VHOST_SCSI=m +CONFIG_VHOST_VSOCK=y +CONFIG_VHOST=y +CONFIG_VHOST_CROSS_ENDIAN_LEGACY=y +CONFIG_BINARY_PRINTF=y + +# +# Library routines +# +CONFIG_RAID6_PQ=y +CONFIG_BITREVERSE=y +# CONFIG_HAVE_ARCH_BITREVERSE is not set +CONFIG_RATIONAL=y +CONFIG_GENERIC_STRNCPY_FROM_USER=y +CONFIG_GENERIC_STRNLEN_USER=y +CONFIG_GENERIC_NET_UTILS=y +CONFIG_GENERIC_FIND_FIRST_BIT=y +CONFIG_GENERIC_PCI_IOMAP=y +CONFIG_GENERIC_IOMAP=y +CONFIG_STMP_DEVICE=y +CONFIG_ARCH_USE_CMPXCHG_LOCKREF=y +CONFIG_ARCH_HAS_FAST_MULTIPLIER=y +CONFIG_CRC_CCITT=y +CONFIG_CRC16=y +CONFIG_CRC_T10DIF=y +CONFIG_CRC_ITU_T=y +CONFIG_CRC32=y +CONFIG_CRC32_SELFTEST=y +CONFIG_CRC32_SLICEBY8=y +# CONFIG_CRC32_SLICEBY4 is not set +# CONFIG_CRC32_SARWATE is not set +# CONFIG_CRC32_BIT is not set +CONFIG_CRC4=y +CONFIG_CRC7=y +CONFIG_LIBCRC32C=y +CONFIG_CRC8=y +CONFIG_XXHASH=y +# CONFIG_AUDIT_ARCH_COMPAT_GENERIC is not set +CONFIG_RANDOM32_SELFTEST=y +CONFIG_842_COMPRESS=y +CONFIG_842_DECOMPRESS=y +CONFIG_ZLIB_INFLATE=y +CONFIG_ZLIB_DEFLATE=y +CONFIG_LZO_COMPRESS=y +CONFIG_LZO_DECOMPRESS=y +CONFIG_LZ4_COMPRESS=y +CONFIG_LZ4HC_COMPRESS=y +CONFIG_LZ4_DECOMPRESS=y +CONFIG_ZSTD_COMPRESS=y +CONFIG_ZSTD_DECOMPRESS=y +CONFIG_XZ_DEC=y +CONFIG_XZ_DEC_X86=y +CONFIG_XZ_DEC_POWERPC=y +CONFIG_XZ_DEC_IA64=y +CONFIG_XZ_DEC_ARM=y +CONFIG_XZ_DEC_ARMTHUMB=y +CONFIG_XZ_DEC_SPARC=y +CONFIG_XZ_DEC_BCJ=y +CONFIG_XZ_DEC_TEST=y +CONFIG_DECOMPRESS_GZIP=y +CONFIG_DECOMPRESS_BZIP2=y +CONFIG_DECOMPRESS_LZMA=y +CONFIG_DECOMPRESS_XZ=y +CONFIG_DECOMPRESS_LZO=y +CONFIG_DECOMPRESS_LZ4=y +CONFIG_GENERIC_ALLOCATOR=y +CONFIG_REED_SOLOMON=y +CONFIG_REED_SOLOMON_ENC8=y +CONFIG_REED_SOLOMON_DEC8=y +CONFIG_REED_SOLOMON_DEC16=y +CONFIG_BCH=y +CONFIG_BCH_CONST_PARAMS=y +CONFIG_TEXTSEARCH=y +CONFIG_TEXTSEARCH_KMP=y +CONFIG_TEXTSEARCH_BM=y +CONFIG_TEXTSEARCH_FSM=y +CONFIG_BTREE=y +CONFIG_INTERVAL_TREE=y +CONFIG_RADIX_TREE_MULTIORDER=y +CONFIG_ASSOCIATIVE_ARRAY=y +CONFIG_HAS_IOMEM=y +CONFIG_HAS_IOPORT_MAP=y +CONFIG_HAS_DMA=y +CONFIG_SGL_ALLOC=y +# CONFIG_DMA_DIRECT_OPS is not set +CONFIG_DMA_VIRT_OPS=y +CONFIG_CHECK_SIGNATURE=y +CONFIG_CPUMASK_OFFSTACK=y +CONFIG_CPU_RMAP=y +CONFIG_DQL=y +CONFIG_GLOB=y +CONFIG_GLOB_SELFTEST=y +CONFIG_NLATTR=y +CONFIG_LRU_CACHE=y +CONFIG_CLZ_TAB=y +CONFIG_CORDIC=y +CONFIG_DDR=y +CONFIG_IRQ_POLL=y +CONFIG_MPILIB=y +CONFIG_SIGNATURE=y +CONFIG_LIBFDT=y +CONFIG_OID_REGISTRY=y +CONFIG_UCS2_STRING=y +CONFIG_FONT_SUPPORT=y +CONFIG_FONTS=y +CONFIG_FONT_8x8=y +CONFIG_FONT_8x16=y +CONFIG_FONT_6x11=y +CONFIG_FONT_7x14=y +CONFIG_FONT_PEARL_8x8=y +CONFIG_FONT_ACORN_8x8=y +CONFIG_FONT_MINI_4x6=y +CONFIG_FONT_6x10=y +CONFIG_FONT_10x18=y +CONFIG_FONT_SUN8x16=y +CONFIG_FONT_SUN12x22=y +CONFIG_SG_SPLIT=y +CONFIG_SG_POOL=y +CONFIG_ARCH_HAS_SG_CHAIN=y +CONFIG_ARCH_HAS_PMEM_API=y +CONFIG_ARCH_HAS_UACCESS_FLUSHCACHE=y +CONFIG_STACKDEPOT=y +CONFIG_SBITMAP=y +CONFIG_PARMAN=y +CONFIG_PRIME_NUMBERS=y +CONFIG_STRING_SELFTEST=y diff --git a/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/tail_logs.txt b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/tail_logs.txt new file mode 100644 index 0000000..f8237d6 --- /dev/null +++ b/infer/results/v416/infer0150/maxyesconfig-fail/failure-files/SigKillFailureFiles/tail_logs.txt @@ -0,0 +1,1000 @@ +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ progress] ............. +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct anonymous_struct_kernel_time_timekeeping.c:41:8 +[6263][ progress] . +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_irq_ops +[6263][ debug] +[6263][ debug] typ_get_recursive_flds: unexpected sizeof(t=) unknown struct type: struct pv_lock_ops +[6263][ progress] .. +[386][ intern err] Error in infer subprocess: died after receiving sigkill (signal number 9) + +[386][ intern err] \ No newline at end of file From d7b0b7bc4e889963e8c6ba51f05332c518367427 Mon Sep 17 00:00:00 2001 From: Ozan Alpay Date: Wed, 4 Jul 2018 11:32:02 +0200 Subject: [PATCH 4/4] After analyzing infer issues, and finding false-positive issues. Some mock-code examples created to understand why infer created false-positive issues. --- .../infer-dead-store-macro/README.md | 116 + .../MockCodes/infer-dead-store-macro/bugs.txt | 45112 ++++++++++++++++ .../Makefile | 5 + .../lib.h | 23 + .../macros.h | 11 + .../main.c | 7 + .../str.h | 3 + .../Makefile | 5 + .../infer-no-dead-store-without-macro/lib.h | 24 + .../macros.h | 3 + .../infer-no-dead-store-without-macro/main.c | 7 + .../infer-no-dead-store-without-macro/str.h | 3 + .../infer-uninitialized-with-loop/README.md | 73 + .../Makefile | 4 + .../lib.h | 22 + .../main.c | 9 + .../Makefile | 4 + .../lib.h | 28 + .../main.c | 8 + 19 files changed, 45467 insertions(+) create mode 100644 infer/MockCodes/infer-dead-store-macro/README.md create mode 100644 infer/MockCodes/infer-dead-store-macro/bugs.txt create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/Makefile create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/lib.h create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/macros.h create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/main.c create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/str.h create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/Makefile create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/lib.h create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/macros.h create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/main.c create mode 100644 infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/str.h create mode 100644 infer/MockCodes/infer-uninitialized-with-loop/README.md create mode 100644 infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/Makefile create mode 100644 infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/lib.h create mode 100644 infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/main.c create mode 100644 infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/Makefile create mode 100644 infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/lib.h create mode 100644 infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/main.c diff --git a/infer/MockCodes/infer-dead-store-macro/README.md b/infer/MockCodes/infer-dead-store-macro/README.md new file mode 100644 index 0000000..afa66c1 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/README.md @@ -0,0 +1,116 @@ +## Infer DEAD_STORE false-posive problem ## +**Infer Version:** : Infer version v0.15.0 +**Kernel-Version:** : Linux-4.16 +**Original Warning:** : [kernel/sched/fair.c](https://github.com/OzanAlpay/linux-kernel-analysis/blob/clang-warning-reports/reports/v416/infer-015/kernel:sched:fair:c:deadstorage:0007.md) +### Testing ### +**Case 1:** +``` +cd infer-false-positive-dead-store-with-macro +infer capture -- make +infer analyze +``` +**Output:** +``` +Found 1 issue + +lib.h:10: error: DEAD_STORE + The value written to &var (type unsigned long) is never used. + 8. + 9. int dummy_func() { + 10. > unsigned long var = 5; + 11. srand(time(NULL)); + 12. d_struct rnd; + +``` +**Expected Output:** +``` +No issues found. +``` +**Case 2:** +``` +cd infer-no-dead-store-without-macro +infer capture -- make +infer analyze +``` +**Output:** +``` +No issues found +``` +**Expected Output:** +``` +No issues found +``` + +**Summary:** +Only difference between this two examples is: +In [infer-false-positive-dead-store-with-macro/macros.h](https://github.com/OzanAlpay/linux-kernel-analysis/blob/infer-documentation/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/macros.h), Inside ```time_after``` macro, we check types with using ```typecheck``` macro, and then compare. +```C +#define typecheck(type,x) \ +({ type __dummy; \ + typeof(x) __dummy2; \ + (void)(&__dummy == &__dummy2); \ + 1; \ +}) +#define time_after(a,b) \ + (typecheck(unsigned long, a) && \ + typecheck(unsigned long, b) && \ + ((long)((b) - (a)) < 0)) +#define time_before(a,b) time_after(b,a) +``` +However [infer-no-dead-store-without-macro/macros.h](https://github.com/OzanAlpay/linux-kernel-analysis/blob/infer-documentation/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/macros.h), we directly compare these two values and then return result. +```C +#define time_after(a,b) \ + (((long)((b) - (a)) < 0)) +#define time_before(a,b) time_after(b,a) + +``` +These two files infer outputs should be equal to ```No issues found```. Because in both cases, we just compare two different unsigned integers, and return the result of comparision. +In addition to that, In [Linux Kernel-v4.16:include/linux/typecheck.h](https://elixir.bootlin.com/linux/v4.16/source/include/linux/typecheck.h) file, typecheck macro defined as following: +```C +/* + * Check at compile time that something is of a particular type. + * Always evaluates to 1 so you may use it easily in comparisons. + */ +#define typecheck(type,x) \ +({ type __dummy; \ + typeof(x) __dummy2; \ + (void)(&__dummy == &__dummy2); \ + 1; \ +}) +``` +As developer stated in comment, these macro is just a check for compile-time and don't have any effect for run-time. Infer is wrong to create a warning for this macro. +**Further Results:** +Also I completed an ```infer-0.15.0``` run on Linux Kernel-v4.16 with using defconfig after applying: +``` +diff --git a/include/linux/typecheck.h b/include/linux/typecheck.h +index 20d3103..5638505 100644 +--- a/include/linux/typecheck.h ++++ b/include/linux/typecheck.h +@@ -6,12 +6,7 @@ + * Check at compile time that something is of a particular type. + * Always evaluates to 1 so you may use it easily in comparisons. + */ +-#define typecheck(type,x) \ +-({ type __dummy; \ +- typeof(x) __dummy2; \ +- (void)(&__dummy == &__dummy2); \ +- 1; \ +-}) ++#define typecheck(type,x) 1 + + /* + * Check at compile time that 'function' is a certain type, or is a pointer +``` +You can find results according to this run in : [with-dummy-typecheck-patch](bugs.txt), and [without patch](../../results/v416/infer0150/defconfig/bugs.txt). +Comparision of results: + +| Results | Total Issues | UNINITIALIZED VALUE | DEAD STORE | NULL DEREFERENCE | MEMORY LEAK | RESOURCE LEAK | +| ------------- | ------------- | ------------- | ------------- | ------------- | -------------- | ------------ | +| Default Linux-v4.16 Defconfig | 5795 | 4664 | 895 | 211 | 16 | 9 | +| Linux-v4.16 Deconfig + dummy-typecheck-patch | 5638 | 4669 | 733 | 211 | 16 | 9 | + + + + + + diff --git a/infer/MockCodes/infer-dead-store-macro/bugs.txt b/infer/MockCodes/infer-dead-store-macro/bugs.txt new file mode 100644 index 0000000..c602551 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/bugs.txt @@ -0,0 +1,45112 @@ +Found 5638 issues + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +arch/x86/lib/msr-smp.c:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. struct msr_info *rv = info; + 10. struct msr *reg; + 11. > int this_cpu = raw_smp_processor_id(); + 12. + 13. if (rv->msrs) + +net/netfilter/utils.c:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. break; + 18. case AF_INET6: + 19. > v6ops = rcu_dereference(nf_ipv6_ops); + 20. if (v6ops) + 21. csum = v6ops->checksum(skb, hook, dataoff, protocol); + +include/linux/netfilter_ingress.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. return false; + 14. #endif + 15. > return rcu_access_pointer(skb->dev->nf_hooks_ingress); + 16. } + 17. + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +include/trace/events/task.h:9: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7. #include + 8. + 9. > TRACE_EVENT(task_newtask, + 10. + 11. TP_PROTO(struct task_struct *task, unsigned long clone_flags), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +arch/x86/entry/vsyscall/vsyscall_trace.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(emulate_vsyscall, + 11. + 12. TP_PROTO(int nr), + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(cpuhp_enter, + 11. + 12. TP_PROTO(unsigned int cpu, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/mdio.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT_CONDITION(mdio_access, + 11. + 12. TP_PROTO(struct mii_bus *bus, char read, + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/printk.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(console, + 11. TP_PROTO(const char *text, size_t len), + 12. + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/swiotlb.h:10: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8. #include + 9. + 10. > TRACE_EVENT(swiotlb_bounced, + 11. + 12. TP_PROTO(struct device *dev, + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/random.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(add_device_randomness, + 12. TP_PROTO(int bytes, unsigned long IP), + 13. + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/udp.h:11: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9. #include + 10. + 11. > TRACE_EVENT(udp_fail_queue_rcv_skb, + 12. + 13. TP_PROTO(int rc, struct sock *sk), + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +include/trace/events/qdisc.h:12: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 10. #include + 11. + 12. > TRACE_EVENT(qdisc_dequeue, + 13. + 14. TP_PROTO(struct Qdisc *qdisc, const struct netdev_queue *txq, + +arch/x86/include/asm/current.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. static __always_inline struct task_struct *get_current(void) + 14. { + 15. > return this_cpu_read_stable(current_task); + 16. } + 17. + +block/blk-lib.c:19: error: NULL_DEREFERENCE + pointer `new` last assigned on line 16 could be null and is dereferenced by call to `bio_chain()` at line 19, column 3. + 17. + 18. if (bio) { + 19. > bio_chain(bio, new); + 20. submit_bio(bio); + 21. } + +block/ioctl.c:146: error: UNINITIALIZED_VALUE + The value read from p.length was never initialized. + 144. disk_part_iter_exit(&piter); + 145. part_nr_sects_write(part, (sector_t)length); + 146. > i_size_write(bdevp->bd_inode, p.length); + 147. mutex_unlock(&bdevp->bd_mutex); + 148. mutex_unlock(&bdev->bd_mutex); + +block/ioctl.c:33: error: UNINITIALIZED_VALUE + The value read from p.pno was never initialized. + 31. if (bdev != bdev->bd_contains) + 32. return -EINVAL; + 33. > partno = p.pno; + 34. if (partno <= 0) + 35. return -EINVAL; + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +drivers/gpu/drm/drm_trace.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #define TRACE_INCLUDE_FILE drm_trace + 12. + 13. > TRACE_EVENT(drm_vblank_event, + 14. TP_PROTO(int crtc, unsigned int seq), + 15. TP_ARGS(crtc, seq), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib_table_lookup, + 14. + 15. TP_PROTO(u32 tb_id, const struct flowi4 *flp), + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +include/trace/events/fib6.h:13: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11. #include + 12. + 13. > TRACE_EVENT(fib6_table_lookup, + 14. + 15. TP_PROTO(const struct net *net, const struct rt6_info *rt, + +net/ipv4/tcp_fastopen.c:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. + 18. rcu_read_lock(); + 19. > ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx); + 20. if (ctxt) { + 21. rcu_read_unlock(); + +tools/include/asm-generic/bitops/fls.h:36: error: DEAD_STORE + The value written to &x (type int) is never used. + 34. } + 35. if (!(x & 0x80000000u)) { + 36. > x <<= 1; + 37. r -= 1; + 38. } + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/napi.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #define NO_DEV "(no_device)" + 13. + 14. > TRACE_EVENT(napi_poll, + 15. + 16. TP_PROTO(struct napi_struct *napi, int work, int budget), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +include/trace/events/net.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. #include + 13. + 14. > TRACE_EVENT(net_dev_start_xmit, + 15. + 16. TP_PROTO(const struct sk_buff *skb, const struct net_device *dev), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +sound/pci/hda/hda_controller_trace.h:14: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 12. struct azx_dev; + 13. + 14. > TRACE_EVENT(azx_pcm_trigger, + 15. + 16. TP_PROTO(struct azx *chip, struct azx_dev *dev, int cmd), + +block/blk-merge.c:50: error: DEAD_STORE + The value written to &tmp (type unsigned long) is never used. + 48. + 49. tmp = bio->bi_iter.bi_sector + split_sectors - alignment; + 50. > tmp = sector_div(tmp, granularity); + 51. + 52. if (split_sectors > tmp) + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/sched.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for calling kthread_stop, performed to end a kthread: + 14. */ + 15. > TRACE_EVENT(sched_kthread_stop, + 16. + 17. TP_PROTO(struct task_struct *t), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +include/trace/events/skb.h:15: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 13. * Tracepoint for free an sk_buff: + 14. */ + 15. > TRACE_EVENT(kfree_skb, + 16. + 17. TP_PROTO(struct sk_buff *skb, void *location), + +kernel/sched/stats.c:46: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 44. /* domain-specific stats */ + 45. rcu_read_lock(); + 46. > for_each_domain(cpu, sd) { + 47. enum cpu_idle_type itype; + 48. + +net/core/net-procfs.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. + 23. h = &net->dev_name_head[get_bucket(*pos)]; + 24. > hlist_for_each_entry_rcu(dev, h, name_hlist) { + 25. if (++count == offset) + 26. return dev; + +tools/lib/subcmd/help.c:20: error: NULL_DEREFERENCE + pointer `ent` last assigned on line 18 could be null and is dereferenced at line 20, column 2. + 18. struct cmdname *ent = malloc(sizeof(*ent) + len + 1); + 19. + 20. > ent->len = len; + 21. memcpy(ent->name, name, len); + 22. ent->name[len] = 0; + +arch/x86/include/asm/irq_regs.h:19: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 17. static inline struct pt_regs *get_irq_regs(void) + 18. { + 19. > return this_cpu_read(irq_regs); + 20. } + 21. + +arch/x86/include/asm/irq_regs.h:19: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 17. static inline struct pt_regs *get_irq_regs(void) + 18. { + 19. > return this_cpu_read(irq_regs); + 20. } + 21. + +drivers/input/input-compat.c:30: error: UNINITIALIZED_VALUE + The value read from compat_event.code was never initialized. + 28. event->input_event_usec = compat_event.usec; + 29. event->type = compat_event.type; + 30. > event->code = compat_event.code; + 31. event->value = compat_event.value; + 32. + +drivers/input/input-compat.c:27: error: UNINITIALIZED_VALUE + The value read from compat_event.sec was never initialized. + 25. return -EFAULT; + 26. + 27. > event->input_event_sec = compat_event.sec; + 28. event->input_event_usec = compat_event.usec; + 29. event->type = compat_event.type; + +drivers/input/input-compat.c:29: error: UNINITIALIZED_VALUE + The value read from compat_event.type was never initialized. + 27. event->input_event_sec = compat_event.sec; + 28. event->input_event_usec = compat_event.usec; + 29. > event->type = compat_event.type; + 30. event->code = compat_event.code; + 31. event->value = compat_event.value; + +drivers/input/input-compat.c:28: error: UNINITIALIZED_VALUE + The value read from compat_event.usec was never initialized. + 26. + 27. event->input_event_sec = compat_event.sec; + 28. > event->input_event_usec = compat_event.usec; + 29. event->type = compat_event.type; + 30. event->code = compat_event.code; + +drivers/input/input-compat.c:31: error: UNINITIALIZED_VALUE + The value read from compat_event.value was never initialized. + 29. event->type = compat_event.type; + 30. event->code = compat_event.code; + 31. > event->value = compat_event.value; + 32. + 33. } else { + +lib/list_sort.c:27: error: MEMORY_LEAK + `tail->next` is not reachable after line 27, column 4. + 25. /* if equal, take 'a' -- important for sort stability */ + 26. if ((*cmp)(priv, a, b) <= 0) { + 27. > tail->next = a; + 28. a = a->next; + 29. } else { + +lib/list_sort.c:30: error: MEMORY_LEAK + `tail->next` is not reachable after line 30, column 4. + 28. a = a->next; + 29. } else { + 30. > tail->next = b; + 31. b = b->next; + 32. } + +lib/list_sort.c:35: error: MEMORY_LEAK + `tail->next` is not reachable after line 35, column 2. + 33. tail = tail->next; + 34. } + 35. > tail->next = a?:b; + 36. return head.next; + 37. } + +lib/list_sort.c:36: error: UNINITIALIZED_VALUE + The value read from head.next was never initialized. + 34. } + 35. tail->next = a?:b; + 36. > return head.next; + 37. } + 38. + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +include/trace/events/syscalls.h:18: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 16. #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS + 17. + 18. > TRACE_EVENT_FN(sys_enter, + 19. + 20. TP_PROTO(struct pt_regs *regs, long id), + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +kernel/irq/cpuhotplug.c:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. { + 20. const struct cpumask *m = irq_data_get_effective_affinity_mask(d); + 21. > unsigned int cpu = smp_processor_id(); + 22. + 23. #ifdef CONFIG_GENERIC_IRQ_EFFECTIVE_AFF_MASK + +lib/dynamic_queue_limits.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. bool all_prev_completed; + 23. + 24. > num_queued = READ_ONCE(dql->num_queued); + 25. + 26. /* Can't complete more than what's in queue */ + +include/linux/netfilter_ingress.h:21: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 19. static inline int nf_hook_ingress(struct sk_buff *skb) + 20. { + 21. > struct nf_hook_entries *e = rcu_dereference(skb->dev->nf_hooks_ingress); + 22. struct nf_hook_state state; + 23. int ret; + +lib/is_single_threaded.c:34: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 32. ret = false; + 33. rcu_read_lock(); + 34. > for_each_process(p) { + 35. if (unlikely(p->flags & PF_KTHREAD)) + 36. continue; + +lib/is_single_threaded.c:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. continue; + 39. + 40. > for_each_thread(p, t) { + 41. if (unlikely(t->mm == mm)) + 42. goto found; + +sound/hda/trace.h:19: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +sound/hda/trace.h:19: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 17. struct hdac_codec; + 18. + 19. > TRACE_EVENT(hda_send_cmd, + 20. TP_PROTO(struct hdac_bus *bus, unsigned int cmd), + 21. TP_ARGS(bus, cmd), + +arch/x86/include/asm/atomic64_64.h:22: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 20. static inline long atomic64_read(const atomic64_t *v) + 21. { + 22. > return READ_ONCE((v)->counter); + 23. } + 24. + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +drivers/gpu/drm/i915/i915_trace.h:20: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 18. /* watermark/fifo updates */ + 19. + 20. > TRACE_EVENT(intel_cpu_fifo_underrun, + 21. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pipe), + 22. TP_ARGS(dev_priv, pipe), + +net/ipv4/tcp_ulp.c:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. struct tcp_ulp_ops *e; + 23. + 24. > list_for_each_entry_rcu(e, &tcp_ulp_list, list) { + 25. if (strcmp(e->name, name) == 0) + 26. return e; + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +arch/x86/lib/msr-smp.c:25: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 23. struct msr_info *rv = info; + 24. struct msr *reg; + 25. > int this_cpu = raw_smp_processor_id(); + 26. + 27. if (rv->msrs) + +block/noop-iosched.c:26: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 24. struct request *rq; + 25. + 26. > rq = list_first_entry_or_null(&nd->queue, struct request, queuelist); + 27. if (rq) { + 28. list_del_init(&rq->queuelist); + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +include/trace/events/rcu.h:21: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 19. * reduction scripts will ignore the "@" and the remainder of the line. + 20. */ + 21. > TRACE_EVENT(rcu_utilization, + 22. + 23. TP_PROTO(const char *s), + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +kernel/sched/isolation.c:26: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 24. if (housekeeping_flags & flags) + 25. return cpumask_any_and(housekeeping_mask, cpu_online_mask); + 26. > return smp_processor_id(); + 27. } + 28. EXPORT_SYMBOL_GPL(housekeeping_any_cpu); + +drivers/tty/tty_port.c:30: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 28. struct tty_ldisc *disc; + 29. + 30. > tty = READ_ONCE(port->itty); + 31. if (!tty) + 32. return 0; + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +include/trace/events/alarmtimer.h:23: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 21. { 1 << ALARM_BOOTTIME_FREEZER, "BOOTTIME Freezer" }) + 22. + 23. > TRACE_EVENT(alarmtimer_suspend, + 24. + 25. TP_PROTO(ktime_t expires, int flag), + +lib/assoc_array.c:101: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr const *) is never used. + 99. if (assoc_array_ptr_is_shortcut(parent)) { + 100. shortcut = assoc_array_ptr_to_shortcut(parent); + 101. > cursor = parent; + 102. parent = READ_ONCE(shortcut->back_pointer); /* Address dependency. */ + 103. slot = shortcut->parent_slot; + +lib/assoc_array.c:41: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 39. /* Descend through a shortcut */ + 40. shortcut = assoc_array_ptr_to_shortcut(cursor); + 41. > cursor = READ_ONCE(shortcut->next_node); /* Address dependency. */ + 42. } + 43. + +lib/assoc_array.c:56: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 54. has_meta = 0; + 55. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 56. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 57. has_meta |= (unsigned long)ptr; + 58. if (ptr && assoc_array_ptr_is_leaf(ptr)) { + +lib/assoc_array.c:85: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 83. node = assoc_array_ptr_to_node(cursor); + 84. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 85. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 86. if (assoc_array_ptr_is_meta(ptr)) { + 87. cursor = ptr; + +lib/assoc_array.c:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. finished_node: + 93. /* Move up to the parent (may need to skip back over a shortcut) */ + 94. > parent = READ_ONCE(node->back_pointer); /* Address dependency. */ + 95. slot = node->parent_slot; + 96. if (parent == stop) + +lib/assoc_array.c:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. shortcut = assoc_array_ptr_to_shortcut(parent); + 101. cursor = parent; + 102. > parent = READ_ONCE(shortcut->back_pointer); /* Address dependency. */ + 103. slot = shortcut->parent_slot; + 104. if (parent == stop) + +net/ipv4/tcp_cong.c:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. struct tcp_congestion_ops *e; + 26. + 27. > list_for_each_entry_rcu(e, &tcp_cong_list, list) { + 28. if (strcmp(e->name, name) == 0) + 29. return e; + +net/ipv6/ip6_offload.c:32: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 30. + 31. if (proto != NEXTHDR_HOP) { + 32. > ops = rcu_dereference(inet6_offloads[proto]); + 33. + 34. if (unlikely(!ops)) + +net/netfilter/nf_conntrack_extend.c:30: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 28. for (i = 0; i < NF_CT_EXT_NUM; i++) { + 29. rcu_read_lock(); + 30. > t = rcu_dereference(nf_ct_ext_types[i]); + 31. + 32. /* Here the nf_ct_ext_type might have been unregisterd. + +tools/include/tools/be_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val >> 8; + 26. > *p++ = val; + 27. } + 28. + +tools/include/tools/le_byteshift.h:26: error: DEAD_STORE + The value written to &p (type unsigned char*) is never used. + 24. { + 25. *p++ = val; + 26. > *p++ = val >> 8; + 27. } + 28. + +drivers/dma-buf/seqno-fence.c:28: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 26 could be null and is dereferenced at line 28, column 9. + 26. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 27. + 28. > return seqno_fence->ops->get_driver_name(fence); + 29. } + 30. + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +include/trace/events/thermal.h:24: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 22. { THERMAL_TRIP_ACTIVE, "ACTIVE"}) + 23. + 24. > TRACE_EVENT(thermal_temperature, + 25. + 26. TP_PROTO(struct thermal_zone_device *tz), + +arch/x86/include/asm/atomic.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. static __always_inline int atomic_read(const atomic_t *v) + 26. { + 27. > return READ_ONCE((v)->counter); + 28. } + 29. + +arch/x86/include/asm/preempt.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. + 30. do { + 31. > old = raw_cpu_read_4(__preempt_count); + 32. new = (old & PREEMPT_NEED_RESCHED) | + 33. (pc & ~PREEMPT_NEED_RESCHED); + +security/selinux/ss/conditional.c:80: error: UNINITIALIZED_VALUE + The value read from s[_] was never initialized. + 78. } + 79. } + 80. > return s[0]; + 81. } + 82. + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > TRACE_EVENT(drm_vblank_event_queued, + 28. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 29. TP_ARGS(file, crtc, seq), + +drivers/pci/proc.c:100: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 98. pci_user_read_config_byte(dev, pos, &val); + 99. __put_user(val, buf); + 100. > buf++; + 101. pos++; + 102. cnt--; + +drivers/pci/proc.c:102: error: DEAD_STORE + The value written to &cnt (type unsigned int) is never used. + 100. buf++; + 101. pos++; + 102. > cnt--; + 103. } + 104. + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. * i2c_smbus_xfer() write data or procedure call request + 26. */ + 27. > TRACE_EVENT_CONDITION(smbus_write, + 28. TP_PROTO(const struct i2c_adapter *adap, + 29. u16 addr, unsigned short flags, + +kernel/task_work.c:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. + 32. do { + 33. > head = READ_ONCE(task->task_works); + 34. if (unlikely(head == &work_exited)) + 35. return -ESRCH; + +kernel/time/tick-oneshot.c:29: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 27. int tick_program_event(ktime_t expires, int force) + 28. { + 29. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 30. + 31. if (unlikely(expires == KTIME_MAX)) { + +kernel/time/tick-oneshot.c:29: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 27. int tick_program_event(ktime_t expires, int force) + 28. { + 29. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 30. + 31. if (unlikely(expires == KTIME_MAX)) { + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:27: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 25. ); + 26. + 27. > DEFINE_EVENT(hda_pm, azx_suspend, + 28. TP_PROTO(struct azx *chip), + 29. TP_ARGS(chip) + +include/net/netfilter/nf_conntrack_timeout.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. struct ctnl_timeout *timeout; + 32. + 33. > timeout = rcu_dereference(t->timeout); + 34. if (timeout == NULL) + 35. return NULL; + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +include/trace/events/xdp.h:28: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 26. __XDP_ACT_MAP(__XDP_ACT_TP_FN) + 27. + 28. > TRACE_EVENT(xdp_exception, + 29. + 30. TP_PROTO(const struct net_device *dev, + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +kernel/irq/irqdesc.c:36: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 34. * bugreports caused by random comandline masks + 35. */ + 36. > cpumask_set_cpu(smp_processor_id(), irq_default_affinity); + 37. return 1; + 38. } + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +lib/dump_stack.c:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. retry: + 40. local_irq_save(flags); + 41. > cpu = smp_processor_id(); + 42. old = atomic_cmpxchg(&dump_lock, -1, cpu); + 43. if (old == -1) { + +block/partitions/amiga.c:36: error: DEAD_STORE + The value written to &blksize (type int) is never used. + 34. struct PartitionBlock *pb; + 35. int start_sect, nr_sects, blk, part, res = 0; + 36. > int blksize = 1; /* Multiplier for disk block size */ + 37. int slot = 1; + 38. char b[BDEVNAME_SIZE]; + +block/partitions/amiga.c:123: error: UNINITIALIZED_VALUE + The value read from dostype[_] was never initialized. + 121. *dt = pb->pb_Environment[16]; + 122. if (dostype[3] < ' ') + 123. > snprintf(tmp, sizeof(tmp), " (%c%c%c^%c)", + 124. dostype[0], dostype[1], + 125. dostype[2], dostype[3] + '@' ); + +block/partitions/amiga.c:127: error: UNINITIALIZED_VALUE + The value read from dostype[_] was never initialized. + 125. dostype[2], dostype[3] + '@' ); + 126. else + 127. > snprintf(tmp, sizeof(tmp), " (%c%c%c%c)", + 128. dostype[0], dostype[1], + 129. dostype[2], dostype[3]); + +drivers/pci/setup-res.c:121: error: UNINITIALIZED_VALUE + The value read from cmd was never initialized. + 119. + 120. if (disable) + 121. > pci_write_config_word(dev, PCI_COMMAND, cmd); + 122. } + 123. + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +include/trace/events/i2c.h:29: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 27. * __i2c_transfer() write request + 28. */ + 29. > TRACE_EVENT_FN(i2c_write, + 30. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 31. int num), + +kernel/irq_work.c:40: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 38. for (;;) { + 39. nflags = flags | IRQ_WORK_CLAIMED; + 40. > oflags = cmpxchg(&work->flags, flags, nflags); + 41. if (oflags == flags) + 42. break; + +net/core/fib_notifier.c:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. for_each_net(net) { + 37. rcu_read_lock(); + 38. > list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) { + 39. if (!try_module_get(ops->owner)) + 40. continue; + +net/netfilter/utils.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. break; + 41. case AF_INET6: + 42. > v6ops = rcu_dereference(nf_ipv6_ops); + 43. if (v6ops) + 44. csum = v6ops->checksum_partial(skb, hook, dataoff, len, + +tools/lib/subcmd/run-command.c:96: error: UNINITIALIZED_VALUE + The value read from fderr[_] was never initialized. + 94. dup_devnull(2); + 95. else if (need_err) { + 96. > dup2(fderr[1], 2); + 97. close_pair(fderr); + 98. } + +tools/lib/subcmd/run-command.c:161: error: UNINITIALIZED_VALUE + The value read from fderr[_] was never initialized. + 159. + 160. if (need_err) + 161. > close(fderr[1]); + 162. + 163. return 0; + +tools/lib/subcmd/run-command.c:86: error: UNINITIALIZED_VALUE + The value read from fdin[_] was never initialized. + 84. dup_devnull(0); + 85. else if (need_in) { + 86. > dup2(fdin[0], 0); + 87. close_pair(fdin); + 88. } else if (cmd->in) { + +tools/lib/subcmd/run-command.c:151: error: UNINITIALIZED_VALUE + The value read from fdin[_] was never initialized. + 149. + 150. if (need_in) + 151. > close(fdin[0]); + 152. else if (cmd->in) + 153. close(cmd->in); + +tools/lib/subcmd/run-command.c:105: error: UNINITIALIZED_VALUE + The value read from fdout[_] was never initialized. + 103. dup2(2, 1); + 104. else if (need_out) { + 105. > dup2(fdout[1], 1); + 106. close_pair(fdout); + 107. } else if (cmd->out > 1) { + +tools/lib/subcmd/run-command.c:156: error: UNINITIALIZED_VALUE + The value read from fdout[_] was never initialized. + 154. + 155. if (need_out) + 156. > close(fdout[1]); + 157. else if (cmd->out) + 158. close(cmd->out); + +kernel/locking/qrwlock.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. * without waiting in the queue. + 41. */ + 42. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 43. return; + 44. } + +kernel/locking/qrwlock.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. * section in the case that the lock is currently held for write. + 57. */ + 58. > atomic_cond_read_acquire(&lock->cnts, !(VAL & _QW_LOCKED)); + 59. + 60. /* + +lib/zlib_inflate/inffast.c:38: error: UNINITIALIZED_VALUE + The value read from mm.us was never initialized. + 36. mm.b[0] = b[0]; + 37. mm.b[1] = b[1]; + 38. > return mm.us; + 39. } + 40. + +net/core/stream.c:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. + 38. rcu_read_lock(); + 39. > wq = rcu_dereference(sk->sk_wq); + 40. if (skwq_has_sleeper(wq)) + 41. wake_up_interruptible_poll(&wq->wait, EPOLLOUT | + +tools/objtool/warn.h:48: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 48, column 3. + 46. + 47. if (func) + 48. > sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. sprintf(str, "%s+0x%lx", name, name_off); + +tools/objtool/warn.h:50: error: NULL_DEREFERENCE + pointer `str` last assigned on line 45 could be null and is dereferenced by call to `sprintf()` at line 50, column 3. + 48. sprintf(str, "%s()+0x%lx", name, name_off); + 49. else + 50. > sprintf(str, "%s+0x%lx", name, name_off); + 51. + 52. return str; + +drivers/dma-buf/seqno-fence.c:35: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 33 could be null and is dereferenced at line 35, column 9. + 33. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 34. + 35. > return seqno_fence->ops->get_timeline_name(fence); + 36. } + 37. + +drivers/edac/edac_pci.c:40: error: DEAD_STORE + The value written to &pci (type edac_pci_ctl_info*) is never used. + 38. edac_dbg(1, "\n"); + 39. + 40. > pci = edac_align_ptr(&p, sizeof(*pci), 1); + 41. pvt = edac_align_ptr(&p, 1, sz_pvt); + 42. size = ((unsigned long)pvt) + sz_pvt; + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +include/trace/events/module.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. { (1UL << TAINT_UNSIGNED_MODULE), "E" }) + 30. + 31. > TRACE_EVENT(module_load, + 32. + 33. TP_PROTO(struct module *mod), + +kernel/power/process.c:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. todo = 0; + 51. read_lock(&tasklist_lock); + 52. > for_each_process_thread(g, p) { + 53. if (p == current || !freeze_task(p)) + 54. continue; + +kernel/power/process.c:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. if (!wakeup) { + 100. read_lock(&tasklist_lock); + 101. > for_each_process_thread(g, p) { + 102. if (p != current && !freezer_should_skip(p) + 103. && freezing(p) && !frozen(p)) + +kernel/tsacct.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. stats->ac_pid = task_pid_nr_ns(tsk, pid_ns); + 63. rcu_read_lock(); + 64. > tcred = __task_cred(tsk); + 65. stats->ac_uid = from_kuid_munged(user_ns, tcred->uid); + 66. stats->ac_gid = from_kgid_munged(user_ns, tcred->gid); + +kernel/tsacct.c:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. stats->ac_gid = from_kgid_munged(user_ns, tcred->gid); + 67. stats->ac_ppid = pid_alive(tsk) ? + 68. > task_tgid_nr_ns(rcu_dereference(tsk->real_parent), pid_ns) : 0; + 69. rcu_read_unlock(); + 70. + +net/ipv6/inet6_connection_sock.c:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. fl6->daddr = ireq->ir_v6_rmt_addr; + 44. rcu_read_lock(); + 45. > final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final); + 46. rcu_read_unlock(); + 47. fl6->saddr = ireq->ir_v6_loc_addr; + +sound/hda/trace.h:31: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +sound/hda/trace.h:31: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 29. ); + 30. + 31. > TRACE_EVENT(hda_get_response, + 32. TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res), + 33. TP_ARGS(bus, addr, res), + +net/ipv4/tcp_ulp.c:36: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 34. struct tcp_ulp_ops *e; + 35. + 36. > list_for_each_entry_rcu(e, &tcp_ulp_list, list) { + 37. if (e->uid == ulp) + 38. return e; + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:32: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 30. ); + 31. + 32. > DEFINE_EVENT(hda_pm, azx_resume, + 33. TP_PROTO(struct azx *chip), + 34. TP_ARGS(chip) + +drivers/base/module.c:62: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 60. + 61. /* Don't check return codes; these calls are idempotent */ + 62. > no_warn = sysfs_create_link(&drv->p->kobj, &mk->kobj, "module"); + 63. driver_name = make_driver_name(drv); + 64. if (driver_name) { + +drivers/base/module.c:66: error: DEAD_STORE + The value written to &no_warn (type int) is never used. + 64. if (driver_name) { + 65. module_create_drivers_dir(mk); + 66. > no_warn = sysfs_create_link(mk->drivers_dir, &drv->p->kobj, + 67. driver_name); + 68. kfree(driver_name); + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. ); + 32. + 33. > DEFINE_EVENT(cgroup_root, cgroup_setup_root, + 34. + 35. TP_PROTO(struct cgroup_root *root), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:33: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 31. * @timer: pointer to struct timer_list + 32. */ + 33. > DEFINE_EVENT(timer_class, timer_init, + 34. + 35. TP_PROTO(struct timer_list *timer), + +kernel/compat.c:57: error: UNINITIALIZED_VALUE + The value read from tx32.calcnt was never initialized. + 55. txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + 57. > txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + 59. txc->stbcnt = tx32.stbcnt; + +kernel/compat.c:46: error: UNINITIALIZED_VALUE + The value read from tx32.constant was never initialized. + 44. txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + 46. > txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + 48. txc->tolerance = tx32.tolerance; + +kernel/compat.c:58: error: UNINITIALIZED_VALUE + The value read from tx32.errcnt was never initialized. + 56. txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + 58. > txc->errcnt = tx32.errcnt; + 59. txc->stbcnt = tx32.stbcnt; + 60. + +kernel/compat.c:44: error: UNINITIALIZED_VALUE + The value read from tx32.esterror was never initialized. + 42. txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + 44. > txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + 46. txc->constant = tx32.constant; + +kernel/compat.c:42: error: UNINITIALIZED_VALUE + The value read from tx32.freq was never initialized. + 40. txc->modes = tx32.modes; + 41. txc->offset = tx32.offset; + 42. > txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + +kernel/compat.c:56: error: UNINITIALIZED_VALUE + The value read from tx32.jitcnt was never initialized. + 54. txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + 56. > txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + +kernel/compat.c:53: error: UNINITIALIZED_VALUE + The value read from tx32.jitter was never initialized. + 51. txc->tick = tx32.tick; + 52. txc->ppsfreq = tx32.ppsfreq; + 53. > txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + +kernel/compat.c:43: error: UNINITIALIZED_VALUE + The value read from tx32.maxerror was never initialized. + 41. txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + 43. > txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + 45. txc->status = tx32.status; + +kernel/compat.c:40: error: UNINITIALIZED_VALUE + The value read from tx32.modes was never initialized. + 38. return -EFAULT; + 39. + 40. > txc->modes = tx32.modes; + 41. txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + +kernel/compat.c:41: error: UNINITIALIZED_VALUE + The value read from tx32.offset was never initialized. + 39. + 40. txc->modes = tx32.modes; + 41. > txc->offset = tx32.offset; + 42. txc->freq = tx32.freq; + 43. txc->maxerror = tx32.maxerror; + +kernel/compat.c:52: error: UNINITIALIZED_VALUE + The value read from tx32.ppsfreq was never initialized. + 50. txc->time.tv_usec = tx32.time.tv_usec; + 51. txc->tick = tx32.tick; + 52. > txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + +kernel/compat.c:47: error: UNINITIALIZED_VALUE + The value read from tx32.precision was never initialized. + 45. txc->status = tx32.status; + 46. txc->constant = tx32.constant; + 47. > txc->precision = tx32.precision; + 48. txc->tolerance = tx32.tolerance; + 49. txc->time.tv_sec = tx32.time.tv_sec; + +kernel/compat.c:54: error: UNINITIALIZED_VALUE + The value read from tx32.shift was never initialized. + 52. txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + 54. > txc->shift = tx32.shift; + 55. txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + +kernel/compat.c:55: error: UNINITIALIZED_VALUE + The value read from tx32.stabil was never initialized. + 53. txc->jitter = tx32.jitter; + 54. txc->shift = tx32.shift; + 55. > txc->stabil = tx32.stabil; + 56. txc->jitcnt = tx32.jitcnt; + 57. txc->calcnt = tx32.calcnt; + +kernel/compat.c:45: error: UNINITIALIZED_VALUE + The value read from tx32.status was never initialized. + 43. txc->maxerror = tx32.maxerror; + 44. txc->esterror = tx32.esterror; + 45. > txc->status = tx32.status; + 46. txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + +kernel/compat.c:59: error: UNINITIALIZED_VALUE + The value read from tx32.stbcnt was never initialized. + 57. txc->calcnt = tx32.calcnt; + 58. txc->errcnt = tx32.errcnt; + 59. > txc->stbcnt = tx32.stbcnt; + 60. + 61. return 0; + +kernel/compat.c:51: error: UNINITIALIZED_VALUE + The value read from tx32.tick was never initialized. + 49. txc->time.tv_sec = tx32.time.tv_sec; + 50. txc->time.tv_usec = tx32.time.tv_usec; + 51. > txc->tick = tx32.tick; + 52. txc->ppsfreq = tx32.ppsfreq; + 53. txc->jitter = tx32.jitter; + +kernel/compat.c:48: error: UNINITIALIZED_VALUE + The value read from tx32.tolerance was never initialized. + 46. txc->constant = tx32.constant; + 47. txc->precision = tx32.precision; + 48. > txc->tolerance = tx32.tolerance; + 49. txc->time.tv_sec = tx32.time.tv_sec; + 50. txc->time.tv_usec = tx32.time.tv_usec; + +security/integrity/iint.c:51: error: UNINITIALIZED_VALUE + The value read from iint was never initialized. + 49. return NULL; + 50. + 51. > return iint; + 52. } + 53. + +net/ipv6/ip6_icmp.c:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. + 38. rcu_read_lock(); + 39. > send = rcu_dereference(ip6_icmp_send); + 40. + 41. if (!send) + +net/netfilter/nf_queue.c:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. { + 36. /* should never happen, we only have one queueing backend in kernel */ + 37. > WARN_ON(rcu_access_pointer(net->nf.queue_handler)); + 38. rcu_assign_pointer(net->nf.queue_handler, qh); + 39. } + +block/ioprio.c:42: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 40. + 41. rcu_read_lock(); + 42. > tcred = __task_cred(task); + 43. if (!uid_eq(tcred->uid, cred->euid) && + 44. !uid_eq(tcred->uid, cred->uid) && !capable(CAP_SYS_NICE)) { + +drivers/scsi/scsi_debugfs.c:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. int alloc_ms = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc); + 39. int timeout_ms = jiffies_to_msecs(rq->timeout); + 40. > const u8 *const cdb = READ_ONCE(cmd->cmnd); + 41. char buf[80] = "(?)"; + 42. + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +include/trace/events/power.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > DEFINE_EVENT(cpu, cpu_idle, + 36. + 37. TP_PROTO(unsigned int state, unsigned int cpu_id), + +init/calibrate.c:138: error: UNINITIALIZED_VALUE + The value read from measured_times[_] was never initialized. + 136. if ((measured_times[max] - estimate) < + 137. (estimate - measured_times[min])) { + 138. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 139. "min bogoMips estimate %d = %lu\n", + 140. min, measured_times[min]); + +init/calibrate.c:144: error: UNINITIALIZED_VALUE + The value read from measured_times[_] was never initialized. + 142. min = max; + 143. } else { + 144. > printk(KERN_NOTICE "calibrate_delay_direct() dropping " + 145. "max bogoMips estimate %d = %lu\n", + 146. max, measured_times[max]); + +net/compat.c:58: error: UNINITIALIZED_VALUE + The value read from msg.msg_control was never initialized. + 56. kmsg->msg_namelen = sizeof(struct sockaddr_storage); + 57. + 58. > kmsg->msg_control = compat_ptr(msg.msg_control); + 59. kmsg->msg_controllen = msg.msg_controllen; + 60. + +net/compat.c:59: error: UNINITIALIZED_VALUE + The value read from msg.msg_controllen was never initialized. + 57. + 58. kmsg->msg_control = compat_ptr(msg.msg_control); + 59. > kmsg->msg_controllen = msg.msg_controllen; + 60. + 61. if (save_addr) + +net/compat.c:46: error: UNINITIALIZED_VALUE + The value read from msg.msg_flags was never initialized. + 44. return -EFAULT; + 45. + 46. > kmsg->msg_flags = msg.msg_flags; + 47. kmsg->msg_namelen = msg.msg_namelen; + 48. + +net/compat.c:83: error: UNINITIALIZED_VALUE + The value read from msg.msg_iov was never initialized. + 81. + 82. return compat_import_iovec(save_addr ? READ : WRITE, + 83. > compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + 85. } + +net/compat.c:82: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 80. kmsg->msg_iocb = NULL; + 81. + 82. > return compat_import_iovec(save_addr ? READ : WRITE, + 83. compat_ptr(msg.msg_iov), msg.msg_iovlen, + 84. UIO_FASTIOV, iov, &kmsg->msg_iter); + +net/compat.c:62: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 60. + 61. if (save_addr) + 62. > *save_addr = compat_ptr(msg.msg_name); + 63. + 64. if (msg.msg_name && kmsg->msg_namelen) { + +net/compat.c:66: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 64. if (msg.msg_name && kmsg->msg_namelen) { + 65. if (!save_addr) { + 66. > err = move_addr_to_kernel(compat_ptr(msg.msg_name), + 67. kmsg->msg_namelen, + 68. kmsg->msg_name); + +net/compat.c:47: error: UNINITIALIZED_VALUE + The value read from msg.msg_namelen was never initialized. + 45. + 46. kmsg->msg_flags = msg.msg_flags; + 47. > kmsg->msg_namelen = msg.msg_namelen; + 48. + 49. if (!msg.msg_name) + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +sound/pci/hda/hda_controller_trace.h:35: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 33. ); + 34. + 35. > TRACE_EVENT(azx_get_position, + 36. + 37. TP_PROTO(struct azx *chip, struct azx_dev *dev, unsigned int pos, unsigned int delay), + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +lib/nmi_backtrace.c:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. void (*raise)(cpumask_t *mask)) + 39. { + 40. > int i, this_cpu = get_cpu(); + 41. + 42. if (test_and_set_bit(0, &backtrace_flag)) { + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(cpuhp_multi_enter, + 38. + 39. TP_PROTO(unsigned int cpu, + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/sched.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. * Tracepoint for the return value of the kthread stopping: + 36. */ + 37. > TRACE_EVENT(sched_kthread_stop_ret, + 38. + 39. TP_PROTO(int ret), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +include/trace/events/skb.h:37: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 35. ); + 36. + 37. > TRACE_EVENT(consume_skb, + 38. + 39. TP_PROTO(struct sk_buff *skb), + +lib/mpi/mpi-pow.c:56: error: DEAD_STORE + The value written to &esign (type int) is never used. + 54. msize = mod->nlimbs; + 55. size = 2 * msize; + 56. > esign = exp->sign; + 57. msign = mod->sign; + 58. + +drivers/dma-buf/seqno-fence.c:42: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 40 could be null and is dereferenced at line 42, column 9. + 40. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 41. + 42. > return seqno_fence->ops->enable_signaling(fence); + 43. } + 44. + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +include/trace/events/workqueue.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. * has been reached). + 37. */ + 38. > TRACE_EVENT(workqueue_queue_work, + 39. + 40. TP_PROTO(unsigned int req_cpu, struct pool_workqueue *pwq, + +ipc/compat.c:45: error: UNINITIALIZED_VALUE + The value read from v.gid was never initialized. + 43. return -EFAULT; + 44. to->uid = v.uid; + 45. > to->gid = v.gid; + 46. to->mode = v.mode; + 47. return 0; + +ipc/compat.c:46: error: UNINITIALIZED_VALUE + The value read from v.mode was never initialized. + 44. to->uid = v.uid; + 45. to->gid = v.gid; + 46. > to->mode = v.mode; + 47. return 0; + 48. } + +ipc/compat.c:44: error: UNINITIALIZED_VALUE + The value read from v.uid was never initialized. + 42. if (copy_from_user(&v, from, sizeof(v))) + 43. return -EFAULT; + 44. > to->uid = v.uid; + 45. to->gid = v.gid; + 46. to->mode = v.mode; + +kernel/irq/spurious.c:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. bool irq_wait_for_poll(struct irq_desc *desc) + 39. { + 40. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 41. "irq poll in progress on cpu %d for irq %d\n", + 42. smp_processor_id(), desc->irq_data.irq)) + +kernel/irq/spurious.c:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. bool irq_wait_for_poll(struct irq_desc *desc) + 39. { + 40. > if (WARN_ONCE(irq_poll_cpu == smp_processor_id(), + 41. "irq poll in progress on cpu %d for irq %d\n", + 42. smp_processor_id(), desc->irq_data.irq)) + +lib/llist.c:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. + 43. do { + 44. > new_last->next = first = READ_ONCE(head->first); + 45. } while (cmpxchg(&head->first, first, new_first) != first); + 46. + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:38: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 36. + 37. #ifdef CONFIG_PM + 38. > DEFINE_EVENT(hda_pm, azx_runtime_suspend, + 39. TP_PROTO(struct azx *chip), + 40. TP_ARGS(chip) + +include/net/netns/generic.h:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. + 44. rcu_read_lock(); + 45. > ng = rcu_dereference(net->gen); + 46. ptr = ng->ptr[id]; + 47. rcu_read_unlock(); + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:39: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 37. ); + 38. + 39. > DEFINE_EVENT(iommu_group_event, add_device_to_group, + 40. + 41. TP_PROTO(int group_id, struct device *dev), + +kernel/smpboot.c:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. void __init idle_thread_set_boot_cpu(void) + 40. { + 41. > per_cpu(idle_threads, smp_processor_id()) = current; + 42. } + 43. + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(msr_trace_class, read_msr, + 41. TP_PROTO(unsigned msr, u64 val, int failed), + 42. TP_ARGS(msr, val, failed) + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(regmap_reg, regmap_reg_write, + 41. + 42. TP_PROTO(struct regmap *map, unsigned int reg, + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(cgroup_root, cgroup_destroy_root, + 41. + 42. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(clk, clk_enable, + 41. + 42. TP_PROTO(struct clk_core *core), + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +include/trace/events/sunrpc.h:40: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 38. ); + 39. + 40. > DEFINE_EVENT(rpc_task_status, rpc_call_status, + 41. TP_PROTO(struct rpc_task *task), + 42. + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +drivers/gpu/drm/i915/i915_trace.h:41: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 39. ); + 40. + 41. > TRACE_EVENT(intel_pch_fifo_underrun, + 42. TP_PROTO(struct drm_i915_private *dev_priv, enum pipe pch_transcoder), + 43. TP_ARGS(dev_priv, pch_transcoder), + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/osq_lock.c:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. { + 46. struct optimistic_spin_node *next = NULL; + 47. > int curr = encode_cpu(smp_processor_id()); + 48. int old; + 49. + +kernel/locking/percpu-rwsem.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. * release in percpu_up_write(). + 63. */ + 64. > if (likely(!smp_load_acquire(&sem->readers_block))) + 65. return 1; + 66. + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +lib/lockref.c:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. void lockref_get(struct lockref *lockref) + 42. { + 43. > CMPXCHG_LOOP( + 44. new.count++; + 45. , + +drivers/clk/clk-gate.c:46: error: DEAD_STORE + The value written to &flags (type unsigned long) is never used. + 44. struct clk_gate *gate = to_clk_gate(hw); + 45. int set = gate->flags & CLK_GATE_SET_TO_DISABLE ? 1 : 0; + 46. > unsigned long uninitialized_var(flags); + 47. u32 reg; + 48. + +net/netfilter/nf_conntrack_extend.c:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. + 62. rcu_read_lock(); + 63. > t = rcu_dereference(nf_ct_ext_types[id]); + 64. if (!t) { + 65. rcu_read_unlock(); + +sound/hda/trace.h:43: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/hda/trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > TRACE_EVENT(hda_unsol_event, + 44. TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex), + 45. TP_ARGS(bus, res, res_ex), + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +sound/pci/hda/hda_intel_trace.h:43: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 41. ); + 42. + 43. > DEFINE_EVENT(hda_pm, azx_runtime_resume, + 44. TP_PROTO(struct azx *chip), + 45. TP_ARGS(chip) + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +drivers/gpu/drm/drm_trace.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > TRACE_EVENT(drm_vblank_event_delivered, + 45. TP_PROTO(struct drm_file *file, int crtc, unsigned int seq), + 46. TP_ARGS(file, crtc, seq), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. ); + 43. + 44. > DEFINE_EVENT(dma_fence, dma_fence_init, + 45. + 46. TP_PROTO(struct dma_fence *fence), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +include/trace/events/syscalls.h:44: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 42. TRACE_EVENT_FLAGS(sys_enter, TRACE_EVENT_FL_CAP_ANY) + 43. + 44. > TRACE_EVENT_FN(sys_exit, + 45. + 46. TP_PROTO(struct pt_regs *regs, long ret), + +lib/genalloc.c:54: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 52. return -EBUSY; + 53. cpu_relax(); + 54. > } while ((nval = cmpxchg(addr, val, val | mask_to_set)) != val); + 55. + 56. return 0; + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:45: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 43. ); + 44. + 45. > DEFINE_EVENT(msr_trace_class, write_msr, + 46. TP_PROTO(unsigned msr, u64 val, int failed), + 47. TP_ARGS(msr, val, failed) + +drivers/dma-buf/seqno-fence.c:49: error: NULL_DEREFERENCE + pointer `seqno_fence` last assigned on line 47 could be null and is dereferenced at line 49, column 9. + 47. struct seqno_fence *seqno_fence = to_seqno_fence(fence); + 48. + 49. > return seqno_fence->ops->signaled && seqno_fence->ops->signaled(fence); + 50. } + 51. + +drivers/usb/core/otg_whitelist.h:47: error: DEAD_STORE + The value written to &id (type usb_device_id*) is never used. + 45. static int is_targeted(struct usb_device *dev) + 46. { + 47. > struct usb_device_id *id = whitelist_table; + 48. + 49. /* HNP test device is _never_ targeted (see OTG spec 6.6.6) */ + +kernel/time/tick-broadcast-hrtimer.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. if (bc_moved) { + 70. /* Bind the "device" to the cpu */ + 71. > bc->bound_on = smp_processor_id(); + 72. } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + +kernel/time/tick-broadcast-hrtimer.c:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. /* Bind the "device" to the cpu */ + 71. bc->bound_on = smp_processor_id(); + 72. > } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + 74. } + +kernel/time/tick-broadcast-hrtimer.c:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. if (bc_moved) { + 70. /* Bind the "device" to the cpu */ + 71. > bc->bound_on = smp_processor_id(); + 72. } else if (bc->bound_on == smp_processor_id()) { + 73. hrtimer_set_expires(&bctimer, expires); + +net/netfilter/nf_nat_core.c:48: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 46. __nf_nat_l3proto_find(u8 family) + 47. { + 48. > return rcu_dereference(nf_nat_l3protos[family]); + 49. } + 50. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +include/trace/events/sunrpc.h:46: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 44. ); + 45. + 46. > DEFINE_EVENT(rpc_task_status, rpc_bind_status, + 47. TP_PROTO(struct rpc_task *task), + 48. + +lib/list_sort.c:58: error: MEMORY_LEAK + `tail->next` is not reachable after line 58, column 4. + 56. /* if equal, take 'a' -- important for sort stability */ + 57. if ((*cmp)(priv, a, b) <= 0) { + 58. > tail->next = a; + 59. a->prev = tail; + 60. a = a->next; + +lib/list_sort.c:62: error: MEMORY_LEAK + `tail->next` is not reachable after line 62, column 4. + 60. a = a->next; + 61. } else { + 62. > tail->next = b; + 63. b->prev = tail; + 64. b = b->next; + +net/sunrpc/sunrpc.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. int loopback = 0; + 50. rcu_read_lock(); + 51. > dst = rcu_dereference(sk->sk_dst_cache); + 52. if (dst && dst->dev && + 53. (dst->dev->features & NETIF_F_LOOPBACK)) + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/cgroup.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(cgroup_root, cgroup_remount, + 48. + 49. TP_PROTO(struct cgroup_root *root), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(clk, clk_enable_complete, + 48. + 49. TP_PROTO(struct clk_core *core), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +include/trace/events/iommu.h:47: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 45. ); + 46. + 47. > DEFINE_EVENT(iommu_group_event, remove_device_from_group, + 48. + 49. TP_PROTO(int group_id, struct device *dev), + +kernel/power/user.c:79: error: DEAD_STORE + The value written to &nr_calls (type int) is never used. + 77. error = __pm_notifier_call_chain(PM_HIBERNATION_PREPARE, -1, &nr_calls); + 78. if (error) + 79. > __pm_notifier_call_chain(PM_POST_HIBERNATION, --nr_calls, NULL); + 80. } else { + 81. /* + +drivers/gpu/drm/i915/i915_ioc32.c:59: error: UNINITIALIZED_VALUE + The value read from req32.param was never initialized. + 57. request = compat_alloc_user_space(sizeof(*request)); + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. > || __put_user(req32.param, &request->param) + 60. || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + +drivers/gpu/drm/i915/i915_ioc32.c:60: error: UNINITIALIZED_VALUE + The value read from req32.value was never initialized. + 58. if (!access_ok(VERIFY_WRITE, request, sizeof(*request)) + 59. || __put_user(req32.param, &request->param) + 60. > || __put_user((void __user *)(unsigned long)req32.value, + 61. &request->value)) + 62. return -EFAULT; + +drivers/usb/core/message.c:64: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 62. if (!wait_for_completion_timeout(&ctx.done, expire)) { + 63. usb_kill_urb(urb); + 64. > retval = (ctx.status == -ENOENT ? -ETIMEDOUT : ctx.status); + 65. + 66. dev_dbg(&urb->dev->dev, + +drivers/usb/core/message.c:74: error: UNINITIALIZED_VALUE + The value read from ctx.status was never initialized. + 72. urb->transfer_buffer_length); + 73. } else + 74. > retval = ctx.status; + 75. out: + 76. if (actual_length) + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > DEFINE_EVENT(regmap_reg, regmap_reg_read, + 50. + 51. TP_PROTO(struct regmap *map, unsigned int reg, + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +include/trace/events/thermal.h:49: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 47. ); + 48. + 49. > TRACE_EVENT(cdev_update, + 50. + 51. TP_PROTO(struct thermal_cooling_device *cdev, unsigned long target), + +kernel/sched/membarrier.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. * iteration. + 85. */ + 86. > if (cpu == raw_smp_processor_id()) + 87. continue; + 88. rcu_read_lock(); + +net/ipv4/xfrm4_protocol.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. return 0; + 57. + 58. > for_each_protocol_rcu(*head, handler) + 59. if ((ret = handler->cb_handler(skb, err)) <= 0) + 60. return ret; + +net/ipv6/xfrm6_protocol.c:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. return 0; + 57. + 58. > for_each_protocol_rcu(*proto_handlers(protocol), handler) + 59. if ((ret = handler->cb_handler(skb, err)) <= 0) + 60. return ret; + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +arch/x86/include/asm/msr-trace.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > DEFINE_EVENT(msr_trace_class, rdpmc, + 51. TP_PROTO(unsigned msr, u64 val, int failed), + 52. TP_ARGS(msr, val, failed) + +block/blk-stat.c:67: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 65. + 66. rcu_read_lock(); + 67. > list_for_each_entry_rcu(cb, &q->stats->callbacks, list) { + 68. if (!blk_stat_is_active(cb)) + 69. continue; + +drivers/edac/edac_device.c:78: error: DEAD_STORE + The value written to &dev_ctl (type edac_device_ctl_info*) is never used. + 76. */ + 77. p = NULL; + 78. > dev_ctl = edac_align_ptr(&p, sizeof(*dev_ctl), 1); + 79. + 80. /* Calc the 'end' offset past end of ONE ctl_info structure + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +include/trace/events/module.h:50: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 48. ); + 49. + 50. > TRACE_EVENT(module_free, + 51. + 52. TP_PROTO(struct module *mod), + +ipc/compat.c:57: error: UNINITIALIZED_VALUE + The value read from v.gid was never initialized. + 55. return -EFAULT; + 56. to->uid = v.uid; + 57. > to->gid = v.gid; + 58. to->mode = v.mode; + 59. return 0; + +ipc/compat.c:58: error: UNINITIALIZED_VALUE + The value read from v.mode was never initialized. + 56. to->uid = v.uid; + 57. to->gid = v.gid; + 58. > to->mode = v.mode; + 59. return 0; + 60. } + +ipc/compat.c:56: error: UNINITIALIZED_VALUE + The value read from v.uid was never initialized. + 54. if (copy_from_user(&v, from, sizeof(v))) + 55. return -EFAULT; + 56. > to->uid = v.uid; + 57. to->gid = v.gid; + 58. to->mode = v.mode; + +net/ipv6/ip6_input.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. const struct inet6_protocol *ipprot; + 63. + 64. > ipprot = rcu_dereference(inet6_protos[ipv6_hdr(skb)->nexthdr]); + 65. if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) + 66. edemux(skb); + +net/ipv6/ip6_input.c:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. + 64. ipprot = rcu_dereference(inet6_protos[ipv6_hdr(skb)->nexthdr]); + 65. > if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) + 66. edemux(skb); + 67. } + +net/sched/act_api.c:55: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 53. const struct tcf_chain *chain = a->goto_chain; + 54. + 55. > res->goto_tp = rcu_dereference_bh(chain->filter_chain); + 56. } + 57. + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(dma_fence, dma_fence_destroy, + 52. + 53. TP_PROTO(struct dma_fence *fence), + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/random.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. ); + 50. + 51. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes, + 52. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 53. + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +include/trace/events/signal.h:51: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 49. * means that si_code is SI_KERNEL. + 50. */ + 51. > TRACE_EVENT(signal_generate, + 52. + 53. TP_PROTO(int sig, struct siginfo *info, struct task_struct *task, + +kernel/futex_compat.c:103: error: DEAD_STORE + The value written to &uentry (type unsigned int) is never used. + 101. if (rc) + 102. return; + 103. > uentry = next_uentry; + 104. entry = next_entry; + 105. pi = next_pi; + +net/core/fib_notifier.c:55: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 53. struct fib_notifier_ops *ops; + 54. + 55. > list_for_each_entry_rcu(ops, &net->fib_notifier_ops, list) { + 56. int err; + 57. + +net/ipv6/ping.c:118: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 116. fl6.flowi6_uid = sk->sk_uid; + 117. fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. > fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + 120. + +net/ipv6/ping.c:135: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_code was never initialized. + 133. + 134. pfh.icmph.type = user_icmph.icmp6_type; + 135. > pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + 137. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv6/ping.c:117: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 115. fl6.flowi6_mark = sk->sk_mark; + 116. fl6.flowi6_uid = sk->sk_uid; + 117. > fl6.fl6_icmp_type = user_icmph.icmp6_type; + 118. fl6.fl6_icmp_code = user_icmph.icmp6_code; + 119. security_sk_classify_flow(sk, flowi6_to_flowi(&fl6)); + +net/ipv6/ping.c:134: error: UNINITIALIZED_VALUE + The value read from user_icmph.icmp6_type was never initialized. + 132. fl6.flowi6_oif = np->ucast_oif; + 133. + 134. > pfh.icmph.type = user_icmph.icmp6_type; + 135. pfh.icmph.code = user_icmph.icmp6_code; + 136. pfh.icmph.checksum = 0; + +net/netfilter/nf_nat_core.c:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. __nf_nat_l4proto_find(u8 family, u8 protonum) + 53. { + 54. > return rcu_dereference(nf_nat_l4protos[family][protonum]); + 55. } + 56. EXPORT_SYMBOL_GPL(__nf_nat_l4proto_find); + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. * counter for this CPU. + 78. */ + 79. > if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. cpu = smp_processor_id(); + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +arch/x86/lib/delay.c:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. + 57. preempt_disable(); + 58. > cpu = smp_processor_id(); + 59. bclock = rdtsc_ordered(); + 60. for (;;) { + +arch/x86/lib/delay.c:81: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 79. if (unlikely(cpu != smp_processor_id())) { + 80. loops -= (now - bclock); + 81. > cpu = smp_processor_id(); + 82. bclock = rdtsc_ordered(); + 83. } + +arch/x86/pci/mmconfig-shared.c:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. + 56. /* keep list sorted by segment and starting bus number */ + 57. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) { + 58. if (cfg->segment > new->segment || + 59. (cfg->segment == new->segment && + +drivers/dma-buf/seqno-fence.c:56: error: NULL_DEREFERENCE + pointer `f` last assigned on line 54 could be null and is dereferenced at line 56, column 14. + 54. struct seqno_fence *f = to_seqno_fence(fence); + 55. + 56. > dma_buf_put(f->sync_buf); + 57. if (f->ops->release) + 58. f->ops->release(fence); + +include/linux/netfilter_ipv6.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. static inline const struct nf_ipv6_ops *nf_get_ipv6_ops(void) + 53. { + 54. > return rcu_dereference(nf_ipv6_ops); + 55. } + 56. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/sunrpc.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. ); + 51. + 52. > TRACE_EVENT(rpc_connect_status, + 53. TP_PROTO(struct rpc_task *task, int status), + 54. + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +include/trace/events/timer.h:52: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 50. * @expires: the timers expiry time + 51. */ + 52. > TRACE_EVENT(timer_start, + 53. + 54. TP_PROTO(struct timer_list *timer, + +drivers/hid/hid-generic.c:57: error: DEAD_STORE + The value written to &ret (type int) is never used. + 55. int ret; + 56. + 57. > ret = driver_attach(&hid_generic.driver); + 58. } + 59. + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/fib.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. ); + 52. + 53. > TRACE_EVENT(fib_table_lookup_nh, + 54. + 55. TP_PROTO(const struct fib_nh *nh), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +include/trace/events/irq.h:53: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 51. * out irq handler latencies. + 52. */ + 53. > TRACE_EVENT(irq_handler_entry, + 54. + 55. TP_PROTO(int irq, struct irqaction *action), + +net/ipv4/tcp_cong.c:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. struct tcp_congestion_ops *e; + 56. + 57. > list_for_each_entry_rcu(e, &tcp_cong_list, list) { + 58. if (e->key == key) + 59. return e; + +net/ipv6/inet6_hashtables.c:63: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 61. struct sock *sk; + 62. const struct hlist_nulls_node *node; + 63. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 64. /* Optimize here for direct hit, only listening connections can + 65. * have wildcards anyways. + +net/ipv6/inet6_hashtables.c:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. + 72. begin: + 73. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 74. if (sk->sk_hash != hash) + 75. continue; + +net/netfilter/utils.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. break; + 63. case AF_INET6: + 64. > v6ops = rcu_dereference(nf_ipv6_ops); + 65. if (v6ops) + 66. ret = v6ops->route(net, dst, fl, strict); + +drivers/gpu/drm/drm_lock.c:71: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 69. _DRM_LOCK_CONT : 0); + 70. } + 71. > prev = cmpxchg(lock, old, new); + 72. } while (prev != old); + 73. spin_unlock_bh(&lock_data->spinlock); + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > DEFINE_EVENT(clk, clk_disable, + 55. + 56. TP_PROTO(struct clk_core *core), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +include/trace/events/skb.h:54: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 52. ); + 53. + 54. > TRACE_EVENT(skb_copy_datagram_iovec, + 55. + 56. TP_PROTO(const struct sk_buff *skb, int len), + +kernel/time/tick-oneshot.c:56: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 54. void tick_resume_oneshot(void) + 55. { + 56. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 57. + 58. clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT); + +kernel/time/tick-oneshot.c:56: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 54. void tick_resume_oneshot(void) + 55. { + 56. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 57. + 58. clockevents_switch_state(dev, CLOCK_EVT_STATE_ONESHOT); + +drivers/dma-buf/dma-fence-array.c:61: error: NULL_DEREFERENCE + pointer `array` last assigned on line 57 could be null and is dereferenced at line 61, column 18. + 59. unsigned i; + 60. + 61. > for (i = 0; i < array->num_fences; ++i) { + 62. cb[i].array = array; + 63. /* + +kernel/task_work.c:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. */ + 70. raw_spin_lock_irqsave(&task->pi_lock, flags); + 71. > while ((work = READ_ONCE(*pprev))) { + 72. if (work->func != func) + 73. pprev = &work->next; + +sound/hda/trace.h:55: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 53. ); + 54. + 55. > DECLARE_EVENT_CLASS(hdac_stream, + 56. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 57. + +lib/decompress_unlzo.c:82: error: DEAD_STORE + The value written to &level (type unsigned char) is never used. + 80. parse += 7; + 81. if (version >= 0x0940) + 82. > level = *parse++; + 83. if (get_unaligned_be32(parse) & HEADER_HAS_FILTER) + 84. parse += 8; /* flags + filter info */ + +kernel/rcu/rcu_segcblist.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. static inline long rcu_segcblist_n_cbs(struct rcu_segcblist *rsclp) + 57. { + 58. > return READ_ONCE(rsclp->len); + 59. } + 60. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +include/trace/events/random.h:57: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 55. ); + 56. + 57. > DEFINE_EVENT(random__mix_pool_bytes, mix_pool_bytes_nolock, + 58. TP_PROTO(const char *pool_name, int bytes, unsigned long IP), + 59. + +kernel/time/tick-sched.c:88: error: DEAD_STORE + The value written to &ticks (type unsigned long) is never used. + 86. incr * ticks); + 87. } + 88. > do_timer(++ticks); + 89. + 90. /* Keep the tick_next_period variable up to date */ + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/base/regmap/trace.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(regmap_reg, regmap_reg_read_cache, + 59. + 60. TP_PROTO(struct regmap *map, unsigned int reg, + +drivers/connector/cn_proc.c:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. + 62. msg->seq = __this_cpu_inc_return(proc_event_counts) - 1; + 63. > ((struct proc_event *)msg->data)->cpu = smp_processor_id(); + 64. + 65. /* + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:58: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 56. ); + 57. + 58. > DEFINE_EVENT(dma_fence, dma_fence_enable_signal, + 59. + 60. TP_PROTO(struct dma_fence *fence), + +lib/errseq.c:94: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 92. + 93. /* Try to swap the new value into place */ + 94. > cur = cmpxchg(eseq, old, new); + 95. + 96. /* + +lib/errseq.c:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. * previous error. + 70. */ + 71. > old = READ_ONCE(*eseq); + 72. + 73. if (WARN(unlikely(err == 0 || (unsigned int)-err > MAX_ERRNO), + +lib/errseq.c:106: error: UNINITIALIZED_VALUE + The value read from cur was never initialized. + 104. old = cur; + 105. } + 106. > return cur; + 107. } + 108. EXPORT_SYMBOL(errseq_set); + +net/ipv6/ip6_offload.c:95: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 93. udpfrag = proto == IPPROTO_UDP && !skb->encapsulation; + 94. + 95. > ops = rcu_dereference(inet6_offloads[proto]); + 96. if (likely(ops && ops->callbacks.gso_segment)) { + 97. skb_reset_transport_header(skb); + +drivers/cpuidle/cpuidle.c:61: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 59. int cpuidle_play_dead(void) + 60. { + 61. > struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices); + 62. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 63. int i; + +drivers/cpuidle/cpuidle.c:61: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 59. int cpuidle_play_dead(void) + 60. { + 61. > struct cpuidle_device *dev = __this_cpu_read(cpuidle_devices); + 62. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 63. int i; + +lib/genalloc.c:69: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 67. return -EBUSY; + 68. cpu_relax(); + 69. > } while ((nval = cmpxchg(addr, val, val & ~mask_to_clear)) != val); + 70. + 71. return 0; + +arch/x86/pci/amd_bus.c:128: error: DEAD_STORE + The value written to &info (type pci_root_info*) is never used. + 126. link = (reg >> 8) & 0x03; + 127. + 128. > info = alloc_pci_root_info(min_bus, max_bus, node, link); + 129. } + 130. + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from bus was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:116: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 114. int min_bus; + 115. int max_bus; + 116. > reg = read_pci_config(bus, slot, 1, + 117. AMD_NB_F1_CONFIG_MAP_REG + (i << 2)); + 118. + +arch/x86/pci/amd_bus.c:143: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 141. + 142. /* get the default node and link for left over res */ + 143. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + +arch/x86/pci/amd_bus.c:145: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 143. reg = read_pci_config(bus, slot, 0, AMD_NB_F0_NODE_ID); + 144. def_node = (reg >> 8) & 0x07; + 145. > reg = read_pci_config(bus, slot, 0, AMD_NB_F0_UNIT_ID); + 146. def_link = (reg >> 8) & 0x03; + 147. + +arch/x86/pci/amd_bus.c:152: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 150. /* io port resource */ + 151. for (i = 0; i < 4; i++) { + 152. > reg = read_pci_config(bus, slot, 1, 0xc0 + (i << 3)); + 153. if (!(reg & 3)) + 154. continue; + +arch/x86/pci/amd_bus.c:157: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 155. + 156. start = reg & 0xfff000; + 157. > reg = read_pci_config(bus, slot, 1, 0xc4 + (i << 3)); + 158. node = reg & 0x07; + 159. link = (reg >> 4) & 0x03; + +arch/x86/pci/amd_bus.c:218: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 216. /* mmio resource */ + 217. for (i = 0; i < 8; i++) { + 218. > reg = read_pci_config(bus, slot, 1, 0x80 + (i << 3)); + 219. if (!(reg & 3)) + 220. continue; + +arch/x86/pci/amd_bus.c:224: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 222. start = reg & 0xffffff00; /* 39:16 on 31:8*/ + 223. start <<= 8; + 224. > reg = read_pci_config(bus, slot, 1, 0x84 + (i << 3)); + 225. node = reg & 0x07; + 226. link = (reg >> 4) & 0x03; + +drivers/tty/tty_audit.c:66: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 64. struct task_struct *tsk = current; + 65. pid_t pid = task_pid_nr(tsk); + 66. > uid_t uid = from_kuid(&init_user_ns, task_uid(tsk)); + 67. uid_t loginuid = from_kuid(&init_user_ns, audit_get_loginuid(tsk)); + 68. unsigned int sessionid = audit_get_sessionid(tsk); + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +lib/lockref.c:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. int retval; + 63. + 64. > CMPXCHG_LOOP( + 65. new.count++; + 66. if (old.count <= 0) + +net/netlabel/netlabel_addrlist.c:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. struct netlbl_af4list *iter; + 64. + 65. > list_for_each_entry_rcu(iter, head, list) + 66. if (iter->valid && (addr & iter->mask) == iter->addr) + 67. return iter; + +sound/core/pcm_lib.c:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. if (runtime->silence_size < runtime->boundary) { + 67. snd_pcm_sframes_t noise_dist, n; + 68. > snd_pcm_uframes_t appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 69. if (runtime->silence_start != appl_ptr) { + 70. n = appl_ptr - runtime->silence_start; + +block/badblocks.c:76: error: DEAD_STORE + The value written to §ors (type int) is never used. + 74. target += (1<shift) - 1; + 75. target >>= bb->shift; + 76. > sectors = target - s; + 77. } + 78. /* 'target' is now the first block after the bad range */ + +drivers/char/agp/compat_ioctl.c:75: error: UNINITIALIZED_VALUE + The value read from ureserve.pid was never initialized. + 73. return -EFAULT; + 74. + 75. > kreserve.pid = ureserve.pid; + 76. kreserve.seg_count = ureserve.seg_count; + 77. + +drivers/char/agp/compat_ioctl.c:76: error: UNINITIALIZED_VALUE + The value read from ureserve.seg_count was never initialized. + 74. + 75. kreserve.pid = ureserve.pid; + 76. > kreserve.seg_count = ureserve.seg_count; + 77. + 78. client = agp_find_client_by_pid(kreserve.pid); + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:61: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 59. ); + 60. + 61. > DEFINE_EVENT(clk, clk_disable_complete, + 62. + 63. TP_PROTO(struct clk_core *core), + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +kernel/sched/idle.c:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. { + 63. rcu_idle_enter(); + 64. > trace_cpu_idle_rcuidle(0, smp_processor_id()); + 65. local_irq_enable(); + 66. stop_critical_timings(); + +kernel/sched/idle.c:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. cpu_relax(); + 70. start_critical_timings(); + 71. > trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id()); + 72. rcu_idle_exit(); + 73. return 1; + +sound/core/vmaster.c:70: error: DEAD_STORE + The value written to &err (type int) is never used. + 68. return -ENOMEM; + 69. uctl->id = slave->slave.id; + 70. > err = slave->slave.get(&slave->slave, uctl); + 71. for (ch = 0; ch < slave->info.count; ch++) + 72. slave->vals[ch] = uctl->value.integer.value[ch]; + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/i2c.h:62: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 60. * __i2c_transfer() read request + 61. */ + 62. > TRACE_EVENT_FN(i2c_read, + 63. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 64. int num), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/sock.h:62: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 60. __print_symbolic(val, tcp_state_names) + 61. + 62. > TRACE_EVENT(sock_rcvqueue_full, + 63. + 64. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +block/blk-ioc.c:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. * will. Hint assignment itself can race safely. + 79. */ + 80. > if (rcu_access_pointer(ioc->icq_hint) == icq) + 81. rcu_assign_pointer(ioc->icq_hint, NULL); + 82. + +drivers/dma-buf/seqno-fence.c:68: error: NULL_DEREFERENCE + pointer `f` last assigned on line 66 could be null and is dereferenced at line 68, column 9. + 66. struct seqno_fence *f = to_seqno_fence(fence); + 67. + 68. > return f->ops->wait(fence, intr, timeout); + 69. } + 70. + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +drivers/gpu/drm/i915/i915_trace.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(intel_memory_cxsr, + 64. TP_PROTO(struct drm_i915_private *dev_priv, bool old, bool new), + 65. TP_ARGS(dev_priv, old, new), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +include/trace/events/random.h:63: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 61. ); + 62. + 63. > TRACE_EVENT(credit_entropy_bits, + 64. TP_PROTO(const char *pool_name, int bits, int entropy_count, + 65. int entropy_total, unsigned long IP), + +block/ioprio.c:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. else + 110. pgrp = find_vpid(who); + 111. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 112. ret = set_task_ioprio(p, ioprio); + 113. if (ret) + +block/ioprio.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. break; + 128. + 129. > for_each_process_thread(g, p) { + 130. if (!uid_eq(task_uid(p), uid) || + 131. !task_pid_vnr(p)) + +block/ioprio.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. + 129. for_each_process_thread(g, p) { + 130. > if (!uid_eq(task_uid(p), uid) || + 131. !task_pid_vnr(p)) + 132. continue; + +drivers/char/agp/isoch.c:140: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 138. dev = cur->dev; + 139. + 140. > mcapndx = cur->capndx; + 141. + 142. pci_read_config_dword(dev, cur->capndx+AGPNISTAT, &mnistat); + +drivers/char/agp/isoch.c:253: error: DEAD_STORE + The value written to &mcapndx (type unsigned char) is never used. + 251. dev = cur->dev; + 252. + 253. > mcapndx = cur->capndx; + 254. + 255. master[cdev].rq += (cdev == ndevs - 1) + +include/linux/idr.h:66: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 64. static inline unsigned int idr_get_cursor(const struct idr *idr) + 65. { + 66. > return READ_ONCE(idr->idr_next); + 67. } + 68. + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/power.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. ); + 63. + 64. > TRACE_EVENT(pstate_sample, + 65. + 66. TP_PROTO(u32 core_busy, + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/rcu.h:64: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 62. * "cpuend": CPU first notices a grace-period end. + 63. */ + 64. > TRACE_EVENT(rcu_grace_period, + 65. + 66. TP_PROTO(const char *rcuname, unsigned long gpnum, const char *gpevent), + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/cpuhp.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > TRACE_EVENT(cpuhp_exit, + 66. + 67. TP_PROTO(unsigned int cpu, + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:65: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 63. ); + 64. + 65. > DEFINE_EVENT(dma_fence, dma_fence_signaled, + 66. + 67. TP_PROTO(struct dma_fence *fence), + +kernel/time/tick-common.c:67: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 65. int tick_is_oneshot_available(void) + 66. { + 67. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 68. + 69. if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT)) + +kernel/time/tick-common.c:67: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 65. int tick_is_oneshot_available(void) + 66. { + 67. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 68. + 69. if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT)) + +kernel/trace/trace_events_trigger.c:75: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 73. return tt; + 74. + 75. > list_for_each_entry_rcu(data, &file->triggers, list) { + 76. if (data->paused) + 77. continue; + +kernel/trace/trace_events_trigger.c:82: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 80. continue; + 81. } + 82. > filter = rcu_dereference_sched(data->filter); + 83. if (filter && !filter_match_preds(filter, rec)) + 84. continue; + +lib/llist.c:75: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 73. old_entry = entry; + 74. next = READ_ONCE(entry->next); + 75. > entry = cmpxchg(&head->first, old_entry, next); + 76. if (entry == old_entry) + 77. break; + +lib/llist.c:69: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 67. struct llist_node *entry, *old_entry, *next; + 68. + 69. > entry = smp_load_acquire(&head->first); + 70. for (;;) { + 71. if (entry == NULL) + +lib/llist.c:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. return NULL; + 73. old_entry = entry; + 74. > next = READ_ONCE(entry->next); + 75. entry = cmpxchg(&head->first, old_entry, next); + 76. if (entry == old_entry) + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +kernel/smpboot.c:70: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 68. unsigned int cpu, boot_cpu; + 69. + 70. > boot_cpu = smp_processor_id(); + 71. + 72. for_each_possible_cpu(cpu) { + +lib/bug.c:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. + 71. rcu_read_lock_sched(); + 72. > list_for_each_entry_rcu(mod, &module_bug_list, bug_list) { + 73. unsigned i; + 74. + +net/ipv4/xfrm4_protocol.c:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. goto out; + 79. + 80. > for_each_protocol_rcu(*head, handler) + 81. if ((ret = handler->input_handler(skb, nexthdr, spi, encap_type)) != -EINVAL) + 82. return ret; + +net/ipv6/xfrm6_protocol.c:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 72. + 73. > for_each_protocol_rcu(esp6_handlers, handler) + 74. if ((ret = handler->handler(skb)) != -EINVAL) + 75. return ret; + +kernel/events/core.c:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. if (p) { + 73. /* -EAGAIN */ + 74. > if (task_cpu(p) != smp_processor_id()) + 75. return; + 76. + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +kernel/sched/isolation.c:85: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 83. cpu_possible_mask, non_housekeeping_mask); + 84. if (cpumask_empty(housekeeping_mask)) + 85. > cpumask_set_cpu(smp_processor_id(), housekeeping_mask); + 86. } else { + 87. cpumask_var_t tmp; + +lib/earlycpio.c:140: error: UNINITIALIZED_VALUE + The value read from ch[_] was never initialized. + 138. + 139. cd.data = (void *)dptr; + 140. > cd.size = ch[C_FILESIZE]; + 141. return cd; /* Found it! */ + 142. } + +drivers/gpu/drm/i915/dvo_sil164.c:94: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 92. + 93. if (i2c_transfer(adapter, msgs, 2) == 2) { + 94. > *ch = in_buf[0]; + 95. return true; + 96. } + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > DEFINE_EVENT(clk, clk_prepare, + 69. + 70. TP_PROTO(struct clk_core *core), + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +include/trace/events/thermal.h:68: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 66. ); + 67. + 68. > TRACE_EVENT(thermal_zone_trip, + 69. + 70. TP_PROTO(struct thermal_zone_device *tz, int trip, + +kernel/locking/rtmutex.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. * still set. + 132. */ + 133. > owner = READ_ONCE(*p); + 134. if (owner & RT_MUTEX_HAS_WAITERS) + 135. WRITE_ONCE(*p, owner & ~RT_MUTEX_HAS_WAITERS); + +lib/rhashtable.c:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. unsigned int i; + 73. + 74. > ntbl = rcu_dereference_raw(ntbl->table); + 75. if (!ntbl) + 76. return; + +net/core/sock_diag.c:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. + 82. rcu_read_lock(); + 83. > filter = rcu_dereference(sk->sk_filter); + 84. if (!filter) + 85. goto out; + +net/ipv6/datagram.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. + 86. rcu_read_lock(); + 87. > opt = flowlabel ? flowlabel->opt : rcu_dereference(np->opt); + 88. final_p = fl6_update_dst(&fl6, opt, &final); + 89. rcu_read_unlock(); + +net/ipv6/xfrm6_mode_transport.c:77: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 74 could be null and is dereferenced at line 77, column 8. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +net/ipv6/xfrm6_mode_transport.c:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. + 76. skb->transport_header += x->props.header_len; + 77. > ops = rcu_dereference(inet6_offloads[xo->proto]); + 78. if (likely(ops && ops->callbacks.gso_segment)) + 79. segs = ops->callbacks.gso_segment(skb, features); + +crypto/sha256_generic.c:230: error: DEAD_STORE + The value written to &a (type unsigned int) is never used. + 228. + 229. /* clear any sensitive info... */ + 230. > a = b = c = d = e = f = g = h = t1 = t2 = 0; + 231. memzero_explicit(W, 64 * sizeof(u32)); + 232. } + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/linux/topology.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. static inline int numa_node_id(void) + 72. { + 73. > return raw_cpu_read(numa_node); + 74. } + 75. #endif + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +include/trace/events/net.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > TRACE_EVENT(net_dev_xmit, + 72. + 73. TP_PROTO(struct sk_buff *skb, + +kernel/locking/qrwlock.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. /* When no more readers or writers, set the locked flag */ + 85. do { + 86. > atomic_cond_read_acquire(&lock->cnts, VAL == _QW_WAITING); + 87. } while (atomic_cmpxchg_relaxed(&lock->cnts, _QW_WAITING, + 88. _QW_LOCKED) != _QW_WAITING); + +kernel/softirq.c:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. { + 73. /* Interrupts are disabled: no need to stop preemption */ + 74. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 75. + 76. if (tsk && tsk->state != TASK_RUNNING) + +kernel/softirq.c:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. { + 73. /* Interrupts are disabled: no need to stop preemption */ + 74. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 75. + 76. if (tsk && tsk->state != TASK_RUNNING) + +security/selinux/netif.c:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. struct sel_netif *netif; + 76. + 77. > list_for_each_entry_rcu(netif, &sel_netif_hash[idx], list) + 78. if (net_eq(netif->nsec.ns, ns) && + 79. netif->nsec.ifindex == ifindex) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:71: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 69. ); + 70. + 71. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_start, + 72. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 73. TP_ARGS(bus, azx_dev) + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +drivers/gpu/drm/i915/intel_uncore.c:78: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 76. const u32 value) + 77. { + 78. > return wait_for_atomic((__raw_i915_read32(i915, d->reg_ack) & ack) == value, + 79. FORCEWAKE_ACK_TIMEOUT_MS); + 80. } + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(dma_fence, dma_fence_wait_start, + 73. + 74. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:72: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 70. ); + 71. + 72. > DEFINE_EVENT(iommu_device_event, attach_device_to_domain, + 73. + 74. TP_PROTO(struct device *dev), + +arch/x86/platform/efi/efi_64.c:104: error: DEAD_STORE + The value written to &vaddr (type unsigned long) is never used. + 102. for (pgd = 0; pgd < n_pgds; pgd++) { + 103. addr_pgd = (unsigned long)(pgd * PGDIR_SIZE); + 104. > vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. save_pgd[pgd] = *pgd_efi; + +arch/x86/platform/efi/efi_64.c:106: error: NULL_DEREFERENCE + pointer `save_pgd` last assigned on line 92 could be null and is dereferenced at line 106, column 3. + 104. vaddr = (unsigned long)__va(pgd * PGDIR_SIZE); + 105. pgd_efi = pgd_offset_k(addr_pgd); + 106. > save_pgd[pgd] = *pgd_efi; + 107. + 108. p4d = p4d_alloc(&init_mm, pgd_efi, addr_pgd); + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:73: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 71. ); + 72. + 73. > DEFINE_EVENT(alarm_class, alarmtimer_fired, + 74. + 75. TP_PROTO(struct alarm *alarm, ktime_t now), + +drivers/gpu/drm/drm_info.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. rcu_read_lock(); /* locks pid_task()->comm */ + 97. task = pid_task(priv->pid, PIDTYPE_PID); + 98. > uid = task ? __task_cred(task)->euid : GLOBAL_ROOT_UID; + 99. seq_printf(m, "%20s %5d %3d %c %c %5d %10u\n", + 100. task ? task->comm : "", + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * put back in the queue. + 73. */ + 74. > TRACE_EVENT(block_rq_requeue, + 75. + 76. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/sunrpc.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > TRACE_EVENT(rpc_request, + 75. TP_PROTO(const struct rpc_task *task), + 76. + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. * is reached. + 73. */ + 74. > DEFINE_EVENT(workqueue_work, workqueue_activate_work, + 75. + 76. TP_PROTO(struct work_struct *work), + +kernel/notifier.c:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. struct notifier_block *nb, *next_nb; + 80. + 81. > nb = rcu_dereference_raw(*nl); + 82. + 83. while (nb && nr_to_call) { + +kernel/notifier.c:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. + 83. while (nb && nr_to_call) { + 84. > next_nb = rcu_dereference_raw(nb->next); + 85. + 86. #ifdef CONFIG_DEBUG_NOTIFIERS + +net/core/filter.c:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. + 96. rcu_read_lock(); + 97. > filter = rcu_dereference(sk->sk_filter); + 98. if (filter) { + 99. struct sock *save_sk = skb->sk; + +net/ipv6/ip6_flowlabel.c:78: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 76. struct ip6_flowlabel *fl; + 77. + 78. > for_each_fl_rcu(FL_HASH(label), fl) { + 79. if (fl->label == label && net_eq(fl->fl_net, net)) + 80. return fl; + +net/netfilter/utils.c:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. break; + 83. case AF_INET6: + 84. > v6ops = rcu_dereference(nf_ipv6_ops); + 85. if (v6ops) + 86. ret = v6ops->reroute(skb, entry); + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:74: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 72. ); + 73. + 74. > DEFINE_EVENT(azx_pcm, azx_pcm_open, + 75. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 76. TP_ARGS(chip, azx_dev) + +tools/objtool/orc_dump.c:102: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 102, column 3. + 100. elf = elf_begin(fd, ELF_C_READ_MMAP, NULL); + 101. if (!elf) { + 102. > WARN_ELF("elf_begin"); + 103. return -1; + 104. } + +tools/objtool/orc_dump.c:107: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 107, column 3. + 105. + 106. if (elf_getshdrnum(elf, &nr_sections)) { + 107. > WARN_ELF("elf_getshdrnum"); + 108. return -1; + 109. } + +tools/objtool/orc_dump.c:112: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 112, column 3. + 110. + 111. if (elf_getshdrstrndx(elf, &shstrtab_idx)) { + 112. > WARN_ELF("elf_getshdrstrndx"); + 113. return -1; + 114. } + +tools/objtool/orc_dump.c:119: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 119, column 4. + 117. scn = elf_getscn(elf, i); + 118. if (!scn) { + 119. > WARN_ELF("elf_getscn"); + 120. return -1; + 121. } + +tools/objtool/orc_dump.c:124: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 124, column 4. + 122. + 123. if (!gelf_getshdr(scn, &sh)) { + 124. > WARN_ELF("gelf_getshdr"); + 125. return -1; + 126. } + +tools/objtool/orc_dump.c:130: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 130, column 4. + 128. name = elf_strptr(elf, shstrtab_idx, sh.sh_name); + 129. if (!name) { + 130. > WARN_ELF("elf_strptr"); + 131. return -1; + 132. } + +tools/objtool/orc_dump.c:136: error: RESOURCE_LEAK + resource acquired by call to `open()` at line 94, column 7 is not released after line 136, column 4. + 134. data = elf_getdata(scn, NULL); + 135. if (!data) { + 136. > WARN_ELF("elf_getdata"); + 137. return -1; + 138. } + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +arch/x86/power/cpu.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. */ + 93. ctxt->gdt_desc.size = GDT_SIZE - 1; + 94. > ctxt->gdt_desc.address = (unsigned long)get_cpu_gdt_rw(smp_processor_id()); + 95. + 96. store_tr(ctxt->tr); + +drivers/ptp/ptp_sysfs.c:101: error: UNINITIALIZED_VALUE + The value read from event.index was never initialized. + 99. goto out; + 100. + 101. > cnt = snprintf(page, PAGE_SIZE, "%u %lld %u\n", + 102. event.index, event.t.sec, event.t.nsec); + 103. out: + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:75: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 73. ); + 74. + 75. > DEFINE_EVENT(clk, clk_prepare_complete, + 76. + 77. TP_PROTO(struct clk_core *core), + +drivers/connector/cn_proc.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. ev->what = PROC_EVENT_FORK; + 91. rcu_read_lock(); + 92. > parent = rcu_dereference(task->real_parent); + 93. ev->event_data.fork.parent_pid = parent->pid; + 94. ev->event_data.fork.parent_tgid = parent->tgid; + +drivers/power/supply/power_supply_sysfs.c:122: error: UNINITIALIZED_VALUE + The value read from value.strval was never initialized. + 120. power_supply_scope_text[value.intval]); + 121. else if (off >= POWER_SUPPLY_PROP_MODEL_NAME) + 122. > return sprintf(buf, "%s\n", value.strval); + 123. + 124. return sprintf(buf, "%d\n", value.intval); + +include/net/netfilter/nf_conntrack_l3proto.h:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. if (unlikely(l3proto >= NFPROTO_NUMPROTO)) + 80. return &nf_conntrack_l3proto_generic; + 81. > return rcu_dereference(nf_ct_l3protos[l3proto]); + 82. } + 83. + +kernel/cgroup/stat.c:96: error: NULL_DEREFERENCE + pointer `pos` last assigned on line 92 could be null and is dereferenced by call to `cgroup_cpu_stat()` at line 96, column 11. + 94. /* walk down to the first leaf */ + 95. while (true) { + 96. > cstat = cgroup_cpu_stat(pos, cpu); + 97. if (cstat->updated_children == pos) + 98. break; + +net/wireless/scan.c:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. return; + 82. + 83. > ies = (void *)rcu_access_pointer(bss->pub.beacon_ies); + 84. if (ies && !bss->pub.hidden_beacon_bss) + 85. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. if (ies && !bss->pub.hidden_beacon_bss) + 85. kfree_rcu(ies, rcu_head); + 86. > ies = (void *)rcu_access_pointer(bss->pub.proberesp_ies); + 87. if (ies) + 88. kfree_rcu(ies, rcu_head); + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +sound/hda/trace.h:76: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 74. ); + 75. + 76. > DEFINE_EVENT(hdac_stream, snd_hdac_stream_stop, + 77. TP_PROTO(struct hdac_bus *bus, struct hdac_stream *azx_dev), + 78. TP_ARGS(bus, azx_dev) + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +include/trace/events/fib.h:77: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 75. ); + 76. + 77. > TRACE_EVENT(fib_validate_source, + 78. + 79. TP_PROTO(const struct net_device *dev, const struct flowi4 *flp), + +drivers/pps/kapi.c:88: error: DEAD_STORE + The value written to &err (type int) is never used. + 86. pr_err("%s: unsupported default parameters\n", + 87. info->name); + 88. > err = -EINVAL; + 89. goto pps_register_source_exit; + 90. } + +drivers/pps/kapi.c:94: error: DEAD_STORE + The value written to &err (type int) is never used. + 92. pr_err("%s: unspecified time format\n", + 93. info->name); + 94. > err = -EINVAL; + 95. goto pps_register_source_exit; + 96. } + +drivers/pps/kapi.c:101: error: DEAD_STORE + The value written to &err (type int) is never used. + 99. pps = kzalloc(sizeof(struct pps_device), GFP_KERNEL); + 100. if (pps == NULL) { + 101. > err = -ENOMEM; + 102. goto pps_register_source_exit; + 103. } + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/linux/netpoll.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. + 82. if (dev && dev->npinfo) { + 83. > int owner = smp_processor_id(); + 84. + 85. while (cmpxchg(&napi->poll_owner, -1, owner) != -1) + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +include/trace/events/rpm.h:78: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 76. ); + 77. + 78. > TRACE_EVENT(rpm_return_int, + 79. TP_PROTO(struct device *dev, unsigned long ip, int ret), + 80. TP_ARGS(dev, ip, ret), + +kernel/ptrace.c:81: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 79. { + 80. rcu_read_lock(); + 81. > __ptrace_link(child, new_parent, __task_cred(new_parent)); + 82. rcu_read_unlock(); + 83. } + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +kernel/trace/blktrace.c:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. struct ring_buffer *buffer = NULL; + 85. int pc = 0; + 86. > int cpu = smp_processor_id(); + 87. bool blk_tracer = blk_tracer_enabled; + 88. ssize_t cgid_len = cgid ? sizeof(*cgid) : 0; + +net/netfilter/nf_log.c:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. if (pf == NFPROTO_UNSPEC) { + 89. for (i = NFPROTO_UNSPEC; i < NFPROTO_NUMPROTO; i++) { + 90. > if (rcu_access_pointer(loggers[i][logger->type])) { + 91. ret = -EEXIST; + 92. goto unlock; + +net/netfilter/nf_log.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. rcu_assign_pointer(loggers[i][logger->type], logger); + 97. } else { + 98. > if (rcu_access_pointer(loggers[pf][logger->type])) { + 99. ret = -EEXIST; + 100. goto unlock; + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/dma_fence.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(dma_fence, dma_fence_wait_end, + 80. + 81. TP_PROTO(struct dma_fence *fence), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +include/trace/events/iommu.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(iommu_device_event, detach_device_from_domain, + 80. + 81. TP_PROTO(struct device *dev), + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:79: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 77. ); + 78. + 79. > DEFINE_EVENT(azx_pcm, azx_pcm_close, + 80. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 81. TP_ARGS(chip, azx_dev) + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:90: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 84 could be null and is dereferenced at line 90, column 6. + 88. + 89. /* Write the MSB and/or LSB */ + 90. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) { + 91. vals[0] = (level & 0xFF00) >> 8; + 92. vals[1] = (level & 0xFF); + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(alarm_class, alarmtimer_start, + 81. + 82. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:80: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 78. ); + 79. + 80. > DEFINE_EVENT(cgroup, cgroup_mkdir, + 81. + 82. TP_PROTO(struct cgroup *cgroup), + +net/core/net-sysfs.c:87: error: DEAD_STORE + The value written to &ret (type int) is never used. + 85. struct net *net = dev_net(netdev); + 86. unsigned long new; + 87. > int ret = -EINVAL; + 88. + 89. if (!ns_capable(net->user_ns, CAP_NET_ADMIN)) + +security/selinux/ibpkey.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. + 86. idx = sel_ib_pkey_hashfn(pkey_num); + 87. > list_for_each_entry_rcu(pkey, &sel_ib_pkey_hash[idx].list, list) { + 88. if (pkey->psec.pkey == pkey_num && + 89. pkey->psec.subnet_prefix == subnet_prefix) + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/linux/sched/clock.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. static inline u64 local_clock(void) + 83. { + 84. > return sched_clock_cpu(raw_smp_processor_id()); + 85. } + 86. #endif + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:82: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 80. ); + 81. + 82. > DEFINE_EVENT(clk, clk_unprepare, + 83. + 84. TP_PROTO(struct clk_core *core), + +lib/sbitmap.c:111: error: UNINITIALIZED_VALUE + The value read from nr was never initialized. + 109. } + 110. + 111. > return nr; + 112. } + 113. + +net/ipv6/icmp.c:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. static inline struct sock *icmpv6_sk(struct net *net) + 83. { + 84. > return net->ipv6.icmp_sk[smp_processor_id()]; + 85. } + 86. + +drivers/base/devtmpfs.c:119: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 117. kfree(tmp); + 118. + 119. > return req.err; + 120. } + 121. + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +include/trace/events/irq.h:83: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 81. * conjunction with the irq_handler_entry to understand irq handler latencies. + 82. */ + 83. > TRACE_EVENT(irq_handler_exit, + 84. + 85. TP_PROTO(int irq, struct irqaction *action, int ret), + +lib/percpu_counter.c:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. + 87. preempt_disable(); + 88. > count = __this_cpu_read(*fbc->counters) + amount; + 89. if (count >= batch || count <= -batch) { + 90. unsigned long flags; + +net/core/fib_notifier.c:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. + 93. rcu_read_lock(); + 94. > for_each_net_rcu(net) { + 95. err = fib_net_dump(net, nb); + 96. if (err) + +net/ipv6/inet6_connection_sock.c:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. + 104. rcu_read_lock(); + 105. > final_p = fl6_update_dst(fl6, rcu_dereference(np->opt), &final); + 106. rcu_read_unlock(); + 107. + +net/ipv6/xfrm6_protocol.c:88: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 86. struct xfrm6_protocol *handler; + 87. + 88. > for_each_protocol_rcu(esp6_handlers, handler) + 89. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 90. break; + +sound/core/hwdep.c:158: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 156. module_put(hw->card->module); + 157. snd_card_unref(hw->card); + 158. > return err; + 159. } + 160. + +drivers/usb/core/usb-acpi.c:100: error: DEAD_STORE + The value written to &status (type unsigned int) is never used. + 98. * no connectable, the port would be not used. + 99. */ + 100. > status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer); + 101. upc = buffer.pointer; + 102. if (!upc || (upc->type != ACPI_TYPE_PACKAGE) + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +include/trace/events/sock.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. ); + 83. + 84. > TRACE_EVENT(sock_exceed_buf_limit, + 85. + 86. TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + +kernel/softirq.c:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. static bool ksoftirqd_running(void) + 85. { + 86. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 87. + 88. return tsk && (tsk->state == TASK_RUNNING); + +kernel/softirq.c:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. static bool ksoftirqd_running(void) + 85. { + 86. > struct task_struct *tsk = __this_cpu_read(ksoftirqd); + 87. + 88. return tsk && (tsk->state == TASK_RUNNING); + +net/netlabel/netlabel_addrlist.c:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. struct netlbl_af4list *iter; + 89. + 90. > list_for_each_entry_rcu(iter, head, list) + 91. if (iter->valid && iter->addr == addr && iter->mask == mask) + 92. return iter; + +net/netlabel/netlabel_addrlist.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. struct netlbl_af4list *n = __af4list_entry(s); + 89. while (i != h && !n->valid) { + 90. > i = rcu_dereference(list_next_rcu(i)); + 91. n = __af4list_entry(i); + 92. } + +net/xfrm/xfrm_input.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. + 91. rcu_read_lock(); + 92. > afinfo = rcu_dereference(xfrm_input_afinfo[family]); + 93. if (unlikely(!afinfo)) + 94. rcu_read_unlock(); + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:84: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 82. ); + 83. + 84. > DEFINE_EVENT(azx_pcm, azx_pcm_hw_params, + 85. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 86. TP_ARGS(chip, azx_dev) + +block/genhd.c:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. struct hd_struct *__disk_get_part(struct gendisk *disk, int partno) + 86. { + 87. > struct disk_part_tbl *ptbl = rcu_dereference(disk->part_tbl); + 88. + 89. if (unlikely(partno < 0 || partno >= ptbl->len)) + +block/genhd.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. if (unlikely(partno < 0 || partno >= ptbl->len)) + 90. return NULL; + 91. > return rcu_dereference(ptbl->part[partno]); + 92. } + 93. + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/iommu.h:86: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 84. ); + 85. + 86. > TRACE_EVENT(map, + 87. + 88. TP_PROTO(unsigned long iova, phys_addr_t paddr, size_t size), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/alarmtimer.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(alarm_class, alarmtimer_cancel, + 88. + 89. TP_PROTO(struct alarm *alarm, ktime_t now), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. ); + 86. + 87. > DEFINE_EVENT(cgroup, cgroup_rmdir, + 88. + 89. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:87: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 85. * Allows to track workqueue execution. + 86. */ + 87. > TRACE_EVENT(workqueue_execute_start, + 88. + 89. TP_PROTO(struct work_struct *work), + +lib/rhashtable.c:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. unsigned int i; + 93. + 94. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 95. + 96. for (i = 0; i < len; i++) + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +include/trace/events/sched.h:88: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 86. * called from the waking context. + 87. */ + 88. > DEFINE_EVENT(sched_wakeup_template, sched_waking, + 89. TP_PROTO(struct task_struct *p), + 90. TP_ARGS(p)); + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/nmi_backtrace.c:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. { + 90. static arch_spinlock_t lock = __ARCH_SPIN_LOCK_UNLOCKED; + 91. > int cpu = smp_processor_id(); + 92. + 93. if (cpumask_test_cpu(cpu, to_cpumask(backtrace_mask))) { + +lib/zlib_inflate/inffast.c:257: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 255. PUP(out) = PUP(from); + 256. if (len > 1) + 257. > PUP(out) = PUP(from); + 258. } + 259. } + +lib/zlib_inflate/inffast.c:304: error: DEAD_STORE + The value written to &from (type unsigned char*) is never used. + 302. } + 303. if (len & 1) + 304. > PUP(out) = PUP(from); + 305. } + 306. } + +net/core/fib_rules.c:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. + 92. rcu_read_lock(); + 93. > list_for_each_entry_rcu(ops, &net->rules_ops, list) { + 94. if (ops->family == family) { + 95. if (!try_module_get(ops->owner)) + +sound/hda/hdac_bus.c:115: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 113. trace_hda_get_response(bus, addr, *res); + 114. } + 115. > return err; + 116. } + 117. EXPORT_SYMBOL_GPL(snd_hdac_bus_exec_verb_unlocked); + +crypto/algapi.c:96: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 94. struct crypto_spawn *spawn, *n; + 95. + 96. > spawn = list_first_entry_or_null(stack, struct crypto_spawn, list); + 97. if (!spawn) + 98. return NULL; + +drivers/gpu/drm/drm_ioc32.c:103: error: UNINITIALIZED_VALUE + The value read from v32.date was never initialized. + 101. .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. > .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. .desc = compat_ptr(v32.desc), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.date_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:105: error: UNINITIALIZED_VALUE + The value read from v32.desc was never initialized. + 103. .date = compat_ptr(v32.date), + 104. .desc_len = v32.desc_len, + 105. > .desc = compat_ptr(v32.desc), + 106. }; + 107. err = drm_ioctl_kernel(file, drm_version, &v, + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.desc_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/drm_ioc32.c:101: error: UNINITIALIZED_VALUE + The value read from v32.name was never initialized. + 99. v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. > .name = compat_ptr(v32.name), + 102. .date_len = v32.date_len, + 103. .date = compat_ptr(v32.date), + +drivers/gpu/drm/drm_ioc32.c:99: error: UNINITIALIZED_VALUE + The value read from v32.name_len was never initialized. + 97. return -EFAULT; + 98. + 99. > v = (struct drm_version) { + 100. .name_len = v32.name_len, + 101. .name = compat_ptr(v32.name), + +drivers/gpu/drm/i915/intel_sprite.c:169: error: UNINITIALIZED_VALUE + The value read from scanline was never initialized. + 167. scanline = intel_get_crtc_scanline(crtc); + 168. + 169. > crtc->debug.scanline_start = scanline; + 170. crtc->debug.start_vbl_time = ktime_get(); + 171. crtc->debug.start_vbl_count = intel_crtc_get_vblank_counter(crtc); + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/clk.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(clk, clk_unprepare_complete, + 90. + 91. TP_PROTO(struct clk_core *core), + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect, + 90. TP_PROTO(const struct net_device *dev, + 91. const struct bpf_prog *xdp, + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +kernel/smp.c:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. init_llist_head(&per_cpu(call_single_queue, i)); + 95. + 96. > smpcfd_prepare_cpu(smp_processor_id()); + 97. } + 98. + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +lib/lockref.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int lockref_get_or_lock(struct lockref *lockref) + 90. { + 91. > CMPXCHG_LOOP( + 92. new.count++; + 93. if (old.count <= 0) + +security/keys/permission.c:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. int key_validate(const struct key *key) + 90. { + 91. > unsigned long flags = READ_ONCE(key->flags); + 92. time64_t expiry = READ_ONCE(key->expiry); + 93. + +security/keys/permission.c:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. { + 91. unsigned long flags = READ_ONCE(key->flags); + 92. > time64_t expiry = READ_ONCE(key->expiry); + 93. + 94. if (flags & (1 << KEY_FLAG_INVALIDATED)) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +sound/pci/hda/hda_controller_trace.h:89: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 87. ); + 88. + 89. > DEFINE_EVENT(azx_pcm, azx_pcm_prepare, + 90. TP_PROTO(struct azx *chip, struct azx_dev *azx_dev), + 91. TP_ARGS(chip, azx_dev) + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. ); + 89. + 90. > DEFINE_EVENT(regmap_block, regmap_hw_read_start, + 91. + 92. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/dma-buf/dma-fence-array.c:95: error: NULL_DEREFERENCE + pointer `array` last assigned on line 92 could be null and is dereferenced at line 95, column 18. + 93. unsigned i; + 94. + 95. > for (i = 0; i < array->num_fences; ++i) + 96. dma_fence_put(array->fences[i]); + 97. + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:90: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 88. * Allows to determine the timer latency. + 89. */ + 90. > TRACE_EVENT(timer_expire_entry, + 91. + 92. TP_PROTO(struct timer_list *timer), + +kernel/exit.c:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. u64 utime, stime; + 97. + 98. > sighand = rcu_dereference_check(tsk->sighand, + 99. lockdep_tasklist_lock_is_held()); + 100. spin_lock(&sighand->siglock); + +kernel/locking/osq_lock.c:169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 167. * true. + 168. */ + 169. > if (smp_load_acquire(&node->locked)) + 170. return true; + 171. + +kernel/locking/osq_lock.c:178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 176. * case its step-C will write us a new @node->prev pointer. + 177. */ + 178. > prev = READ_ONCE(node->prev); + 179. } + 180. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +kernel/locking/osq_lock.c:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. struct optimistic_spin_node *node = this_cpu_ptr(&osq_node); + 93. struct optimistic_spin_node *prev, *next; + 94. > int curr = encode_cpu(smp_processor_id()); + 95. int old; + 96. + +kernel/task_work.c:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. raw_spin_lock_irq(&task->pi_lock); + 101. do { + 102. > work = READ_ONCE(task->task_works); + 103. head = !work && (task->flags & PF_EXITING) ? + 104. &work_exited : NULL; + +net/ipv4/ip_options.c:178: error: UNINITIALIZED_VALUE + The value read from faddr was never initialized. + 176. } + 177. if (doffset > 3) { + 178. > dopt->faddr = faddr; + 179. dptr[0] = start[0]; + 180. dptr[1] = doffset+3; + +net/ipv4/tcp_minisocks.c:148: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 146. if (tmp_opt.saw_tstamp) { + 147. tcptw->tw_ts_recent_stamp = get_seconds(); + 148. > tcptw->tw_ts_recent = tmp_opt.rcv_tsval; + 149. } + 150. + +net/ipv4/tcp_minisocks.c:191: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 189. + 190. if (tmp_opt.saw_tstamp) { + 191. > tcptw->tw_ts_recent = tmp_opt.rcv_tsval; + 192. tcptw->tw_ts_recent_stamp = get_seconds(); + 193. } + +net/netfilter/nf_nat_sip.c:112: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 99 could be null and is dereferenced at line 112, column 13. + 110. ct->tuplehash[dir].tuple.dst.u.udp.port == port) { + 111. newaddr = ct->tuplehash[!dir].tuple.src.u3; + 112. > newport = ct_sip_info->forced_dport ? : + 113. ct->tuplehash[!dir].tuple.src.u.udp.port; + 114. } else + +drivers/gpu/drm/drm_hashtab.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. hashed_key = hash_long(key, ht->order); + 99. h_list = &ht->table[hashed_key]; + 100. > hlist_for_each_entry_rcu(entry, h_list, head) { + 101. if (entry->key == key) + 102. return &entry->head; + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/random.h:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. ); + 90. + 91. > TRACE_EVENT(push_to_pool, + 92. TP_PROTO(const char *pool_name, int pool_bits, int input_bits), + 93. + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:91: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 89. ); + 90. + 91. > DEFINE_EVENT(tcp_event_sk_skb, tcp_retransmit_skb, + 92. + 93. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:92: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 90. ); + 91. + 92. > DEFINE_EVENT(module_refcnt, module_get, + 93. + 94. TP_PROTO(struct module *mod, unsigned long ip), + +net/ipv4/xfrm4_protocol.c:99: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 97. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 98. + 99. > for_each_protocol_rcu(esp4_handlers, handler) + 100. if ((ret = handler->handler(skb)) != -EINVAL) + 101. return ret; + +drivers/gpu/drm/i915/dvo_tfp410.c:119: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 117. + 118. if (i2c_transfer(adapter, msgs, 2) == 2) { + 119. > *ch = in_buf[0]; + 120. return true; + 121. } + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. ); + 92. + 93. > TRACE_EVENT(g4x_wm, + 94. TP_PROTO(struct intel_crtc *crtc, const struct g4x_wm_values *wm), + 95. TP_ARGS(crtc, wm), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +include/trace/events/i2c.h:93: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 91. * __i2c_transfer() read reply + 92. */ + 93. > TRACE_EVENT_FN(i2c_reply, + 94. TP_PROTO(const struct i2c_adapter *adap, const struct i2c_msg *msg, + 95. int num), + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +kernel/trace/trace_clock.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. local_irq_save(flags); + 100. + 101. > this_cpu = raw_smp_processor_id(); + 102. now = sched_clock_cpu(this_cpu); + 103. /* + +net/ipv6/sit.c:104: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 102. int ifindex = dev ? dev->ifindex : 0; + 103. + 104. > for_each_ip_tunnel_rcu(t, sitn->tunnels_r_l[h0 ^ h1]) { + 105. if (local == t->parms.iph.saddr && + 106. remote == t->parms.iph.daddr && + +net/ipv6/sit.c:112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 110. return t; + 111. } + 112. > for_each_ip_tunnel_rcu(t, sitn->tunnels_r[h0]) { + 113. if (remote == t->parms.iph.daddr && + 114. (!dev || !t->parms.link || ifindex == t->parms.link || + +net/ipv6/sit.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. return t; + 118. } + 119. > for_each_ip_tunnel_rcu(t, sitn->tunnels_l[h1]) { + 120. if (local == t->parms.iph.saddr && + 121. (!dev || !t->parms.link || ifindex == t->parms.link || + +net/ipv6/sit.c:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. return t; + 125. } + 126. > t = rcu_dereference(sitn->tunnels_wc[0]); + 127. if (t && (t->dev->flags & IFF_UP)) + 128. return t; + +net/ipv6/xfrm6_protocol.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 99. + 100. > for_each_protocol_rcu(ah6_handlers, handler) + 101. if ((ret = handler->handler(skb)) != -EINVAL) + 102. return ret; + +drivers/tty/tty_jobctrl.c:105: error: MEMORY_LEAK + `tty->pgrp` is not reachable after line 105, column 2. + 103. put_pid(tty->session); + 104. put_pid(tty->pgrp); + 105. > tty->pgrp = get_pid(task_pgrp(current)); + 106. spin_unlock_irqrestore(&tty->ctrl_lock, flags); + 107. tty->session = get_pid(task_session(current)); + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:94: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 92. ); + 93. + 94. > DEFINE_EVENT(cgroup, cgroup_release, + 95. + 96. TP_PROTO(struct cgroup *cgroup), + +net/ipv4/tunnel4.c:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. goto drop; + 100. + 101. > for_each_tunnel_rcu(tunnel4_handlers, handler) + 102. if (!handler->handler(skb)) + 103. return 0; + +security/keys/request_key.c:99: error: DEAD_STORE + The value written to &cred (type cred const *) is never used. + 97. { + 98. static char const request_key[] = "/sbin/request-key"; + 99. > const struct cred *cred = current_cred(); + 100. key_serial_t prkey, sskey; + 101. struct key *key = cons->key, *authkey = cons->authkey, *keyring, + +security/keys/request_key.c:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. + 148. rcu_read_lock(); + 149. > session = rcu_dereference(cred->session_keyring); + 150. if (!session) + 151. session = cred->user->session_keyring; + +security/selinux/netport.c:100: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 98. + 99. idx = sel_netport_hashfn(pnum); + 100. > list_for_each_entry_rcu(port, &sel_netport_hash[idx].list, list) + 101. if (port->psec.port == pnum && port->psec.protocol == protocol) + 102. return port; + +drivers/gpu/drm/i915/i915_gem_batch_pool.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. * than replace the existing fence. + 132. */ + 133. > if (rcu_access_pointer(resv->fence)) { + 134. reservation_object_lock(resv, NULL); + 135. reservation_object_add_excl_fence(resv, NULL); + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:95: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 93. * i2c_smbus_xfer() read data request + 94. */ + 95. > TRACE_EVENT_CONDITION(smbus_read, + 96. TP_PROTO(const struct i2c_adapter *adap, + 97. u16 addr, unsigned short flags, + +net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c:114: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 112. + 113. /* rcu_read_lock()ed by nf_hook_thresh */ + 114. > helper = rcu_dereference(help->helper); + 115. if (!helper) + 116. return NF_ACCEPT; + +drivers/gpu/drm/i915/i915_gem_context.c:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. rcu_read_lock(); + 108. radix_tree_for_each_slot(slot, &ctx->handles_vma, &iter, 0) { + 109. > struct i915_vma *vma = rcu_dereference_raw(*slot); + 110. + 111. radix_tree_iter_delete(&ctx->handles_vma, &iter, slot); + +drivers/scsi/scsi_logging.c:115: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 113. if (!WARN_ON(off >= logbuf_len)) { + 114. va_start(args, fmt); + 115. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 116. va_end(args); + 117. } + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +include/trace/events/sched.h:96: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 94. * It it not always called from the waking context. + 95. */ + 96. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup, + 97. TP_PROTO(struct task_struct *p), + 98. TP_ARGS(p)); + +net/ipv4/ip_tunnel.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. head = &itn->tunnels[hash]; + 107. + 108. > hlist_for_each_entry_rcu(t, head, hash_node) { + 109. if (local != t->parms.iph.saddr || + 110. remote != t->parms.iph.daddr || + +net/ipv4/ip_tunnel.c:123: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 121. } + 122. + 123. > hlist_for_each_entry_rcu(t, head, hash_node) { + 124. if (remote != t->parms.iph.daddr || + 125. t->parms.iph.saddr != 0 || + +net/ipv4/ip_tunnel.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. head = &itn->tunnels[hash]; + 140. + 141. > hlist_for_each_entry_rcu(t, head, hash_node) { + 142. if ((local != t->parms.iph.saddr || t->parms.iph.daddr != 0) && + 143. (local != t->parms.iph.daddr || !ipv4_is_multicast(local))) + +net/ipv4/ip_tunnel.c:161: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 159. goto skip_key_lookup; + 160. + 161. > hlist_for_each_entry_rcu(t, head, hash_node) { + 162. if (t->parms.i_key != key || + 163. t->parms.iph.saddr != 0 || + +net/ipv4/ip_tunnel.c:178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 176. return cand; + 177. + 178. > t = rcu_dereference(itn->collect_md_tun); + 179. if (t && t->dev->flags & IFF_UP) + 180. return t; + +net/ipv6/inet6_hashtables.c:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. score++; + 120. } + 121. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 122. score++; + 123. } + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(regmap_block, regmap_hw_read_done, + 98. + 99. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/signal.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. * matching generated signals and delivered signals may not be correct. + 96. */ + 97. > TRACE_EVENT(signal_deliver, + 98. + 99. TP_PROTO(int sig, struct siginfo *info, struct k_sigaction *ka), + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:97: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 95. ); + 96. + 97. > DEFINE_EVENT(xdp_redirect_template, xdp_redirect_err, + 98. TP_PROTO(const struct net_device *dev, + 99. const struct bpf_prog *xdp, + +net/ipv4/inetpeer.c:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. int cmp; + 112. + 113. > next = rcu_dereference_raw(*pp); + 114. if (!next) + 115. break; + +net/netfilter/nf_conntrack_core.c:105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 103. * It pairs with the smp_store_release() in nf_conntrack_all_unlock() + 104. */ + 105. > if (likely(smp_load_acquire(&nf_conntrack_locks_all) == false)) + 106. return; + 107. + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +arch/x86/lib/msr-smp.c:110: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 108. rv.msr_no = msr_no; + 109. + 110. > this_cpu = get_cpu(); + 111. + 112. if (cpumask_test_cpu(this_cpu, mask)) + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +block/blk-softirq.c:108: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 106. + 107. local_irq_save(flags); + 108. > cpu = smp_processor_id(); + 109. + 110. /* + +include/net/busy_poll.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. { + 101. #ifdef CONFIG_NET_RX_BUSY_POLL + 102. > unsigned long bp_usec = READ_ONCE(sk->sk_ll_usec); + 103. + 104. if (bp_usec) { + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +include/ras/ras_event.h:98: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 96. * Default error mechanisms for Memory Controller errors (CE and UE) + 97. */ + 98. > TRACE_EVENT(mc_event, + 99. + 100. TP_PROTO(const unsigned int err_type, + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +lib/iommu-common.c:105: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 103. unsigned int align_order) + 104. { + 105. > unsigned int pool_hash = __this_cpu_read(iommu_hash_common); + 106. unsigned long n, end, start, limit, boundary_size; + 107. struct iommu_pool *pool; + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +net/core/netpoll.c:123: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 121. } + 122. txq = netdev_get_tx_queue(dev, q_index); + 123. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 124. if (netif_xmit_frozen_or_stopped(txq) || + 125. netpoll_start_xmit(skb, dev, txq) != NETDEV_TX_OK) { + +net/ipv6/netfilter/nf_conntrack_l3proto_ipv6.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. return NF_ACCEPT; + 118. /* rcu_read_lock()ed by nf_hook_thresh */ + 119. > helper = rcu_dereference(help->helper); + 120. if (!helper) + 121. return NF_ACCEPT; + +drivers/char/agp/frontend.c:112: error: DEAD_STORE + The value written to &num_segments (type int) is never used. + 110. pg_count = size / 4096; + 111. seg = *(client->segments); + 112. > num_segments = client->num_segments; + 113. + 114. for (i = 0; i < client->num_segments; i++) { + +drivers/md/dm-kcopyd.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. spin_lock_irq(&throttle_spinlock); + 109. + 110. > throttle = READ_ONCE(t->throttle); + 111. + 112. if (likely(throttle >= 100)) + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +include/trace/events/module.h:99: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 97. ); + 98. + 99. > DEFINE_EVENT(module_refcnt, module_put, + 100. + 101. TP_PROTO(struct module *mod, unsigned long ip), + +kernel/rcu/rcu.h:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. static inline unsigned long rcu_seq_current(unsigned long *sp) + 100. { + 101. > return READ_ONCE(*sp); + 102. } + 103. + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +kernel/time/tick-common.c:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. void tick_handle_periodic(struct clock_event_device *dev) + 100. { + 101. > int cpu = smp_processor_id(); + 102. ktime_t next = dev->next_event; + 103. + +drivers/gpu/drm/i915/intel_dp_mst.c:110: error: NULL_DEREFERENCE + pointer `old_conn_state` last assigned on line 109 could be null and is dereferenced at line 110, column 13. + 108. + 109. old_conn_state = drm_atomic_get_old_connector_state(state, connector); + 110. > old_crtc = old_conn_state->crtc; + 111. if (!old_crtc) + 112. return ret; + +kernel/sched/cpuacct.c:104: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 102 could be null and is dereferenced at line 104, column 14. + 102. struct cpuacct *ca = css_ca(css); + 103. + 104. > free_percpu(ca->cpustat); + 105. free_percpu(ca->cpuusage); + 106. kfree(ca); + +drivers/pci/vc.c:150: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 148. if (ctrl2 & PCI_VC_RES_CTRL_ENABLE) { + 149. ctrl2 &= ~PCI_VC_RES_CTRL_ENABLE; + 150. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 151. } + 152. + +drivers/pci/vc.c:155: error: UNINITIALIZED_VALUE + The value read from ctrl_pos2 was never initialized. + 153. /* Enable on both ends */ + 154. ctrl2 |= PCI_VC_RES_CTRL_ENABLE; + 155. > pci_write_config_dword(link, ctrl_pos2, ctrl2); + 156. enable: + 157. ctrl |= PCI_VC_RES_CTRL_ENABLE; + +drivers/pci/vc.c:163: error: UNINITIALIZED_VALUE + The value read from status_pos2 was never initialized. + 161. pci_err(dev, "VC%d negotiation stuck pending\n", id); + 162. + 163. > if (link && !pci_wait_for_pending(link, status_pos2, + 164. PCI_VC_RES_STATUS_NEGO)) + 165. pci_err(link, "VC%d negotiation stuck pending\n", id); + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +include/trace/events/cgroup.h:101: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 99. ); + 100. + 101. > DEFINE_EVENT(cgroup, cgroup_rename, + 102. + 103. TP_PROTO(struct cgroup *cgroup), + +net/netfilter/nf_queue.c:106: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 104. + 105. rcu_read_lock(); + 106. > qh = rcu_dereference(net->nf.queue_handler); + 107. if (qh) + 108. qh->nf_hook_drop(net); + +net/netfilter/nfnetlink.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. return NULL; + 107. + 108. > return rcu_dereference(table[subsys_id].subsys); + 109. } + 110. + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/rcu.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. * "CleanupMore": Clean up, and another no-CB GP is needed. + 101. */ + 102. > TRACE_EVENT(rcu_future_grace_period, + 103. + 104. TP_PROTO(const char *rcuname, unsigned long gpnum, unsigned long completed, + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +include/trace/events/tcp.h:102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 100. * active reset, skb should be NULL + 101. */ + 102. > DEFINE_EVENT(tcp_event_sk_skb, tcp_send_reset, + 103. + 104. TP_PROTO(const struct sock *sk, const struct sk_buff *skb), + +net/ipv4/datagram.c:118: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 116. return; + 117. } + 118. > inet_opt = rcu_dereference(inet->inet_opt); + 119. if (inet_opt && inet_opt->opt.srr) + 120. daddr = inet_opt->opt.faddr; + +arch/x86/include/asm/mmu_context.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. + 108. /* READ_ONCE synchronizes with smp_store_release */ + 109. > ldt = READ_ONCE(mm->context.ldt); + 110. + 111. /* + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +include/trace/events/sched.h:103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 101. * Tracepoint for waking up a new task: + 102. */ + 103. > DEFINE_EVENT(sched_wakeup_template, sched_wakeup_new, + 104. TP_PROTO(struct task_struct *p), + 105. TP_ARGS(p)); + +net/ipv4/netfilter/nf_reject_ipv4.c:128: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 126. + 127. skb_reserve(nskb, LL_MAX_HEADER); + 128. > niph = nf_reject_iphdr_put(nskb, oldskb, IPPROTO_TCP, + 129. ip4_dst_hoplimit(skb_dst(nskb))); + 130. nf_reject_ip_tcphdr_put(nskb, oldskb, oth); + +net/ipv4/netfilter/nf_reject_ipv4.c:135: error: DEAD_STORE + The value written to &niph (type iphdr*) is never used. + 133. goto free_nskb; + 134. + 135. > niph = ip_hdr(nskb); + 136. + 137. /* "Never happens" */ + +net/netfilter/nfnetlink_log.c:110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 108. + 109. head = &log->instance_table[instance_hashfn(group_num)]; + 110. > hlist_for_each_entry_rcu(inst, head, hlist) { + 111. if (inst->group_num == group_num) + 112. return inst; + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:104: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 102. ); + 103. + 104. > DEFINE_EVENT(regmap_block, regmap_hw_write_start, + 105. + 106. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/gpu/drm/drm_lock.c:114: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 112. old = *lock; + 113. new = context | _DRM_LOCK_HELD; + 114. > prev = cmpxchg(lock, old, new); + 115. } while (prev != old); + 116. return 1; + +drivers/pps/pps.c:227: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 225. /* Check for supported capabilities */ + 226. if ((bind_args.edge & ~pps->info.mode) != 0) { + 227. > dev_err(pps->dev, "unsupported capabilities (%x)\n", + 228. bind_args.edge); + 229. return -EINVAL; + +drivers/pps/pps.c:236: error: UNINITIALIZED_VALUE + The value read from bind_args.edge was never initialized. + 234. (bind_args.edge & ~PPS_CAPTUREBOTH) != 0 || + 235. bind_args.consumer != PPS_KC_HARDPPS) { + 236. > dev_err(pps->dev, "invalid kernel consumer bind" + 237. " parameters (%x)\n", bind_args.edge); + 238. return -EINVAL; + +drivers/pps/pps.c:141: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 139. return -EFAULT; + 140. if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) { + 141. > dev_dbg(pps->dev, "capture mode unspecified (%x)\n", + 142. params.mode); + 143. return -EINVAL; + +drivers/pps/pps.c:148: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 146. /* Check for supported capabilities */ + 147. if ((params.mode & ~pps->info.mode) != 0) { + 148. > dev_dbg(pps->dev, "unsupported capabilities (%x)\n", + 149. params.mode); + 150. return -EINVAL; + +drivers/pps/pps.c:161: error: UNINITIALIZED_VALUE + The value read from params.mode was never initialized. + 159. if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) { + 160. /* section 3.3 of RFC 2783 interpreted */ + 161. > dev_dbg(pps->dev, "time format unspecified (%x)\n", + 162. params.mode); + 163. pps->params.mode |= PPS_TSFMT_TSPEC; + +include/linux/rbtree_latch.h:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. int (*comp)(void *key, struct latch_tree_node *node)) + 107. { + 108. > struct rb_node *node = rcu_dereference_raw(ltr->tree[idx].rb_node); + 109. struct latch_tree_node *ltn; + 110. int c; + +include/linux/rbtree_latch.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. + 116. if (c < 0) + 117. > node = rcu_dereference_raw(node->rb_left); + 118. else if (c > 0) + 119. node = rcu_dereference_raw(node->rb_right); + +include/linux/rbtree_latch.h:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. node = rcu_dereference_raw(node->rb_left); + 118. else if (c > 0) + 119. > node = rcu_dereference_raw(node->rb_right); + 120. else + 121. return ltn; + +drivers/pnp/support.c:126: error: DEAD_STORE + The value written to &len (type int) is never used. + 124. case IORESOURCE_IO: + 125. port = &option->u.port; + 126. > len += scnprintf(buf + len, sizeof(buf) - len, "io min %#llx " + 127. "max %#llx align %lld size %lld flags %#x", + 128. (unsigned long long) port->min, + +drivers/pnp/support.c:135: error: DEAD_STORE + The value written to &len (type int) is never used. + 133. case IORESOURCE_MEM: + 134. mem = &option->u.mem; + 135. > len += scnprintf(buf + len, sizeof(buf) - len, "mem min %#llx " + 136. "max %#llx align %lld size %lld flags %#x", + 137. (unsigned long long) mem->min, + +drivers/pnp/support.c:158: error: DEAD_STORE + The value written to &len (type int) is never used. + 156. irq->flags); + 157. if (irq->flags & IORESOURCE_IRQ_OPTIONAL) + 158. > len += scnprintf(buf + len, sizeof(buf) - len, + 159. " (optional)"); + 160. break; + +drivers/pnp/support.c:174: error: DEAD_STORE + The value written to &len (type int) is never used. + 172. " %d", i); + 173. } + 174. > len += scnprintf(buf + len, sizeof(buf) - len, " (bitmask %#x) " + 175. "flags %#x", dma->map, dma->flags); + 176. break; + +kernel/cgroup/freezer.c:108: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 107 could be null and is dereferenced by call to `parent_freezer()` at line 108, column 27. + 106. { + 107. struct freezer *freezer = css_freezer(css); + 108. > struct freezer *parent = parent_freezer(freezer); + 109. + 110. mutex_lock(&freezer_mutex); + +drivers/tty/serial/serial_core.c:115: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 113. if (port) + 114. port->ops->stop_tx(port); + 115. > uart_port_unlock(port, flags); + 116. } + 117. + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:106: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 104. ); + 105. + 106. > DEFINE_EVENT(irq_matrix_global, irq_matrix_online, + 107. + 108. TP_PROTO(struct irq_matrix *matrix), + +kernel/smp.c:108: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 106. static __always_inline void csd_lock_wait(call_single_data_t *csd) + 107. { + 108. > smp_cond_load_acquire(&csd->flags, !(VAL & CSD_FLAG_LOCK)); + 109. } + 110. + +kernel/smpboot.c:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. preempt_enable(); + 127. if (ht->park && td->status == HP_THREAD_ACTIVE) { + 128. > BUG_ON(td->cpu != smp_processor_id()); + 129. ht->park(td->cpu); + 130. td->status = HP_THREAD_PARKED; + +kernel/smpboot.c:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. } + 136. + 137. > BUG_ON(td->cpu != smp_processor_id()); + 138. + 139. /* Check for state change setup */ + +net/core/sysctl_net_core.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. for_each_possible_cpu(i) { + 158. sd = &per_cpu(softnet_data, i); + 159. > if (rcu_dereference(sd->flow_limit)) + 160. cpumask_set_cpu(i, mask); + 161. } + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +include/trace/events/module.h:107: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 105. #endif /* CONFIG_MODULE_UNLOAD */ + 106. + 107. > TRACE_EVENT(module_request, + 108. + 109. TP_PROTO(char *name, bool wait, unsigned long ip), + +kernel/locking/rtmutex_common.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. static inline struct task_struct *rt_mutex_owner(struct rt_mutex *lock) + 108. { + 109. > unsigned long owner = (unsigned long) READ_ONCE(lock->owner); + 110. + 111. return (struct task_struct *) (owner & ~RT_MUTEX_HAS_WAITERS); + +net/ipv4/tcp_ulp.c:114: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 112. *buf = '\0'; + 113. rcu_read_lock(); + 114. > list_for_each_entry_rcu(ulp_ops, &tcp_ulp_list, list) { + 115. offs += snprintf(buf + offs, maxlen - offs, + 116. "%s%s", + +drivers/pci/pci-acpi.c:119: error: UNINITIALIZED_VALUE + The value read from mcfg_addr was never initialized. + 117. return 0; + 118. + 119. > return (phys_addr_t)mcfg_addr; + 120. } + 121. + +include/linux/seqlock.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. + 112. repeat: + 113. > ret = READ_ONCE(s->sequence); + 114. if (unlikely(ret & 1)) { + 115. cpu_relax(); + +kernel/trace/trace_events_trigger.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct event_trigger_data *data; + 114. + 115. > list_for_each_entry_rcu(data, &file->triggers, list) { + 116. if (data->paused) + 117. continue; + +net/netfilter/nf_conntrack_irc.c:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. IPPROTO_TCP, NULL, &port); + 211. + 212. > nf_nat_irc = rcu_dereference(nf_nat_irc_hook); + 213. if (nf_nat_irc && ct->status & IPS_NAT_MASK) + 214. ret = nf_nat_irc(skb, ctinfo, protoff, + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +include/trace/events/iommu.h:109: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 107. ); + 108. + 109. > TRACE_EVENT(unmap, + 110. + 111. TP_PROTO(unsigned long iova, size_t size, size_t unmapped_size), + +lib/hexdump.c:205: error: DEAD_STORE + The value written to &lx (type int) is never used. + 203. return lx; + 204. overflow2: + 205. > linebuf[lx++] = '\0'; + 206. overflow1: + 207. return ascii ? ascii_column + len : (groupsize * 2 + 1) * ngroups - 1; + +net/ipv4/xfrm4_protocol.c:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. struct xfrm4_protocol *handler; + 112. + 113. > for_each_protocol_rcu(esp4_handlers, handler) + 114. if (!handler->err_handler(skb, info)) + 115. break; + +net/xfrm/xfrm_policy.c:116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 114. return NULL; + 115. rcu_read_lock(); + 116. > afinfo = rcu_dereference(xfrm_policy_afinfo[family]); + 117. if (unlikely(!afinfo)) + 118. rcu_read_unlock(); + +net/ipv6/af_inet6.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. err = -ESOCKTNOSUPPORT; + 128. rcu_read_lock(); + 129. > list_for_each_entry_rcu(answer, &inetsw6[sock->type], list) { + 130. + 131. err = 0; + +net/ipv6/xfrm6_protocol.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct xfrm6_protocol *handler; + 114. + 115. > for_each_protocol_rcu(ah6_handlers, handler) + 116. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 117. break; + +net/netlabel/netlabel_addrlist.c:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. struct netlbl_af6list *iter; + 114. + 115. > list_for_each_entry_rcu(iter, head, list) + 116. if (iter->valid && + 117. ipv6_masked_addr_cmp(&iter->addr, &iter->mask, addr) == 0) + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. ); + 110. + 111. > DEFINE_EVENT(regmap_block, regmap_hw_write_done, + 112. + 113. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/pci/proc.c:173: error: DEAD_STORE + The value written to &buf (type char const *) is never used. + 171. __get_user(val, buf); + 172. pci_user_write_config_byte(dev, pos, val); + 173. > buf++; + 174. pos++; + 175. cnt--; + +drivers/pci/proc.c:175: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 173. buf++; + 174. pos++; + 175. > cnt--; + 176. } + 177. + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:111: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 109. trace_xdp_redirect_err(dev, xdp, to, err, NULL, 0); + 110. + 111. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map, + 112. TP_PROTO(const struct net_device *dev, + 113. const struct bpf_prog *xdp, + +kernel/time/tick-oneshot.c:117: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 115. + 116. local_irq_save(flags); + 117. > ret = __this_cpu_read(tick_cpu_device.mode) == TICKDEV_MODE_ONESHOT; + 118. local_irq_restore(flags); + 119. + +net/netfilter/nf_conntrack_standalone.c:119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 117. st->bucket < st->htable_size; + 118. st->bucket++) { + 119. > n = rcu_dereference( + 120. hlist_nulls_first_rcu(&st->hash[st->bucket])); + 121. if (!is_a_nulls(n)) + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +include/trace/events/workqueue.h:112: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 110. * Allows to track workqueue execution. + 111. */ + 112. > DEFINE_EVENT(workqueue_work, workqueue_execute_end, + 113. + 114. TP_PROTO(struct work_struct *work), + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +kernel/panic.c:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. int old_cpu, cpu; + 115. + 116. > cpu = raw_smp_processor_id(); + 117. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, cpu); + 118. + +net/ipv6/xfrm6_mode_tunnel.c:116: error: NULL_DEREFERENCE + pointer `xo` last assigned on line 114 could be null and is dereferenced at line 116, column 6. + 114. struct xfrm_offload *xo = xfrm_offload(skb); + 115. + 116. > if (xo->flags & XFRM_GSO_SEGMENT) + 117. skb->transport_header = skb->network_header + sizeof(struct ipv6hdr); + 118. + +net/sched/act_api.c:121: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 119. struct idr *idr = &idrinfo->action_idr; + 120. struct tc_action *p; + 121. > unsigned long id = 1; + 122. + 123. spin_lock_bh(&idrinfo->lock); + +arch/x86/include/asm/syscall.h:138: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 136. case 5: + 137. if (!n--) break; + 138. > *args++ = regs->bp; + 139. case 6: + 140. if (!n--) break; + +arch/x86/include/asm/syscall.h:165: error: DEAD_STORE + The value written to &args (type unsigned long*) is never used. + 163. case 5: + 164. if (!n--) break; + 165. > *args++ = regs->r9; + 166. case 6: + 167. if (!n--) break; + +arch/x86/include/asm/syscall.h:140: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 138. *args++ = regs->bp; + 139. case 6: + 140. > if (!n--) break; + 141. default: + 142. BUG(); + +arch/x86/include/asm/syscall.h:167: error: DEAD_STORE + The value written to &n (type unsigned int) is never used. + 165. *args++ = regs->r9; + 166. case 6: + 167. > if (!n--) break; + 168. default: + 169. BUG(); + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > DEFINE_EVENT(irq_matrix_global, irq_matrix_offline, + 114. + 115. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +include/trace/events/random.h:113: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 111. ); + 112. + 113. > TRACE_EVENT(debit_entropy, + 114. TP_PROTO(const char *pool_name, int debit_bits), + 115. + +net/core/sock_reuseport.c:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. struct sock_reuseport *old_reuse, *reuse; + 116. + 117. > if (!rcu_access_pointer(sk2->sk_reuseport_cb)) { + 118. int err = reuseport_alloc(sk2); + 119. + +net/ipv4/tunnel4.c:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. goto drop; + 119. + 120. > for_each_tunnel_rcu(tunnel64_handlers, handler) + 121. if (!handler->handler(skb)) + 122. return 0; + +net/ipv6/udp.c:157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 155. } + 156. + 157. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 158. score++; + 159. + +drivers/iommu/dmar.c:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. + 119. if (*devices && *cnt) { + 120. > for_each_active_dev_scope(*devices, *cnt, i, tmp_dev) + 121. put_device(tmp_dev); + 122. kfree(*devices); + +include/net/busy_poll.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. { + 116. #ifdef CONFIG_NET_RX_BUSY_POLL + 117. > unsigned int napi_id = READ_ONCE(sk->sk_napi_id); + 118. + 119. if (napi_id >= MIN_NAPI_ID) + +net/ipv4/tcp_fastopen.c:122: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 120. rcu_read_lock(); + 121. + 122. > ctx = rcu_dereference(inet_csk(sk)->icsk_accept_queue.fastopenq.ctx); + 123. if (!ctx) + 124. ctx = rcu_dereference(sock_net(sk)->ipv4.tcp_fastopen_ctx); + +net/ipv4/tcp_fastopen.c:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. ctx = rcu_dereference(inet_csk(sk)->icsk_accept_queue.fastopenq.ctx); + 123. if (!ctx) + 124. > ctx = rcu_dereference(sock_net(sk)->ipv4.tcp_fastopen_ctx); + 125. + 126. if (ctx) { + +security/selinux/netnode.c:131: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 129. } + 130. + 131. > list_for_each_entry_rcu(node, &sel_netnode_hash[idx].list, list) + 132. if (node->nsec.family == family) + 133. switch (family) { + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 113. ); + 114. + 115. > DEFINE_EVENT(clk_rate, clk_set_rate, + 116. + 117. TP_PROTO(struct clk_core *core, unsigned long rate), + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +ipc/syscall.c:155: error: UNINITIALIZED_VALUE + The value read from ipck.msgtyp was never initialized. + 153. if (copy_from_user(&ipck, uptr, sizeof(ipck))) + 154. return -EFAULT; + 155. > return compat_sys_msgrcv(first, ipck.msgp, second, + 156. ipck.msgtyp, third); + 157. } + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +kernel/irq_work.c:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. + 126. /* All work should have been flushed before going offline */ + 127. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 128. + 129. return true; + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +lib/lockref.c:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. int lockref_put_return(struct lockref *lockref) + 116. { + 117. > CMPXCHG_LOOP( + 118. new.count--; + 119. if (old.count <= 0) + +net/netfilter/nf_conntrack_helper.c:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. + 125. h = helper_hash(tuple); + 126. > hlist_for_each_entry_rcu(helper, &nf_ct_helper_hash[h], hnode) { + 127. if (nf_ct_tuple_src_mask_cmp(tuple, &helper->tuple, &mask)) + 128. return helper; + +net/netfilter/nf_conntrack_proto.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. return &nf_conntrack_l4proto_generic; + 120. + 121. > return rcu_dereference(nf_ct_protos[l3proto][l4proto]); + 122. } + 123. EXPORT_SYMBOL_GPL(__nf_ct_l4proto_find); + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +include/trace/events/block.h:116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 114. * additional work required to complete the request. + 115. */ + 116. > TRACE_EVENT(block_rq_complete, + 117. + 118. TP_PROTO(struct request *rq, int error, unsigned int nr_bytes), + +kernel/events/ring_buffer.c:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. event = event->parent; + 136. + 137. > rb = rcu_dereference(event->rb); + 138. if (unlikely(!rb)) + 139. goto out; + +kernel/events/ring_buffer.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. + 159. do { + 160. > tail = READ_ONCE(rb->user_page->data_tail); + 161. offset = head = local_read(&rb->head); + 162. if (!rb->overwrite) { + +kernel/sched/membarrier.c:165: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 163. * iteration. + 164. */ + 165. > if (cpu == raw_smp_processor_id()) + 166. continue; + 167. rcu_read_lock(); + +lib/rhashtable.c:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. int i; + 123. + 124. > ntbl = rcu_dereference(*prev); + 125. if (ntbl) + 126. return ntbl; + +arch/x86/pci/mmconfig-shared.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. struct pci_mmcfg_region *cfg; + 120. + 121. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) + 122. if (cfg->segment == segment && + 123. cfg->start_bus <= bus && bus <= cfg->end_bus) + +include/linux/ptrace.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. { + 119. if (unlikely(task->ptrace)) + 120. > return rcu_dereference(task->parent); + 121. return NULL; + 122. } + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +include/trace/events/sock.h:117: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 115. ); + 116. + 117. > TRACE_EVENT(inet_sock_set_state, + 118. + 119. TP_PROTO(const struct sock *sk, const int oldstate, const int newstate), + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +kernel/time/tick-sched.c:119: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 117. static void tick_sched_do_timer(ktime_t now) + 118. { + 119. > int cpu = smp_processor_id(); + 120. + 121. #ifdef CONFIG_NO_HZ_COMMON + +net/netfilter/nf_conntrack_expect.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. + 128. h = nf_ct_expect_dst_hash(net, tuple); + 129. > hlist_for_each_entry_rcu(i, &nf_ct_expect_hash[h], hnode) { + 130. if (nf_ct_exp_equal(tuple, i, zone, net)) + 131. return i; + +block/partition-generic.c:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. int cpu; + 125. + 126. > cpu = part_stat_lock(); + 127. part_round_stats(q, cpu, p); + 128. part_stat_unlock(); + +block/partition-generic.c:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. int cpu; + 125. + 126. > cpu = part_stat_lock(); + 127. part_round_stats(q, cpu, p); + 128. part_stat_unlock(); + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/base/regmap/trace.h:118: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 116. ); + 117. + 118. > TRACE_EVENT(regcache_sync, + 119. + 120. TP_PROTO(struct regmap *map, const char *type, + +drivers/gpu/drm/i915/intel_dsi.c:136: error: DEAD_STORE + The value written to &data (type unsigned char const *) is never used. + 134. + 135. header = packet.header; + 136. > data = packet.payload; + 137. + 138. if (msg->flags & MIPI_DSI_MSG_USE_LPM) { + +net/ipv4/xfrm4_protocol.c:125: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 123. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 124. + 125. > for_each_protocol_rcu(ah4_handlers, handler) + 126. if ((ret = handler->handler(skb)) != -EINVAL) + 127. return ret; + +net/ipv6/inet6_connection_sock.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. fl6.daddr = sk->sk_v6_daddr; + 138. + 139. > res = ip6_xmit(sk, skb, &fl6, sk->sk_mark, rcu_dereference(np->opt), + 140. np->tclass); + 141. rcu_read_unlock(); + +net/netlabel/netlabel_domainhash.c:129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 127. for (iter = 0, val = 0, len = strlen(key); iter < len; iter++) + 128. val = (val << 4 | (val >> (8 * sizeof(u32) - 4))) ^ key[iter]; + 129. > return val & (netlbl_domhsh_rcu_deref(netlbl_domhsh)->size - 1); + 130. } + 131. + +drivers/gpu/drm/drm_lock.c:137: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 135. old = *lock; + 136. new = _DRM_LOCKING_CONTEXT(old); + 137. > prev = cmpxchg(lock, old, new); + 138. } while (prev != old); + 139. + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.chan was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:270: error: UNINITIALIZED_VALUE + The value read from pd.func was never initialized. + 268. if (mutex_lock_interruptible(&ptp->pincfg_mux)) + 269. return -ERESTARTSYS; + 270. > err = ptp_set_pinfunc(ptp, pin_index, pd.func, pd.chan); + 271. mutex_unlock(&ptp->pincfg_mux); + 272. break; + +drivers/ptp/ptp_chardev.c:245: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 243. break; + 244. } + 245. > pin_index = pd.index; + 246. if (pin_index >= ops->n_pins) { + 247. err = -EINVAL; + +drivers/ptp/ptp_chardev.c:263: error: UNINITIALIZED_VALUE + The value read from pd.index was never initialized. + 261. break; + 262. } + 263. > pin_index = pd.index; + 264. if (pin_index >= ops->n_pins) { + 265. err = -EINVAL; + +kernel/irq/spurious.c:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. goto out; + 126. + 127. > irq_poll_cpu = smp_processor_id(); + 128. + 129. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. goto out; + 126. + 127. > irq_poll_cpu = smp_processor_id(); + 128. + 129. for_each_irq_desc(i, desc) { + +lib/errseq.c:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. errseq_t errseq_sample(errseq_t *eseq) + 120. { + 121. > errseq_t old = READ_ONCE(*eseq); + 122. errseq_t new = old; + 123. + +net/ipv4/fib_frontend.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. + 129. head = &net->ipv4.fib_table_hash[h]; + 130. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 131. if (tb->tb_id == id) + 132. return tb; + +drivers/scsi/scsi_transport_spi.c:143: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 141. break; + 142. } + 143. > return result; + 144. } + 145. + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ); + 119. + 120. > DEFINE_EVENT(irq_matrix_global, irq_matrix_reserve, + 121. + 122. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:120: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 118. ) + 119. + 120. > DEFINE_EVENT(net_dev_template, net_dev_queue, + 121. + 122. TP_PROTO(struct sk_buff *skb), + +net/ipv6/tcp_ipv6.c:198: error: UNINITIALIZED_VALUE + The value read from fl6.flowlabel was never initialized. + 196. + 197. sk->sk_v6_daddr = usin->sin6_addr; + 198. > np->flow_label = fl6.flowlabel; + 199. + 200. /* + +net/ipv6/xfrm6_protocol.c:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip6 = NULL; + 126. + 127. > for_each_protocol_rcu(ipcomp6_handlers, handler) + 128. if ((ret = handler->handler(skb)) != -EINVAL) + 129. return ret; + +net/sunrpc/clnt.c:147: error: UNINITIALIZED_VALUE + The value read from dentry was never initialized. + 145. } + 146. dput(dir); + 147. > return dentry; + 148. } + 149. + +sound/core/info.c:130: error: DEAD_STORE + The value written to &offset (type long long) is never used. + 128. mutex_lock(&entry->access); + 129. if (entry->c.ops->llseek) { + 130. > offset = entry->c.ops->llseek(entry, + 131. data->file_private_data, + 132. file, offset, orig); + +block/blk-mq.h:129: error: DEAD_STORE + The value written to &new_val (type unsigned long long) is never used. + 127. if (state == MQ_RQ_IN_FLIGHT) { + 128. WARN_ON_ONCE((old_val & MQ_RQ_STATE_MASK) != MQ_RQ_IDLE); + 129. > new_val += MQ_RQ_GEN_INC; + 130. } + 131. + +block/blk-mq.h:124: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 122. enum mq_rq_state state) + 123. { + 124. > u64 old_val = READ_ONCE(rq->gstate); + 125. u64 new_val = (old_val & ~MQ_RQ_STATE_MASK) | state; + 126. + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:121: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 119. * be invalid. We solely track the pointer. + 120. */ + 121. > DEFINE_EVENT(timer_class, timer_expire_exit, + 122. + 123. TP_PROTO(struct timer_list *timer), + +drivers/base/devtmpfs.c:148: error: UNINITIALIZED_VALUE + The value read from req.err was never initialized. + 146. + 147. kfree(tmp); + 148. > return req.err; + 149. } + 150. + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +include/trace/events/clk.h:122: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 120. ); + 121. + 122. > DEFINE_EVENT(clk_rate, clk_set_rate_complete, + 123. + 124. TP_PROTO(struct clk_core *core, unsigned long rate), + +arch/x86/entry/vsyscall/vsyscall_64.c:208: error: UNINITIALIZED_VALUE + The value read from syscall_nr was never initialized. + 206. * here doesn't matter. + 207. */ + 208. > regs->orig_ax = syscall_nr; + 209. regs->ax = -ENOSYS; + 210. tmp = secure_computing(NULL); + +drivers/scsi/scsi_logging.c:140: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 138. if (off < logbuf_len) { + 139. va_start(args, fmt); + 140. > off += vscnprintf(logbuf + off, logbuf_len - off, fmt, args); + 141. va_end(args); + 142. } + +kernel/compat.c:134: error: UNINITIALIZED_VALUE + The value read from ts.tv_nsec was never initialized. + 132. + 133. ts64->tv_sec = ts.tv_sec; + 134. > ts64->tv_nsec = ts.tv_nsec; + 135. + 136. return 0; + +kernel/compat.c:133: error: UNINITIALIZED_VALUE + The value read from ts.tv_sec was never initialized. + 131. return -EFAULT; + 132. + 133. > ts64->tv_sec = ts.tv_sec; + 134. ts64->tv_nsec = ts.tv_nsec; + 135. + +net/ipv6/xfrm6_policy.c:165: error: DEAD_STORE + The value written to &exthdr (type ipv6_opt_hdr*) is never used. + 163. offset += ipv6_optlen(exthdr); + 164. nexthdr = exthdr->nexthdr; + 165. > exthdr = (struct ipv6_opt_hdr *)(nh + offset); + 166. break; + 167. + +net/sched/cls_api.c:135: error: DEAD_STORE + The value written to &err (type int) is never used. + 133. return ERR_PTR(-ENOBUFS); + 134. + 135. > err = -ENOENT; + 136. tp->ops = tcf_proto_lookup_ops(kind); + 137. if (!tp->ops) { + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/i2c.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. * __i2c_transfer() result + 125. */ + 126. > TRACE_EVENT_FN(i2c_result, + 127. TP_PROTO(const struct i2c_adapter *adap, int num, int ret), + 128. TP_ARGS(adap, num, ret), + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +include/trace/events/xdp.h:126: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 124. ); + 125. + 126. > DEFINE_EVENT_PRINT(xdp_redirect_template, xdp_redirect_map_err, + 127. TP_PROTO(const struct net_device *dev, + 128. const struct bpf_prog *xdp, + +lib/radix-tree.c:130: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 128. { + 129. unsigned int offset = (index >> parent->shift) & RADIX_TREE_MAP_MASK; + 130. > void __rcu **entry = rcu_dereference_raw(parent->slots[offset]); + 131. + 132. #ifdef CONFIG_RADIX_TREE_MULTIORDER + +drivers/base/power/runtime.c:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. goto out; + 136. + 137. > autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); + 138. if (autosuspend_delay < 0) + 139. goto out; + +drivers/base/power/runtime.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. goto out; + 140. + 141. > last_busy = READ_ONCE(dev->power.last_busy); + 142. elapsed = jiffies - last_busy; + 143. if (elapsed < 0) + +drivers/tty/serial/serial_core.c:135: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 133. port = uart_port_lock(state, flags); + 134. __uart_start(tty); + 135. > uart_port_unlock(port, flags); + 136. } + 137. + +drivers/usb/storage/sierra_ms.c:197: error: DEAD_STORE + The value written to &result (type int) is never used. + 195. } + 196. complete: + 197. > result = device_create_file(&us->pusb_intf->dev, &dev_attr_truinst); + 198. + 199. return 0; + +drivers/usb/storage/sierra_ms.c:134: error: DEAD_STORE + The value written to &retries (type int) is never used. + 132. struct Scsi_Host *sh; + 133. + 134. > retries = 3; + 135. result = 0; + 136. udev = us->pusb_dev; + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(irq_matrix_global, irq_matrix_remove_reserved, + 128. + 129. TP_PROTO(struct irq_matrix *matrix), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 125. ); + 126. + 127. > DEFINE_EVENT(net_dev_template, netif_receive_skb, + 128. + 129. TP_PROTO(struct sk_buff *skb), + +net/ipv6/addrlabel.c:133: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 131. struct ip6addrlbl_entry *p; + 132. + 133. > hlist_for_each_entry_rcu(p, &net->ipv6.ip6addrlbl_table.head, list) { + 134. if (__ip6addrlbl_match(p, addr, type, ifindex)) + 135. return p; + +net/netfilter/nf_conntrack_standalone.c:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. struct ct_iter_state *st = seq->private; + 131. + 132. > head = rcu_dereference(hlist_nulls_next_rcu(head)); + 133. while (is_a_nulls(head)) { + 134. if (likely(get_nulls_value(head) == st->bucket)) { + +net/netfilter/nf_conntrack_standalone.c:138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 136. return NULL; + 137. } + 138. > head = rcu_dereference( + 139. hlist_nulls_first_rcu(&st->hash[st->bucket])); + 140. } + +drivers/gpu/drm/drm_ioc32.c:139: error: UNINITIALIZED_VALUE + The value read from uq32.unique was never initialized. + 137. uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. > .unique = compat_ptr(uq32.unique), + 140. }; + 141. + +drivers/gpu/drm/drm_ioc32.c:137: error: UNINITIALIZED_VALUE + The value read from uq32.unique_len was never initialized. + 135. if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32))) + 136. return -EFAULT; + 137. > uq = (struct drm_unique){ + 138. .unique_len = uq32.unique_len, + 139. .unique = compat_ptr(uq32.unique), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * we can determine the softirq handler routine. + 127. */ + 128. > DEFINE_EVENT(softirq, softirq_entry, + 129. + 130. TP_PROTO(unsigned int vec_nr), + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +include/trace/events/sched.h:128: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 126. * Tracepoint for task switches, performed by the scheduler: + 127. */ + 128. > TRACE_EVENT(sched_switch, + 129. + 130. TP_PROTO(bool preempt, + +net/ipv4/inet_connection_sock.c:152: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 150. sk2->sk_state == TCP_LISTEN) && + 151. (!reuseport || !sk2->sk_reuseport || + 152. > rcu_access_pointer(sk->sk_reuseport_cb) || + 153. (sk2->sk_state != TCP_TIME_WAIT && + 154. !uid_eq(uid, sock_i_uid(sk2))))) { + +net/ipv6/inet6_hashtables.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. u32 phash = 0; + 140. + 141. > inet_lhash2_for_each_icsk_rcu(icsk, &ilb2->head) { + 142. sk = (struct sock *)icsk; + 143. score = compute_score(sk, net, hnum, daddr, dif, sdif, + +drivers/char/hw_random/via-rng.c:177: error: DEAD_STORE + The value written to &hi (type unsigned int) is never used. + 175. /* perhaps-unnecessary sanity check; remove after testing if + 176. unneeded */ + 177. > rdmsr(MSR_VIA_RNG, lo, hi); + 178. if ((lo & VIA_RNG_ENABLE) == 0) { + 179. pr_err(PFX "cannot enable VIA C3 RNG, aborting\n"); + +drivers/connector/cn_proc.c:147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 145. ev->event_data.id.process_tgid = task->tgid; + 146. rcu_read_lock(); + 147. > cred = __task_cred(task); + 148. if (which_id == PROC_EVENT_UID) { + 149. ev->event_data.id.r.ruid = from_kuid_munged(&init_user_ns, cred->uid); + +include/linux/seqlock.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. static inline unsigned raw_read_seqcount(const seqcount_t *s) + 131. { + 132. > unsigned ret = READ_ONCE(s->sequence); + 133. smp_rmb(); + 134. return ret; + +kernel/cgroup/freezer.c:136: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 132 could be null and is dereferenced at line 136, column 6. + 134. mutex_lock(&freezer_mutex); + 135. + 136. > if (freezer->state & CGROUP_FREEZING) + 137. atomic_dec(&system_freezing_cnt); + 138. + +drivers/input/input.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. rcu_read_lock(); + 141. + 142. > handle = rcu_dereference(dev->grab); + 143. if (handle) { + 144. count = input_to_handler(handle, vals, count); + +drivers/input/input.c:146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 144. count = input_to_handler(handle, vals, count); + 145. } else { + 146. > list_for_each_entry_rcu(handle, &dev->h_list, d_node) + 147. if (handle->open) { + 148. count = input_to_handler(handle, vals, count); + +init/initramfs.c:137: error: NULL_DEREFERENCE + pointer `de` last assigned on line 133 could be null and is dereferenced at line 137, column 2. + 135. panic("can't allocate dir_entry buffer"); + 136. INIT_LIST_HEAD(&de->list); + 137. > de->name = kstrdup(name, GFP_KERNEL); + 138. de->mtime = mtime; + 139. list_add(&de->list, &dir_list); + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/random.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. ); + 131. + 132. > TRACE_EVENT(add_input_randomness, + 133. TP_PROTO(int input_bits), + 134. + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +include/trace/events/timer.h:132: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 130. * @timer: pointer to struct timer_list + 131. */ + 132. > DEFINE_EVENT(timer_class, timer_cancel, + 133. + 134. TP_PROTO(struct timer_list *timer), + +net/core/gen_stats.c:149: error: UNINITIALIZED_VALUE + The value read from seq was never initialized. + 147. bstats->bytes = b->bytes; + 148. bstats->packets = b->packets; + 149. > } while (running && read_seqcount_retry(running, seq)); + 150. } + 151. EXPORT_SYMBOL(__gnet_stats_copy_basic); + +net/ipv6/netfilter/nf_reject_ipv6.c:187: error: DEAD_STORE + The value written to &ip6h (type ipv6hdr*) is never used. + 185. + 186. skb_reserve(nskb, hh_len + dst->header_len); + 187. > ip6h = nf_reject_ip6hdr_put(nskb, oldskb, IPPROTO_TCP, + 188. ip6_dst_hoplimit(dst)); + 189. nf_reject_ip6_tcphdr_put(nskb, oldskb, otcph, otcplen); + +block/genhd.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. + 138. rcu_read_lock(); + 139. > ptbl = rcu_dereference(disk->part_tbl); + 140. + 141. piter->disk = disk; + +drivers/gpu/drm/i915/intel_lspcon.c:154: error: UNINITIALIZED_VALUE + The value read from adaptor_type was never initialized. + 152. + 153. if (adaptor_type != DRM_DP_DUAL_MODE_LSPCON) { + 154. > DRM_DEBUG_KMS("No LSPCON detected, found %s\n", + 155. drm_dp_get_dual_mode_type_name(adaptor_type)); + 156. return false; + +include/net/inet_sock.h:135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 133. static inline struct ip_options_rcu *ireq_opt_deref(const struct inet_request_sock *ireq) + 134. { + 135. > return rcu_dereference_check(ireq->ireq_opt, + 136. refcount_read(&ireq->req.rsk_refcnt) > 0); + 137. } + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +lib/lockref.c:135: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 133. int lockref_put_or_lock(struct lockref *lockref) + 134. { + 135. > CMPXCHG_LOOP( + 136. new.count--; + 137. if (old.count <= 1) + +net/ipv6/syncookies.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. fl6.flowi6_proto = IPPROTO_TCP; + 233. fl6.daddr = ireq->ir_v6_rmt_addr; + 234. > final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), &final); + 235. fl6.saddr = ireq->ir_v6_loc_addr; + 236. fl6.flowi6_oif = ireq->ir_iif; + +net/netfilter/nf_conntrack_helper.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. + 139. for (i = 0; i < nf_ct_helper_hsize; i++) { + 140. > hlist_for_each_entry_rcu(h, &nf_ct_helper_hash[i], hnode) { + 141. if (strcmp(h->name, name)) + 142. continue; + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/irq_matrix.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(irq_matrix_global_update, irq_matrix_assign_system, + 135. + 136. TP_PROTO(int bit, struct irq_matrix *matrix), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +include/trace/events/net.h:134: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 132. ); + 133. + 134. > DEFINE_EVENT(net_dev_template, netif_rx, + 135. + 136. TP_PROTO(struct sk_buff *skb), + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +kernel/panic.c:166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 164. * panic_cpu to this CPU. In this case, this is also the 1st CPU. + 165. */ + 166. > this_cpu = raw_smp_processor_id(); + 167. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 168. + +net/ipv4/af_inet.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. + 158. kfree(rcu_dereference_protected(inet->inet_opt, 1)); + 159. > dst_release(rcu_dereference_check(sk->sk_dst_cache, 1)); + 160. dst_release(sk->sk_rx_dst); + 161. sk_refcnt_debug_dec(sk); + +net/netlabel/netlabel_cipso_v4.c:137: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 135. struct netlbl_audit *audit_info) + 136. { + 137. > int ret_val = -EINVAL; + 138. struct cipso_v4_doi *doi_def = NULL; + 139. struct nlattr *nla_a; + +drivers/gpu/drm/i915/dvo_ch7xxx.c:161: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 159. + 160. if (i2c_transfer(adapter, msgs, 2) == 2) { + 161. > *ch = in_buf[0]; + 162. return true; + 163. } + +drivers/tty/sysrq.c:147: error: NULL_DEREFERENCE + pointer `killer` last assigned on line 137 could be null and is dereferenced at line 147, column 2. + 145. panic_on_oops = 1; /* force panic */ + 146. wmb(); + 147. > *killer = 1; + 148. } + 149. static struct sysrq_key_op sysrq_crash_op = { + +net/ipv4/xfrm4_protocol.c:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. struct xfrm4_protocol *handler; + 138. + 139. > for_each_protocol_rcu(ah4_handlers, handler) + 140. if (!handler->err_handler(skb, info)) + 141. break; + +net/ipv6/mcast.c:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. + 148. rcu_read_lock(); + 149. > for_each_pmc_rcu(np, mc_lst) { + 150. if ((ifindex == 0 || mc_lst->ifindex == ifindex) && + 151. ipv6_addr_equal(&mc_lst->addr, addr)) { + +net/netlabel/netlabel_addrlist.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. struct netlbl_af6list *iter; + 140. + 141. > list_for_each_entry_rcu(iter, head, list) + 142. if (iter->valid && + 143. ipv6_addr_equal(&iter->addr, addr) && + +drivers/usb/core/devio.c:140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 138. u64 lim; + 139. + 140. > lim = READ_ONCE(usbfs_memory_mb); + 141. lim <<= 20; + 142. + +include/linux/percpu-refcount.h:152: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 150. * with smp_store_release() in __percpu_ref_switch_to_percpu(). + 151. */ + 152. > percpu_ptr = READ_ONCE(ref->percpu_count_ptr); + 153. + 154. /* + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. * i2c_smbus_xfer() read data or procedure call reply + 136. */ + 137. > TRACE_EVENT_CONDITION(smbus_reply, + 138. TP_PROTO(const struct i2c_adapter *adap, + 139. u16 addr, unsigned short flags, + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:137: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 135. ); + 136. + 137. > DEFINE_EVENT(rpc_task_running, rpc_task_begin, + 138. + 139. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +lib/assoc_array.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. void *iterator_data) + 141. { + 142. > struct assoc_array_ptr *root = READ_ONCE(array->root); /* Address dependency. */ + 143. + 144. if (!root) + +net/ipv6/xfrm6_protocol.c:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. struct xfrm6_protocol *handler; + 141. + 142. > for_each_protocol_rcu(ipcomp6_handlers, handler) + 143. if (!handler->err_handler(skb, opt, type, code, offset, info)) + 144. break; + +net/netfilter/nf_conntrack_sip.c:174: error: UNINITIALIZED_VALUE + The value read from end was never initialized. + 172. + 173. if (endp) + 174. > *endp = end; + 175. return 1; + 176. } + +arch/x86/entry/common.c:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. local_irq_disable(); + 174. + 175. > cached_flags = READ_ONCE(current_thread_info()->flags); + 176. + 177. if (!(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +kernel/nsproxy.c:141: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 139. { + 140. struct nsproxy *old_ns = tsk->nsproxy; + 141. > struct user_namespace *user_ns = task_cred_xxx(tsk, user_ns); + 142. struct nsproxy *new_ns; + 143. + +block/blk-mq-sched.c:143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 141. struct request_queue *q = hctx->queue; + 142. LIST_HEAD(rq_list); + 143. > struct blk_mq_ctx *ctx = READ_ONCE(hctx->dispatch_from); + 144. + 145. do { + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 137. ); + 138. + 139. > DEFINE_EVENT(cgroup_migrate, cgroup_attach_task, + 140. + 141. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +security/commoncap.c:147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 145. rcu_read_lock(); + 146. cred = current_cred(); + 147. > child_cred = __task_cred(child); + 148. if (mode & PTRACE_MODE_FSCREDS) + 149. caller_caps = &cred->cap_effective; + +include/linux/page-flags.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. static inline struct page *compound_head(struct page *page) + 141. { + 142. > unsigned long head = READ_ONCE(page->compound_head); + 143. + 144. if (unlikely(head & 1)) + +kernel/smp.c:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. smp_call_func_t func, void *info) + 143. { + 144. > if (cpu == smp_processor_id()) { + 145. unsigned long flags; + 146. + +net/ipv6/ip6_offload.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. for (;;) { + 149. if (proto != NEXTHDR_HOP) { + 150. > *opps = rcu_dereference(inet6_offloads[proto]); + 151. if (unlikely(!(*opps))) + 152. break; + +net/ipv6/ipv6_sockglue.c:821: error: DEAD_STORE + The value written to &retv (type int) is never used. + 819. goto e_inval; + 820. + 821. > retv = -EINVAL; + 822. + 823. /* check PUBLIC/TMP/PUBTMP_DEFAULT conflicts */ + +net/ipv6/ipv6_sockglue.c:685: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 683. psin6 = (struct sockaddr_in6 *)&greq.gr_group; + 684. if (optname == MCAST_JOIN_GROUP) + 685. > retv = ipv6_sock_mc_join(sk, greq.gr_interface, + 686. &psin6->sin6_addr); + 687. else + +net/ipv6/ipv6_sockglue.c:688: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 686. &psin6->sin6_addr); + 687. else + 688. > retv = ipv6_sock_mc_drop(sk, greq.gr_interface, + 689. &psin6->sin6_addr); + 690. break; + +net/ipv6/ipv6_sockglue.c:721: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 719. + 720. psin6 = (struct sockaddr_in6 *)&greqs.gsr_group; + 721. > retv = ipv6_sock_mc_join(sk, greqs.gsr_interface, + 722. &psin6->sin6_addr); + 723. /* prior join w/ different source is ok */ + +net/ipv6/ipv6_sockglue.c:644: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 642. + 643. if (optname == IPV6_ADD_MEMBERSHIP) + 644. > retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + +net/ipv6/ipv6_sockglue.c:646: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 644. retv = ipv6_sock_mc_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 645. else + 646. > retv = ipv6_sock_mc_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_multiaddr); + 647. break; + 648. } + +net/ipv6/ipv6_sockglue.c:662: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 660. + 661. if (optname == IPV6_JOIN_ANYCAST) + 662. > retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + +net/ipv6/ipv6_sockglue.c:664: error: UNINITIALIZED_VALUE + The value read from mreq.ipv6mr_ifindex was never initialized. + 662. retv = ipv6_sock_ac_join(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 663. else + 664. > retv = ipv6_sock_ac_drop(sk, mreq.ipv6mr_ifindex, &mreq.ipv6mr_acaddr); + 665. break; + 666. } + +net/ipv6/ipv6_sockglue.c:481: error: UNINITIALIZED_VALUE + The value read from pkt.ipi6_ifindex was never initialized. + 479. goto e_inval; + 480. + 481. > np->sticky_pktinfo.ipi6_ifindex = pkt.ipi6_ifindex; + 482. np->sticky_pktinfo.ipi6_addr = pkt.ipi6_addr; + 483. retv = 0; + +drivers/char/hpet.c:167: error: DEAD_STORE + The value written to &m (type unsigned long) is never used. + 165. + 166. t = devp->hd_ireqfreq; + 167. > m = read_counter(&devp->hd_timer->hpet_compare); + 168. mc = read_counter(&hpet->hpet_mc); + 169. /* The time for the next interrupt would logically be t + m, + +drivers/clk/clk.c:159: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 157. if (!IS_ENABLED(CONFIG_SMP)) + 158. local_save_flags(flags); + 159. > return flags; + 160. } + 161. spin_lock_irqsave(&enable_lock, flags); + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/gpu/drm/i915/i915_trace.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. ); + 141. + 142. > TRACE_EVENT(vlv_wm, + 143. TP_PROTO(struct intel_crtc *crtc, const struct vlv_wm_values *wm), + 144. TP_ARGS(crtc, wm), + +drivers/rtc/rtc-dev.c:194: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 192. sizeof(unsigned long); + 193. } + 194. > return ret; + 195. } + 196. + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:142: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 140. * we can determine the softirq handler routine. + 141. */ + 142. > DEFINE_EVENT(softirq, softirq_exit, + 143. + 144. TP_PROTO(unsigned int vec_nr), + +net/netfilter/nf_queue.c:146: error: DEAD_STORE + The value written to &status (type int) is never used. + 144. unsigned int index, unsigned int queuenum) + 145. { + 146. > int status = -ENOENT; + 147. struct nf_queue_entry *entry = NULL; + 148. const struct nf_queue_handler *qh; + +net/netfilter/nf_queue.c:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. + 152. /* QUEUE == DROP if no one is waiting, to be safe. */ + 153. > qh = rcu_dereference(net->nf.queue_handler); + 154. if (!qh) { + 155. status = -ESRCH; + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +arch/x86/events/intel/bts.c:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. bts_config_buffer(struct bts_buffer *buf) + 145. { + 146. > int cpu = raw_smp_processor_id(); + 147. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 148. struct bts_phys *phys = &buf->buf[buf->cur_buf]; + +crypto/scompress.c:149: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 147. struct crypto_scomp *scomp = *tfm_ctx; + 148. void **ctx = acomp_request_ctx(req); + 149. > const int cpu = get_cpu(); + 150. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 151. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +crypto/scompress.c:149: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 147. struct crypto_scomp *scomp = *tfm_ctx; + 148. void **ctx = acomp_request_ctx(req); + 149. > const int cpu = get_cpu(); + 150. u8 *scratch_src = *per_cpu_ptr(scomp_src_scratches, cpu); + 151. u8 *scratch_dst = *per_cpu_ptr(scomp_dst_scratches, cpu); + +drivers/gpu/drm/drm_modes.c:252: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 250. vsyncandback_porch = tmp1; + 251. /* 10. Find number of lines in back porch */ + 252. > vback_porch = vsyncandback_porch - vsync; + 253. drm_mode->vtotal = vdisplay_rnd + 2 * vmargin + + 254. vsyncandback_porch + CVT_MIN_V_PORCH; + +drivers/gpu/drm/drm_sysfs.c:150: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 148. enum drm_connector_status status; + 149. + 150. > status = READ_ONCE(connector->status); + 151. + 152. return snprintf(buf, PAGE_SIZE, "%s\n", + +drivers/gpu/drm/i915/i915_gem_shrinker.c:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. spin_lock(&i915->mm.obj_lock); + 225. while (count < target && + 226. > (obj = list_first_entry_or_null(phase->list, + 227. typeof(*obj), + 228. mm.link))) { + +drivers/hid/hid-ntrig.c:162: error: DEAD_STORE + The value written to &ret (type int) is never used. + 160. + 161. if (ret == 8) { + 162. > ret = ntrig_version_string(&data[2], buf); + 163. + 164. hid_info(hdev, "Firmware version: %s (%02x%02x %02x%02x)\n", + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +include/trace/events/power.h:144: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 142. { PM_EVENT_RECOVER, "recover" }) + 143. + 144. > DEFINE_EVENT(cpu, cpu_frequency, + 145. + 146. TP_PROTO(unsigned int frequency, unsigned int cpu_id), + +kernel/kprobes.c:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. retry: + 152. rcu_read_lock(); + 153. > list_for_each_entry_rcu(kip, &c->pages, list) { + 154. if (kip->nused < slots_per_page(c)) { + 155. int i; + +net/ipv4/xfrm4_protocol.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; + 150. + 151. > for_each_protocol_rcu(ipcomp4_handlers, handler) + 152. if ((ret = handler->handler(skb)) != -EINVAL) + 153. return ret; + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/rcu.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. * All but the type of RCU are extracted from the rcu_node structure. + 144. */ + 145. > TRACE_EVENT(rcu_grace_period_init, + 146. + 147. TP_PROTO(const char *rcuname, unsigned long gpnum, u8 level, + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:145: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 143. ); + 144. + 145. > DEFINE_EVENT(rpc_task_running, rpc_task_run_action, + 146. + 147. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +kernel/irq/spurious.c:152: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 150. if (atomic_inc_return(&irq_poll_active) != 1) + 151. goto out; + 152. > irq_poll_cpu = smp_processor_id(); + 153. + 154. for_each_irq_desc(i, desc) { + +kernel/irq/spurious.c:152: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 150. if (atomic_inc_return(&irq_poll_active) != 1) + 151. goto out; + 152. > irq_poll_cpu = smp_processor_id(); + 153. + 154. for_each_irq_desc(i, desc) { + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +lib/percpu_ida.c:183: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 181. tag = tags->freelist[--tags->nr_free]; + 182. if (tags->nr_free) + 183. > cpumask_set_cpu(smp_processor_id(), + 184. &pool->cpus_have_tags); + 185. } + +arch/x86/platform/efi/efi_64.c:183: error: DEAD_STORE + The value written to &p4d (type p4d_t*) is never used. + 181. } + 182. + 183. > p4d = (p4d_t *)pgd_page_vaddr(*pgd); + 184. p4d_free(&init_mm, p4d); + 185. } + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +include/trace/events/cgroup.h:146: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 144. ); + 145. + 146. > DEFINE_EVENT(cgroup_migrate, cgroup_transfer_tasks, + 147. + 148. TP_PROTO(struct cgroup *dst_cgrp, struct task_struct *task, bool threadgroup), + +kernel/time/posix-timers.c:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. struct k_itimer *timer; + 152. + 153. > hlist_for_each_entry_rcu(timer, head, t_hash) { + 154. if ((timer->it_signal == sig) && (timer->it_id == id)) + 155. return timer; + +net/core/net-procfs.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. + 155. rcu_read_lock(); + 156. > fl = rcu_dereference(sd->flow_limit); + 157. if (fl) + 158. flow_limit_count = fl->count; + +block/blk-mq.h:150: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 148. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 149. { + 150. > return __blk_mq_get_ctx(q, get_cpu()); + 151. } + 152. + +block/blk-mq.h:150: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 148. static inline struct blk_mq_ctx *blk_mq_get_ctx(struct request_queue *q) + 149. { + 150. > return __blk_mq_get_ctx(q, get_cpu()); + 151. } + 152. + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:157: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 155. return -EFAULT; + 156. + 157. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 158. + 159. if (memory == NULL) + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > DEFINE_EVENT(clk_parent, clk_set_parent, + 149. + 150. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +include/trace/events/random.h:148: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 146. ); + 147. + 148. > TRACE_EVENT(add_disk_randomness, + 149. TP_PROTO(dev_t dev, int input_bits), + 150. + +net/core/rtnetlink.c:155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 153. protocol = PF_UNSPEC; + 154. + 155. > tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]); + 156. if (!tab) + 157. tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]); + +net/core/rtnetlink.c:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]); + 156. if (!tab) + 157. > tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]); + 158. + 159. return tab[msgtype]; + +net/ipv4/udp.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. inet_rcv_saddr_equal(sk, sk2, true)) { + 164. if (sk2->sk_reuseport && sk->sk_reuseport && + 165. > !rcu_access_pointer(sk->sk_reuseport_cb) && + 166. uid_eq(uid, sock_i_uid(sk2))) { + 167. if (!bitmap) + +net/sunrpc/auth_gss/gss_rpc_xdr.c:158: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 156. if (unlikely(p == NULL)) + 157. return -ENOSPC; + 158. > count = be32_to_cpup(p++); + 159. memset(&dummy, 0, sizeof(dummy)); + 160. for (i = 0; i < count; i++) { + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:149: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 147. ); + 148. + 149. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_reserve_managed, + 150. + 151. TP_PROTO(int bit, unsigned int cpu, + +kernel/sys.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. static bool set_one_prio_perm(struct task_struct *p) + 150. { + 151. > const struct cred *cred = current_cred(), *pcred = __task_cred(p); + 152. + 153. if (uid_eq(pcred->uid, cred->euid) || + +lib/errseq.c:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. int errseq_check(errseq_t *eseq, errseq_t since) + 150. { + 151. > errseq_t cur = READ_ONCE(*eseq); + 152. + 153. if (likely(cur == since)) + +net/core/dst.c:153: error: DEAD_STORE + The value written to &dst (type dst_entry*) is never used. + 151. struct dst_entry *dst = container_of(head, struct dst_entry, rcu_head); + 152. + 153. > dst = dst_destroy(dst); + 154. } + 155. + +net/netlabel/netlabel_domainhash.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. if (domain != NULL) { + 158. bkt = netlbl_domhsh_hash(domain); + 159. > bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt]; + 160. list_for_each_entry_rcu(iter, bkt_list, list) + 161. if (iter->valid && + +net/netlabel/netlabel_domainhash.c:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. bkt = netlbl_domhsh_hash(domain); + 159. bkt_list = &netlbl_domhsh_rcu_deref(netlbl_domhsh)->tbl[bkt]; + 160. > list_for_each_entry_rcu(iter, bkt_list, list) + 161. if (iter->valid && + 162. netlbl_family_match(iter->family, family) && + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. #define __parse_subcmd(c,f,h) libata_trace_parse_subcmd(p, c, f, h) + 150. + 151. > TRACE_EVENT(ata_qc_issue, + 152. + 153. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +include/trace/events/power.h:151: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 149. ); + 150. + 151. > TRACE_EVENT(device_pm_callback_start, + 152. + 153. TP_PROTO(struct device *dev, const char *pm_ops, int event), + +net/ipv4/udp_offload.c:171: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 169. case ENCAP_TYPE_IPPROTO: + 170. offloads = is_ipv6 ? inet6_offloads : inet_offloads; + 171. > ops = rcu_dereference(offloads[skb->inner_ipproto]); + 172. if (!ops || !ops->callbacks.gso_segment) + 173. goto out_unlock; + +net/netlabel/netlabel_addrlist.h:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. struct netlbl_af6list *n = __af6list_entry(s); + 156. while (i != h && !n->valid) { + 157. > i = rcu_dereference(list_next_rcu(i)); + 158. n = __af6list_entry(i); + 159. } + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +arch/x86/power/cpu.c:154: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 152. static void fix_processor_context(void) + 153. { + 154. > int cpu = smp_processor_id(); + 155. #ifdef CONFIG_X86_64 + 156. struct desc_struct *desc = get_cpu_gdt_rw(cpu); + +drivers/gpu/drm/drm_drv.c:158: error: NULL_DEREFERENCE + pointer `slot` last assigned on line 157 could be null and is dereferenced at line 158, column 10. + 156. + 157. slot = drm_minor_get_slot(dev, type); + 158. > minor = *slot; + 159. if (!minor) + 160. return; + +net/ipv4/tunnel4.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. struct xfrm_tunnel *handler; + 155. + 156. > for_each_tunnel_rcu(tunnel4_handlers, handler) + 157. if (!handler->err_handler(skb, info)) + 158. break; + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +include/trace/events/sunrpc.h:153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 151. ); + 152. + 153. > DEFINE_EVENT(rpc_task_running, rpc_task_complete, + 154. + 155. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const void *action), + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/irq/cpuhotplug.c:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. + 166. if (affinity_broken) { + 167. > pr_warn_ratelimited("IRQ %u: no longer affine to CPU%u\n", + 168. irq, smp_processor_id()); + 169. } + +kernel/ksysfs.c:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. struct kobj_attribute *attr, char *buf) + 155. { + 156. > return sprintf(buf, "%d\n", READ_ONCE(rcu_expedited)); + 157. } + 158. static ssize_t rcu_expedited_store(struct kobject *kobj, + +drivers/dma-buf/reservation.c:207: error: UNINITIALIZED_VALUE + The value read from k was never initialized. + 205. + 206. /* Drop the references to the signaled fences */ + 207. > for (i = k; i < fobj->shared_max; ++i) { + 208. struct dma_fence *f; + 209. + +kernel/printk/printk.c:183: error: UNINITIALIZED_VALUE + The value read from old was never initialized. + 181. + 182. /* ... and restore old setting. */ + 183. > devkmsg_log = old; + 184. strncpy(devkmsg_log_str, old_str, DEVKMSG_STR_MAX_SIZE); + 185. + +net/ipv4/ip_input.c:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. struct net *net = dev_net(dev); + 161. + 162. > for (ra = rcu_dereference(ip_ra_chain); ra; ra = rcu_dereference(ra->next)) { + 163. struct sock *sk = ra->sk; + 164. + +net/ipv4/ip_input.c:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. struct net *net = dev_net(dev); + 161. + 162. > for (ra = rcu_dereference(ip_ra_chain); ra; ra = rcu_dereference(ra->next)) { + 163. struct sock *sk = ra->sk; + 164. + +drivers/gpu/drm/drm_framebuffer.c:184: error: NULL_DEREFERENCE + pointer `info` last assigned on line 172 could be null and is dereferenced at line 184, column 18. + 182. } + 183. + 184. > for (i = 0; i < info->num_planes; i++) { + 185. unsigned int width = fb_plane_width(r->width, info, i); + 186. unsigned int height = fb_plane_height(r->height, info, i); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:166: error: DEAD_STORE + The value written to &ret_val (type unsigned int) is never used. + 164. * at the end of this routine. + 165. */ + 166. > ret_val = e1000_read_phy_reg(hw, 0x2F5B, &phy_saved_data); + 167. + 168. /* Disabled the PHY transmitter */ + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/clk.h:155: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(clk_parent, clk_set_parent_complete, + 156. + 157. TP_PROTO(struct clk_core *core, struct clk_core *parent), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:155: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 153. ); + 154. + 155. > DEFINE_EVENT(tcp_event_sk, tcp_receive_reset, + 156. + 157. TP_PROTO(const struct sock *sk), + +lib/decompress_bunzip2.c:271: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 269. } + 270. /* Find largest and smallest lengths in this group */ + 271. > minLen = maxLen = length[0]; + 272. + 273. for (i = 1; i < symCount; i++) { + +lib/decompress_bunzip2.c:275: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 273. for (i = 1; i < symCount; i++) { + 274. if (length[i] > maxLen) + 275. > maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. minLen = length[i]; + +lib/decompress_bunzip2.c:277: error: UNINITIALIZED_VALUE + The value read from length[_] was never initialized. + 275. maxLen = length[i]; + 276. else if (length[i] < minLen) + 277. > minLen = length[i]; + 278. } + 279. + +drivers/gpu/drm/drm_sysfs.c:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. int dpms; + 162. + 163. > dpms = READ_ONCE(connector->dpms); + 164. + 165. return snprintf(buf, PAGE_SIZE, "%s\n", + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +include/trace/events/irq.h:156: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 154. * we can determine the softirq raise to run latency. + 155. */ + 156. > DEFINE_EVENT(softirq, softirq_raise, + 157. + 158. TP_PROTO(unsigned int vec_nr), + +kernel/events/callchain.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. return NULL; + 164. + 165. > entries = rcu_dereference(callchain_cpus_entries); + 166. if (!entries) + 167. return NULL; + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +kernel/events/callchain.c:169: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 167. return NULL; + 168. + 169. > cpu = smp_processor_id(); + 170. + 171. return (((void *)entries->cpu_entries[cpu]) + + +net/ipv4/tcp_cong.c:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. + 162. rcu_read_lock(); + 163. > ca = rcu_dereference(net->ipv4.tcp_congestion_control); + 164. if (unlikely(!try_module_get(ca->owner))) + 165. ca = &tcp_reno; + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.addr was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.fd was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.flags was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.len was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +arch/x86/ia32/sys_ia32.c:167: error: UNINITIALIZED_VALUE + The value read from a.prot was never initialized. + 165. return -EINVAL; + 166. + 167. > return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd, + 168. a.offset>>PAGE_SHIFT); + 169. } + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 155. ); + 156. + 157. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_remove_managed, + 158. + 159. TP_PROTO(int bit, unsigned int cpu, + +kernel/time/timekeeping.c:159: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 157. static inline u64 tk_clock_read(struct tk_read_base *tkr) + 158. { + 159. > struct clocksource *clock = READ_ONCE(tkr->clock); + 160. + 161. return clock->read(clock); + +drivers/dma/virt-dma.h:160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 158. static inline struct virt_dma_desc *vchan_next_desc(struct virt_dma_chan *vc) + 159. { + 160. > return list_first_entry_or_null(&vc->desc_issued, + 161. struct virt_dma_desc, node); + 162. } + +include/linux/cpuidle.h:159: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 157. extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev); + 158. static inline struct cpuidle_device *cpuidle_get_device(void) + 159. > {return __this_cpu_read(cpuidle_devices); } + 160. #else + 161. static inline void disable_cpuidle(void) { } + +include/linux/cpuidle.h:159: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 157. extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev); + 158. static inline struct cpuidle_device *cpuidle_get_device(void) + 159. > {return __this_cpu_read(cpuidle_devices); } + 160. #else + 161. static inline void disable_cpuidle(void) { } + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +include/trace/events/iommu.h:158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 156. ); + 157. + 158. > DEFINE_EVENT(iommu_error, io_page_fault, + 159. + 160. TP_PROTO(struct device *dev, unsigned long iova, int flags), + +net/ipv4/inet_fragment.c:170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 168. local_bh_disable(); + 169. + 170. > for (i = READ_ONCE(f->next_bucket); budget; --budget) { + 171. evicted += inet_evict_bucket(f, &f->hash[i]); + 172. i = (i + 1) & (INETFRAGS_HASHSZ - 1); + +kernel/softirq.c:177: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 175. preempt_count_sub(cnt - 1); + 176. + 177. > if (unlikely(!in_interrupt() && local_softirq_pending())) { + 178. /* + 179. * Run softirq if any pending. And do it in its own stack + +lib/ioremap.c:170: error: DEAD_STORE + The value written to &start (type unsigned long) is never used. + 168. BUG_ON(addr >= end); + 169. + 170. > start = addr; + 171. phys_addr -= addr; + 172. pgd = pgd_offset_k(addr); + +drivers/dma-buf/dma-buf.c:185: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 183. rcu_read_lock(); + 184. + 185. > fobj = rcu_dereference(resv->fence); + 186. if (fobj) + 187. shared_count = fobj->shared_count; + +drivers/dma-buf/dma-buf.c:190: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 188. else + 189. shared_count = 0; + 190. > fence_excl = rcu_dereference(resv->fence_excl); + 191. if (read_seqcount_retry(&resv->seq, seq)) { + 192. rcu_read_unlock(); + +drivers/dma-buf/dma-buf.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. + 246. for (i = 0; i < shared_count; ++i) { + 247. > struct dma_fence *fence = rcu_dereference(fobj->shared[i]); + 248. + 249. if (!dma_fence_get_rcu(fence)) { + +net/netfilter/nf_log.c:179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 177. } + 178. + 179. > if (rcu_access_pointer(loggers[pf][type]) == NULL) + 180. request_module("nf-logger-%u-%u", pf, type); + 181. + +net/netfilter/nf_log.c:183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 181. + 182. rcu_read_lock(); + 183. > logger = rcu_dereference(loggers[pf][type]); + 184. if (logger == NULL) + 185. goto out; + +tools/lib/subcmd/exec-cmd.c:169: error: NULL_DEREFERENCE + pointer `nargv` last assigned on line 167 could be null and is dereferenced at line 169, column 2. + 167. nargv = malloc(sizeof(*nargv) * (argc + 2)); + 168. + 169. > nargv[0] = subcmd_config.exec_name; + 170. for (argc = 0; argv[argc]; argc++) + 171. nargv[argc + 1] = argv[argc]; + +net/ipv4/xfrm4_protocol.c:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. struct xfrm4_protocol *handler; + 164. + 165. > for_each_protocol_rcu(ipcomp4_handlers, handler) + 166. if (!handler->err_handler(skb, info)) + 167. break; + +arch/x86/lib/msr-smp.c:174: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 172. *h = rv.reg.h; + 173. + 174. > return err ? err : rv.err; + 175. } + 176. EXPORT_SYMBOL(rdmsr_safe_on_cpu); + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(regmap_bool, regmap_cache_only, + 163. + 164. TP_PROTO(struct regmap *map, bool flag), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +include/trace/events/tcp.h:162: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 160. ); + 161. + 162. > DEFINE_EVENT(tcp_event_sk, tcp_destroy_sock, + 163. + 164. TP_PROTO(const struct sock *sk), + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +net/core/filter.c:164: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 162. BPF_CALL_0(__get_raw_cpu_id) + 163. { + 164. > return raw_smp_processor_id(); + 165. } + 166. + +net/ipv4/tunnel4.c:166: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 164. struct xfrm_tunnel *handler; + 165. + 166. > for_each_tunnel_rcu(tunnel64_handlers, handler) + 167. if (!handler->err_handler(skb, info)) + 168. break; + +net/netlabel/netlabel_addrlist.c:175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 173. * address mask such that the entry with the widest mask (smallest + 174. * numerical value) appears first in the list */ + 175. > list_for_each_entry_rcu(iter, head, list) + 176. if (iter->valid && + 177. ntohl(entry->mask) > ntohl(iter->mask)) { + +drivers/net/ethernet/intel/e1000e/netdev.c:189: error: UNINITIALIZED_VALUE + The value read from regs[_] was never initialized. + 187. + 188. snprintf(rname, 16, "%s%s", reginfo->name, "[0-1]"); + 189. > pr_info("%-15s %08x %08x\n", rname, regs[0], regs[1]); + 190. } + 191. + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +include/trace/events/timer.h:163: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 161. * @mode: the hrtimers mode + 162. */ + 163. > TRACE_EVENT(hrtimer_init, + 164. + 165. TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid, + +init/initramfs.c:175: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 173. parsed[i] = simple_strtoul(buf, NULL, 16); + 174. } + 175. > ino = parsed[0]; + 176. mode = parsed[1]; + 177. uid = parsed[2]; + +init/initramfs.c:176: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 174. } + 175. ino = parsed[0]; + 176. > mode = parsed[1]; + 177. uid = parsed[2]; + 178. gid = parsed[3]; + +init/initramfs.c:177: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 175. ino = parsed[0]; + 176. mode = parsed[1]; + 177. > uid = parsed[2]; + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + +init/initramfs.c:178: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 176. mode = parsed[1]; + 177. uid = parsed[2]; + 178. > gid = parsed[3]; + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + +init/initramfs.c:179: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 177. uid = parsed[2]; + 178. gid = parsed[3]; + 179. > nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + +init/initramfs.c:180: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 178. gid = parsed[3]; + 179. nlink = parsed[4]; + 180. > mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. major = parsed[7]; + +init/initramfs.c:181: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 179. nlink = parsed[4]; + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. > body_len = parsed[6]; + 182. major = parsed[7]; + 183. minor = parsed[8]; + +init/initramfs.c:182: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 180. mtime = parsed[5]; /* breaks in y2106 */ + 181. body_len = parsed[6]; + 182. > major = parsed[7]; + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + +init/initramfs.c:183: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 181. body_len = parsed[6]; + 182. major = parsed[7]; + 183. > minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. name_len = parsed[11]; + +init/initramfs.c:185: error: UNINITIALIZED_VALUE + The value read from parsed[_] was never initialized. + 183. minor = parsed[8]; + 184. rdev = new_encode_dev(MKDEV(parsed[9], parsed[10])); + 185. > name_len = parsed[11]; + 186. } + 187. + +net/ipv6/ip6_offload.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. rcu_read_lock(); + 193. proto = iph->nexthdr; + 194. > ops = rcu_dereference(inet6_offloads[proto]); + 195. if (!ops || !ops->callbacks.gro_receive) { + 196. __pskb_pull(skb, skb_gro_offset(skb)); + +net/ipv6/ip6_offload.c:203: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 201. __skb_push(skb, skb_gro_offset(skb)); + 202. + 203. > ops = rcu_dereference(inet6_offloads[proto]); + 204. if (!ops || !ops->callbacks.gro_receive) + 205. goto out_unlock; + +net/ipv6/udp.c:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. result = NULL; + 175. badness = -1; + 176. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 177. score = compute_score(sk, net, saddr, sport, + 178. daddr, hnum, dif, sdif, exact_dif); + +arch/x86/lib/delay.c:175: error: DEAD_STORE + The value written to &xloops (type unsigned long) is never used. + 173. :"1" (xloops), "0" (lpj * (HZ / 4))); + 174. + 175. > __delay(++xloops); + 176. } + 177. EXPORT_SYMBOL(__const_udelay); + +arch/x86/lib/delay.c:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. void __const_udelay(unsigned long xloops) + 166. { + 167. > unsigned long lpj = this_cpu_read(cpu_info.loops_per_jiffy) ? : loops_per_jiffy; + 168. int d0; + 169. + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:165: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 163. ); + 164. + 165. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc_managed, + 166. + 167. TP_PROTO(int bit, unsigned int cpu, + +block/genhd.c:177: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 175. /* get part_tbl */ + 176. rcu_read_lock(); + 177. > ptbl = rcu_dereference(piter->disk->part_tbl); + 178. + 179. /* determine iteration parameters */ + +block/genhd.c:196: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 194. struct hd_struct *part; + 195. + 196. > part = rcu_dereference(ptbl->part[piter->idx]); + 197. if (!part) + 198. continue; + +kernel/sched/cpuacct.c:174: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 169 could be null and is dereferenced by call to `cpuacct_cpuusage_read()` at line 174, column 20. + 172. + 173. for_each_possible_cpu(i) + 174. > totalcpuusage += cpuacct_cpuusage_read(ca, i, index); + 175. + 176. return totalcpuusage; + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +include/trace/events/random.h:167: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 165. ); + 166. + 167. > TRACE_EVENT(xfer_secondary_pool, + 168. TP_PROTO(const char *pool_name, int xfer_bits, int request_bits, + 169. int pool_entropy, int input_entropy), + +drivers/gpu/drm/drm_ioc32.c:179: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 177. return -EFAULT; + 178. + 179. > map.offset = m32.offset; + 180. err = drm_ioctl_kernel(file, drm_legacy_getmap_ioctl, &map, DRM_UNLOCKED); + 181. if (err) + +drivers/gpu/drm/drm_ioc32.c:187: error: UNINITIALIZED_VALUE + The value read from map.flags was never initialized. + 185. m32.size = map.size; + 186. m32.type = map.type; + 187. > m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. m32.mtrr = map.mtrr; + +drivers/gpu/drm/drm_ioc32.c:189: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + 189. > m32.mtrr = map.mtrr; + 190. if (copy_to_user(argp, &m32, sizeof(m32))) + 191. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:185: error: UNINITIALIZED_VALUE + The value read from map.size was never initialized. + 183. + 184. m32.offset = map.offset; + 185. > m32.size = map.size; + 186. m32.type = map.type; + 187. m32.flags = map.flags; + +drivers/gpu/drm/drm_ioc32.c:186: error: UNINITIALIZED_VALUE + The value read from map.type was never initialized. + 184. m32.offset = map.offset; + 185. m32.size = map.size; + 186. > m32.type = map.type; + 187. m32.flags = map.flags; + 188. m32.handle = ptr_to_compat(map.handle); + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +lib/lockref.c:172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 170. int retval; + 171. + 172. > CMPXCHG_LOOP( + 173. new.count++; + 174. if (old.count < 0) + +drivers/gpu/drm/drm_sysfs.c:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. bool enabled; + 175. + 176. > enabled = READ_ONCE(connector->encoder); + 177. + 178. return snprintf(buf, PAGE_SIZE, enabled ? "enabled\n" : "disabled\n"); + +net/core/dev_ioctl.c:184: error: UNINITIALIZED_VALUE + The value read from cfg.rx_filter was never initialized. + 182. + 183. tx_type = cfg.tx_type; + 184. > rx_filter = cfg.rx_filter; + 185. + 186. switch (tx_type) { + +net/core/dev_ioctl.c:183: error: UNINITIALIZED_VALUE + The value read from cfg.tx_type was never initialized. + 181. return -EINVAL; + 182. + 183. > tx_type = cfg.tx_type; + 184. rx_filter = cfg.rx_filter; + 185. + +net/ipv4/devinet.c:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. struct in_ifaddr *ifa; + 173. + 174. > hlist_for_each_entry_rcu(ifa, &inet_addr_lst[hash], hash) + 175. if (ifa->ifa_local == addr && + 176. net_eq(dev_net(ifa->ifa_dev->dev), net)) + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/base/regmap/trace.h:170: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 168. ); + 169. + 170. > DEFINE_EVENT(regmap_bool, regmap_cache_bypass, + 171. + 172. TP_PROTO(struct regmap *map, bool flag), + +drivers/md/dm.c:172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 170. static int __dm_get_module_param_int(int *module_param, int min, int max) + 171. { + 172. > int param = READ_ONCE(*module_param); + 173. int modified_param = 0; + 174. bool modified = true; + +kernel/ksysfs.c:173: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 171. struct kobj_attribute *attr, char *buf) + 172. { + 173. > return sprintf(buf, "%d\n", READ_ONCE(rcu_normal)); + 174. } + 175. static ssize_t rcu_normal_store(struct kobject *kobj, + +net/sched/act_api.c:178: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 176. struct idr *idr = &idrinfo->action_idr; + 177. struct tc_action *p; + 178. > unsigned long id = 1; + 179. + 180. nest = nla_nest_start(skb, 0); + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +drivers/clocksource/i8253.c:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. * when it is used as broadcast device later. + 180. */ + 181. > i8253_clockevent.cpumask = cpumask_of(smp_processor_id()); + 182. + 183. clockevents_config_and_register(&i8253_clockevent, PIT_TICK_RATE, + +drivers/tty/tty_jobctrl.c:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. { + 173. struct task_struct *p; + 174. > do_each_pid_task(session, PIDTYPE_SID, p) { + 175. proc_clear_tty(p); + 176. } while_each_pid_task(session, PIDTYPE_SID, p); + +include/linux/ptrace.h:183: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 181. + 182. rcu_read_lock(); + 183. > ns = task_active_pid_ns(rcu_dereference(current->parent)); + 184. if (ns) + 185. message = pid_nr_ns(pid, ns); + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +include/ras/ras_event.h:171: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 169. * has occurred. UEFI 2.6 spec section N.2.4.4. + 170. */ + 171. > TRACE_EVENT(arm_event, + 172. + 173. TP_PROTO(const struct cper_sec_proc_arm *proc), + +lib/asn1_decoder.c:400: error: UNINITIALIZED_VALUE + The value read from cons_datalen_stack[_] was never initialized. + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. > datalen = cons_datalen_stack[csp]; + 401. pr_debug("- end cons t=%zu dp=%zu l=%zu/%zu\n", + 402. tdp, dp, len, datalen); + +lib/asn1_decoder.c:397: error: UNINITIALIZED_VALUE + The value read from cons_dp_stack[_] was never initialized. + 395. goto cons_stack_underflow; + 396. csp--; + 397. > tdp = cons_dp_stack[csp]; + 398. hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + +lib/asn1_decoder.c:398: error: UNINITIALIZED_VALUE + The value read from cons_hdrlen_stack[_] was never initialized. + 396. csp--; + 397. tdp = cons_dp_stack[csp]; + 398. > hdr = cons_hdrlen_stack[csp]; + 399. len = datalen; + 400. datalen = cons_datalen_stack[csp]; + +lib/asn1_decoder.c:463: error: UNINITIALIZED_VALUE + The value read from jump_stack[_] was never initialized. + 461. if (unlikely(jsp <= 0)) + 462. goto jump_stack_underflow; + 463. > pc = jump_stack[--jsp]; + 464. flags |= FLAG_MATCHED | FLAG_LAST_MATCHED; + 465. goto next_op; + +drivers/char/agp/compat_ioctl.c:181: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 179. return -EFAULT; + 180. + 181. > memory = agp_find_mem_by_key(bind_info.key); + 182. + 183. if (memory == NULL) + +drivers/char/agp/compat_ioctl.c:186: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 184. return -EINVAL; + 185. + 186. > return agp_bind_memory(memory, bind_info.pg_start); + 187. } + 188. + +include/linux/ptr_ring.h:176: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 174. { + 175. if (likely(r->size)) + 176. > return READ_ONCE(r->queue[r->consumer_head]); + 177. return NULL; + 178. } + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:173: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 171. ); + 172. + 173. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_assign, + 174. + 175. TP_PROTO(int bit, unsigned int cpu, + +lib/assoc_array.c:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. pr_devel("-->%s()\n", __func__); + 188. + 189. > cursor = READ_ONCE(array->root); /* Address dependency. */ + 190. if (!cursor) + 191. return assoc_array_walk_tree_empty; + +lib/assoc_array.c:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. slot = segments >> (level & ASSOC_ARRAY_KEY_CHUNK_MASK); + 212. slot &= ASSOC_ARRAY_FAN_MASK; + 213. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 214. + 215. pr_devel("consider slot %x [ix=%d type=%lu]\n", + +lib/assoc_array.c:286: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 284. + 285. /* The shortcut matches the leaf's index to this point. */ + 286. > cursor = READ_ONCE(shortcut->next_node); /* Address dependency. */ + 287. if (((level ^ sc_level) & ~ASSOC_ARRAY_KEY_CHUNK_MASK) != 0) { + 288. level = sc_level; + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +include/trace/events/sched.h:174: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 172. * Tracepoint for a task being migrated: + 173. */ + 174. > TRACE_EVENT(sched_migrate_task, + 175. + 176. TP_PROTO(struct task_struct *p, int dest_cpu), + +kernel/time/clocksource.c:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. /* Check the deviation from the watchdog clocksource. */ + 225. if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) { + 226. > pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n", + 227. smp_processor_id(), cs->name); + 228. pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n", + +kernel/time/clocksource.c:280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 278. * to each other. + 279. */ + 280. > next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); + 281. if (next_cpu >= nr_cpu_ids) + 282. next_cpu = cpumask_first(cpu_online_mask); + +kernel/time/clocksource.c:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. /* Check the deviation from the watchdog clocksource. */ + 225. if (abs(cs_nsec - wd_nsec) > WATCHDOG_THRESHOLD) { + 226. > pr_warn("timekeeping watchdog on CPU%d: Marking clocksource '%s' as unstable because the skew is too large:\n", + 227. smp_processor_id(), cs->name); + 228. pr_warn(" '%s' wd_now: %llx wd_last: %llx mask: %llx\n", + +kernel/time/clocksource.c:280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 278. * to each other. + 279. */ + 280. > next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask); + 281. if (next_cpu >= nr_cpu_ids) + 282. next_cpu = cpumask_first(cpu_online_mask); + +arch/x86/include/asm/atomic64_64.h:177: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 175. static inline long atomic64_cmpxchg(atomic64_t *v, long old, long new) + 176. { + 177. > return cmpxchg(&v->counter, old, new); + 178. } + 179. + +block/ioprio.c:199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 197. else + 198. pgrp = find_vpid(who); + 199. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 200. tmpio = get_task_ioprio(p); + 201. if (tmpio < 0) + +block/ioprio.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. break; + 218. + 219. > for_each_process_thread(g, p) { + 220. if (!uid_eq(task_uid(p), user->uid) || + 221. !task_pid_vnr(p)) + +block/ioprio.c:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. + 219. for_each_process_thread(g, p) { + 220. > if (!uid_eq(task_uid(p), user->uid) || + 221. !task_pid_vnr(p)) + 222. continue; + +drivers/md/md-bitmap.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. rdev_dec_pending(rdev, mddev); + 197. } + 198. > list_for_each_entry_continue_rcu(rdev, &mddev->disks, same_set) { + 199. if (rdev->raid_disk >= 0 && + 200. !test_bit(Faulty, &rdev->flags)) { + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +kernel/stop_machine.c:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. struct multi_stop_data *msdata = data; + 178. enum multi_stop_state curstate = MULTI_STOP_NONE; + 179. > int cpu = smp_processor_id(), err = 0; + 180. unsigned long flags; + 181. bool is_active; + +net/sched/sch_mq.c:179: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 177 could be null and is dereferenced at line 179, column 9. + 177. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 178. + 179. > return dev_queue->qdisc_sleeping; + 180. } + 181. + +net/sunrpc/xprtmultipath.c:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. if (xpi->xpi_ops != NULL) + 180. return xpi->xpi_ops; + 181. > return rcu_dereference(xpi->xpi_xpswitch)->xps_iter_ops; + 182. } + 183. + +security/commoncap.c:182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 180. + 181. rcu_read_lock(); + 182. > cred = __task_cred(parent); + 183. child_cred = current_cred(); + 184. if (cred->user_ns == child_cred->user_ns && + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +net/core/netpoll.c:180: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 178. { + 179. struct napi_struct *napi; + 180. > int cpu = smp_processor_id(); + 181. + 182. list_for_each_entry(napi, &dev->napi_list, dev_list) { + +security/keys/proc.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. /* come up with a suitable timeout value */ + 222. > expiry = READ_ONCE(key->expiry); + 223. if (expiry == 0) { + 224. memcpy(xbuf, "perm", 5); + +security/keys/proc.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. ((FLAGS & (1 << FLAG)) ? LETTER : '-') + 246. + 247. > flags = READ_ONCE(key->flags); + 248. seq_printf(m, "%08x %c%c%c%c%c%c%c %5d %4s %08x %5d %5d %-9.9s ", + 249. key->serial, + +arch/x86/lib/msr-smp.c:190: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 188. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 189. + 190. > return err ? err : rv.err; + 191. } + 192. EXPORT_SYMBOL(wrmsr_safe_on_cpu); + +drivers/firmware/dmi-id.c:206: error: DEAD_STORE + The value written to &i (type int) is never used. + 204. ADD_DMI_ATTR(chassis_serial, DMI_CHASSIS_SERIAL); + 205. ADD_DMI_ATTR(chassis_asset_tag, DMI_CHASSIS_ASSET_TAG); + 206. > sys_dmi_attributes[i++] = &sys_dmi_modalias_attr.attr; + 207. } + 208. + +drivers/gpu/drm/i915/intel_hdmi.c:189: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 183 could be null and is dereferenced at line 189, column 37. + 187. return false; + 188. + 189. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 190. return false; + 191. + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +include/trace/events/power.h:179: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 177. ); + 178. + 179. > TRACE_EVENT(device_pm_callback_end, + 180. + 181. TP_PROTO(struct device *dev, int error), + +lib/errseq.c:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. * to take the lock that protects the "since" value. + 188. */ + 189. > old = READ_ONCE(*eseq); + 190. if (old != *since) { + 191. /* + +net/sunrpc/auth_gss/auth_gss.c:186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 184. + 185. rcu_read_lock(); + 186. > ctx = rcu_dereference(gss_cred->gc_ctx); + 187. if (ctx) + 188. gss_get_ctx(ctx); + +drivers/pci/probe.c:254: error: UNINITIALIZED_VALUE + The value read from orig_cmd was never initialized. + 252. + 253. if (!dev->mmio_always_on && (orig_cmd & PCI_COMMAND_DECODE_ENABLE)) + 254. > pci_write_config_word(dev, PCI_COMMAND, orig_cmd); + 255. + 256. if (!sz64) + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(clk_phase, clk_set_phase, + 182. + 183. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:181: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 179. ); + 180. + 181. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_alloc, + 182. + 183. TP_PROTO(int bit, unsigned int cpu, + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +drivers/gpu/drm/i915/i915_trace.h:182: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 180. ); + 181. + 182. > TRACE_EVENT(vlv_fifo_size, + 183. TP_PROTO(struct intel_crtc *crtc, u32 sprite0_start, u32 sprite1_start, u32 fifo_size), + 184. TP_ARGS(crtc, sprite0_start, sprite1_start, fifo_size), + +include/linux/seqlock.h:184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 182. static inline unsigned raw_seqcount_begin(const seqcount_t *s) + 183. { + 184. > unsigned ret = READ_ONCE(s->sequence); + 185. smp_rmb(); + 186. return ret & ~1; + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +arch/x86/events/intel/bts.c:185: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 183. static void bts_update(struct bts_ctx *bts) + 184. { + 185. > int cpu = raw_smp_processor_id(); + 186. struct debug_store *ds = per_cpu(cpu_hw_events, cpu).ds; + 187. struct bts_buffer *buf = perf_get_aux(&bts->handle); + +arch/x86/entry/common.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. lockdep_sys_exit(); + 192. + 193. > cached_flags = READ_ONCE(ti->flags); + 194. + 195. if (unlikely(cached_flags & EXIT_TO_USERMODE_LOOP_FLAGS)) + +kernel/exit.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. * can't be modifying its own credentials. But shut RCU-lockdep up */ + 191. rcu_read_lock(); + 192. > atomic_dec(&__task_cred(p)->user->processes); + 193. rcu_read_unlock(); + 194. + +net/ipv4/udp.c:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. inet_rcv_saddr_equal(sk, sk2, true)) { + 201. if (sk2->sk_reuseport && sk->sk_reuseport && + 202. > !rcu_access_pointer(sk->sk_reuseport_cb) && + 203. uid_eq(uid, sock_i_uid(sk2))) { + 204. res = 0; + +net/netlabel/netlabel_domainhash.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. return entry; + 192. if (family == AF_INET || family == AF_UNSPEC) { + 193. > entry = netlbl_domhsh_rcu_deref(netlbl_domhsh_def_ipv4); + 194. if (entry != NULL && entry->valid) + 195. return entry; + +net/netlabel/netlabel_domainhash.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. } + 197. if (family == AF_INET6 || family == AF_UNSPEC) { + 198. > entry = netlbl_domhsh_rcu_deref(netlbl_domhsh_def_ipv6); + 199. if (entry != NULL && entry->valid) + 200. return entry; + +net/netlink/genetlink.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. netlink_table_grab(); + 233. rcu_read_lock(); + 234. > for_each_net_rcu(net) { + 235. err = __netlink_change_ngroups(net->genl_sock, + 236. mc_groups_longs * BITS_PER_LONG); + +arch/x86/include/asm/atomic.h:187: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 185. static __always_inline int atomic_cmpxchg(atomic_t *v, int old, int new) + 186. { + 187. > return cmpxchg(&v->counter, old, new); + 188. } + 189. + +net/netfilter/nf_conntrack_netlink.c:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. return 0; + 194. + 195. > helper = rcu_dereference(help->helper); + 196. if (!helper) + 197. goto out; + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +include/trace/events/rcu.h:186: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 184. * "done": Someone else did the expedited grace period for us. + 185. */ + 186. > TRACE_EVENT(rcu_exp_grace_period, + 187. + 188. TP_PROTO(const char *rcuname, unsigned long gpseq, const char *gpevent), + +kernel/seccomp.c:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. u32 ret = SECCOMP_RET_ALLOW; + 191. /* Make sure cross-thread synced filter points somewhere sane. */ + 192. > struct seccomp_filter *f = + 193. READ_ONCE(current->seccomp.filter); + 194. + +scripts/mod/file2alias.c:196: error: DEAD_STORE + The value written to &bcdDevice_lo (type unsigned short) is never used. + 194. DEF_FIELD(symval, usb_device_id, idVendor); + 195. DEF_FIELD(symval, usb_device_id, idProduct); + 196. > DEF_FIELD(symval, usb_device_id, bcdDevice_lo); + 197. DEF_FIELD(symval, usb_device_id, bDeviceClass); + 198. DEF_FIELD(symval, usb_device_id, bDeviceSubClass); + +drivers/video/fbdev/core/fbcvt.c:192: error: DEAD_STORE + The value written to &aspect (type unsigned int) is never used. + 190. u32 xres = cvt->xres; + 191. u32 yres = cvt->yres; + 192. > u32 aspect = -1; + 193. + 194. if (xres == (yres * 4)/3 && !((yres * 4) % 3)) + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +include/trace/events/clk.h:188: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 186. ); + 187. + 188. > DEFINE_EVENT(clk_phase, clk_set_phase_complete, + 189. + 190. TP_PROTO(struct clk_core *core, int phase), + +kernel/cred.c:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. + 194. do { + 195. > cred = __task_cred((task)); + 196. BUG_ON(!cred); + 197. } while (!atomic_inc_not_zero(&((struct cred *)cred)->usage)); + +net/netfilter/nf_nat_core.c:200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 198. const struct nf_conn *ct; + 199. + 200. > hlist_for_each_entry_rcu(ct, &nf_nat_bysource[h], nat_bysource) { + 201. if (same_src(ct, tuple) && + 202. net_eq(net, nf_ct_net(ct)) && + +drivers/char/agp/compat_ioctl.c:198: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 196. return -EFAULT; + 197. + 198. > memory = agp_find_mem_by_key(unbind.key); + 199. + 200. if (memory == NULL) + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +include/trace/events/irq_matrix.h:189: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 187. ); + 188. + 189. > DEFINE_EVENT(irq_matrix_cpu, irq_matrix_free, + 190. + 191. TP_PROTO(int bit, unsigned int cpu, + +kernel/power/process.c:210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 208. + 209. read_lock(&tasklist_lock); + 210. > for_each_process_thread(g, p) { + 211. /* No other threads should have PF_SUSPEND_TASK set */ + 212. WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK)); + +kernel/sys.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. else + 223. pgrp = task_pgrp(current); + 224. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 225. error = set_one_prio(p, niceval, error); + 226. } while_each_pid_thread(pgrp, PIDTYPE_PGID, p); + +kernel/sys.c:238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 236. goto out_unlock; /* No processes for this user */ + 237. } + 238. > do_each_thread(g, p) { + 239. if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) + 240. error = set_one_prio(p, niceval, error); + +kernel/sys.c:239: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 237. } + 238. do_each_thread(g, p) { + 239. > if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) + 240. error = set_one_prio(p, niceval, error); + 241. } while_each_thread(g, p); + +net/core/netpoll.c:193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 191. { + 192. const struct net_device_ops *ops; + 193. > struct netpoll_info *ni = rcu_dereference_bh(dev->npinfo); + 194. + 195. /* Don't do any rx activity if the dev_lock mutex is held + +security/selinux/hooks.c:199: error: NULL_DEREFERENCE + pointer `tsec` last assigned on line 195 could be null and is dereferenced at line 199, column 15. + 197. panic("SELinux: Failed to initialize initial task.\n"); + 198. + 199. > tsec->osid = tsec->sid = SECINITSID_KERNEL; + 200. cred->security = tsec; + 201. } + +drivers/md/dm.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. unsigned def, unsigned max) + 193. { + 194. > unsigned param = READ_ONCE(*module_param); + 195. unsigned modified_param = 0; + 196. + +drivers/tty/tty_jobctrl.c:199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 197. read_lock(&tasklist_lock); + 198. if (tty->session) { + 199. > do_each_pid_task(tty->session, PIDTYPE_SID, p) { + 200. spin_lock_irq(&p->sighand->siglock); + 201. if (p->signal->tty == tty) { + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +include/trace/events/timer.h:191: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 189. * @hrtimer: pointer to struct hrtimer + 190. */ + 191. > TRACE_EVENT(hrtimer_start, + 192. + 193. TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode), + +net/sched/sch_mq.c:198: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 194 could be null and is dereferenced at line 198, column 18. + 196. tcm->tcm_parent = TC_H_ROOT; + 197. tcm->tcm_handle |= TC_H_MIN(cl); + 198. > tcm->tcm_info = dev_queue->qdisc_sleeping->handle; + 199. return 0; + 200. } + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:192: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 190. * operation would access. + 191. */ + 192. > DEFINE_EVENT(block_rq, block_rq_insert, + 193. + 194. TP_PROTO(struct request_queue *q, struct request *rq), + +net/ipv4/ip_input.c:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. raw = raw_local_deliver(skb, protocol); + 204. + 205. > ipprot = rcu_dereference(inet_protos[protocol]); + 206. if (ipprot) { + 207. int ret; + +net/wireless/reg.c:194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 192. static struct regulatory_request *get_last_request(void) + 193. { + 194. > return rcu_dereference_rtnl(last_request); + 195. } + 196. + +scripts/kconfig/menu.c:195: error: MEMORY_LEAK + memory dynamically allocated by call to `expr_alloc_symbol()` at line 195, column 28 is not reachable after line 195, column 2. + 193. void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep) + 194. { + 195. > menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep); + 196. } + 197. + +arch/x86/lib/msr-smp.c:206: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 204. err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1); + 205. + 206. > return err ? err : rv.err; + 207. } + 208. EXPORT_SYMBOL(wrmsrl_safe_on_cpu); + +include/linux/netfilter.h:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. switch (pf) { + 211. case NFPROTO_IPV4: + 212. > hook_head = rcu_dereference(net->nf.hooks_ipv4[hook]); + 213. break; + 214. case NFPROTO_IPV6: + +include/linux/netfilter.h:215: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 213. break; + 214. case NFPROTO_IPV6: + 215. > hook_head = rcu_dereference(net->nf.hooks_ipv6[hook]); + 216. break; + 217. case NFPROTO_ARP: + +net/ipv6/proc.c:206: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 204. snmp_get_cpu_field_batch(buff, itemlist, pcpumib); + 205. for (i = 0; itemlist[i].name; i++) + 206. > seq_printf(seq, "%-32s\t%lu\n", + 207. itemlist[i].name, buff[i]); + 208. } else { + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +drivers/base/regmap/trace.h:195: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 193. ); + 194. + 195. > DEFINE_EVENT(regmap_block, regmap_async_write_start, + 196. + 197. TP_PROTO(struct regmap *map, unsigned int reg, int count), + +kernel/ucount.c:204: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 202. int max; + 203. tns = iter->ns; + 204. > max = READ_ONCE(tns->ucount_max[type]); + 205. if (!atomic_inc_below(&iter->ucount[type], max)) + 206. goto fail; + +net/netfilter/nf_log.c:208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 206. + 207. rcu_read_lock(); + 208. > logger = rcu_dereference(loggers[pf][type]); + 209. module_put(logger->me); + 210. rcu_read_unlock(); + +net/sunrpc/xprtmultipath.c:198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 196. struct rpc_xprt *xprt_switch_find_first_entry(struct list_head *head) + 197. { + 198. > return list_first_or_null_rcu(head, struct rpc_xprt, xprt_switch); + 199. } + 200. + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +arch/x86/include/asm/desc.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. asm volatile("lldt %w0"::"q" (0)); + 200. else { + 201. > unsigned cpu = smp_processor_id(); + 202. ldt_desc ldt; + 203. + +drivers/gpu/drm/drm_ioc32.c:210: error: UNINITIALIZED_VALUE + The value read from m32.flags was never initialized. + 208. map.size = m32.size; + 209. map.type = m32.type; + 210. > map.flags = m32.flags; + 211. + 212. err = drm_ioctl_kernel(file, drm_legacy_addmap_ioctl, &map, + +drivers/gpu/drm/drm_ioc32.c:207: error: UNINITIALIZED_VALUE + The value read from m32.offset was never initialized. + 205. return -EFAULT; + 206. + 207. > map.offset = m32.offset; + 208. map.size = m32.size; + 209. map.type = m32.type; + +drivers/gpu/drm/drm_ioc32.c:208: error: UNINITIALIZED_VALUE + The value read from m32.size was never initialized. + 206. + 207. map.offset = m32.offset; + 208. > map.size = m32.size; + 209. map.type = m32.type; + 210. map.flags = m32.flags; + +drivers/gpu/drm/drm_ioc32.c:209: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 207. map.offset = m32.offset; + 208. map.size = m32.size; + 209. > map.type = m32.type; + 210. map.flags = m32.flags; + 211. + +drivers/gpu/drm/drm_ioc32.c:221: error: UNINITIALIZED_VALUE + The value read from m32.type was never initialized. + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + 221. > pr_err_ratelimited("compat_drm_addmap truncated handle %p for type %d offset %x\n", + 222. map.handle, m32.type, m32.offset); + 223. + +drivers/gpu/drm/drm_ioc32.c:218: error: UNINITIALIZED_VALUE + The value read from map.mtrr was never initialized. + 216. + 217. m32.offset = map.offset; + 218. > m32.mtrr = map.mtrr; + 219. m32.handle = ptr_to_compat(map.handle); + 220. if (map.handle != compat_ptr(m32.handle)) + +kernel/sched/cpuacct.c:209: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 199 could be null and is dereferenced by call to `cpuacct_cpuusage_write()` at line 209, column 3. + 207. + 208. for_each_possible_cpu(cpu) + 209. > cpuacct_cpuusage_write(ca, cpu, 0); + 210. + 211. return 0; + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:197: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 195. ); + 196. + 197. > DEFINE_EVENT(rpc_task_queued, rpc_task_sleep, + 198. + 199. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/kthread.c:219: error: NULL_DEREFERENCE + pointer `done` last assigned on line 211 could be null and is dereferenced by call to `complete()` at line 219, column 3. + 217. if (!self) { + 218. create->result = ERR_PTR(-ENOMEM); + 219. > complete(done); + 220. do_exit(-ENOMEM); + 221. } + +net/ipv6/udp.c:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. result = NULL; + 242. badness = -1; + 243. > sk_for_each_rcu(sk, &hslot->head) { + 244. score = compute_score(sk, net, saddr, sport, daddr, hnum, dif, + 245. sdif, exact_dif); + +lib/idr.c:211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 209. if (WARN_ON_ONCE(id > INT_MAX)) + 210. break; + 211. > ret = fn(id, rcu_dereference_raw(*slot), data); + 212. if (ret) + 213. return ret; + +net/ipv6/seg6.c:215: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 213. + 214. rcu_read_lock(); + 215. > tun_src = rcu_dereference(seg6_pernet(net)->tun_src); + 216. + 217. if (nla_put(msg, SEG6_ATTR_DST, sizeof(struct in6_addr), tun_src)) + +kernel/power/user.c:373: error: UNINITIALIZED_VALUE + The value read from swap_area.dev was never initialized. + 371. * so we need to recode them + 372. */ + 373. > swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. offset = swap_area.offset; + +kernel/power/user.c:375: error: UNINITIALIZED_VALUE + The value read from swap_area.offset was never initialized. + 373. swdev = new_decode_dev(swap_area.dev); + 374. if (swdev) { + 375. > offset = swap_area.offset; + 376. data->swap = swap_type_of(swdev, offset, NULL); + 377. if (data->swap < 0) + +net/netlabel/netlabel_addrlist.c:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. * address mask such that the entry with the widest mask (smallest + 212. * numerical value) appears first in the list */ + 213. > list_for_each_entry_rcu(iter, head, list) + 214. if (iter->valid && + 215. ipv6_addr_cmp(&entry->mask, &iter->mask) > 0) { + +block/ioctl.c:218: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 216. return -EFAULT; + 217. + 218. > start = range[0]; + 219. len = range[1]; + 220. + +block/ioctl.c:219: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 217. + 218. start = range[0]; + 219. > len = range[1]; + 220. + 221. if (start & 511) + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +drivers/gpu/drm/i915/intel_guc_submission.c:215: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 213. * release the doorbell + 214. */ + 215. > if (wait_for_us(!(I915_READ(GEN8_DRBREGL(db_id)) & GEN8_DRB_VALID), 10)) + 216. WARN_ONCE(true, "Doorbell never became invalid after disable\n"); + 217. } + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +include/trace/events/scsi.h:200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 198. #define __parse_cdb(cdb, len) scsi_trace_parse_cdb(p, cdb, len) + 199. + 200. > TRACE_EVENT(scsi_dispatch_cmd_start, + 201. + 202. TP_PROTO(struct scsi_cmnd *cmd), + +net/netlabel/netlabel_unlabeled.c:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. static u32 netlbl_unlhsh_hash(int ifindex) + 201. { + 202. > return ifindex & (netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->size - 1); + 203. } + 204. + +drivers/char/hpet.c:254: error: UNINITIALIZED_VALUE + The value read from gsi was never initialized. + 252. v |= irq << Tn_INT_ROUTE_CNF_SHIFT; + 253. writel(v, &timer->hpet_config); + 254. > devp->hd_hdwirq = gsi; + 255. spin_unlock_irq(&hpet_lock); + 256. } + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +include/trace/events/power.h:201: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 199. ); + 200. + 201. > TRACE_EVENT(suspend_resume, + 202. + 203. TP_PROTO(const char *action, int val, bool start), + +kernel/sched/loadavg.c:208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 206. * If we're still before the pending sample window, we're done. + 207. */ + 208. > this_rq->calc_load_update = READ_ONCE(calc_load_update); + 209. if (time_before(jiffies, this_rq->calc_load_update)) + 210. return; + +net/sunrpc/xprtmultipath.c:204: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 202. struct rpc_xprt *xprt_iter_first_entry(struct rpc_xprt_iter *xpi) + 203. { + 204. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 205. + 206. if (xps == NULL) + +crypto/rsa.c:218: error: DEAD_STORE + The value written to &ret (type int) is never used. + 216. } + 217. + 218. > ret = -ENOMEM; + 219. s = mpi_read_raw_from_sgl(req->src, req->src_len); + 220. if (!s) { + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:202: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 200. ); + 201. + 202. > DEFINE_EVENT(regmap_async, regmap_async_io_complete, + 203. + 204. TP_PROTO(struct regmap *map), + +drivers/tty/tty_audit.c:209: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 207. dev_t dev; + 208. + 209. > audit_tty = READ_ONCE(current->signal->audit_tty); + 210. if (~audit_tty & AUDIT_TTY_ENABLE) + 211. return; + +net/sched/sch_mq.c:207: error: NULL_DEREFERENCE + pointer `dev_queue` last assigned on line 205 could be null and is dereferenced at line 207, column 8. + 205. struct netdev_queue *dev_queue = mq_queue_get(sch, cl); + 206. + 207. > sch = dev_queue->qdisc_sleeping; + 208. if (gnet_stats_copy_basic(&sch->running, d, NULL, &sch->bstats) < 0 || + 209. gnet_stats_copy_queue(d, NULL, &sch->qstats, sch->q.qlen) < 0) + +security/selinux/avc.c:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. slots_used++; + 216. chain_len = 0; + 217. > hlist_for_each_entry_rcu(node, head, list) + 218. chain_len++; + 219. if (chain_len > max_chain_len) + +drivers/input/mouse/synaptics.c:215: error: UNINITIALIZED_VALUE + The value read from resp.be_val was never initialized. + 213. return error; + 214. + 215. > *val = be32_to_cpu(resp.be_val); + 216. return 0; + 217. } + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +include/trace/events/smbus.h:203: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 201. * i2c_smbus_xfer() result + 202. */ + 203. > TRACE_EVENT(smbus_result, + 204. TP_PROTO(const struct i2c_adapter *adap, + 205. u16 addr, unsigned short flags, + +kernel/cgroup/freezer.c:221: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 220 could be null and is dereferenced at line 221, column 6. + 219. + 220. freezer = task_freezer(task); + 221. > if (freezer->state & CGROUP_FREEZING) + 222. freeze_task(task); + 223. + +drivers/gpu/drm/i915/intel_dp_mst.c:245: error: DEAD_STORE + The value written to &ret (type int) is never used. + 243. I915_WRITE(DP_TP_STATUS(port), temp); + 244. + 245. > ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); + 246. } + 247. + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_frags_entry, + 206. + 207. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +include/trace/events/sunrpc.h:205: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 203. ); + 204. + 205. > DEFINE_EVENT(rpc_task_queued, rpc_task_wakeup, + 206. + 207. TP_PROTO(const struct rpc_clnt *clnt, const struct rpc_task *task, const struct rpc_wait_queue *q), + +kernel/fork.c:214: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 212. struct vm_struct *s; + 213. + 214. > s = this_cpu_xchg(cached_stacks[i], NULL); + 215. + 216. if (!s) + +kernel/fork.c:214: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 212. struct vm_struct *s; + 213. + 214. > s = this_cpu_xchg(cached_stacks[i], NULL); + 215. + 216. if (!s) + +net/sunrpc/stats.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. + 218. rcu_read_lock(); + 219. > xprt = rcu_dereference(clnt->cl_xprt); + 220. if (xprt) + 221. xprt->ops->print_stats(xprt, seq); + +security/commoncap.c:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. /* Derived from kernel/capability.c:sys_capget. */ + 211. rcu_read_lock(); + 212. > cred = __task_cred(target); + 213. *effective = cred->cap_effective; + 214. *inheritable = cred->cap_inheritable; + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +kernel/locking/osq_lock.c:209: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 207. { + 208. struct optimistic_spin_node *node, *next; + 209. > int curr = encode_cpu(smp_processor_id()); + 210. + 211. /* + +drivers/pci/pcie/aspm.c:271: error: UNINITIALIZED_VALUE + The value read from child_reg[_] was never initialized. + 269. pci_err(parent, "ASPM: Could not configure common clock\n"); + 270. list_for_each_entry(child, &linkbus->devices, bus_list) + 271. > pcie_capability_write_word(child, PCI_EXP_LNKCTL, + 272. child_reg[PCI_FUNC(child->devfn)]); + 273. pcie_capability_write_word(parent, PCI_EXP_LNKCTL, parent_reg); + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +include/trace/events/block.h:207: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 205. * device driver for processing. + 206. */ + 207. > DEFINE_EVENT(block_rq, block_rq_issue, + 208. + 209. TP_PROTO(struct request_queue *q, struct request *rq), + +kernel/audit_tree.c:214: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 212. struct audit_chunk *p; + 213. + 214. > list_for_each_entry_rcu(p, list, hash) { + 215. if (chunk_to_key(p) == key) { + 216. atomic_long_inc(&p->refs); + +kernel/rcu/tree.c:211: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 209. unsigned long rcu_rnp_online_cpus(struct rcu_node *rnp) + 210. { + 211. > return READ_ONCE(rnp->qsmaskinitnext); + 212. } + 213. + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +kernel/smp.c:223: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 221. + 222. /* There shouldn't be any pending callbacks on an offline CPU. */ + 223. > if (unlikely(warn_cpu_offline && !cpu_online(smp_processor_id()) && + 224. !warned && !llist_empty(head))) { + 225. warned = true; + +kernel/smp.c:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. !warned && !llist_empty(head))) { + 225. warned = true; + 226. > WARN(1, "IPI on offline CPU %d\n", smp_processor_id()); + 227. + 228. /* + +arch/x86/lib/msr-smp.c:221: error: UNINITIALIZED_VALUE + The value read from rv.err was never initialized. + 219. *q = rv.reg.q; + 220. + 221. > return err ? err : rv.err; + 222. } + 223. EXPORT_SYMBOL(rdmsrl_safe_on_cpu); + +crypto/algboss.c:213: error: DEAD_STORE + The value written to &type (type unsigned int) is never used. + 211. { + 212. struct crypto_test_param *param = data; + 213. > u32 type = param->type; + 214. int err = 0; + 215. + +drivers/gpu/drm/i915/intel_guc_fw.c:223: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 221. * execlist mode if this happens.) + 222. */ + 223. > ret = wait_for(guc_ready(guc, &status), 100); + 224. DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + +drivers/gpu/drm/i915/intel_guc_fw.c:224: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 222. */ + 223. ret = wait_for(guc_ready(guc, &status), 100); + 224. > DRM_DEBUG_DRIVER("GuC status %#x\n", status); + 225. + 226. if ((status & GS_BOOTROM_MASK) == GS_BOOTROM_RSA_FAILED) { + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +kernel/sched/idle.c:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. static void do_idle(void) + 211. { + 212. > int cpu = smp_processor_id(); + 213. /* + 214. * If the arch has a polling bit, we maintain an invariant: + +lib/bug.c:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. + 215. rcu_read_lock_sched(); + 216. > list_for_each_entry_rcu(mod, &module_bug_list, bug_list) + 217. clear_once_table(mod->bug_table, + 218. mod->bug_table + mod->num_bugs); + +net/core/dst.c:222: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 220. + 221. new = (unsigned long) p; + 222. > prev = cmpxchg(&dst->_metrics, old, new); + 223. + 224. if (prev != old) { + +net/core/net-procfs.c:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. int t; + 215. + 216. > list_for_each_entry_rcu(pt, &ptype_all, list) { + 217. if (i == pos) + 218. return pt; + +net/core/net-procfs.c:223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 221. + 222. for (t = 0; t < PTYPE_HASH_SIZE; t++) { + 223. > list_for_each_entry_rcu(pt, &ptype_base[t], list) { + 224. if (i == pos) + 225. return pt; + +net/ipv4/tcp_metrics.c:218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 216. int depth = 0; + 217. + 218. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 219. tm = rcu_dereference(tm->tcpm_next)) { + 220. if (addr_same(&tm->tcpm_saddr, saddr) && + +net/ipv4/tcp_metrics.c:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. + 218. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 219. > tm = rcu_dereference(tm->tcpm_next)) { + 220. if (addr_same(&tm->tcpm_saddr, saddr) && + 221. addr_same(&tm->tcpm_daddr, daddr) && + +net/sunrpc/xprtmultipath.c:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. struct rpc_xprt *pos; + 216. + 217. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 218. if (cur == pos) + 219. return pos; + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:212: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 210. ); + 211. + 212. > DEFINE_EVENT(net_dev_rx_verbose_template, napi_gro_receive_entry, + 213. + 214. TP_PROTO(const struct sk_buff *skb), + +net/wireless/radiotap.c:304: error: UNINITIALIZED_VALUE + The value read from size was never initialized. + 302. iterator->this_arg_index = iterator->_arg_index; + 303. iterator->this_arg = iterator->_arg; + 304. > iterator->this_arg_size = size; + 305. + 306. /* internally move on the size of this arg */ + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:213: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 211. /* plane updates */ + 212. + 213. > TRACE_EVENT(intel_update_plane, + 214. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 215. TP_ARGS(plane, crtc), + +drivers/tty/tty_buffer.c:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. * no pending memory accesses to the freed buffer + 225. */ + 226. > while ((next = smp_load_acquire(&buf->head->next)) != NULL) { + 227. tty_buffer_free(port, buf->head); + 228. buf->head = next; + +drivers/video/fbdev/core/fbcvt.c:261: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 259. if (cvt->flags & FB_CVT_FLAG_REDUCED_BLANK) { + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. > cnt -= read; + 262. offset += read; + 263. } + +drivers/video/fbdev/core/fbcvt.c:262: error: DEAD_STORE + The value written to &offset (type int) is never used. + 260. read = snprintf(buf+offset, cnt, "-R"); + 261. cnt -= read; + 262. > offset += read; + 263. } + 264. } + +include/linux/inetdevice.h:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. static inline struct in_device *__in_dev_get_rcu(const struct net_device *dev) + 215. { + 216. > return rcu_dereference(dev->ip_ptr); + 217. } + 218. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +include/trace/events/random.h:214: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 212. ); + 213. + 214. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes, + 215. TP_PROTO(int nbytes, unsigned long IP), + 216. + +lib/genalloc.c:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. + 219. rcu_read_lock(); + 220. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 221. if (addr >= chunk->start_addr && addr <= chunk->end_addr) { + 222. paddr = chunk->phys_addr + (addr - chunk->start_addr); + +lib/rhashtable.c:221: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 219. do { + 220. new_tbl = tbl; + 221. > tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 222. } while (tbl); + 223. + +net/netfilter/nf_log.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. rcu_read_lock(); + 228. if (loginfo != NULL) + 229. > logger = rcu_dereference(loggers[pf][loginfo->type]); + 230. else + 231. logger = rcu_dereference(net->nf.nf_loggers[pf]); + +net/netfilter/nf_log.c:231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 229. logger = rcu_dereference(loggers[pf][loginfo->type]); + 230. else + 231. > logger = rcu_dereference(net->nf.nf_loggers[pf]); + 232. + 233. if (logger) { + +net/ipv6/proc.c:225: error: UNINITIALIZED_VALUE + The value read from buff64[_] was never initialized. + 223. snmp_get_cpu_field64_batch(buff64, itemlist, mib, syncpoff); + 224. for (i = 0; itemlist[i].name; i++) + 225. > seq_printf(seq, "%-32s\t%llu\n", itemlist[i].name, buff64[i]); + 226. } + 227. + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +include/trace/events/tcp.h:216: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 214. ); + 215. + 216. > TRACE_EVENT(tcp_retransmit_synack, + 217. + 218. TP_PROTO(const struct sock *sk, const struct request_sock *req), + +kernel/audit.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. rcu_read_lock(); + 222. > ac = rcu_dereference(auditd_conn); + 223. rc = (ac && ac->pid == task_tgid(task) ? 1 : 0); + 224. rcu_read_unlock(); + +net/netlabel/netlabel_unlabeled.c:223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 221. + 222. bkt = netlbl_unlhsh_hash(ifindex); + 223. > bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]; + 224. list_for_each_entry_rcu(iter, bkt_list, list) + 225. if (iter->valid && iter->ifindex == ifindex) + +net/netlabel/netlabel_unlabeled.c:224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 222. bkt = netlbl_unlhsh_hash(ifindex); + 223. bkt_list = &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]; + 224. > list_for_each_entry_rcu(iter, bkt_list, list) + 225. if (iter->valid && iter->ifindex == ifindex) + 226. return iter; + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +lib/percpu_ida.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. + 234. if (nr_free == 1) { + 235. > cpumask_set_cpu(smp_processor_id(), + 236. &pool->cpus_have_tags); + 237. wake_up(&pool->wait); + +net/wireless/trace.h:217: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +net/wireless/trace.h:217: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 215. *************************************************************/ + 216. + 217. > TRACE_EVENT(rdev_suspend, + 218. TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), + 219. TP_ARGS(wiphy, wow), + +security/selinux/hooks.c:222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 220. + 221. rcu_read_lock(); + 222. > sid = cred_sid(__task_cred(task)); + 223. rcu_read_unlock(); + 224. return sid; + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +drivers/base/regmap/trace.h:218: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 216. ); + 217. + 218. > DEFINE_EVENT(regmap_async, regmap_async_complete_done, + 219. + 220. TP_PROTO(struct regmap *map), + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +kernel/cgroup/stat.c:222: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 220. { + 221. u64_stats_update_end(&cstat->sync); + 222. > cgroup_cpu_stat_updated(cgrp, smp_processor_id()); + 223. put_cpu_ptr(cstat); + 224. } + +net/core/sock_reuseport.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. + 228. rcu_read_lock(); + 229. > reuse = rcu_dereference(sk->sk_reuseport_cb); + 230. + 231. /* if memory allocation failed or add call is not yet complete */ + +net/core/sock_reuseport.c:235: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 233. goto out; + 234. + 235. > prog = rcu_dereference(reuse->prog); + 236. socks = READ_ONCE(reuse->num_socks); + 237. if (likely(socks)) { + +net/core/sock_reuseport.c:236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 234. + 235. prog = rcu_dereference(reuse->prog); + 236. > socks = READ_ONCE(reuse->num_socks); + 237. if (likely(socks)) { + 238. /* paired with smp_wmb() in reuseport_add_sock() */ + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/ras/ras_event.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. * + 218. */ + 219. > TRACE_EVENT(non_standard_event, + 220. + 221. TP_PROTO(const uuid_le *sec_type, + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:219: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 217. ); + 218. + 219. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_receive_skb_entry, + 220. + 221. TP_PROTO(const struct sk_buff *skb), + +drivers/scsi/scsi_logging.c:249: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 247. if (cmd->cmd_len > 16) { + 248. /* Print opcode in one line and use separate lines for CDB */ + 249. > off += scnprintf(logbuf + off, logbuf_len - off, "\n"); + 250. dev_printk(KERN_INFO, &cmd->device->sdev_gendev, "%s", logbuf); + 251. scsi_log_release_buffer(logbuf); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +drivers/tty/sysrq.c:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. + 224. /* Idle CPUs have no interesting backtrace. */ + 225. > if (idle_cpu(smp_processor_id())) + 226. return; + 227. + +drivers/tty/sysrq.c:229: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 227. + 228. spin_lock_irqsave(&show_lock, flags); + 229. > pr_info("CPU%d:\n", smp_processor_id()); + 230. show_stack(NULL, NULL); + 231. spin_unlock_irqrestore(&show_lock, flags); + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +include/trace/events/random.h:220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 218. ); + 219. + 220. > DEFINE_EVENT(random__get_random_bytes, get_random_bytes_arch, + 221. TP_PROTO(int nbytes, unsigned long IP), + 222. + +drivers/iommu/dmar.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. } + 263. + 264. > for_each_dev_scope(devices, devices_cnt, i, tmp) + 265. if (tmp == NULL) { + 266. devices[i].bus = info->dev->bus->number; + +net/xfrm/xfrm_state.c:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. typemap = afinfo->type_map; + 233. + 234. > type = READ_ONCE(typemap[proto]); + 235. if (unlikely(type && !try_module_get(type->owner))) + 236. type = NULL; + +security/selinux/ss/conditional.c:238: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 236. goto err; + 237. + 238. > booldatum->value = le32_to_cpu(buf[0]); + 239. booldatum->state = le32_to_cpu(buf[1]); + 240. + +security/selinux/ss/conditional.c:239: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 237. + 238. booldatum->value = le32_to_cpu(buf[0]); + 239. > booldatum->state = le32_to_cpu(buf[1]); + 240. + 241. rc = -EINVAL; + +security/selinux/ss/conditional.c:245: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 243. goto err; + 244. + 245. > len = le32_to_cpu(buf[2]); + 246. if (((len == 0) || (len == (u32)-1))) + 247. goto err; + +drivers/tty/vt/vt_ioctl.c:240: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 238. op->width = 8; + 239. op->height = cfdarg.charheight; + 240. > op->charcount = cfdarg.charcount; + 241. op->data = cfdarg.chardata; + 242. return con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:248: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 246. op->width = 8; + 247. op->height = cfdarg.charheight; + 248. > op->charcount = cfdarg.charcount; + 249. op->data = cfdarg.chardata; + 250. i = con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:241: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 239. op->height = cfdarg.charheight; + 240. op->charcount = cfdarg.charcount; + 241. > op->data = cfdarg.chardata; + 242. return con_font_op(vc_cons[fg_console].d, op); + 243. case GIO_FONTX: { + +drivers/tty/vt/vt_ioctl.c:249: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 247. op->height = cfdarg.charheight; + 248. op->charcount = cfdarg.charcount; + 249. > op->data = cfdarg.chardata; + 250. i = con_font_op(vc_cons[fg_console].d, op); + 251. if (i) + +drivers/tty/vt/vt_ioctl.c:239: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 237. op->flags = KD_FONT_FLAG_OLD; + 238. op->width = 8; + 239. > op->height = cfdarg.charheight; + 240. op->charcount = cfdarg.charcount; + 241. op->data = cfdarg.chardata; + +drivers/tty/vt/vt_ioctl.c:247: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 245. op->flags = KD_FONT_FLAG_OLD; + 246. op->width = 8; + 247. > op->height = cfdarg.charheight; + 248. op->charcount = cfdarg.charcount; + 249. op->data = cfdarg.chardata; + +include/net/ip6_fib.h:230: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 228. + 229. rcu_read_lock(); + 230. > fn = rcu_dereference(rt->rt6i_node); + 231. + 232. if (fn) { + +net/core/netpoll.c:229: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 227. might_sleep(); + 228. idx = srcu_read_lock(&netpoll_srcu); + 229. > ni = srcu_dereference(dev->npinfo, &netpoll_srcu); + 230. if (ni) + 231. down(&ni->dev_lock); + +net/ipv4/ip_tunnel.c:236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 234. struct hlist_head *head = ip_bucket(itn, parms); + 235. + 236. > hlist_for_each_entry_rcu(t, head, hash_node) { + 237. if (local == t->parms.iph.saddr && + 238. remote == t->parms.iph.daddr && + +net/ipv6/ip6_input.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. resubmit_final: + 246. raw = raw6_local_deliver(skb, nexthdr); + 247. > ipprot = rcu_dereference(inet6_protos[nexthdr]); + 248. if (ipprot) { + 249. int ret; + +net/sunrpc/xprtmultipath.c:227: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 225. struct rpc_xprt *xprt_iter_current_entry(struct rpc_xprt_iter *xpi) + 226. { + 227. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 228. struct list_head *head; + 229. + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:225: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 223. * performance. + 224. */ + 225. > TRACE_EVENT(block_bio_bounce, + 226. + 227. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +kernel/trace/blktrace.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. if (act_log_check(bt, what, sector, pid)) + 258. return; + 259. > cpu = raw_smp_processor_id(); + 260. + 261. if (blk_tracer) { + +arch/x86/events/intel/bts.c:232: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 229 could be null and is dereferenced at line 232, column 7. + 230. u64 config = 0; + 231. + 232. > if (!buf->snapshot) + 233. config |= ARCH_PERFMON_EVENTSEL_INT; + 234. if (!event->attr.exclude_kernel) + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +drivers/base/regmap/trace.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > TRACE_EVENT(regcache_drop_region, + 227. + 228. TP_PROTO(struct regmap *map, unsigned int from, + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. ); + 225. + 226. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_entry, + 227. + 228. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +include/trace/events/sched.h:226: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 224. * Tracepoint for freeing a task: + 225. */ + 226. > DEFINE_EVENT(sched_process_template, sched_process_free, + 227. TP_PROTO(struct task_struct *p), + 228. TP_ARGS(p)); + +net/ipv4/inet_hashtables.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. score += 4; + 250. } + 251. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 252. score++; + 253. } + +net/ipv4/netfilter/ip_tables.c:263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 261. local_bh_disable(); + 262. addend = xt_write_recseq_begin(); + 263. > private = READ_ONCE(table->private); /* Address dependency. */ + 264. cpu = smp_processor_id(); + 265. table_base = private->entries; + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = READ_ONCE(table->private); /* Address dependency. */ + 264. > cpu = smp_processor_id(); + 265. table_base = private->entries; + 266. jumpstack = (struct ipt_entry **)private->jumpstack[cpu]; + +net/ipv4/netfilter/ip_tables.c:276: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 274. */ + 275. if (static_key_false(&xt_tee_enabled)) + 276. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 277. + 278. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv4/netfilter/ip_tables.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. addend = xt_write_recseq_begin(); + 263. private = READ_ONCE(table->private); /* Address dependency. */ + 264. > cpu = smp_processor_id(); + 265. table_base = private->entries; + 266. jumpstack = (struct ipt_entry **)private->jumpstack[cpu]; + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:233: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 230 could be null and is dereferenced at line 233, column 6. + 231. struct intel_panel *panel = &connector->panel; + 232. + 233. > if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) + 234. panel->backlight.max = 0xFFFF; + 235. else + +kernel/power/process.c:237: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 235. + 236. read_lock(&tasklist_lock); + 237. > for_each_process_thread(g, p) { + 238. if (p->flags & (PF_KTHREAD | PF_WQ_WORKER)) + 239. __thaw_task(p); + +lib/rhashtable.c:261: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 259. + 260. spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING); + 261. > head = rht_dereference_bucket(new_tbl->buckets[new_hash], + 262. new_tbl, new_hash); + 263. + +lib/rhashtable.c:231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 229. struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht); + 230. struct bucket_table *new_tbl = rhashtable_last_table(ht, + 231. > rht_dereference_rcu(old_tbl->future_tbl, ht)); + 232. struct rhash_head __rcu **pprev = rht_bucket_var(old_tbl, old_hash); + 233. int err = -EAGAIN; + +lib/rhashtable.c:269: error: UNINITIALIZED_VALUE + The value read from next was never initialized. + 267. spin_unlock(new_bucket_lock); + 268. + 269. > rcu_assign_pointer(*pprev, next); + 270. + 271. out: + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +include/trace/events/timer.h:228: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 226. * Allows to determine the timer latency. + 227. */ + 228. > TRACE_EVENT(hrtimer_expire_entry, + 229. + 230. TP_PROTO(struct hrtimer *hrtimer, ktime_t *now), + +net/ipv4/tcp_metrics.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. hash = hash_32(hash, tcp_metrics_hash_log); + 259. + 260. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 261. tm = rcu_dereference(tm->tcpm_next)) { + 262. if (addr_same(&tm->tcpm_saddr, &saddr) && + +net/ipv4/tcp_metrics.c:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. + 260. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 261. > tm = rcu_dereference(tm->tcpm_next)) { + 262. if (addr_same(&tm->tcpm_saddr, &saddr) && + 263. addr_same(&tm->tcpm_daddr, &daddr) && + +kernel/rcu/tree.c:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. { + 232. RCU_LOCKDEP_WARN(preemptible(), "rcu_sched_qs() invoked with preemption enabled!!!"); + 233. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + +kernel/rcu/tree.c:236: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 234. return; + 235. trace_rcu_grace_period(TPS("rcu_sched"), + 236. > __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. TPS("cpuqs")); + 238. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false); + 239. > if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 240. return; + 241. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.exp, false); + +kernel/rcu/tree.c:235: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 233. if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s)) + 234. return; + 235. > trace_rcu_grace_period(TPS("rcu_sched"), + 236. __this_cpu_read(rcu_sched_data.gpnum), + 237. TPS("cpuqs")); + +lib/idr.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. + 246. *nextid = id; + 247. > return rcu_dereference_raw(*slot); + 248. } + 249. EXPORT_SYMBOL(idr_get_next); + +net/netfilter/nf_conntrack_helper.c:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. * we cannot reallocate the helper extension area. + 272. */ + 273. > struct nf_conntrack_helper *tmp = rcu_dereference(help->helper); + 274. + 275. if (tmp && tmp->help != helper->help) { + +block/blk-lib.c:253: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 252 could be null and is dereferenced at line 253, column 3. + 251. while (nr_sects) { + 252. bio = next_bio(bio, 0, gfp_mask); + 253. > bio->bi_iter.bi_sector = sector; + 254. bio_set_dev(bio, bdev); + 255. bio->bi_opf = REQ_OP_WRITE_ZEROES; + +drivers/video/backlight/backlight.c:234: error: DEAD_STORE + The value written to &rc (type int) is never used. + 232. struct device_attribute *attr, char *buf) + 233. { + 234. > int rc = -ENXIO; + 235. struct backlight_device *bd = to_backlight_device(dev); + 236. + +kernel/rcu/srcutree.c:238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 236. WARN_ON_ONCE(rcu_scheduler_active == RCU_SCHEDULER_INIT); + 237. /* The smp_load_acquire() pairs with the smp_store_release(). */ + 238. > if (!rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq_needed))) /*^^^*/ + 239. return; /* Already initialized. */ + 240. spin_lock_irqsave_rcu_node(sp, flags); + +block/ioctl.c:246: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 244. return -EFAULT; + 245. + 246. > start = range[0]; + 247. len = range[1]; + 248. end = start + len - 1; + +block/ioctl.c:247: error: UNINITIALIZED_VALUE + The value read from range[_] was never initialized. + 245. + 246. start = range[0]; + 247. > len = range[1]; + 248. end = start + len - 1; + 249. + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +include/trace/events/net.h:233: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 231. ); + 232. + 233. > DEFINE_EVENT(net_dev_rx_verbose_template, netif_rx_ni_entry, + 234. + 235. TP_PROTO(const struct sk_buff *skb), + +kernel/exit.c:245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 243. */ + 244. retry: + 245. > task = rcu_dereference(*ptask); + 246. if (!task) + 247. return NULL; + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +include/trace/events/sched.h:234: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 232. * Tracepoint for a task exiting: + 233. */ + 234. > DEFINE_EVENT(sched_process_template, sched_process_exit, + 235. TP_PROTO(struct task_struct *p), + 236. TP_ARGS(p)); + +drivers/gpu/drm/i915/i915_debugfs.c:245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 243. int ret; + 244. + 245. > total = READ_ONCE(dev_priv->mm.object_count); + 246. objects = kvmalloc_array(total, sizeof(*objects), GFP_KERNEL); + 247. if (!objects) + +kernel/audit.c:241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 239. + 240. rcu_read_lock(); + 241. > ac = rcu_dereference(auditd_conn); + 242. if (!ac || !ac->pid) + 243. pid = 0; + +security/selinux/ss/mls.c:366: error: DEAD_STORE + The value written to &p (type char*) is never used. + 364. goto out; + 365. } + 366. > *scontext = ++p; + 367. rc = 0; + 368. out: + +drivers/gpu/drm/i915/intel_hdmi.c:248: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 240 could be null and is dereferenced at line 248, column 37. + 246. return false; + 247. + 248. > if ((val & VIDEO_DIP_PORT_MASK) != VIDEO_DIP_PORT(intel_dig_port->base.port)) + 249. return false; + 250. + +drivers/video/fbdev/core/bitblit.c:252: error: DEAD_STORE + The value written to &mode (type int) is never used. + 250. if (softback_lines) { + 251. if (y + softback_lines >= vc->vc_rows) { + 252. > mode = CM_ERASE; + 253. ops->cursor_flash = 0; + 254. return; + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +kernel/time/tick-common.c:239: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 237. { + 238. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 239. > int cpu = smp_processor_id(); + 240. + 241. clockevents_exchange_device(td->evtdev, newdev); + +kernel/trace/trace_events.c:242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 240. struct trace_pid_list *pid_list; + 241. + 242. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 243. if (!pid_list) + 244. return false; + +net/core/netpoll.c:240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 238. struct netpoll_info *ni; + 239. rcu_read_lock(); + 240. > ni = rcu_dereference(dev->npinfo); + 241. if (ni) + 242. up(&ni->dev_lock); + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +arch/x86/include/asm/desc.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. { + 240. struct desc_ptr gdt; + 241. > int cpu = raw_smp_processor_id(); + 242. bool restore = 0; + 243. struct desc_struct *fixmap_gdt; + +drivers/firmware/efi/esrt.c:305: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_count was never initialized. + 303. */ + 304. if (tmpesrt.fw_resource_count > 128) { + 305. > pr_err("ESRT says fw_resource_count has very large value %d.\n", + 306. tmpesrt.fw_resource_count); + 307. goto err_memunmap; + +drivers/firmware/efi/esrt.c:286: error: UNINITIALIZED_VALUE + The value read from tmpesrt.fw_resource_version was never initialized. + 284. entry_size = sizeof (*v1_entries); + 285. } else { + 286. > pr_err("Unsupported ESRT version %lld.\n", + 287. tmpesrt.fw_resource_version); + 288. return; + +lib/sbitmap.c:246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 244. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. > unsigned long word = READ_ONCE(sb->map[i].word); + 247. unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + +lib/sbitmap.c:247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 245. for (i = 0; i < sb->map_nr; i++) { + 246. unsigned long word = READ_ONCE(sb->map[i].word); + 247. > unsigned int word_bits = READ_ONCE(sb->map[i].depth); + 248. + 249. while (word_bits > 0) { + +net/core/gen_estimator.c:240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 238. bool gen_estimator_active(struct net_rate_estimator __rcu **rate_est) + 239. { + 240. > return !!rcu_access_pointer(*rate_est); + 241. } + 242. EXPORT_SYMBOL(gen_estimator_active); + +net/sunrpc/xprtmultipath.c:248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 246. + 247. head = &xps->xps_xprt_list; + 248. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 249. if (rpc_cmp_addr_port(sap, (struct sockaddr *)&pos->addr)) { + 250. pr_info("RPC: addr %s already in xprt switch\n", + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +kernel/profile.c:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. static void __profile_flip_buffers(void *unused) + 240. { + 241. > int cpu = smp_processor_id(); + 242. + 243. per_cpu(cpu_profile_flip, cpu) = !per_cpu(cpu_profile_flip, cpu); + +net/core/dst.c:245: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 243. + 244. new = ((unsigned long) &dst_default_metrics) | DST_METRICS_READ_ONLY; + 245. > prev = cmpxchg(&dst->_metrics, old, new); + 246. if (prev == old) + 247. kfree(__DST_METRICS_PTR(old)); + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +drivers/tty/sysrq.c:254: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 252. regs = get_irq_regs(); + 253. if (regs) { + 254. > pr_info("CPU%d:\n", smp_processor_id()); + 255. show_regs(regs); + 256. } + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +include/trace/events/sched.h:241: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 239. * Tracepoint for waiting on task to unschedule: + 240. */ + 241. > DEFINE_EVENT(sched_process_template, sched_wait_task, + 242. TP_PROTO(struct task_struct *p), + 243. TP_ARGS(p)); + +kernel/kexec.c:265: error: UNINITIALIZED_VALUE + The value read from in.buf was never initialized. + 263. return -EFAULT; + 264. + 265. > out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + +kernel/kexec.c:266: error: UNINITIALIZED_VALUE + The value read from in.bufsz was never initialized. + 264. + 265. out.buf = compat_ptr(in.buf); + 266. > out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. out.memsz = in.memsz; + +kernel/kexec.c:267: error: UNINITIALIZED_VALUE + The value read from in.mem was never initialized. + 265. out.buf = compat_ptr(in.buf); + 266. out.bufsz = in.bufsz; + 267. > out.mem = in.mem; + 268. out.memsz = in.memsz; + 269. + +kernel/kexec.c:268: error: UNINITIALIZED_VALUE + The value read from in.memsz was never initialized. + 266. out.bufsz = in.bufsz; + 267. out.mem = in.mem; + 268. > out.memsz = in.memsz; + 269. + 270. result = copy_to_user(&ksegments[i], &out, sizeof(out)); + +lib/random32.c:250: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 248. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. > state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + +lib/random32.c:251: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 249. get_random_bytes(&seeds, sizeof(seeds)); + 250. state->s1 = __seed(seeds[0], 2U); + 251. > state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + +lib/random32.c:252: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 250. state->s1 = __seed(seeds[0], 2U); + 251. state->s2 = __seed(seeds[1], 8U); + 252. > state->s3 = __seed(seeds[2], 16U); + 253. state->s4 = __seed(seeds[3], 128U); + 254. + +lib/random32.c:253: error: UNINITIALIZED_VALUE + The value read from seeds[_] was never initialized. + 251. state->s2 = __seed(seeds[1], 8U); + 252. state->s3 = __seed(seeds[2], 16U); + 253. > state->s4 = __seed(seeds[3], 128U); + 254. + 255. prandom_warmup(state); + +net/ipv6/ip6_flowlabel.c:249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 247. + 248. rcu_read_lock_bh(); + 249. > for_each_sk_fl_rcu(np, sfl) { + 250. struct ip6_flowlabel *fl = sfl->fl; + 251. if (fl->label == label) { + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +include/trace/events/scsi.h:242: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 240. ); + 241. + 242. > TRACE_EVENT(scsi_dispatch_cmd_error, + 243. + 244. TP_PROTO(struct scsi_cmnd *cmd, int rtn), + +net/sunrpc/auth_gss/gss_rpc_xdr.c:253: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 251. if (unlikely(p == NULL)) + 252. return -ENOSPC; + 253. > count = be32_to_cpup(p++); + 254. if (!count) + 255. return 0; + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +kernel/softirq.c:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. current->flags &= ~PF_MEMALLOC; + 258. + 259. > pending = local_softirq_pending(); + 260. account_irq_enter_time(current); + 261. + +kernel/softirq.c:300: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 298. local_irq_disable(); + 299. + 300. > pending = local_softirq_pending(); + 301. if (pending) { + 302. if (time_before(jiffies, end) && !need_resched() && + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/gpu/drm/i915/i915_trace.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > TRACE_EVENT(intel_disable_plane, + 244. TP_PROTO(struct drm_plane *plane, struct intel_crtc *crtc), + 245. TP_ARGS(plane, crtc), + +drivers/md/dm-stripe.c:255: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 253. sector = *result; + 254. if (sc->chunk_size_shift < 0) + 255. > *result -= sector_div(sector, sc->chunk_size); + 256. else + 257. *result = sector & ~(sector_t)(sc->chunk_size - 1); + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:243: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 241. ); + 242. + 243. > DEFINE_EVENT(wakeup_source, wakeup_source_activate, + 244. + 245. TP_PROTO(const char *name, unsigned int state), + +net/netfilter/nf_log.c:256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 254. + 255. rcu_read_lock(); + 256. > logger = rcu_dereference(net->nf.nf_loggers[pf]); + 257. if (logger) { + 258. va_start(args, fmt); + +arch/x86/events/intel/uncore.c:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. box = container_of(hrtimer, struct intel_uncore_box, hrtimer); + 252. > if (!box->n_active || box->cpu != smp_processor_id()) + 253. return HRTIMER_NORESTART; + 254. /* + +include/linux/dma-fence.h:250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 248. struct dma_fence *fence; + 249. + 250. > fence = rcu_dereference(*fencep); + 251. if (!fence) + 252. return NULL; + +include/linux/dma-fence.h:271: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 269. * the right fence, as below. + 270. */ + 271. > if (fence == rcu_access_pointer(*fencep)) + 272. return rcu_pointer_handoff(fence); + 273. + +init/main.c:254: error: DEAD_STORE + The value written to &val (type char*) is never used. + 252. val[-2] = '='; + 253. memmove(val-1, val, strlen(val)+1); + 254. > val--; + 255. } else + 256. BUG(); + +kernel/cgroup/freezer.c:253: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 246 could be null and is dereferenced at line 253, column 8. + 251. lockdep_assert_held(&freezer_mutex); + 252. + 253. > if (!(freezer->state & CGROUP_FREEZING) || + 254. (freezer->state & CGROUP_FROZEN)) + 255. return; + +net/core/gen_estimator.c:251: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 249. + 250. rcu_read_lock(); + 251. > est = rcu_dereference(*rate_est); + 252. if (!est) { + 253. rcu_read_unlock(); + +net/ipv6/inet6_hashtables.c:255: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 253. struct net *net = sock_net(sk); + 254. const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + 257. inet->inet_dport); + +net/ipv6/inet6_hashtables.c:254: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 252. const int dif = sk->sk_bound_dev_if; + 253. struct net *net = sock_net(sk); + 254. > const int sdif = l3mdev_master_ifindex_by_index(net, dif); + 255. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 256. const unsigned int hash = inet6_ehashfn(net, daddr, lport, saddr, + +net/packet/af_packet.c:265: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 263. local_bh_disable(); + 264. + 265. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 266. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 267. ret = netdev_start_xmit(skb, dev, txq, false); + +net/packet/af_packet.c:265: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 263. local_bh_disable(); + 264. + 265. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 266. if (!netif_xmit_frozen_or_drv_stopped(txq)) + 267. ret = netdev_start_xmit(skb, dev, txq, false); + +drivers/gpu/drm/i915/intel_dp_aux_backlight.c:254: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 249 could be null and is dereferenced at line 254, column 6. + 252. * the panel can support backlight control over the aux channel + 253. */ + 254. > if (intel_dp->edp_dpcd[1] & DP_EDP_TCON_BACKLIGHT_ADJUSTMENT_CAP && + 255. (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_AUX_SET_CAP) && + 256. !(intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_PWM_PIN_CAP)) { + +kernel/profile.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. + 250. mutex_lock(&profile_flip_mutex); + 251. > j = per_cpu(cpu_profile_flip, get_cpu()); + 252. put_cpu(); + 253. on_each_cpu(__profile_flip_buffers, NULL, 1); + +kernel/rcu/tree.c:249: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 247. { + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. > if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + +kernel/rcu/tree.c:251: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. trace_rcu_grace_period(TPS("rcu_bh"), + 251. > __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + 253. __this_cpu_write(rcu_bh_data.cpu_no_qs.b.norm, false); + +kernel/rcu/tree.c:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!"); + 249. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) { + 250. > trace_rcu_grace_period(TPS("rcu_bh"), + 251. __this_cpu_read(rcu_bh_data.gpnum), + 252. TPS("cpuqs")); + +net/ipv4/af_inet.c:266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 264. err = -ESOCKTNOSUPPORT; + 265. rcu_read_lock(); + 266. > list_for_each_entry_rcu(answer, &inetsw[sock->type], list) { + 267. + 268. err = 0; + +net/ipv4/inet_connection_sock.c:255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 253. if (!sk->sk_reuseport) + 254. return 0; + 255. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 256. return 0; + 257. if (!uid_eq(tb->fastuid, uid)) + +arch/x86/entry/common.c:249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 247. { + 248. struct thread_info *ti = current_thread_info(); + 249. > u32 cached_flags = READ_ONCE(ti->flags); + 250. + 251. CT_WARN_ON(ct_state() != CONTEXT_KERNEL); + +drivers/gpu/drm/i915/intel_dp_mst.c:268: error: DEAD_STORE + The value written to &ret (type int) is never used. + 266. DRM_ERROR("Timed out waiting for ACT sent\n"); + 267. + 268. > ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + +drivers/gpu/drm/i915/intel_dp_mst.c:270: error: DEAD_STORE + The value written to &ret (type int) is never used. + 268. ret = drm_dp_check_act_status(&intel_dp->mst_mgr); + 269. + 270. > ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); + 271. if (pipe_config->has_audio) + 272. intel_audio_codec_enable(encoder, pipe_config, conn_state); + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +include/trace/events/sched.h:248: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 246. * Tracepoint for a waiting task: + 247. */ + 248. > TRACE_EVENT(sched_process_wait, + 249. + 250. TP_PROTO(struct pid *pid), + +kernel/kprobes.c:256: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 254. mutex_lock(&c->mutex); + 255. rcu_read_lock(); + 256. > list_for_each_entry_rcu(kip, &c->pages, list) { + 257. idx = ((long)slot - (long)kip->insns) / + 258. (c->insn_size * sizeof(kprobe_opcode_t)); + +kernel/kprobes.c:277: error: UNINITIALIZED_VALUE + The value read from idx was never initialized. + 275. collect_garbage_slots(c); + 276. } else { + 277. > collect_one_slot(kip, idx); + 278. } + 279. } + +lib/iomap.c:250: error: DEAD_STORE + The value written to &port (type unsigned long) is never used. + 248. void pci_iounmap(struct pci_dev *dev, void __iomem * addr) + 249. { + 250. > IO_COND(addr, /* nothing */, iounmap(addr)); + 251. } + 252. EXPORT_SYMBOL(pci_iounmap); + +net/ipv4/tcp_cong.c:254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 252. + 253. rcu_read_lock(); + 254. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) { + 255. offs += snprintf(buf + offs, maxlen - offs, + 256. "%s%s", + +sound/core/pcm_native.c:268: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 266. + 267. if (trace_hw_mask_param_enabled()) + 268. > old_mask = *m; + 269. + 270. changed = snd_mask_refine(m, constrs_mask(constrs, k)); + +kernel/events/core.c:252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 250. { + 251. struct perf_event_context *ctx = event->ctx; + 252. > struct task_struct *task = READ_ONCE(ctx->task); /* verified in event_function */ + 253. struct event_function_struct efs = { + 254. .event = event, + +kernel/fork.c:256: error: UNINITIALIZED_VALUE + The value read from pco_ret__ was never initialized. + 254. + 255. for (i = 0; i < NR_CACHED_STACKS; i++) { + 256. > if (this_cpu_cmpxchg(cached_stacks[i], + 257. NULL, tsk->stack_vm_area) != NULL) + 258. continue; + +drivers/base/power/main.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. * walking. + 263. */ + 264. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 265. if (READ_ONCE(link->status) != DL_STATE_DORMANT) + 266. dpm_wait(link->supplier, async); + +drivers/gpu/drm/i915/intel_guc_log.c:280: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.read_ptr was never initialized. + 278. sizeof(struct guc_log_buffer_state)); + 279. buffer_size = guc_get_log_buffer_size(type); + 280. > read_offset = log_buf_state_local.read_ptr; + 281. write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + +drivers/gpu/drm/i915/intel_guc_log.c:281: error: UNINITIALIZED_VALUE + The value read from log_buf_state_local.sampled_write_ptr was never initialized. + 279. buffer_size = guc_get_log_buffer_size(type); + 280. read_offset = log_buf_state_local.read_ptr; + 281. > write_offset = log_buf_state_local.sampled_write_ptr; + 282. full_cnt = log_buf_state_local.buffer_full_cnt; + 283. + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +include/trace/events/power.h:250: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 248. ); + 249. + 250. > DEFINE_EVENT(wakeup_source, wakeup_source_deactivate, + 251. + 252. TP_PROTO(const char *name, unsigned int state), + +net/ipv6/netfilter/ip6_tables.c:285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 283. local_bh_disable(); + 284. addend = xt_write_recseq_begin(); + 285. > private = READ_ONCE(table->private); /* Address dependency. */ + 286. cpu = smp_processor_id(); + 287. table_base = private->entries; + +net/ipv6/netfilter/ip6_tables.c:286: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 284. addend = xt_write_recseq_begin(); + 285. private = READ_ONCE(table->private); /* Address dependency. */ + 286. > cpu = smp_processor_id(); + 287. table_base = private->entries; + 288. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +net/ipv6/netfilter/ip6_tables.c:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. */ + 297. if (static_key_false(&xt_tee_enabled)) + 298. > jumpstack += private->stacksize * __this_cpu_read(nf_skb_duplicated); + 299. + 300. e = get_entry(table_base, private->hook_entry[hook]); + +net/ipv6/netfilter/ip6_tables.c:286: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 284. addend = xt_write_recseq_begin(); + 285. private = READ_ONCE(table->private); /* Address dependency. */ + 286. > cpu = smp_processor_id(); + 287. table_base = private->entries; + 288. jumpstack = (struct ip6t_entry **)private->jumpstack[cpu]; + +drivers/gpu/drm/drm_ioc32.c:263: error: UNINITIALIZED_VALUE + The value read from c32.idx was never initialized. + 261. return -EFAULT; + 262. + 263. > client.idx = c32.idx; + 264. + 265. err = drm_ioctl_kernel(file, drm_getclient, &client, DRM_UNLOCKED); + +drivers/gpu/drm/drm_ioc32.c:270: error: UNINITIALIZED_VALUE + The value read from client.auth was never initialized. + 268. + 269. c32.idx = client.idx; + 270. > c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + +drivers/gpu/drm/drm_ioc32.c:274: error: UNINITIALIZED_VALUE + The value read from client.iocs was never initialized. + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. > c32.iocs = client.iocs; + 275. + 276. if (copy_to_user(argp, &c32, sizeof(c32))) + +drivers/gpu/drm/drm_ioc32.c:273: error: UNINITIALIZED_VALUE + The value read from client.magic was never initialized. + 271. c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. > c32.magic = client.magic; + 274. c32.iocs = client.iocs; + 275. + +drivers/gpu/drm/drm_ioc32.c:271: error: UNINITIALIZED_VALUE + The value read from client.pid was never initialized. + 269. c32.idx = client.idx; + 270. c32.auth = client.auth; + 271. > c32.pid = client.pid; + 272. c32.uid = client.uid; + 273. c32.magic = client.magic; + +drivers/gpu/drm/drm_ioc32.c:272: error: UNINITIALIZED_VALUE + The value read from client.uid was never initialized. + 270. c32.auth = client.auth; + 271. c32.pid = client.pid; + 272. > c32.uid = client.uid; + 273. c32.magic = client.magic; + 274. c32.iocs = client.iocs; + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +include/trace/events/random.h:252: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 250. + 251. + 252. > DEFINE_EVENT(random__extract_entropy, extract_entropy, + 253. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 254. unsigned long IP), + +kernel/sched/core.c:257: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 255. struct rq_flags rf; + 256. + 257. > WARN_ON_ONCE(cpu_of(rq) != smp_processor_id()); + 258. + 259. rq_lock(rq, &rf); + +net/netfilter/nf_queue.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. #endif + 259. case NFPROTO_IPV4: + 260. > return rcu_dereference(net->nf.hooks_ipv4[hooknum]); + 261. case NFPROTO_IPV6: + 262. return rcu_dereference(net->nf.hooks_ipv6[hooknum]); + +net/netfilter/nf_queue.c:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. return rcu_dereference(net->nf.hooks_ipv4[hooknum]); + 261. case NFPROTO_IPV6: + 262. > return rcu_dereference(net->nf.hooks_ipv6[hooknum]); + 263. default: + 264. WARN_ON_ONCE(1); + +include/linux/reservation.h:258: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 256. struct dma_fence *fence; + 257. + 258. > if (!rcu_access_pointer(obj->fence_excl)) + 259. return NULL; + 260. + +net/core/fib_rules.c:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. rcu_read_lock(); + 260. + 261. > list_for_each_entry_rcu(rule, &ops->rules_list, list) { + 262. jumped: + 263. if (!fib_rule_match(rule, ops, fl, flags, arg)) + +net/core/fib_rules.c:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. struct fib_rule *target; + 268. + 269. > target = rcu_dereference(rule->ctarget); + 270. if (target == NULL) { + 271. continue; + +block/genhd.c:260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 258. int i; + 259. + 260. > ptbl = rcu_dereference(disk->part_tbl); + 261. + 262. part = rcu_dereference(ptbl->last_lookup); + +block/genhd.c:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. ptbl = rcu_dereference(disk->part_tbl); + 261. + 262. > part = rcu_dereference(ptbl->last_lookup); + 263. if (part && sector_in_part(part, sector)) + 264. return part; + +block/genhd.c:267: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 265. + 266. for (i = 1; i < ptbl->len; i++) { + 267. > part = rcu_dereference(ptbl->part[i]); + 268. + 269. if (part && sector_in_part(part, sector)) { + +drivers/cpufreq/acpi-cpufreq.c:258: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 256. u32 val, dummy; + 257. + 258. > rdmsr(MSR_IA32_PERF_CTL, val, dummy); + 259. return val; + 260. } + +drivers/pcmcia/ds.c:282: error: UNINITIALIZED_VALUE + The value read from cis_config.base was never initialized. + 280. &cis_config); + 281. if (!ret) { + 282. > p_dev->config_base = cis_config.base; + 283. p_dev->config_regs = cis_config.rmask[0]; + 284. dev_dbg(dev, "base %x, regs %x", p_dev->config_base, + +security/keys/request_key.c:272: error: NULL_DEREFERENCE + pointer `cred` last assigned on line 257 could be null and is dereferenced at line 272, column 11. + 270. /* use a default keyring; falling through the cases until we + 271. * find one that we actually have */ + 272. > switch (cred->jit_keyring) { + 273. case KEY_REQKEY_DEFL_DEFAULT: + 274. case KEY_REQKEY_DEFL_REQUESTOR_KEYRING: + +security/keys/request_key.c:303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 301. rcu_read_lock(); + 302. dest_keyring = key_get( + 303. > rcu_dereference(cred->session_keyring)); + 304. rcu_read_unlock(); + 305. + +net/ipv4/inet_timewait_sock.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. rcu_read_lock(); + 267. restart: + 268. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 269. if (sk->sk_state != TCP_TIME_WAIT) + 270. continue; + +net/ipv6/xfrm6_policy.c:274: error: NULL_DEREFERENCE + pointer `xdst` last assigned on line 273 could be null and is dereferenced at line 274, column 12. + 272. in6_dev_hold(loopback_idev); + 273. xdst = (struct xfrm_dst *)xfrm_dst_child(&xdst->u.dst); + 274. > } while (xdst->u.dst.xfrm); + 275. + 276. __in6_dev_put(loopback_idev); + +net/wireless/trace.h:255: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +net/wireless/trace.h:255: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 253. ); + 254. + 255. > TRACE_EVENT(rdev_return_int, + 256. TP_PROTO(struct wiphy *wiphy, int ret), + 257. TP_ARGS(wiphy, ret), + +arch/x86/include/asm/tlbflush.h:263: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 261. + 262. local_irq_save(flags); + 263. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 264. if ((cr4 | mask) != cr4) + 265. __cr4_set(cr4 | mask); + +arch/x86/include/asm/tlbflush.h:263: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 261. + 262. local_irq_save(flags); + 263. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 264. if ((cr4 | mask) != cr4) + 265. __cr4_set(cr4 | mask); + +net/ipv4/sysctl_net_ipv4.c:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. + 273. rcu_read_lock(); + 274. > ctxt = rcu_dereference(net->ipv4.tcp_fastopen_ctx); + 275. if (ctxt) + 276. memcpy(user_key, ctxt->key, TCP_FASTOPEN_KEY_LENGTH); + +net/ipv4/sysctl_net_ipv4.c:281: error: UNINITIALIZED_VALUE + The value read from user_key[_] was never initialized. + 279. rcu_read_unlock(); + 280. + 281. > snprintf(tbl.data, tbl.maxlen, "%08x-%08x-%08x-%08x", + 282. user_key[0], user_key[1], user_key[2], user_key[3]); + 283. ret = proc_dostring(&tbl, write, buffer, lenp, ppos); + +net/ipv4/sysctl_net_ipv4.c:296: error: UNINITIALIZED_VALUE + The value read from user_key[_] was never initialized. + 294. + 295. bad_key: + 296. > pr_debug("proc FO key set 0x%x-%x-%x-%x <- 0x%s: %u\n", + 297. user_key[0], user_key[1], user_key[2], user_key[3], + 298. (char *)tbl.data, ret); + +net/sunrpc/xprtmultipath.c:264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 262. struct rpc_xprt *pos, *prev = NULL; + 263. + 264. > list_for_each_entry_rcu(pos, head, xprt_switch) { + 265. if (cur == prev) + 266. return pos; + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +include/trace/events/random.h:259: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 257. ); + 258. + 259. > DEFINE_EVENT(random__extract_entropy, extract_entropy_user, + 260. TP_PROTO(const char *pool_name, int nbytes, int entropy_count, + 261. unsigned long IP), + +kernel/sys.c:290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 288. else + 289. pgrp = task_pgrp(current); + 290. > do_each_pid_thread(pgrp, PIDTYPE_PGID, p) { + 291. niceval = nice_to_rlimit(task_nice(p)); + 292. if (niceval > retval) + +kernel/sys.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. goto out_unlock; /* No processes for this user */ + 305. } + 306. > do_each_thread(g, p) { + 307. if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) { + 308. niceval = nice_to_rlimit(task_nice(p)); + +kernel/sys.c:307: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 305. } + 306. do_each_thread(g, p) { + 307. > if (uid_eq(task_uid(p), uid) && task_pid_vnr(p)) { + 308. niceval = nice_to_rlimit(task_nice(p)); + 309. if (niceval > retval) + +drivers/gpu/drm/i915/intel_uc.c:359: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 357. ret = -EINVAL; + 358. + 359. > dev_err(dev_priv->drm.dev, "GuC initialization failed %d\n", ret); + 360. return ret; + 361. } + +drivers/gpu/drm/i915/intel_uc.c:360: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 358. + 359. dev_err(dev_priv->drm.dev, "GuC initialization failed %d\n", ret); + 360. > return ret; + 361. } + 362. + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +include/trace/events/tcp.h:261: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 259. #include + 260. + 261. > TRACE_EVENT(tcp_probe, + 262. + 263. TP_PROTO(struct sock *sk, struct sk_buff *skb), + +lib/idr.c:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. + 273. *nextid = iter.index + base; + 274. > return rcu_dereference_raw(*slot); + 275. } + 276. EXPORT_SYMBOL(idr_get_next_ul); + +drivers/tty/serial/serial_core.c:283: error: NULL_DEREFERENCE + pointer `uport` last assigned on line 264 could be null and is dereferenced by call to `uart_port_dtr_rts()` at line 283, column 4. + 281. + 282. if (!tty || C_HUPCL(tty)) + 283. > uart_port_dtr_rts(uport, 0); + 284. + 285. uart_port_shutdown(port); + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +include/trace/events/block.h:262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 260. * block IO operation @bio. + 261. */ + 262. > TRACE_EVENT(block_bio_complete, + 263. + 264. TP_PROTO(struct request_queue *q, struct bio *bio, int error), + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +kernel/time/tick-broadcast.c:264: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 262. static bool tick_do_broadcast(struct cpumask *mask) + 263. { + 264. > int cpu = smp_processor_id(); + 265. struct tick_device *td; + 266. bool local = false; + +net/netlink/genetlink.c:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. netlink_table_grab(); + 268. rcu_read_lock(); + 269. > for_each_net_rcu(net) { + 270. for (i = 0; i < family->n_mcgrps; i++) + 271. __netlink_clear_multicast_users( + +net/sched/sch_api.c:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. return root; + 272. + 273. > hash_for_each_possible_rcu(qdisc_dev(root)->qdisc_hash, q, hash, handle) { + 274. if (q->handle == handle) + 275. return q; + +drivers/tty/vt/vt_ioctl.c:274: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 272. if (!perm) + 273. return -EPERM; + 274. > return con_set_unimap(vc, tmp.entry_ct, tmp.entries); + 275. case GIO_UNIMAP: + 276. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:278: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 276. if (!perm && fg_console != vc->vc_num) + 277. return -EPERM; + 278. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp.entries); + 279. } + 280. return 0; + +net/ipv4/tcp_cong.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. + 267. rcu_read_lock(); + 268. > ca = rcu_dereference(net->ipv4.tcp_congestion_control); + 269. strncpy(name, ca->name, TCP_CA_NAME_MAX); + 270. rcu_read_unlock(); + +net/ipv6/ip6_flowlabel.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. struct ipv6_fl_socklist *sfl; + 267. + 268. > if (!rcu_access_pointer(np->ipv6_fl_list)) + 269. return; + 270. + +drivers/base/power/runtime.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. struct device_link *link; + 267. + 268. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) { + 269. int retval; + 270. + +sound/core/pcm_lib.c:408: error: DEAD_STORE + The value written to &hw_base (type unsigned long) is never used. + 406. /* move new_hw_ptr according jiffies not pos variable */ + 407. new_hw_ptr = old_hw_ptr; + 408. > hw_base = delta; + 409. /* use loop to avoid checks for delta overflows */ + 410. /* the delta value is small or zero in most cases */ + +kernel/power/swap.c:273: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 272 could be null and is dereferenced at line 273, column 2. + 271. + 272. bio = bio_alloc(__GFP_RECLAIM | __GFP_HIGH, 1); + 273. > bio->bi_iter.bi_sector = page_off * (PAGE_SIZE >> 9); + 274. bio_set_dev(bio, hib_resume_bdev); + 275. bio_set_op_attrs(bio, op, op_flags); + +net/ipv4/inet_hashtables.c:278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 276. u32 phash = 0; + 277. + 278. > inet_lhash2_for_each_icsk_rcu(icsk, &ilb2->head) { + 279. sk = (struct sock *)icsk; + 280. score = compute_score(sk, net, hnum, daddr, + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +drivers/cpufreq/cpufreq_governor.c:271: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 269. + 270. policy_dbs = container_of(irq_work, struct policy_dbs_info, irq_work); + 271. > schedule_work_on(smp_processor_id(), &policy_dbs->work); + 272. } + 273. + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +include/trace/events/libata.h:266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 264. ); + 265. + 266. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_internal, + 267. TP_PROTO(struct ata_queued_cmd *qc), + 268. TP_ARGS(qc)); + +kernel/sched/wait_bit.c:268: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 266. __sched int bit_wait_timeout(struct wait_bit_key *word, int mode) + 267. { + 268. > unsigned long now = READ_ONCE(jiffies); + 269. if (time_after_eq(now, word->timeout)) + 270. return -EAGAIN; + +kernel/seccomp.c:276: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 274. /* Validate all threads being eligible for synchronization. */ + 275. caller = current; + 276. > for_each_thread(caller, thread) { + 277. pid_t failed; + 278. + +scripts/sortextable.c:313: error: DEAD_STORE + The value written to &custom_sort (type _fn_(*)) is never used. + 311. case EM_386: + 312. case EM_X86_64: + 313. > custom_sort = x86_sort_relative_table; + 314. break; + 315. + +scripts/sortextable.c:321: error: DEAD_STORE + The value written to &custom_sort (type _fn_(*)) is never used. + 319. case EM_PPC: + 320. case EM_PPC64: + 321. > custom_sort = sort_relative_table; + 322. break; + 323. case EM_ARCOMPACT: + +kernel/irq/matrix.c:280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 278. cm->available--; + 279. m->global_available--; + 280. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 281. } + 282. + +kernel/irq/matrix.c:280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 278. cm->available--; + 279. m->global_available--; + 280. > trace_irq_matrix_assign(bit, smp_processor_id(), m, cm); + 281. } + 282. + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +kernel/smp.c:282: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 280. * as well as CPU removal + 281. */ + 282. > this_cpu = get_cpu(); + 283. + 284. /* + +drivers/gpu/drm/drm_crtc_helper.c:281: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 279. bool saved_enabled; + 280. struct drm_encoder *encoder; + 281. > bool ret = true; + 282. + 283. drm_warn_on_modeset_not_all_locked(dev); + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. /* pipe updates */ + 268. + 269. > TRACE_EVENT(i915_pipe_update_start, + 270. TP_PROTO(struct intel_crtc *crtc), + 271. TP_ARGS(crtc), + +drivers/net/ethernet/intel/e1000e/ethtool.c:321: error: DEAD_STORE + The value written to &advertising (type unsigned int) is never used. + 319. hw->phy.autoneg_advertised = advertising | + 320. ADVERTISED_TP | ADVERTISED_Autoneg; + 321. > advertising = hw->phy.autoneg_advertised; + 322. if (adapter->fc_autoneg) + 323. hw->fc.requested_mode = e1000_fc_default; + +kernel/profile.c:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. + 273. mutex_lock(&profile_flip_mutex); + 274. > i = per_cpu(cpu_profile_flip, get_cpu()); + 275. put_cpu(); + 276. on_each_cpu(__profile_flip_buffers, NULL, 1); + +kernel/time/posix-cpu-timers.c:285: error: UNINITIALIZED_VALUE + The value read from rtn was never initialized. + 283. + 284. if (!err) + 285. > *tp = ns_to_timespec64(rtn); + 286. + 287. return err; + +net/wireless/trace.h:269: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +net/wireless/trace.h:269: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 267. ); + 268. + 269. > TRACE_EVENT(rdev_scan, + 270. TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), + 271. TP_ARGS(wiphy, request), + +arch/x86/include/asm/tlbflush.h:275: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 273. + 274. local_irq_save(flags); + 275. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 276. if ((cr4 & ~mask) != cr4) + 277. __cr4_set(cr4 & ~mask); + +arch/x86/include/asm/tlbflush.h:275: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 273. + 274. local_irq_save(flags); + 275. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 276. if ((cr4 & ~mask) != cr4) + 277. __cr4_set(cr4 & ~mask); + +drivers/net/ethernet/intel/e1000/e1000_param.c:283: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 281. struct e1000_tx_ring *tx_ring = adapter->tx_ring; + 282. int i; + 283. > e1000_mac_type mac_type = adapter->hw.mac_type; + 284. + 285. opt = (struct e1000_option) { + +drivers/net/ethernet/intel/e1000/e1000_param.c:311: error: DEAD_STORE + The value written to &mac_type (type int) is never used. + 309. struct e1000_rx_ring *rx_ring = adapter->rx_ring; + 310. int i; + 311. > e1000_mac_type mac_type = adapter->hw.mac_type; + 312. + 313. opt = (struct e1000_option) { + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +include/trace/events/libata.h:270: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 268. TP_ARGS(qc)); + 269. + 270. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_failed, + 271. TP_PROTO(struct ata_queued_cmd *qc), + 272. TP_ARGS(qc)); + +drivers/cpufreq/acpi-cpufreq.c:275: error: DEAD_STORE + The value written to &dummy (type unsigned int) is never used. + 273. u32 val, dummy; + 274. + 275. > rdmsr(MSR_AMD_PERF_CTL, val, dummy); + 276. return val; + 277. } + +kernel/ptrace.c:311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 309. caller_gid = cred->gid; + 310. } + 311. > tcred = __task_cred(task); + 312. if (uid_eq(caller_uid, tcred->euid) && + 313. uid_eq(caller_uid, tcred->suid) && + +include/net/neighbour.h:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. struct net_device *dev) + 280. { + 281. > struct neigh_hash_table *nht = rcu_dereference_bh(tbl->nht); + 282. struct neighbour *n; + 283. u32 hash_val; + +include/net/neighbour.h:286: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 284. + 285. hash_val = hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift); + 286. > for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 287. n != NULL; + 288. n = rcu_dereference_bh(n->next)) { + +include/net/neighbour.h:288: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 286. for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 287. n != NULL; + 288. > n = rcu_dereference_bh(n->next)) { + 289. if (n->dev == dev && key_eq(n, pkey)) + 290. return n; + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +kernel/trace/trace_events_filter.c:277: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 275. int match = 0; + 276. + 277. > cpu = raw_smp_processor_id(); + 278. cmp = pred->val; + 279. + +net/sunrpc/xprtmultipath.c:285: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 283. if (pos == NULL) + 284. break; + 285. > cur = cmpxchg_relaxed(cursor, old, pos); + 286. if (cur == old) + 287. break; + +net/sunrpc/xprtmultipath.c:279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 277. struct rpc_xprt *cur, *pos, *old; + 278. + 279. > cur = READ_ONCE(*cursor); + 280. for (;;) { + 281. old = cur; + +net/sunrpc/xprtmultipath.c:289: error: UNINITIALIZED_VALUE + The value read from pos was never initialized. + 287. break; + 288. } + 289. > return pos; + 290. } + 291. + +drivers/gpu/drm/i915/intel_uncore.c:278: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 276. * thread to wake up. + 277. */ + 278. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 279. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 280. DRM_ERROR("GT thread status wait timed out\n"); + +drivers/gpu/drm/i915/intel_uncore.c:278: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 276. * thread to wake up. + 277. */ + 278. > if (wait_for_atomic_us((__raw_i915_read32(dev_priv, GEN6_GT_THREAD_STATUS_REG) & + 279. GEN6_GT_THREAD_STATUS_CORE_MASK) == 0, 500)) + 280. DRM_ERROR("GT thread status wait timed out\n"); + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +include/trace/events/sched.h:273: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 271. * Tracepoint for do_fork: + 272. */ + 273. > TRACE_EVENT(sched_process_fork, + 274. + 275. TP_PROTO(struct task_struct *parent, struct task_struct *child), + +drivers/cpufreq/cpufreq_governor.c:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. */ + 297. smp_rmb(); + 298. > lst = READ_ONCE(policy_dbs->last_sample_time); + 299. delta_ns = time - lst; + 300. if ((s64)delta_ns < policy_dbs->sample_delay_ns) + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/libata.h:274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 272. TP_ARGS(qc)); + 273. + 274. > DEFINE_EVENT(ata_qc_complete_template, ata_qc_complete_done, + 275. TP_PROTO(struct ata_queued_cmd *qc), + 276. TP_ARGS(qc)); + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 272. * determine the runtime of the callback function. + 273. */ + 274. > DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit, + 275. + 276. TP_PROTO(struct hrtimer *hrtimer), + +net/ipv4/tcp_cong.c:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. *buf = '\0'; + 280. rcu_read_lock(); + 281. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) { + 282. if (!(ca->flags & TCP_CONG_NON_RESTRICTED)) + 283. continue; + +drivers/ata/libata-scsi.c:299: error: UNINITIALIZED_VALUE + The value read from ncq_prio_enable was never initialized. + 297. spin_unlock_irq(ap->lock); + 298. + 299. > return rc ? rc : snprintf(buf, 20, "%u\n", ncq_prio_enable); + 300. } + 301. + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +init/calibrate.c:279: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 277. unsigned long lpj; + 278. static bool printed; + 279. > int this_cpu = smp_processor_id(); + 280. + 281. if (per_cpu(cpu_loops_per_jiffy, this_cpu)) { + +net/ipv6/calipso.c:278: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 276. const struct netlbl_lsm_secattr *secattr) + 277. { + 278. > int ret_val = -EPERM; + 279. u32 bkt; + 280. struct calipso_map_cache_entry *entry = NULL; + +drivers/base/power/main.c:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. * unregistration). + 292. */ + 293. > list_for_each_entry_rcu(link, &dev->links.consumers, s_node) + 294. if (READ_ONCE(link->status) != DL_STATE_DORMANT) + 295. dpm_wait(link->consumer, async); + +drivers/gpu/drm/i915/i915_gem_request.h:281: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 279. i915_gem_request_global_seqno(const struct drm_i915_gem_request *request) + 280. { + 281. > return READ_ONCE(request->global_seqno); + 282. } + 283. + +drivers/iommu/dmar.c:287: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 285. return 0; + 286. + 287. > for_each_active_dev_scope(devices, count, index, tmp) + 288. if (tmp == &info->dev->dev) { + 289. RCU_INIT_POINTER(devices[index].dev, NULL); + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +include/trace/events/libata.h:278: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 276. TP_ARGS(qc)); + 277. + 278. > TRACE_EVENT(ata_eh_link_autopsy, + 279. + 280. TP_PROTO(struct ata_device *dev, unsigned int eh_action, unsigned int eh_err_mask), + +kernel/sched/wait_bit.c:280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 278. __sched int bit_wait_io_timeout(struct wait_bit_key *word, int mode) + 279. { + 280. > unsigned long now = READ_ONCE(jiffies); + 281. if (time_after_eq(now, word->timeout)) + 282. return -EAGAIN; + +scripts/kconfig/symbol.c:290: error: NULL_DEREFERENCE + pointer `def_sym` last assigned on line 289 could be null and is dereferenced at line 290, column 7. + 288. continue; + 289. def_sym = prop_get_symbol(prop); + 290. > if (def_sym->visible != no) + 291. return def_sym; + 292. } + +sound/hda/hdac_regmap.c:348: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 346. out: + 347. codec_pm_unlock(codec, pm_lock); + 348. > return err; + 349. } + 350. + +drivers/video/fbdev/core/fbmem.c:286: error: DEAD_STORE + The value written to &fg (type unsigned char) is never used. + 284. const u8 *src = logo->data; + 285. u8 xor = (info->fix.visual == FB_VISUAL_MONO01) ? 0xff : 0; + 286. > u8 fg = 1, d; + 287. + 288. switch (fb_get_color_depth(&info->var, &info->fix)) { + +include/linux/seqlock.h:282: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 280. { + 281. /* Pairs with the first smp_wmb() in raw_write_seqcount_latch() */ + 282. > int seq = READ_ONCE(s->sequence); /* ^^^ */ + 283. return seq; + 284. } + +kernel/sched/cpuacct.c:301: error: UNINITIALIZED_VALUE + The value read from val[_] was never initialized. + 299. seq_printf(sf, "%s %lld\n", + 300. cpuacct_stat_desc[stat], + 301. > (long long)nsec_to_clock_t(val[stat])); + 302. } + 303. + +net/wireless/trace.h:281: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 279. ); + 280. + 281. > DECLARE_EVENT_CLASS(wiphy_only_evt, + 282. TP_PROTO(struct wiphy *wiphy), + 283. TP_ARGS(wiphy), + +net/packet/af_packet.c:287: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 285. + 286. rcu_read_lock(); + 287. > dev = rcu_dereference(po->cached_dev); + 288. if (likely(dev)) + 289. dev_hold(dev); + +drivers/cpuidle/governors/menu.c:294: error: NULL_DEREFERENCE + pointer `device` last assigned on line 286 could be null and is dereferenced by call to `dev_pm_qos_raw_read_value()` at line 294, column 23. + 292. unsigned int expected_interval; + 293. unsigned long nr_iowaiters, cpu_load; + 294. > int resume_latency = dev_pm_qos_raw_read_value(device); + 295. + 296. if (data->needs_update) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +kernel/profile.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. i = primary = (pc & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 292. secondary = (~(pc << 1) & (NR_PROFILE_GRP - 1)) << PROFILE_GRPSHIFT; + 293. > cpu = get_cpu(); + 294. hits = per_cpu(cpu_profile_hits, cpu)[per_cpu(cpu_profile_flip, cpu)]; + 295. if (!hits) { + +net/ipv6/sit.c:289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 287. struct ip_tunnel_prl_entry *prl; + 288. + 289. > for_each_prl_rcu(t->prl) + 290. if (prl->addr == addr) + 291. break; + +sound/core/pcm_native.c:304: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 302. + 303. if (trace_hw_interval_param_enabled()) + 304. > old_interval = *i; + 305. + 306. changed = snd_interval_refine(i, constrs_interval(constrs, k)); + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +include/trace/events/timer.h:285: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 283. * @hrtimer: pointer to struct hrtimer + 284. */ + 285. > DEFINE_EVENT(hrtimer_class, hrtimer_cancel, + 286. + 287. TP_PROTO(struct hrtimer *hrtimer), + +security/selinux/ss/services.c:456: error: UNINITIALIZED_VALUE + The value read from s[_] was never initialized. + 454. + 455. BUG_ON(sp != 0); + 456. > return s[0]; + 457. } + 458. + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +drivers/thermal/x86_pkg_temp_thermal.c:289: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 287. { + 288. struct thermal_zone_device *tzone = NULL; + 289. > int cpu = smp_processor_id(); + 290. struct pkg_device *pkgdev; + 291. u64 msr_val, wr_val; + +block/blk-lib.c:305: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 303 could be null and is dereferenced at line 305, column 3. + 303. bio = next_bio(bio, __blkdev_sectors_to_bio_pages(nr_sects), + 304. gfp_mask); + 305. > bio->bi_iter.bi_sector = sector; + 306. bio_set_dev(bio, bdev); + 307. bio_set_op_attrs(bio, REQ_OP_WRITE, 0); + +drivers/dma-buf/reservation.c:343: error: DEAD_STORE + The value written to &new (type dma_fence*) is never used. + 341. } + 342. + 343. > new = dma_fence_get_rcu_safe(&src->fence_excl); + 344. rcu_read_unlock(); + 345. + +drivers/dma-buf/reservation.c:296: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 294. + 295. rcu_read_lock(); + 296. > src_list = rcu_dereference(src->fence); + 297. + 298. retry: + +drivers/dma-buf/reservation.c:310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 308. + 309. rcu_read_lock(); + 310. > src_list = rcu_dereference(src->fence); + 311. if (!src_list || src_list->shared_count > shared_count) { + 312. kfree(dst_list); + +drivers/dma-buf/reservation.c:321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 319. struct dma_fence *fence; + 320. + 321. > fence = rcu_dereference(src_list->shared[i]); + 322. if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, + 323. &fence->flags)) + +drivers/dma-buf/reservation.c:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. if (!dma_fence_get_rcu(fence)) { + 327. kfree(dst_list); + 328. > src_list = rcu_dereference(src->fence); + 329. goto retry; + 330. } + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +kernel/time/tick-common.c:290: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 288. struct clock_event_device *newdev) + 289. { + 290. > if (!tick_check_percpu(curdev, newdev, smp_processor_id())) + 291. return false; + 292. + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +drivers/cpuidle/driver.c:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. int cpu; + 292. + 293. > cpu = get_cpu(); + 294. drv = __cpuidle_get_cpu_driver(cpu); + 295. put_cpu(); + +kernel/kprobes.c:294: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 292. + 293. rcu_read_lock(); + 294. > list_for_each_entry_rcu(kip, &c->pages, list) { + 295. if (addr >= (unsigned long)kip->insns && + 296. addr < (unsigned long)kip->insns + PAGE_SIZE) { + +net/netfilter/nf_conntrack_helper.c:292: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 290. struct nf_conn_help *help = nfct_help(ct); + 291. + 292. > if (help && rcu_dereference_raw(help->helper) == me) { + 293. nf_conntrack_event(IPCT_HELPER, ct); + 294. RCU_INIT_POINTER(help->helper, NULL); + +drivers/base/power/runtime.c:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. struct device_link *link; + 292. + 293. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 294. if (link->rpm_active && + 295. READ_ONCE(link->status) != DL_STATE_SUPPLIER_UNBIND) { + +drivers/gpu/drm/drm_fb_helper.c:291: error: DEAD_STORE + The value written to &helper (type drm_fb_helper*) is never used. + 289. int drm_fb_helper_debug_enter(struct fb_info *info) + 290. { + 291. > struct drm_fb_helper *helper = info->par; + 292. const struct drm_crtc_helper_funcs *funcs; + 293. int i; + +lib/genalloc.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. nbits = (size + (1UL << order) - 1) >> order; + 305. rcu_read_lock(); + 306. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 307. if (size > atomic_long_read(&chunk->avail)) + 308. continue; + +arch/x86/events/amd/core.c:319: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 317. if (new == -1 || hwc->idx == idx) + 318. /* assign free slot, prefer hwc->idx */ + 319. > old = cmpxchg(nb->owners + idx, NULL, event); + 320. else if (nb->owners[idx] == event) + 321. /* event already present */ + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +include/trace/events/random.h:291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 289. ); + 290. + 291. > TRACE_EVENT(urandom_read, + 292. TP_PROTO(int got_bits, int pool_left, int input_left), + 293. + +kernel/exit.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. * see comment in rcuwait_wait_event() regarding ->exit_state. + 314. */ + 315. > task = rcu_dereference(w->task); + 316. if (task) + 317. wake_up_process(task); + +net/ipv4/tcp_cong.c:313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 311. + 312. /* pass 2 clear old values */ + 313. > list_for_each_entry_rcu(ca, &tcp_cong_list, list) + 314. ca->flags &= ~TCP_CONG_NON_RESTRICTED; + 315. + +net/sunrpc/xprtmultipath.c:296: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 294. xprt_switch_find_xprt_t find_next) + 295. { + 296. > struct rpc_xprt_switch *xps = rcu_dereference(xpi->xpi_xpswitch); + 297. + 298. if (xps == NULL) + +net/netlabel/netlabel_calipso.c:295: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 293. static int netlbl_calipso_remove(struct sk_buff *skb, struct genl_info *info) + 294. { + 295. > int ret_val = -EINVAL; + 296. struct netlbl_domhsh_walk_arg cb_arg; + 297. struct netlbl_audit audit_info; + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +net/wireless/trace.h:293: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 291. ); + 292. + 293. > DEFINE_EVENT(wiphy_only_evt, rdev_resume, + 294. TP_PROTO(struct wiphy *wiphy), + 295. TP_ARGS(wiphy) + +kernel/locking/qspinlock.c:467: error: UNINITIALIZED_VALUE + The value read from VAL was never initialized. + 465. goto locked; + 466. + 467. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 468. + 469. locked: + +kernel/locking/qspinlock.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. * implementations imply full barriers. + 361. */ + 362. > smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_MASK)); + 363. + 364. /* + +kernel/locking/qspinlock.c:430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 428. + 429. pv_wait_node(node, prev); + 430. > arch_mcs_spin_lock_contended(&node->locked); + 431. + 432. /* + +kernel/locking/qspinlock.c:438: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 436. * to reduce latency in the upcoming MCS unlock operation. + 437. */ + 438. > next = READ_ONCE(node->next); + 439. if (next) + 440. prefetchw(next); + +kernel/locking/qspinlock.c:467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 465. goto locked; + 466. + 467. > val = smp_cond_load_acquire(&lock->val.counter, !(VAL & _Q_LOCKED_PENDING_MASK)); + 468. + 469. locked: + +kernel/locking/qspinlock.c:502: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 500. */ + 501. if (!next) { + 502. > while (!(next = READ_ONCE(node->next))) + 503. cpu_relax(); + 504. } + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +kernel/locking/qspinlock.c:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. node = this_cpu_ptr(&mcs_nodes[0]); + 378. idx = node->count++; + 379. > tail = encode_tail(smp_processor_id(), idx); + 380. + 381. node += idx; + +arch/x86/platform/efi/efi.c:342: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 340. efi_systab.tables = data ? (unsigned long)data->tables : + 341. systab64->tables; + 342. > tmp |= data ? data->tables : systab64->tables; + 343. + 344. early_memunmap(systab64, sizeof(*systab64)); + +drivers/char/hw_random/core.c:297: error: DEAD_STORE + The value written to &ret (type int) is never used. + 295. static int enable_best_rng(void) + 296. { + 297. > int ret = -ENODEV; + 298. + 299. BUG_ON(!mutex_is_locked(&rng_mutex)); + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/i915_trace.h:295: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 293. ); + 294. + 295. > TRACE_EVENT(i915_pipe_update_vblank_evaded, + 296. TP_PROTO(struct intel_crtc *crtc), + 297. TP_ARGS(crtc), + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:312: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 310. + 311. status |= GMBUS_SATOER; + 312. > ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + +drivers/gpu/drm/i915/intel_i2c.c:314: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 312. ret = wait_for_us((gmbus2 = I915_READ_FW(GMBUS2)) & status, 2); + 313. if (ret) + 314. > ret = wait_for((gmbus2 = I915_READ_FW(GMBUS2)) & status, 50); + 315. + 316. I915_WRITE_FW(GMBUS4, 0); + +drivers/gpu/drm/i915/intel_lpe_audio.c:302: error: DEAD_STORE + The value written to &desc (type irq_desc*) is never used. + 300. return; + 301. + 302. > desc = irq_to_desc(dev_priv->lpe_audio.irq); + 303. + 304. lpe_audio_platdev_destroy(dev_priv); + +drivers/md/dm-io.c:314: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 314, column 29. + 312. */ + 313. if (op == REQ_OP_DISCARD) + 314. > special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + +drivers/md/dm-io.c:316: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 316, column 29. + 314. special_cmd_max_sectors = q->limits.max_discard_sectors; + 315. else if (op == REQ_OP_WRITE_ZEROES) + 316. > special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. special_cmd_max_sectors = q->limits.max_write_same_sectors; + +drivers/md/dm-io.c:318: error: NULL_DEREFERENCE + pointer `q` last assigned on line 305 could be null and is dereferenced at line 318, column 29. + 316. special_cmd_max_sectors = q->limits.max_write_zeroes_sectors; + 317. else if (op == REQ_OP_WRITE_SAME) + 318. > special_cmd_max_sectors = q->limits.max_write_same_sectors; + 319. if ((op == REQ_OP_DISCARD || op == REQ_OP_WRITE_ZEROES || + 320. op == REQ_OP_WRITE_SAME) && special_cmd_max_sectors == 0) { + +usr/gen_init_cpio.c:303: error: DEAD_STORE + The value written to &file (type int) is never used. + 301. struct stat buf; + 302. long size; + 303. > int file = -1; + 304. int retval; + 305. int rc = -1; + +kernel/capability.c:302: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 300. + 301. rcu_read_lock(); + 302. > ret = security_capable(__task_cred(t), ns, cap); + 303. rcu_read_unlock(); + 304. + +kernel/sched/cputime.c:325: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 323. times->sum_exec_runtime = sig->sum_sched_runtime; + 324. + 325. > for_each_thread(tsk, t) { + 326. task_cputime(t, &utime, &stime); + 327. times->utime += utime; + +net/ipv6/sit.c:329: error: DEAD_STORE + The value written to &ret (type int) is never used. + 327. kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC); + 328. if (!kp) { + 329. > ret = -ENOMEM; + 330. goto out; + 331. } + +net/ipv6/sit.c:335: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 333. + 334. c = 0; + 335. > for_each_prl_rcu(t->prl) { + 336. if (c >= cmax) + 337. break; + +lib/rhashtable.c:305: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 303. + 304. /* Did somebody beat us to it? */ + 305. > if (rcu_access_pointer(old_tbl->future_tbl)) { + 306. spin_unlock_bh(old_tbl->locks); + 307. return -EEXIST; + +drivers/char/hpet.c:335: error: UNINITIALIZED_VALUE + The value read from data was never initialized. + 333. } + 334. + 335. > retval = put_user(data, (unsigned long __user *)buf); + 336. if (!retval) + 337. retval = sizeof(unsigned long); + +drivers/iommu/dmar.c:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. struct acpi_dmar_hardware_unit *drhd; + 303. + 304. > for_each_drhd_unit(dmaru) { + 305. if (dmaru->include_all) + 306. continue; + +include/net/addrconf.h:300: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 298. static inline struct inet6_dev *__in6_dev_get(const struct net_device *dev) + 299. { + 300. > return rcu_dereference_rtnl(dev->ip6_ptr); + 301. } + 302. + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +include/ras/ras_event.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. {PCI_ERR_UNC_TLPPRE, "TLP Prefix Blocked Error"} + 297. + 298. > TRACE_EVENT(aer_event, + 299. TP_PROTO(const char *dev_name, + 300. const u32 status, + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +net/wireless/trace.h:298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 296. ); + 297. + 298. > DEFINE_EVENT(wiphy_only_evt, rdev_return_void, + 299. TP_PROTO(struct wiphy *wiphy), + 300. TP_ARGS(wiphy) + +arch/x86/events/intel/bts.c:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 303. struct bts_buffer *buf = NULL; + 304. > int state = READ_ONCE(bts->state); + 305. + 306. if (state == BTS_STATE_ACTIVE) + +drivers/gpu/drm/i915/intel_uncore.c:311: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 309. + 310. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 311. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 312. GT_FIFO_NUM_RESERVED_ENTRIES, + 313. GT_FIFO_TIMEOUT_MS)) { + +drivers/gpu/drm/i915/intel_uncore.c:311: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 309. + 310. if (n <= GT_FIFO_NUM_RESERVED_ENTRIES) { + 311. > if (wait_for_atomic((n = fifo_free_entries(dev_priv)) > + 312. GT_FIFO_NUM_RESERVED_ENTRIES, + 313. GT_FIFO_TIMEOUT_MS)) { + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +include/trace/events/timer.h:299: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 297. * @expires: the itimers expiry time + 298. */ + 299. > TRACE_EVENT(itimer_state, + 300. + 301. TP_PROTO(int which, const struct itimerval *const value, + +net/ipv4/inet_hashtables.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. + 344. port_lookup: + 345. > sk_for_each_rcu(sk, &ilb->head) { + 346. score = compute_score(sk, net, hnum, daddr, + 347. dif, sdif, exact_dif); + +net/sched/sch_generic.c:325: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 323. + 324. if (likely(skb)) { + 325. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 326. if (!netif_xmit_frozen_or_stopped(txq)) + 327. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +net/sched/sch_generic.c:325: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 323. + 324. if (likely(skb)) { + 325. > HARD_TX_LOCK(dev, txq, smp_processor_id()); + 326. if (!netif_xmit_frozen_or_stopped(txq)) + 327. skb = dev_hard_start_xmit(skb, dev, txq, &ret); + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +kernel/time/tick-common.c:306: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 304. int cpu; + 305. + 306. > cpu = smp_processor_id(); + 307. td = &per_cpu(tick_cpu_device, cpu); + 308. curdev = td->evtdev; + +include/net/inet_sock.h:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. { + 303. /* state change might impact lockless readers. */ + 304. > return smp_load_acquire(&sk->sk_state); + 305. } + 306. + +net/netfilter/nf_conntrack_helper.c:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. if (help) { + 307. rcu_read_lock(); + 308. > helper = rcu_dereference(help->helper); + 309. if (helper && helper->destroy) + 310. helper->destroy(ct); + +kernel/events/core.c:306: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 304. struct perf_event_context *ctx = event->ctx; + 305. struct perf_cpu_context *cpuctx = __get_cpu_context(ctx); + 306. > struct task_struct *task = READ_ONCE(ctx->task); + 307. struct perf_event_context *task_ctx = NULL; + 308. + +include/net/ipv6.h:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. + 307. rcu_read_lock(); + 308. > opt = rcu_dereference(np->opt); + 309. if (opt) { + 310. if (!refcount_inc_not_zero(&opt->refcnt)) + +net/ipv4/sysctl_net_ipv4.c:312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 310. rcu_read_lock(); + 311. + 312. > ipprot = rcu_dereference(inet_protos[protocol]); + 313. if (ipprot) + 314. ipprot->early_demux = enabled ? ipprot->early_demux_handler : + +net/ipv4/sysctl_net_ipv4.c:318: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 316. + 317. #if IS_ENABLED(CONFIG_IPV6) + 318. > ip6prot = rcu_dereference(inet6_protos[protocol]); + 319. if (ip6prot) + 320. ip6prot->early_demux = enabled ? ip6prot->early_demux_handler : + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +net/wireless/trace.h:303: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 301. ); + 302. + 303. > DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, + 304. TP_PROTO(struct wiphy *wiphy), + 305. TP_ARGS(wiphy) + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +include/trace/events/libata.h:304: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 302. ); + 303. + 304. > TRACE_EVENT(ata_eh_link_autopsy_qc, + 305. + 306. TP_PROTO(struct ata_queued_cmd *qc), + +kernel/notifier.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. * is, we re-check the list after having taken the lock anyway: + 314. */ + 315. > if (rcu_access_pointer(nh->head)) { + 316. down_read(&nh->rwsem); + 317. ret = notifier_call_chain(&nh->head, val, v, nr_to_call, + +scripts/kconfig/symbol.c:314: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 313 could be null and is dereferenced at line 314, column 2. + 312. flags = sym->flags; + 313. prop = sym_get_choice_prop(sym); + 314. > expr_list_for_each_sym(prop->expr, e, def_sym) { + 315. sym_calc_visibility(def_sym); + 316. if (def_sym->visible != no) + +drivers/edac/edac_mc.c:345: error: DEAD_STORE + The value written to &mci (type mem_ctl_info*) is never used. + 343. * hardcode everything into a single struct. + 344. */ + 345. > mci = edac_align_ptr(&ptr, sizeof(*mci), 1); + 346. layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers); + 347. for (i = 0; i < n_layers; i++) { + +drivers/edac/edac_mc.c:431: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 429. for (i = 0; i < tot_dimms; i++) { + 430. chan = mci->csrows[row]->channels[chn]; + 431. > off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]); + 432. if (off < 0 || off >= tot_dimms) { + 433. edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n"); + +drivers/edac/edac_mc.c:452: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 450. len -= n; + 451. for (j = 0; j < n_layers; j++) { + 452. > n = snprintf(p, len, "%s#%u", + 453. edac_layer_name[layers[j].type], + 454. pos[j]); + +drivers/edac/edac_mc.c:457: error: UNINITIALIZED_VALUE + The value read from pos[_] was never initialized. + 455. p += n; + 456. len -= n; + 457. > dimm->location[j] = pos[j]; + 458. + 459. if (len <= 0) + +drivers/gpu/drm/drm_lock.c:316: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 314. do { + 315. old = *lock; + 316. > prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT); + 317. } while (prev != old); + 318. wake_up_interruptible(&lock_data->lock_queue); + +kernel/printk/printk_safe.c:313: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 311. * the lock must be taken on another CPU and we could wait for it. + 312. */ + 313. > if ((this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) && + 314. raw_spin_is_locked(&logbuf_lock)) { + 315. this_cpu_or(printk_context, PRINTK_NMI_CONTEXT_MASK); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:316: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 314. if (unlikely(p == NULL)) + 315. return -ENOSPC; + 316. > p = xdr_decode_hyper(p, &status->major_status); + 317. + 318. /* status->mech */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:327: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 325. if (unlikely(p == NULL)) + 326. return -ENOSPC; + 327. > p = xdr_decode_hyper(p, &status->minor_status); + 328. + 329. /* status->major_status_string */ + +include/net/ip_fib.h:321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 319. res->tclassid = 0; + 320. + 321. > tb = rcu_dereference_rtnl(net->ipv4.fib_main); + 322. if (tb) + 323. err = fib_table_lookup(tb, flp, res, flags); + +include/net/ip_fib.h:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. goto out; + 327. + 328. > tb = rcu_dereference_rtnl(net->ipv4.fib_default); + 329. if (tb) + 330. err = fib_table_lookup(tb, flp, res, flags); + +kernel/reboot.c:315: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 310 could be null and is dereferenced at line 315, column 18. + 313. + 314. /* We only trust the superuser with rebooting the system. */ + 315. > if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT)) + 316. return -EPERM; + 317. + +net/ipv6/mcast.c:311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 309. struct ipv6_pinfo *np = inet6_sk(sk); + 310. + 311. > if (!rcu_access_pointer(np->ipv6_mc_list)) + 312. return; + 313. rtnl_lock(); + +drivers/input/evdev.c:322: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 320. rcu_read_lock(); + 321. + 322. > client = rcu_dereference(evdev->grab); + 323. + 324. if (client) + +drivers/input/evdev.c:327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 325. evdev_pass_values(client, vals, count, ev_time); + 326. else + 327. > list_for_each_entry_rcu(client, &evdev->client_list, node) + 328. evdev_pass_values(client, vals, count, ev_time); + 329. + +kernel/seccomp.c:317: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 315. /* Synchronize all threads. */ + 316. caller = current; + 317. > for_each_thread(caller, thread) { + 318. /* Skip current, since it needs no changes. */ + 319. if (thread == caller) + +lib/assoc_array.c:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. */ + 327. for (slot = 0; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 328. > ptr = READ_ONCE(node->slots[slot]); /* Address dependency. */ + 329. if (ptr && assoc_array_ptr_is_leaf(ptr)) { + 330. /* We need a barrier between the read of the pointer + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +net/wireless/trace.h:308: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 306. ); + 307. + 308. > DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, + 309. TP_PROTO(struct wiphy *wiphy), + 310. TP_ARGS(wiphy) + +kernel/sched/loadavg.c:315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 313. long delta, active, n; + 314. + 315. > sample_window = READ_ONCE(calc_load_update); + 316. if (!time_before(jiffies, sample_window + 10)) { + 317. /* + +include/net/addrconf.h:316: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 314. + 315. rcu_read_lock(); + 316. > idev = rcu_dereference(dev->ip6_ptr); + 317. if (idev) + 318. refcount_inc(&idev->refcnt); + +include/net/ip_tunnels.h:323: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 321. + 322. rcu_read_lock(); + 323. > ops = rcu_dereference(iptun_encaps[e->type]); + 324. if (likely(ops && ops->encap_hlen)) + 325. hlen = ops->encap_hlen(e); + +net/ipv4/cipso_ipv4.c:314: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 312. const struct netlbl_lsm_secattr *secattr) + 313. { + 314. > int ret_val = -EPERM; + 315. u32 bkt; + 316. struct cipso_v4_map_cache_entry *entry = NULL; + +net/ipv4/ip_input.c:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. int protocol = iph->protocol; + 332. + 333. > ipprot = rcu_dereference(inet_protos[protocol]); + 334. if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) { + 335. err = edemux(skb); + +net/ipv4/ip_input.c:334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 332. + 333. ipprot = rcu_dereference(inet_protos[protocol]); + 334. > if (ipprot && (edemux = READ_ONCE(ipprot->early_demux))) { + 335. err = edemux(skb); + 336. if (unlikely(err)) + +net/netlink/af_netlink.c:319: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 317. return; + 318. + 319. > list_for_each_entry_rcu(tmp, &nn->netlink_tap_all, list) { + 320. ret = __netlink_deliver_tap_skb(skb, tmp->dev); + 321. if (unlikely(ret)) + +net/packet/af_packet.c:313: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 311. static u16 __packet_pick_tx_queue(struct net_device *dev, struct sk_buff *skb) + 312. { + 313. > return (u16) raw_smp_processor_id() % dev->real_num_tx_queues; + 314. } + 315. + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.agp_start was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.count was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.flags was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.high_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.low_mark was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/gpu/drm/drm_ioc32.c:324: error: UNINITIALIZED_VALUE + The value read from desc32.size was never initialized. + 322. return -EFAULT; + 323. + 324. > desc = (struct drm_buf_desc){ + 325. desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, + 326. desc32.flags, desc32.agp_start + +drivers/i2c/i2c-core-smbus.c:479: error: UNINITIALIZED_VALUE + The value read from msgbuf1[_] was never initialized. + 477. break; + 478. case I2C_SMBUS_BYTE_DATA: + 479. > data->byte = msgbuf1[0]; + 480. break; + 481. case I2C_SMBUS_WORD_DATA: + +net/netfilter/nf_conntrack_core.c:318: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 316. + 317. /* add this conntrack to the (per cpu) dying list */ + 318. > ct->cpu = smp_processor_id(); + 319. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 320. + +net/netfilter/nf_conntrack_core.c:318: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 316. + 317. /* add this conntrack to the (per cpu) dying list */ + 318. > ct->cpu = smp_processor_id(); + 319. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 320. + +net/wireless/trace.h:313: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 311. ); + 312. + 313. > DECLARE_EVENT_CLASS(wiphy_enabled_evt, + 314. TP_PROTO(struct wiphy *wiphy, bool enabled), + 315. TP_ARGS(wiphy, enabled), + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +drivers/md/md.c:345: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 343. md_handle_request(mddev, bio); + 344. + 345. > cpu = part_stat_lock(); + 346. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]); + 347. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw], sectors); + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +kernel/softirq.c:326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 324. local_irq_save(flags); + 325. + 326. > pending = local_softirq_pending(); + 327. + 328. if (pending && !ksoftirqd_running()) + +drivers/char/agp/isoch.c:336: error: DEAD_STORE + The value written to &arqsz (type unsigned int) is never used. + 334. return -ENODEV; + 335. + 336. > arqsz = (tstatus >> 13) & 0x7; + 337. + 338. /* + +kernel/pid.c:322: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 320. if (pid) { + 321. struct hlist_node *first; + 322. > first = rcu_dereference_check(hlist_first_rcu(&pid->tasks[type]), + 323. lockdep_tasklist_lock_is_held()); + 324. if (first) + +kernel/rcu/tree_exp.h:326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 324. rnp = rdp->mynode; + 325. if (!(READ_ONCE(rnp->expmask) & rdp->grpmask) || + 326. > __this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)) + 327. return; + 328. if (rcu_is_cpu_rrupt_from_idle()) { + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +kernel/rcu/tree_exp.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. /* Store .exp before .rcu_urgent_qs. */ + 335. smp_store_release(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs), true); + 336. > resched_cpu(smp_processor_id()); + 337. } + 338. + +lib/zlib_inflate/inflate.c:494: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 492. NEEDBITS(this.bits); + 493. DROPBITS(this.bits); + 494. > state->lens[state->have++] = this.val; + 495. } + 496. else { + +lib/zlib_inflate/inflate.c:580: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 578. } + 579. DROPBITS(this.bits); + 580. > state->length = (unsigned)this.val; + 581. if ((int)(this.op) == 0) { + 582. state->mode = LIT; + +lib/zlib_inflate/inflate.c:625: error: UNINITIALIZED_VALUE + The value read from this.val was never initialized. + 623. break; + 624. } + 625. > state->offset = (unsigned)this.val; + 626. state->extra = (unsigned)(this.op) & 15; + 627. state->mode = DISTEXT; + +net/core/netpoll.c:322: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 320. + 321. list_for_each_entry(napi, &dev->napi_list, dev_list) { + 322. > if (napi->poll_owner == smp_processor_id()) + 323. return 1; + 324. } + +drivers/char/hw_random/core.c:322: error: DEAD_STORE + The value written to &err (type int) is never used. + 320. const char *buf, size_t len) + 321. { + 322. > int err = -ENODEV; + 323. struct hwrng *rng; + 324. + +net/ipv6/mcast.c:427: error: DEAD_STORE + The value written to &rv (type int) is never used. + 425. pmc->sflist = psl = newpsl; + 426. } + 427. > rv = 1; /* > 0 for insert logic below if sl_count is 0 */ + 428. for (i = 0; i < psl->sl_count; i++) { + 429. rv = !ipv6_addr_equal(&psl->sl_addr[i], source); + +net/ipv6/mcast.c:347: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 345. err = -EADDRNOTAVAIL; + 346. + 347. > for_each_pmc_rcu(inet6, pmc) { + 348. if (pgsr->gsr_interface && pmc->ifindex != pgsr->gsr_interface) + 349. continue; + +net/compat.c:330: error: UNINITIALIZED_VALUE + The value read from f32.filter was never initialized. + 328. memset(&f, 0, sizeof(f)); + 329. f.len = f32.len; + 330. > f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + 332. return NULL; + +net/compat.c:329: error: UNINITIALIZED_VALUE + The value read from f32.len was never initialized. + 327. return NULL; + 328. memset(&f, 0, sizeof(f)); + 329. > f.len = f32.len; + 330. f.filter = compat_ptr(f32.filter); + 331. if (copy_to_user(kfprog, &f, sizeof(struct sock_fprog))) + +drivers/gpu/drm/i915/i915_gem.c:337: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 335. return ret; + 336. + 337. > while ((vma = list_first_entry_or_null(&obj->vma_list, + 338. struct i915_vma, + 339. obj_link))) { + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +drivers/gpu/drm/i915/i915_trace.h:320: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 318. ); + 319. + 320. > TRACE_EVENT(i915_pipe_update_end, + 321. TP_PROTO(struct intel_crtc *crtc, u32 frame, int scanline_end), + 322. TP_ARGS(crtc, frame, scanline_end), + +sound/core/pcm_native.c:397: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 395. if (trace_hw_interval_param_enabled()) { + 396. if (hw_is_interval(r->var)) + 397. > old_interval = *hw_param_interval(params, r->var); + 398. } + 399. + +sound/core/pcm_native.c:393: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 391. if (trace_hw_mask_param_enabled()) { + 392. if (hw_is_mask(r->var)) + 393. > old_mask = *hw_param_mask(params, r->var); + 394. } + 395. if (trace_hw_interval_param_enabled()) { + +net/wireless/scan.c:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 327. + 328. > list_for_each_entry_rcu(pos, &rdev->sched_scan_req_list, list) { + 329. if (pos->reqid == reqid) + 330. return pos; + +net/ipv6/ip6_fib.c:332: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 330. struct fib6_table *tb; + 331. + 332. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) + 333. fib_seq += tb->fib_seq; + 334. } + +drivers/iommu/dmar.c:329: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 327. struct dmar_drhd_unit *dmaru; + 328. + 329. > for_each_drhd_unit(dmaru) + 330. if (dmar_remove_dev_scope(info, dmaru->segment, + 331. dmaru->devices, dmaru->devices_cnt)) + +net/netfilter/nf_log.c:327: error: DEAD_STORE + The value written to &net (type net*) is never used. + 325. static void *seq_start(struct seq_file *seq, loff_t *pos) + 326. { + 327. > struct net *net = seq_file_net(seq); + 328. + 329. mutex_lock(&nf_log_mutex); + +net/netlabel/netlabel_unlabeled.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. goto add_iface_failure; + 344. list_add_tail_rcu(&iface->list, + 345. > &netlbl_unlhsh_rcu_deref(netlbl_unlhsh)->tbl[bkt]); + 346. } else { + 347. INIT_LIST_HEAD(&iface->list); + +net/netlabel/netlabel_unlabeled.c:348: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 346. } else { + 347. INIT_LIST_HEAD(&iface->list); + 348. > if (netlbl_unlhsh_rcu_deref(netlbl_unlhsh_def) != NULL) + 349. goto add_iface_failure; + 350. rcu_assign_pointer(netlbl_unlhsh_def, iface); + +drivers/gpu/drm/drm_dp_mst_topology.c:373: error: DEAD_STORE + The value written to &crc4 (type unsigned char) is never used. + 371. if (msg->curchunk_idx >= msg->curchunk_len) { + 372. /* do CRC */ + 373. > crc4 = drm_dp_msg_data_crc4(msg->chunk, msg->curchunk_len - 1); + 374. /* copy chunk into bigger msg */ + 375. memcpy(&msg->msg[msg->curlen], msg->chunk, msg->curchunk_len - 1); + +include/linux/netfilter.h:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. + 332. rcu_read_lock(); + 333. > decodefn = rcu_dereference(nf_nat_decode_session_hook); + 334. if (decodefn) + 335. decodefn(skb, fl); + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:327: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 325. * in queue @q. + 326. */ + 327. > DEFINE_EVENT(block_bio_merge, block_bio_backmerge, + 328. + 329. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +kernel/events/ring_buffer.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. */ + 383. if (!rb->aux_overwrite) { + 384. > aux_tail = READ_ONCE(rb->user_page->aux_tail); + 385. handle->wakeup = rb->aux_wakeup + rb->aux_watermark; + 386. if (aux_head - aux_tail < perf_aux_size(rb)) + +ipc/msg.c:348: error: UNINITIALIZED_VALUE + The value read from tbuf_old.msg_lqbytes was never initialized. + 346. + 347. if (tbuf_old.msg_qbytes == 0) + 348. > out->msg_qbytes = tbuf_old.msg_lqbytes; + 349. else + 350. out->msg_qbytes = tbuf_old.msg_qbytes; + +ipc/msg.c:350: error: UNINITIALIZED_VALUE + The value read from tbuf_old.msg_qbytes was never initialized. + 348. out->msg_qbytes = tbuf_old.msg_lqbytes; + 349. else + 350. > out->msg_qbytes = tbuf_old.msg_qbytes; + 351. + 352. return 0; + +net/netfilter/nf_conntrack_core.c:333: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 331. + 332. /* add this conntrack to the (per cpu) unconfirmed list */ + 333. > ct->cpu = smp_processor_id(); + 334. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 335. + +net/netfilter/nf_conntrack_core.c:333: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 331. + 332. /* add this conntrack to the (per cpu) unconfirmed list */ + 333. > ct->cpu = smp_processor_id(); + 334. pcpu = per_cpu_ptr(nf_ct_net(ct)->ct.pcpu_lists, ct->cpu); + 335. + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +net/wireless/trace.h:328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 326. ); + 327. + 328. > DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, + 329. TP_PROTO(struct wiphy *wiphy, bool enabled), + 330. TP_ARGS(wiphy, enabled) + +drivers/gpu/drm/drm_dp_helper.c:340: error: UNINITIALIZED_VALUE + The value read from values[_] was never initialized. + 338. return err; + 339. + 340. > link->revision = values[0]; + 341. link->rate = drm_dp_bw_code_to_link_rate(values[1]); + 342. link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK; + +drivers/gpu/drm/drm_dp_helper.c:341: error: UNINITIALIZED_VALUE + The value read from values[_] was never initialized. + 339. + 340. link->revision = values[0]; + 341. > link->rate = drm_dp_bw_code_to_link_rate(values[1]); + 342. link->num_lanes = values[2] & DP_MAX_LANE_COUNT_MASK; + 343. + +kernel/exit.c:334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 332. struct task_struct *p; + 333. + 334. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 335. if ((p == ignored_task) || + 336. (p->exit_state && thread_group_empty(p)) || + +net/core/netpoll.c:339: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 337. lockdep_assert_irqs_disabled(); + 338. + 339. > npinfo = rcu_dereference_bh(np->dev->npinfo); + 340. if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) { + 341. dev_kfree_skb_irq(skb); + +drivers/gpu/drm/i915/i915_gem_request.c:350: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 348. * noops - they are safe to be replayed on a reset. + 349. */ + 350. > tail = READ_ONCE(request->ring->tail); + 351. } else { + 352. tail = request->postfix; + +drivers/dma-buf/sync_file.c:352: error: UNINITIALIZED_VALUE + The value read from data.fd2 was never initialized. + 350. } + 351. + 352. > fence2 = sync_file_fdget(data.fd2); + 353. if (!fence2) { + 354. err = -ENOENT; + +drivers/tty/vt/vt_ioctl.c:814: error: DEAD_STORE + The value written to &arg (type unsigned long) is never used. + 812. vt_disallocate_all(); + 813. else + 814. > ret = vt_disallocate(--arg); + 815. break; + 816. + +drivers/tty/vt/vt_ioctl.c:881: error: UNINITIALIZED_VALUE + The value read from v.v_clin was never initialized. + 879. vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. > vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_cols was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:883: error: UNINITIALIZED_VALUE + The value read from v.v_rows was never initialized. + 881. vc_cons[i].d->vc_font.height = v.v_clin; + 882. vc_cons[i].d->vc_resize_user = 1; + 883. > vc_resize(vc_cons[i].d, v.v_cols, v.v_rows); + 884. console_unlock(); + 885. } + +drivers/tty/vt/vt_ioctl.c:879: error: UNINITIALIZED_VALUE + The value read from v.v_vlin was never initialized. + 877. console_lock(); + 878. if (v.v_vlin) + 879. > vc_cons[i].d->vc_scan_lines = v.v_vlin; + 880. if (v.v_clin) + 881. vc_cons[i].d->vc_font.height = v.v_clin; + +include/net/ip_tunnels.h:344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 342. + 343. rcu_read_lock(); + 344. > ops = rcu_dereference(iptun_encaps[t->encap.type]); + 345. if (likely(ops && ops->build_header)) + 346. ret = ops->build_header(skb, &t->encap, protocol, fl4); + +net/core/fib_rules.c:339: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 337. if (!ops) + 338. return -EAFNOSUPPORT; + 339. > list_for_each_entry_rcu(rule, &ops->rules_list, list) + 340. call_fib_rule_notifier(nb, net, FIB_EVENT_RULE_ADD, rule, + 341. family); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:344: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 342. */ + 343. #define done (READ_ONCE(desc->fence) == fence) + 344. > err = wait_for_us(done, 10); + 345. if (err) + 346. err = wait_for(done, 10); + +drivers/gpu/drm/i915/intel_guc_ct.c:346: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 344. err = wait_for_us(done, 10); + 345. if (err) + 346. > err = wait_for(done, 10); + 347. #undef done + 348. + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +drivers/thermal/x86_pkg_temp_thermal.c:334: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 332. static int pkg_thermal_notify(u64 msr_val) + 333. { + 334. > int cpu = smp_processor_id(); + 335. struct pkg_device *pkgdev; + 336. unsigned long flags; + +ipc/sem.c:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. + 366. /* pairs with smp_store_release() */ + 367. > if (!smp_load_acquire(&sma->use_global_lock)) { + 368. /* fast path successful! */ + 369. return sops->sem_num; + +arch/x86/events/intel/bts.c:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. { + 335. struct bts_ctx *bts = this_cpu_ptr(&bts_ctx); + 336. > int state = READ_ONCE(bts->state); + 337. + 338. /* + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: DEAD_STORE + The value written to &ret (type int) is never used. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/wireless/trace.h:333: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 331. ); + 332. + 333. > TRACE_EVENT(rdev_add_virtual_intf, + 334. TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), + 335. TP_ARGS(wiphy, name, type), + +net/netfilter/nf_conntrack_helper.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. bool found = false; + 339. + 340. > list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) { + 341. if (!strcmp(cur->name, name)) { + 342. found = true; + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +drivers/cpufreq/acpi-cpufreq.c:347: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 345. int this_cpu; + 346. + 347. > this_cpu = get_cpu(); + 348. if (cpumask_test_cpu(this_cpu, mask)) + 349. do_drv_write(&cmd); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/scsi.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. ); + 335. + 336. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_done, + 337. TP_PROTO(struct scsi_cmnd *cmd), + 338. TP_ARGS(cmd)); + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +include/trace/events/timer.h:336: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 334. * @now: current time, used to calculate the latency of itimer + 335. */ + 336. > TRACE_EVENT(itimer_expire, + 337. + 338. TP_PROTO(int which, struct pid *pid, unsigned long long now), + +kernel/kprobes.c:342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 340. + 341. head = &kprobe_table[hash_ptr(addr, KPROBE_HASH_BITS)]; + 342. > hlist_for_each_entry_rcu(p, head, hlist) { + 343. if (p->addr == addr) + 344. return p; + +net/ipv6/calipso.c:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. struct calipso_doi *iter; + 339. + 340. > list_for_each_entry_rcu(iter, &calipso_doi_list, list) + 341. if (iter->doi == doi && refcount_read(&iter->refcount)) + 342. return iter; + +scripts/kconfig/symbol.c:352: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 351 could be null and is dereferenced by call to `prop_get_symbol()` at line 352, column 18. + 350. sym->flags &= ~SYMBOL_NEED_SET_CHOICE_VALUES; + 351. prop = sym_get_choice_prop(sym); + 352. > sym_calc_value(prop_get_symbol(prop)); + 353. } + 354. + +kernel/capability.c:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. + 342. rcu_read_lock(); + 343. > ret = security_capable_noaudit(__task_cred(t), ns, cap); + 344. rcu_read_unlock(); + 345. + +net/netfilter/nf_log.c:339: error: DEAD_STORE + The value written to &net (type net*) is never used. + 337. static void *seq_next(struct seq_file *s, void *v, loff_t *pos) + 338. { + 339. > struct net *net = seq_file_net(s); + 340. + 341. (*pos)++; + +include/net/ip.h:341: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 339. int ip_dont_fragment(const struct sock *sk, const struct dst_entry *dst) + 340. { + 341. > u8 pmtudisc = READ_ONCE(inet_sk(sk)->pmtudisc); + 342. + 343. return pmtudisc == IP_PMTUDISC_DO || + +sound/hda/hdmi_chmap.c:376: error: UNINITIALIZED_VALUE + The value read from non_pcm_mapping[_] was never initialized. + 374. + 375. for (i = 0; i < 8; i++) { + 376. > int slotsetup = non_pcm ? non_pcm_mapping[i] : hdmi_channel_mapping[ca][i]; + 377. int hdmi_slot = slotsetup & 0x0f; + 378. int channel = (slotsetup & 0xf0) >> 4; + +block/badblocks.c:356: error: DEAD_STORE + The value written to §ors (type int) is never used. + 354. s >>= bb->shift; + 355. target >>= bb->shift; + 356. > sectors = target - s; + 357. } + 358. + +drivers/base/power/wakeup.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. + 344. srcuidx = srcu_read_lock(&wakeup_srcu); + 345. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 346. dev_pm_arm_wake_irq(ws->wakeirq); + 347. srcu_read_unlock(&wakeup_srcu, srcuidx); + +security/keys/process_keys.c:396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 394. rcu_read_lock(); + 395. key_ref = keyring_search_aux( + 396. > make_key_ref(rcu_dereference(ctx->cred->session_keyring), 1), + 397. ctx); + 398. rcu_read_unlock(); + +block/blk-sysfs.c:343: error: DEAD_STORE + The value written to &ret (type long) is never used. + 341. queue_rq_affinity_store(struct request_queue *q, const char *page, size_t count) + 342. { + 343. > ssize_t ret = -EINVAL; + 344. #ifdef CONFIG_SMP + 345. unsigned long val; + +drivers/tty/sysrq.c:345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 343. + 344. read_lock(&tasklist_lock); + 345. > for_each_process(p) { + 346. if (p->flags & PF_KTHREAD) + 347. continue; + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +include/trace/events/scsi.h:340: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 338. TP_ARGS(cmd)); + 339. + 340. > DEFINE_EVENT(scsi_cmd_done_timeout_template, scsi_dispatch_cmd_timeout, + 341. TP_PROTO(struct scsi_cmnd *cmd), + 342. TP_ARGS(cmd)); + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +drivers/gpu/drm/i915/i915_trace.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. /* object tracking */ + 342. + 343. > TRACE_EVENT(i915_gem_object_create, + 344. TP_PROTO(struct drm_i915_gem_object *obj), + 345. TP_ARGS(obj), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +include/trace/events/block.h:343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 341. * operation in queue @q. + 342. */ + 343. > DEFINE_EVENT(block_bio_merge, block_bio_frontmerge, + 344. + 345. TP_PROTO(struct request_queue *q, struct request *rq, struct bio *bio), + +drivers/gpu/drm/drm_ioc32.c:356: error: UNINITIALIZED_VALUE + The value read from b32.high_mark was never initialized. + 354. buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. > buf.high_mark = b32.high_mark; + 357. + 358. return drm_ioctl_kernel(file, drm_legacy_markbufs, &buf, + +drivers/gpu/drm/drm_ioc32.c:355: error: UNINITIALIZED_VALUE + The value read from b32.low_mark was never initialized. + 353. + 354. buf.size = b32.size; + 355. > buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + 357. + +drivers/gpu/drm/drm_ioc32.c:354: error: UNINITIALIZED_VALUE + The value read from b32.size was never initialized. + 352. return -EFAULT; + 353. + 354. > buf.size = b32.size; + 355. buf.low_mark = b32.low_mark; + 356. buf.high_mark = b32.high_mark; + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +include/trace/events/scsi.h:344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 342. TP_ARGS(cmd)); + 343. + 344. > TRACE_EVENT(scsi_eh_wakeup, + 345. + 346. TP_PROTO(struct Scsi_Host *shost), + +security/selinux/ss/ebitmap.c:360: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 358. goto out; + 359. + 360. > mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. count = le32_to_cpu(buf[2]); + +security/selinux/ss/ebitmap.c:361: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 359. + 360. mapunit = le32_to_cpu(buf[0]); + 361. > e->highbit = le32_to_cpu(buf[1]); + 362. count = le32_to_cpu(buf[2]); + 363. + +security/selinux/ss/ebitmap.c:362: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 360. mapunit = le32_to_cpu(buf[0]); + 361. e->highbit = le32_to_cpu(buf[1]); + 362. > count = le32_to_cpu(buf[2]); + 363. + 364. if (mapunit != BITS_PER_U64) { + +lib/assoc_array.c:413: error: DEAD_STORE + The value written to &cursor (type assoc_array_ptr*) is never used. + 411. shortcut = assoc_array_ptr_to_shortcut(parent); + 412. BUG_ON(shortcut->next_node != cursor); + 413. > cursor = parent; + 414. parent = shortcut->back_pointer; + 415. slot = shortcut->parent_slot; + +net/sunrpc/xprtsock.c:382: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 380. err = 0; + 381. } + 382. > return err; + 383. } + 384. + +scripts/kallsyms.c:472: error: UNINITIALIZED_VALUE + The value read from best_idx[_] was never initialized. + 470. output_label("kallsyms_token_index"); + 471. for (i = 0; i < 256; i++) + 472. > printf("\t.short\t%d\n", best_idx[i]); + 473. printf("\n"); + 474. } + +net/sched/act_api.c:354: error: DEAD_STORE + The value written to &id (type unsigned long) is never used. + 352. struct tc_action *p; + 353. int ret; + 354. > unsigned long id = 1; + 355. + 356. idr_for_each_entry_ul(idr, p, id) { + +net/xfrm/xfrm_policy.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. return &net->xfrm.policy_inexact[dir]; + 362. + 363. > return rcu_dereference_check(net->xfrm.policy_bydst[dir].table, + 364. lockdep_is_held(&net->xfrm.xfrm_policy_lock)) + hash; + 365. } + +block/blk-ioc.c:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. */ + 361. rcu_read_lock(); + 362. > icq = rcu_dereference(ioc->icq_hint); + 363. if (icq && icq->q == q) + 364. goto out; + +drivers/gpu/drm/i915/intel_uncore.c:415: error: UNINITIALIZED_VALUE + The value read from irqflags was never initialized. + 413. assert_forcewakes_inactive(dev_priv); + 414. + 415. > spin_unlock_irqrestore(&dev_priv->uncore.lock, irqflags); + 416. } + 417. + +lib/sbitmap.c:355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 353. + 354. hint = this_cpu_read(*sbq->alloc_hint); + 355. > depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + 357. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:354: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 352. int nr; + 353. + 354. > hint = this_cpu_read(*sbq->alloc_hint); + 355. depth = READ_ONCE(sbq->sb.depth); + 356. if (unlikely(hint >= depth)) { + +kernel/locking/rwsem-xadd.c:353: error: DEAD_STORE + The value written to &ret (type _Bool) is never used. + 351. { + 352. struct task_struct *owner; + 353. > bool ret = true; + 354. + 355. if (need_resched()) + +kernel/locking/rwsem-xadd.c:359: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 357. + 358. rcu_read_lock(); + 359. > owner = READ_ONCE(sem->owner); + 360. if (!rwsem_owner_is_writer(owner)) { + 361. /* + +net/ipv4/tcp_minisocks.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. + 362. mss = tcp_mss_clamp(tp, dst_metric_advmss(dst)); + 363. > window_clamp = READ_ONCE(tp->window_clamp); + 364. /* Set this up on the first call only */ + 365. req->rsk_window_clamp = window_clamp ? : dst_metric(dst, RTAX_WINDOW); + +net/wireless/trace.h:350: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 348. ); + 349. + 350. > DECLARE_EVENT_CLASS(wiphy_wdev_evt, + 351. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 352. TP_ARGS(wiphy, wdev), + +scripts/asn1_compiler.c:361: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 361, column 3. + 359. token_list = tokens = calloc((end - buffer) / 2, sizeof(struct token)); + 360. if (!tokens) { + 361. > perror(NULL); + 362. exit(1); + 363. } + +arch/x86/include/asm/tlbflush.h:360: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 358. WARN_ON_ONCE(preemptible()); + 359. + 360. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 361. + 362. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +arch/x86/include/asm/tlbflush.h:360: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 358. WARN_ON_ONCE(preemptible()); + 359. + 360. > invalidate_user_asid(this_cpu_read(cpu_tlbstate.loaded_mm_asid)); + 361. + 362. /* If current->mm == NULL then the read_cr3() "borrows" an mm */ + +net/netfilter/nf_conntrack_helper.c:357: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 355. bool found = false; + 356. + 357. > list_for_each_entry_rcu(cur, &nf_ct_helper_expectfn_list, head) { + 358. if (cur->expectfn == symbol) { + 359. found = true; + +net/sunrpc/auth_gss/gss_rpc_xdr.c:378: error: DEAD_STORE + The value written to &err (type int) is never used. + 376. opt.value.data = LUCID_VALUE; + 377. opt.value.len = sizeof(LUCID_VALUE); + 378. > err = gssx_enc_option(xdr, &opt); + 379. + 380. /* ..and user creds */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:371: error: NULL_DEREFERENCE + pointer `p` last assigned on line 370 could be null and is dereferenced at line 371, column 2. + 369. /* ctx->options */ + 370. p = xdr_reserve_space(xdr, 4); + 371. > *p = cpu_to_be32(2); + 372. + 373. /* we want a lucid_v1 context */ + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +include/trace/events/rcu.h:353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 351. * All but the type of RCU are extracted from the rcu_node structure. + 352. */ + 353. > TRACE_EVENT(rcu_quiescent_state_report, + 354. + 355. TP_PROTO(const char *rcuname, unsigned long gpnum, + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +kernel/time/tick-broadcast.c:375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 373. goto out; + 374. + 375. > cpu = smp_processor_id(); + 376. bc = tick_broadcast_device.evtdev; + 377. bc_stopped = cpumask_empty(tick_broadcast_mask); + +drivers/base/power/wakeup.c:361: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 359. + 360. srcuidx = srcu_read_lock(&wakeup_srcu); + 361. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 362. dev_pm_disarm_wake_irq(ws->wakeirq); + 363. srcu_read_unlock(&wakeup_srcu, srcuidx); + +security/selinux/ss/conditional.c:368: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 366. return rc; + 367. + 368. > len = le32_to_cpu(buf[0]); + 369. if (len == 0) + 370. return 0; + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +drivers/gpu/drm/i915/i915_debugfs.c:376: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 374. } + 375. + 376. > print_file_stats(m, "[k]batch pool", stats); + 377. } + 378. + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:356: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 354. * but not actually running due to scheduler contention). + 355. */ + 356. > DEFINE_EVENT(sched_stat_template, sched_stat_wait, + 357. TP_PROTO(struct task_struct *tsk, u64 delay), + 358. TP_ARGS(tsk, delay)); + +kernel/sched/loadavg.c:361: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 359. long active, delta; + 360. + 361. > sample_window = READ_ONCE(calc_load_update); + 362. if (time_before(jiffies, sample_window + 10)) + 363. return; + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +drivers/cpufreq/cpufreq_ondemand.c:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. return -ENOMEM; + 366. + 367. > cpu = get_cpu(); + 368. idle_time = get_cpu_idle_time_us(cpu, NULL); + 369. put_cpu(); + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +include/trace/events/block.h:357: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 355. * About to place the block IO operation @bio into queue @q. + 356. */ + 357. > TRACE_EVENT(block_bio_queue, + 358. + 359. TP_PROTO(struct request_queue *q, struct bio *bio), + +kernel/sched/clock.c:371: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 369. scd = cpu_sdc(cpu); + 370. + 371. > if (cpu != smp_processor_id()) + 372. clock = sched_clock_remote(scd); + 373. else + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:394: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 392. + 393. /* ...and verify the command was successful. */ + 394. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 395. + 396. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +drivers/dma/dmaengine.c:361: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 359. struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type) + 360. { + 361. > return this_cpu_read(channel_table[tx_type]->chan); + 362. } + 363. EXPORT_SYMBOL(dma_find_channel); + +drivers/dma/dmaengine.c:361: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 359. struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type) + 360. { + 361. > return this_cpu_read(channel_table[tx_type]->chan); + 362. } + 363. EXPORT_SYMBOL(dma_find_channel); + +kernel/exit.c:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. struct task_struct *p; + 362. + 363. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 364. if (p->signal->flags & SIGNAL_STOP_STOPPED) + 365. return true; + +kernel/pid.c:365: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 363. if (type != PIDTYPE_PID) + 364. task = task->group_leader; + 365. > pid = get_pid(rcu_dereference(task->pids[type].pid)); + 366. rcu_read_unlock(); + 367. return pid; + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +drivers/gpu/drm/i915/i915_trace.h:360: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 358. ); + 359. + 360. > TRACE_EVENT(i915_gem_shrink, + 361. TP_PROTO(struct drm_i915_private *i915, unsigned long target, unsigned flags), + 362. TP_ARGS(i915, target, flags), + +include/linux/key.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. { + 362. /* Barrier versus mark_key_instantiated(). */ + 363. > return smp_load_acquire(&key->state); + 364. } + 365. + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +kernel/smp.c:368: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 366. + 367. /* Try for same CPU (cheapest) */ + 368. > cpu = get_cpu(); + 369. if (cpumask_test_cpu(cpu, mask)) + 370. goto call; + +include/linux/netfilter/x_tables.h:369: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 367. * called xt_write_recseq_begin(). + 368. */ + 369. > addend = (__this_cpu_read(xt_recseq.sequence) + 1) & 1; + 370. + 371. /* + +kernel/printk/printk_safe.c:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. { + 363. /* Use extra buffer in NMI when logbuf_lock is taken or in safe mode. */ + 364. > if (this_cpu_read(printk_context) & PRINTK_NMI_CONTEXT_MASK) + 365. return vprintk_nmi(fmt, args); + 366. + +kernel/printk/printk_safe.c:368: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 366. + 367. /* Use extra buffer to prevent a recursion deadlock in safe mode. */ + 368. > if (this_cpu_read(printk_context) & PRINTK_SAFE_CONTEXT_MASK) + 369. return vprintk_safe(fmt, args); + 370. + +kernel/printk/printk_safe.c:375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 373. * But avoid calling console drivers that might have their own locks. + 374. */ + 375. > if (this_cpu_read(printk_context) & PRINTK_NMI_DEFERRED_CONTEXT_MASK) + 376. return vprintk_deferred(fmt, args); + 377. + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/sunrpc.h:362: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 360. TP_ARGS(xprt, socket, error)) + 361. + 362. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. ); + 362. + 363. > DEFINE_EVENT(pm_qos_request, pm_qos_add_request, + 364. + 365. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +include/trace/events/sunrpc.h:363: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 361. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + +drivers/scsi/scsi_logging.c:375: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 373. return; + 374. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 375. > off += scsi_format_sense_hdr(logbuf + off, logbuf_len - off, sshdr); + 376. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + 377. scsi_log_release_buffer(logbuf); + +drivers/scsi/scsi_logging.c:383: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 381. return; + 382. off = sdev_format_header(logbuf, logbuf_len, name, tag); + 383. > off += scsi_format_extd_sense(logbuf + off, logbuf_len - off, + 384. sshdr->asc, sshdr->ascq); + 385. dev_printk(KERN_INFO, &sdev->sdev_gendev, "%s", logbuf); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. * including iowait, see below). + 363. */ + 364. > DEFINE_EVENT(sched_stat_template, sched_stat_sleep, + 365. TP_PROTO(struct task_struct *tsk, u64 delay), + 366. TP_ARGS(tsk, delay)); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +include/trace/events/sunrpc.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. DEFINE_RPC_SOCKET_EVENT(rpc_socket_state_change); + 363. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_connect); + 364. > DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:364: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 362. ); + 363. + 364. > DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, + 365. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 366. TP_ARGS(wiphy, wdev) + +drivers/gpu/drm/drm_modes.c:459: error: DEAD_STORE + The value written to &hperiod (type unsigned int) is never used. + 457. vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. > hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + 460. + 461. /* 13. Find the actual Vertical field frequency: */ + +drivers/gpu/drm/drm_modes.c:452: error: DEAD_STORE + The value written to &vback_porch (type int) is never used. + 450. vsync_plus_bp = (vsync_plus_bp + 500) / 1000; + 451. /* 9. Find the number of lines in V back porch alone: */ + 452. > vback_porch = vsync_plus_bp - V_SYNC_RQD; + 453. /* 10. Find the total number of lines in Vertical field period: */ + 454. vtotal_lines = vdisplay_rnd + top_margin + bottom_margin + + +drivers/gpu/drm/drm_modes.c:457: error: DEAD_STORE + The value written to &vfieldrate_est (type unsigned int) is never used. + 455. vsync_plus_bp + GTF_MIN_V_PORCH; + 456. /* 11. Estimate the Vertical field frequency: */ + 457. > vfieldrate_est = hfreq_est / vtotal_lines; + 458. /* 12. Find the actual horizontal period: */ + 459. hperiod = 1000000 / (vfieldrate_rqd * vtotal_lines); + +drivers/gpu/drm/drm_modes.c:465: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 463. /* 14. Find the Vertical frame frequency: */ + 464. if (interlaced) + 465. > vframe_rate = vfield_rate / 2; + 466. else + 467. vframe_rate = vfield_rate; + +drivers/gpu/drm/drm_modes.c:467: error: DEAD_STORE + The value written to &vframe_rate (type unsigned int) is never used. + 465. vframe_rate = vfield_rate / 2; + 466. else + 467. > vframe_rate = vfield_rate; + 468. /* 15. Find number of pixels in left margin: */ + 469. if (margins) + +include/net/ip.h:375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 373. return dst_mtu(dst); + 374. + 375. > return min(READ_ONCE(dst->dev->mtu), IP_MAX_MTU); + 376. } + 377. + +drivers/usb/core/message.c:455: error: DEAD_STORE + The value written to &i (type int) is never used. + 453. urb->transfer_buffer_length = len; + 454. } + 455. > io->urbs[--i]->transfer_flags &= ~URB_NO_INTERRUPT; + 456. + 457. /* transaction state */ + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +include/trace/events/sunrpc.h:366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 364. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_error); + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + +drivers/md/dm-stripe.c:384: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 382. } + 383. buffer[i] = '\0'; + 384. > DMEMIT("1 %s", buffer); + 385. break; + 386. + +drivers/pcmcia/ti113x.h:417: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 415. dev_info(&socket->dev->dev, + 416. "TI: all-serial interrupts ok\n"); + 417. > mfunc_old = mfunc; + 418. goto out; + 419. } + +drivers/pcmcia/ti113x.h:462: error: DEAD_STORE + The value written to &mfunc_old (type unsigned int) is never used. + 460. pci_irq_status = yenta_probe_cb_irq(socket); + 461. if (pci_irq_status == 1) { + 462. > mfunc_old = mfunc; + 463. dev_info(&socket->dev->dev, "TI: parallel PCI interrupts ok\n"); + 464. } else { + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +include/trace/events/sunrpc.h:367: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 365. DEFINE_RPC_SOCKET_EVENT_DONE(rpc_socket_reset_connection); + 366. DEFINE_RPC_SOCKET_EVENT(rpc_socket_close); + 367. > DEFINE_RPC_SOCKET_EVENT(rpc_socket_shutdown); + 368. + 369. DECLARE_EVENT_CLASS(rpc_xprt_event, + +net/netfilter/nf_conntrack_helper.c:385: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 383. + 384. /* rcu_read_lock()ed by nf_hook_thresh */ + 385. > helper = rcu_dereference(help->helper); + 386. + 387. nf_log_packet(nf_ct_net(ct), nf_ct_l3num(ct), 0, skb, NULL, NULL, NULL, + +net/xfrm/xfrm_policy.c:380: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 378. hash = __addr_hash(daddr, saddr, family, hmask, dbits, sbits); + 379. + 380. > return rcu_dereference_check(net->xfrm.policy_bydst[dir].table, + 381. lockdep_is_held(&net->xfrm.xfrm_policy_lock)) + hash; + 382. } + +drivers/dma/dmaengine.c:374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 372. + 373. rcu_read_lock(); + 374. > list_for_each_entry_rcu(device, &dma_device_list, global_node) { + 375. if (dma_has_cap(DMA_PRIVATE, device->cap_mask)) + 376. continue; + +include/net/sch_generic.h:370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 368. static inline struct Qdisc *qdisc_root(const struct Qdisc *qdisc) + 369. { + 370. > struct Qdisc *q = rcu_dereference_rtnl(qdisc->dev_queue->qdisc); + 371. + 372. return q; + +arch/x86/include/asm/tlbflush.h:391: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 389. raw_local_irq_save(flags); + 390. + 391. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 392. /* toggle PGE */ + 393. native_write_cr4(cr4 ^ X86_CR4_PGE); + +arch/x86/include/asm/tlbflush.h:391: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 389. raw_local_irq_save(flags); + 390. + 391. > cr4 = this_cpu_read(cpu_tlbstate.cr4); + 392. /* toggle PGE */ + 393. native_write_cr4(cr4 ^ X86_CR4_PGE); + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:369: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 367. ); + 368. + 369. > DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, + 370. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 371. TP_ARGS(wiphy, wdev) + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 368. ); + 369. + 370. > DEFINE_EVENT(pm_qos_request, pm_qos_update_request, + 371. + 372. TP_PROTO(int pm_qos_class, s32 value), + +kernel/signal.c:381: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 379. */ + 380. rcu_read_lock(); + 381. > user = get_uid(__task_cred(t)->user); + 382. atomic_inc(&user->sigpending); + 383. rcu_read_unlock(); + +kernel/sched/cpuacct.c:377: error: NULL_DEREFERENCE + pointer `ca` last assigned on line 376 could be null and is dereferenced at line 377, column 3. + 375. rcu_read_lock(); + 376. for (ca = task_ca(tsk); ca != &root_cpuacct; ca = parent_ca(ca)) + 377. > this_cpu_ptr(ca->cpustat)->cpustat[index] += val; + 378. rcu_read_unlock(); + 379. } + +drivers/iommu/dmar.c:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. struct dmar_drhd_unit *dmaru; + 376. + 377. > list_for_each_entry_rcu(dmaru, &dmar_drhd_units, list) + 378. if (dmaru->segment == drhd->segment && + 379. dmaru->reg_base_addr == drhd->address) + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:372: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 370. * due to waiting on IO to complete). + 371. */ + 372. > DEFINE_EVENT(sched_stat_template, sched_stat_iowait, + 373. TP_PROTO(struct task_struct *tsk, u64 delay), + 374. TP_ARGS(tsk, delay)); + +kernel/time/tick-common.c:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. void tick_handover_do_timer(void) + 373. { + 374. > if (tick_do_timer_cpu == smp_processor_id()) { + 375. int cpu = cpumask_first(cpu_online_mask); + 376. + +net/ipv4/udp.c:416: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 414. } + 415. + 416. > if (sk->sk_incoming_cpu == raw_smp_processor_id()) + 417. score++; + 418. return score; + +kernel/params.c:384: error: UNINITIALIZED_VALUE + The value read from v was never initialized. + 382. ret = param_set_bool(val, &boolkp); + 383. if (ret == 0) + 384. > *(int *)kp->arg = v; + 385. return ret; + 386. } + +net/ipv4/cipso_ipv4.c:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. struct cipso_v4_doi *iter; + 376. + 377. > list_for_each_entry_rcu(iter, &cipso_v4_doi_list, list) + 378. if (iter->doi == doi && refcount_read(&iter->refcount)) + 379. return iter; + +drivers/tty/vt/vc_screen.c:536: error: DEAD_STORE + The value written to &con_buf0 (type char*) is never used. + 534. unsigned char c; + 535. + 536. > c = *con_buf0++; + 537. #ifdef __BIG_ENDIAN + 538. vcs_scr_writew(vc, (vcs_scr_readw(vc, org) & 0xff) | (c << 8), org); + +lib/genalloc.c:386: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 384. nbits = (size + (1UL << order) - 1) >> order; + 385. rcu_read_lock(); + 386. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { + 387. if (addr >= chunk->start_addr && addr <= chunk->end_addr) { + 388. BUG_ON(addr + size - 1 > chunk->end_addr); + +net/netfilter/nf_conntrack_ftp.c:523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 521. /* Now, NAT might want to mangle the packet, and register the + 522. * (possibly changed) expectation itself. */ + 523. > nf_nat_ftp = rcu_dereference(nf_nat_ftp_hook); + 524. if (nf_nat_ftp && ct->status & IPS_NAT_MASK) + 525. ret = nf_nat_ftp(skb, ctinfo, search[dir][i].ftptype, + +net/wireless/trace.h:374: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/wireless/trace.h:374: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 372. ); + 373. + 374. > TRACE_EVENT(rdev_change_virtual_intf, + 375. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 376. enum nl80211_iftype type), + +net/ipv4/proc.c:396: error: UNINITIALIZED_VALUE + The value read from buff64[_] was never initialized. + 394. offsetof(struct ipstats_mib, syncp)); + 395. for (i = 0; snmp4_ipstats_list[i].name; i++) + 396. > seq_printf(seq, " %llu", buff64[i]); + 397. + 398. return 0; + +kernel/rcu/srcutree.c:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. for_each_possible_cpu(cpu) + 386. flush_delayed_work(&per_cpu_ptr(sp->sda, cpu)->work); + 387. > if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 388. WARN_ON(srcu_readers_active(sp))) { + 389. pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + +kernel/rcu/srcutree.c:389: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 387. if (WARN_ON(rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) != SRCU_STATE_IDLE) || + 388. WARN_ON(srcu_readers_active(sp))) { + 389. > pr_info("cleanup_srcu_struct: Active srcu_struct %p state: %d\n", sp, rcu_seq_state(READ_ONCE(sp->srcu_gp_seq))); + 390. return; /* Caller forgot to stop doing call_srcu()? */ + 391. } + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +include/trace/events/power.h:377: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 375. ); + 376. + 377. > DEFINE_EVENT(pm_qos_request, pm_qos_remove_request, + 378. + 379. TP_PROTO(int pm_qos_class, s32 value), + +lib/sbitmap.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. + 383. hint = this_cpu_read(*sbq->alloc_hint); + 384. > depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + 386. hint = depth ? prandom_u32() % depth : 0; + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +lib/sbitmap.c:383: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 381. int nr; + 382. + 383. > hint = this_cpu_read(*sbq->alloc_hint); + 384. depth = READ_ONCE(sbq->sb.depth); + 385. if (unlikely(hint >= depth)) { + +net/netlabel/netlabel_unlabeled.c:408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 406. } else { + 407. ifindex = 0; + 408. > iface = rcu_dereference(netlbl_unlhsh_def); + 409. } + 410. if (iface == NULL) { + +include/net/ip.h:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. } + 386. + 387. > return min(READ_ONCE(skb_dst(skb)->dev->mtu), IP_MAX_MTU); + 388. } + 389. + +net/sunrpc/svc_xprt.c:411: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 409. /* find a thread for this xprt */ + 410. rcu_read_lock(); + 411. > list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) { + 412. if (test_and_set_bit(RQ_BUSY, &rqstp->rq_flags)) + 413. continue; + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +net/sunrpc/svc_xprt.c:398: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 396. } + 397. + 398. > cpu = get_cpu(); + 399. pool = svc_pool_for_cpu(xprt->xpt_server, cpu); + 400. + +sound/pci/hda/hda_controller.c:391: error: DEAD_STORE + The value written to &timeout (type unsigned int) is never used. + 389. bool direction; + 390. u32 dma_select; + 391. > u32 timeout = 200; + 392. u32 retry_count = 0; + 393. + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +include/trace/events/sched.h:379: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 377. * Tracepoint for accounting blocked time (time the task is in uninterruptible). + 378. */ + 379. > DEFINE_EVENT(sched_stat_template, sched_stat_blocked, + 380. TP_PROTO(struct task_struct *tsk, u64 delay), + 381. TP_ARGS(tsk, delay)); + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +kernel/softirq.c:382: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 380. { + 381. #ifdef CONFIG_NO_HZ_COMMON + 382. > int cpu = smp_processor_id(); + 383. + 384. /* Make sure that timer wheel updates are propagated */ + +drivers/dma-buf/reservation.c:400: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 398. seq = read_seqcount_begin(&obj->seq); + 399. + 400. > fence_excl = rcu_dereference(obj->fence_excl); + 401. if (fence_excl && !dma_fence_get_rcu(fence_excl)) + 402. goto unlock; + +drivers/dma-buf/reservation.c:404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 402. goto unlock; + 403. + 404. > fobj = rcu_dereference(obj->fence); + 405. if (fobj) { + 406. struct dma_fence **nshared; + +drivers/dma-buf/reservation.c:426: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 424. + 425. for (i = 0; i < shared_count; ++i) { + 426. > shared[i] = rcu_dereference(fobj->shared[i]); + 427. if (!dma_fence_get_rcu(shared[i])) + 428. break; + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +drivers/gpu/drm/i915/i915_trace.h:380: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 378. ); + 379. + 380. > TRACE_EVENT(i915_vma_bind, + 381. TP_PROTO(struct i915_vma *vma, unsigned flags), + 382. TP_ARGS(vma, flags), + +kernel/time/timer.c:382: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 380. unsigned long round_jiffies(unsigned long j) + 381. { + 382. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 383. } + 384. EXPORT_SYMBOL_GPL(round_jiffies); + +kernel/time/timer.c:382: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 380. unsigned long round_jiffies(unsigned long j) + 381. { + 382. > return round_jiffies_common(j, raw_smp_processor_id(), false); + 383. } + 384. EXPORT_SYMBOL_GPL(round_jiffies); + +kernel/locking/rwsem-xadd.c:383: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 381. static noinline bool rwsem_spin_on_owner(struct rw_semaphore *sem) + 382. { + 383. > struct task_struct *owner = READ_ONCE(sem->owner); + 384. + 385. if (!rwsem_owner_is_writer(owner)) + +net/core/net_namespace.c:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. static void net_free(struct net *net) + 383. { + 384. > kfree(rcu_access_pointer(net->gen)); + 385. kmem_cache_free(net_cachep, net); + 386. } + +net/ipv4/inet_connection_sock.c:424: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 422. } + 423. finish_wait(sk_sleep(sk), &wait); + 424. > return err; + 425. } + 426. + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_base_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +drivers/base/regmap/regcache-rbtree.c:454: error: UNINITIALIZED_VALUE + The value read from new_top_reg was never initialized. + 452. + 453. if (rbnode) { + 454. > ret = regcache_rbtree_insert_to_block(map, rbnode, + 455. new_base_reg, + 456. new_top_reg, reg, + +kernel/kprobes.c:387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 385. struct kprobe *kp; + 386. + 387. > list_for_each_entry_rcu(kp, &p->list, list) { + 388. if (kp->pre_handler && likely(!kprobe_disabled(kp))) { + 389. set_kprobe_instance(kp); + +kernel/sched/core.c:386: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 384. { + 385. struct thread_info *ti = task_thread_info(p); + 386. > return !(fetch_or(&ti->flags, _TIF_NEED_RESCHED) & _TIF_POLLING_NRFLAG); + 387. } + 388. + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +include/trace/events/power.h:384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 382. ); + 383. + 384. > TRACE_EVENT(pm_qos_update_request_timeout, + 385. + 386. TP_PROTO(int pm_qos_class, s32 value, unsigned long timeout_us), + +net/xfrm/xfrm_policy.c:413: error: DEAD_STORE + The value written to &entry0 (type hlist_node*) is never used. + 411. hlist_add_behind_rcu(&pol->bydst, entry0); + 412. } + 413. > entry0 = &pol->bydst; + 414. } + 415. if (!hlist_empty(list)) { + +net/xfrm/xfrm_policy.c:406: error: DEAD_STORE + The value written to &h0 (type unsigned int) is never used. + 404. hlist_del_rcu(&pol->bydst); + 405. hlist_add_head_rcu(&pol->bydst, ndsttable + h); + 406. > h0 = h; + 407. } else { + 408. if (h != h0) + +drivers/gpu/drm/drm_ioc32.c:402: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 400. return err; + 401. + 402. > if (put_user(req32.count, &argp->count)) + 403. return -EFAULT; + 404. + +drivers/gpu/drm/drm_mm.c:387: error: DEAD_STORE + The value written to &end (type unsigned long long) is never used. + 385. int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node) + 386. { + 387. > u64 end = node->start + node->size; + 388. struct drm_mm_node *hole; + 389. u64 hole_start, hole_end; + +kernel/cgroup/freezer.c:409: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 398 could be null and is dereferenced at line 409, column 10. + 407. else + 408. freezer_apply_state(pos_f, + 409. > parent->state & CGROUP_FREEZING, + 410. CGROUP_FREEZING_PARENT); + 411. + +net/ipv4/inet_hashtables.c:392: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 390. const int dif, const int sdif) + 391. { + 392. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + +net/ipv4/inet_hashtables.c:393: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 391. { + 392. INET_ADDR_COOKIE(acookie, saddr, daddr); + 393. > const __portpair ports = INET_COMBINED_PORTS(sport, hnum); + 394. struct sock *sk; + 395. const struct hlist_nulls_node *node; + +net/ipv4/inet_hashtables.c:404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 402. + 403. begin: + 404. > sk_nulls_for_each_rcu(sk, node, &head->chain) { + 405. if (sk->sk_hash != hash) + 406. continue; + +drivers/net/ethernet/intel/e1000/e1000_main.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. struct e1000_rx_ring *ring = &adapter->rx_ring[i]; + 408. adapter->alloc_rx_buf(adapter, ring, + 409. > E1000_DESC_UNUSED(ring)); + 410. } + 411. } + +net/ipv4/tcp.c:391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 389. static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp) + 390. { + 391. > u32 rate = READ_ONCE(tp->rate_delivered); + 392. u32 intv = READ_ONCE(tp->rate_interval_us); + 393. u64 rate64 = 0; + +net/ipv4/tcp.c:392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 390. { + 391. u32 rate = READ_ONCE(tp->rate_delivered); + 392. > u32 intv = READ_ONCE(tp->rate_interval_us); + 393. u64 rate64 = 0; + 394. + +security/selinux/ss/avtab.c:489: error: DEAD_STORE + The value written to &items (type unsigned int) is never used. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:486: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 484. + 485. items = 0; + 486. > key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:487: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 485. items = 0; + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. > key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + +security/selinux/ss/avtab.c:488: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 486. key.source_type = le16_to_cpu(buf16[items++]); + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. > key.target_class = le16_to_cpu(buf16[items++]); + 489. key.specified = le16_to_cpu(buf16[items++]); + 490. + +security/selinux/ss/avtab.c:489: error: UNINITIALIZED_VALUE + The value read from buf16[_] was never initialized. + 487. key.target_type = le16_to_cpu(buf16[items++]); + 488. key.target_class = le16_to_cpu(buf16[items++]); + 489. > key.specified = le16_to_cpu(buf16[items++]); + 490. + 491. if (!policydb_type_isvalid(pol, key.source_type) || + +security/selinux/ss/avtab.c:413: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 411. return rc; + 412. } + 413. > items2 = le32_to_cpu(buf32[0]); + 414. if (items2 > ARRAY_SIZE(buf32)) { + 415. printk(KERN_ERR "SELinux: avtab: entry overflow\n"); + +security/selinux/ss/avtab.c:426: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 424. items = 0; + 425. + 426. > val = le32_to_cpu(buf32[items++]); + 427. key.source_type = (u16)val; + 428. if (key.source_type != val) { + +security/selinux/ss/avtab.c:432: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 430. return -EINVAL; + 431. } + 432. > val = le32_to_cpu(buf32[items++]); + 433. key.target_type = (u16)val; + 434. if (key.target_type != val) { + +security/selinux/ss/avtab.c:438: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 436. return -EINVAL; + 437. } + 438. > val = le32_to_cpu(buf32[items++]); + 439. key.target_class = (u16)val; + 440. if (key.target_class != val) { + +security/selinux/ss/avtab.c:445: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 443. } + 444. + 445. > val = le32_to_cpu(buf32[items++]); + 446. enabled = (val & AVTAB_ENABLED_OLD) ? AVTAB_ENABLED : 0; + 447. + +security/selinux/ss/avtab.c:465: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 463. if (val & spec_order[i]) { + 464. key.specified = spec_order[i] | enabled; + 465. > datum.u.data = le32_to_cpu(buf32[items++]); + 466. rc = insertf(a, &key, &datum, p); + 467. if (rc) + +security/selinux/ss/avtab.c:532: error: UNINITIALIZED_VALUE + The value read from buf32[_] was never initialized. + 530. } + 531. for (i = 0; i < ARRAY_SIZE(xperms.perms.p); i++) + 532. > xperms.perms.p[i] = le32_to_cpu(buf32[i]); + 533. datum.u.xperms = &xperms; + 534. } else { + +lib/idr.c:422: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 420. } + 421. new = iter.index * IDA_BITMAP_BITS; + 422. > bitmap = rcu_dereference_raw(*slot); + 423. if (radix_tree_exception(bitmap)) { + 424. unsigned long tmp = (unsigned long)bitmap; + +lib/idr.c:432: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 430. return 0; + 431. } + 432. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 433. if (!bitmap) + 434. return -EAGAIN; + +lib/idr.c:464: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 462. return 0; + 463. } + 464. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 465. if (!bitmap) + 466. return -EAGAIN; + +lib/idr.c:432: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 430. return 0; + 431. } + 432. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 433. if (!bitmap) + 434. return -EAGAIN; + +lib/idr.c:464: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 462. return 0; + 463. } + 464. > bitmap = this_cpu_xchg(ida_bitmap, NULL); + 465. if (!bitmap) + 466. return -EAGAIN; + +net/ipv6/anycast.c:399: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 397. found = ipv6_chk_acast_dev(dev, addr); + 398. else + 399. > for_each_netdev_rcu(net, dev) + 400. if (ipv6_chk_acast_dev(dev, addr)) { + 401. found = true; + +block/blk-mq-sched.c:408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 406. + 407. rcu_read_lock(); + 408. > list_for_each_entry_rcu_rr(q, queue, &set->tag_list, + 409. tag_set_list) { + 410. queue_for_each_hw_ctx(q, hctx2, i) + +drivers/gpu/drm/i915/dvo_ns2501.c:418: error: UNINITIALIZED_VALUE + The value read from in_buf[_] was never initialized. + 416. + 417. if (i2c_transfer(adapter, msgs, 2) == 2) { + 418. > *ch = in_buf[0]; + 419. return true; + 420. } + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +include/trace/events/timer.h:392: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 390. __print_symbolic(val, TICK_DEP_NAMES) + 391. + 392. > TRACE_EVENT(tick_stop, + 393. + 394. TP_PROTO(int success, int dependency), + +init/main.c:411: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 409. rcu_read_lock(); + 410. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 411. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 412. rcu_read_unlock(); + 413. + +init/main.c:411: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 409. rcu_read_lock(); + 410. tsk = find_task_by_pid_ns(pid, &init_pid_ns); + 411. > set_cpus_allowed_ptr(tsk, cpumask_of(smp_processor_id())); + 412. rcu_read_unlock(); + 413. + +net/wireless/trace.h:392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 390. ); + 391. + 392. > DECLARE_EVENT_CLASS(key_handle, + 393. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 394. bool pairwise, const u8 *mac_addr), + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:393: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 391. ); + 392. + 393. > DEFINE_EVENT(rpc_xprt_event, xprt_timer, + 394. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 395. TP_ARGS(xprt, xid, status)); + +net/ipv6/raw.c:395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 393. static inline int rawv6_rcv_skb(struct sock *sk, struct sk_buff *skb) + 394. { + 395. > if ((raw6_sk(sk)->checksum || rcu_access_pointer(sk->sk_filter)) && + 396. skb_checksum_complete(skb)) { + 397. atomic_inc(&sk->sk_drops); + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +drivers/gpu/drm/i915/i915_debugfs.c:413: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 411. mutex_unlock(&dev->struct_mutex); + 412. + 413. > print_file_stats(m, "[k]contexts", stats); + 414. } + 415. + +net/netlabel/netlabel_calipso.c:396: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 394. static const struct netlbl_calipso_ops *netlbl_calipso_ops_get(void) + 395. { + 396. > return READ_ONCE(calipso_ops); + 397. } + 398. + +kernel/sched/core.c:405: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 403. if (val & _TIF_NEED_RESCHED) + 404. return true; + 405. > old = cmpxchg(&ti->flags, val, val | _TIF_NEED_RESCHED); + 406. if (old == val) + 407. break; + +kernel/sched/core.c:398: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 396. { + 397. struct thread_info *ti = task_thread_info(p); + 398. > typeof(ti->flags) old, val = READ_ONCE(ti->flags); + 399. + 400. for (;;) { + +kernel/softirq.c:404: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 402. account_irq_exit_time(current); + 403. preempt_count_sub(HARDIRQ_OFFSET); + 404. > if (!in_interrupt() && local_softirq_pending()) + 405. invoke_softirq(); + 406. + +net/xfrm/xfrm_state.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. return NULL; + 408. + 409. > mode = READ_ONCE(afinfo->mode_map[encap]); + 410. if (unlikely(mode && !try_module_get(mode->owner))) + 411. mode = NULL; + +drivers/cpuidle/sysfs.c:398: error: DEAD_STORE + The value written to &ret (type int) is never used. + 396. static int cpuidle_add_state_sysfs(struct cpuidle_device *device) + 397. { + 398. > int i, ret = -ENOMEM; + 399. struct cpuidle_state_kobj *kobj; + 400. struct cpuidle_device_kobj *kdev = device->kobj_dev; + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/rcu.h:397: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 395. * "rqc" if the CPU got a quiescent state via its rcu_qs_ctr. + 396. */ + 397. > TRACE_EVENT(rcu_fqs, + 398. + 399. TP_PROTO(const char *rcuname, unsigned long gpnum, int cpu, const char *qsevent), + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:397: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 395. TP_ARGS(xprt, xid, status)); + 396. + 397. > DEFINE_EVENT(rpc_xprt_event, xprt_lookup_rqst, + 398. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 399. TP_ARGS(xprt, xid, status)); + +net/ipv6/ip6_fib.c:416: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 414. struct fib6_table *tb; + 415. + 416. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) + 417. fib6_table_dump(net, tb, w); + 418. } + +usr/gen_init_cpio.c:448: error: MEMORY_LEAK + memory dynamically allocated by call to `malloc()` at line 422, column 11 is not reachable after line 448, column 6. + 446. mode, uid, gid, nlinks); + 447. fail: + 448. > if (dname_len) free(dname); + 449. return rc; + 450. } + +drivers/gpu/drm/i915/i915_gem_object.h:404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 402. i915_gem_object_is_framebuffer(const struct drm_i915_gem_object *obj) + 403. { + 404. > return READ_ONCE(obj->framebuffer_references); + 405. } + 406. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:530: error: DEAD_STORE + The value written to &icr (type unsigned int) is never used. + 528. + 529. /* Clear any pending interrupt events. */ + 530. > icr = er32(ICR); + 531. + 532. /* If MWI was previously enabled, reenable it. */ + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:401: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 399. TP_ARGS(xprt, xid, status)); + 400. + 401. > DEFINE_EVENT(rpc_xprt_event, xprt_transmit, + 402. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 403. TP_ARGS(xprt, xid, status)); + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +kernel/profile.c:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. + 405. if (!user_mode(regs) && prof_cpu_mask != NULL && + 406. > cpumask_test_cpu(smp_processor_id(), prof_cpu_mask)) + 407. profile_hit(type, (void *)profile_pc(regs)); + 408. } + +kernel/time/timer.c:403: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 401. unsigned long round_jiffies_relative(unsigned long j) + 402. { + 403. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 404. } + 405. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +kernel/time/timer.c:403: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 401. unsigned long round_jiffies_relative(unsigned long j) + 402. { + 403. > return __round_jiffies_relative(j, raw_smp_processor_id()); + 404. } + 405. EXPORT_SYMBOL_GPL(round_jiffies_relative); + +net/ipv4/proc.c:419: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 417. /* MaxConn field is signed, RFC 2012 */ + 418. if (snmp4_tcp_list[i].entry == TCP_MIB_MAXCONN) + 419. > seq_printf(seq, " %ld", buff[i]); + 420. else + 421. seq_printf(seq, " %lu", buff[i]); + +net/ipv4/proc.c:421: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 419. seq_printf(seq, " %ld", buff[i]); + 420. else + 421. > seq_printf(seq, " %lu", buff[i]); + 422. } + 423. + +net/ipv4/proc.c:433: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 431. seq_puts(seq, "\nUdp:"); + 432. for (i = 0; snmp4_udp_list[i].name; i++) + 433. > seq_printf(seq, " %lu", buff[i]); + 434. + 435. memset(buff, 0, TCPUDP_MIB_MAX * sizeof(unsigned long)); + +net/ipv4/proc.c:445: error: UNINITIALIZED_VALUE + The value read from buff[_] was never initialized. + 443. seq_puts(seq, "\nUdpLite:"); + 444. for (i = 0; snmp4_udp_list[i].name; i++) + 445. > seq_printf(seq, " %lu", buff[i]); + 446. + 447. seq_putc(seq, '\n'); + +security/selinux/ss/conditional.c:412: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 410. goto err; + 411. + 412. > node->cur_state = le32_to_cpu(buf[0]); + 413. + 414. /* expr */ + +security/selinux/ss/conditional.c:415: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 413. + 414. /* expr */ + 415. > len = le32_to_cpu(buf[1]); + 416. + 417. for (i = 0; i < len; i++) { + +security/selinux/ss/conditional.c:427: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 425. goto err; + 426. + 427. > expr->expr_type = le32_to_cpu(buf[0]); + 428. expr->bool = le32_to_cpu(buf[1]); + 429. + +security/selinux/ss/conditional.c:428: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 426. + 427. expr->expr_type = le32_to_cpu(buf[0]); + 428. > expr->bool = le32_to_cpu(buf[1]); + 429. + 430. if (!expr_isvalid(p, expr)) { + +net/sunrpc/rpc_pipe.c:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. rcu_read_lock(); + 408. seq_printf(m, "RPC server: %s\n", + 409. > rcu_dereference(clnt->cl_xprt)->servername); + 410. seq_printf(m, "service: %s (%d) version %d\n", clnt->cl_program->name, + 411. clnt->cl_prog, clnt->cl_vers); + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/smp.c:407: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 405. { + 406. struct call_function_data *cfd; + 407. > int cpu, next_cpu, this_cpu = smp_processor_id(); + 408. + 409. /* + +kernel/power/user.c:422: error: UNINITIALIZED_VALUE + The value read from offset was never initialized. + 420. err = snapshot_ioctl(file, cmd, (unsigned long) &offset); + 421. set_fs(old_fs); + 422. > if (!err && put_user(offset, uoffset)) + 423. err = -EFAULT; + 424. return err; + +kernel/seccomp.c:416: error: UNINITIALIZED_VALUE + The value read from fprog32.filter was never initialized. + 414. goto out; + 415. fprog.len = fprog32.len; + 416. > fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + 418. #endif + +kernel/seccomp.c:415: error: UNINITIALIZED_VALUE + The value read from fprog32.len was never initialized. + 413. if (copy_from_user(&fprog32, user_filter, sizeof(fprog32))) + 414. goto out; + 415. > fprog.len = fprog32.len; + 416. fprog.filter = compat_ptr(fprog32.filter); + 417. } else /* falls through to the if below. */ + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +include/trace/events/sunrpc.h:405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 403. TP_ARGS(xprt, xid, status)); + 404. + 405. > DEFINE_EVENT(rpc_xprt_event, xprt_complete_rqst, + 406. TP_PROTO(struct rpc_xprt *xprt, __be32 xid, int status), + 407. TP_ARGS(xprt, xid, status)); + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/gpu/drm/i915/i915_trace.h:406: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 404. ); + 405. + 406. > TRACE_EVENT(i915_vma_unbind, + 407. TP_PROTO(struct i915_vma *vma), + 408. TP_ARGS(vma), + +drivers/pcmcia/ds.c:430: error: UNINITIALIZED_VALUE + The value read from func_id.func was never initialized. + 428. CISTPL_FUNCID, &func_id)) { + 429. mutex_lock(&p_dev->socket->ops_mutex); + 430. > p_dev->func_id = func_id.func; + 431. p_dev->has_func_id = 1; + 432. mutex_unlock(&p_dev->socket->ops_mutex); + +drivers/pcmcia/ds.c:421: error: UNINITIALIZED_VALUE + The value read from manf_id.card was never initialized. + 419. mutex_lock(&p_dev->socket->ops_mutex); + 420. p_dev->manf_id = manf_id.manf; + 421. > p_dev->card_id = manf_id.card; + 422. p_dev->has_manf_id = 1; + 423. p_dev->has_card_id = 1; + +drivers/pcmcia/ds.c:420: error: UNINITIALIZED_VALUE + The value read from manf_id.manf was never initialized. + 418. CISTPL_MANFID, &manf_id)) { + 419. mutex_lock(&p_dev->socket->ops_mutex); + 420. > p_dev->manf_id = manf_id.manf; + 421. p_dev->card_id = manf_id.card; + 422. p_dev->has_manf_id = 1; + +crypto/api.c:439: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 437. } + 438. + 439. > return ERR_PTR(err); + 440. } + 441. EXPORT_SYMBOL_GPL(crypto_alloc_base); + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +include/trace/events/sunrpc.h:409: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 407. TP_ARGS(xprt, xid, status)); + 408. + 409. > TRACE_EVENT(xs_tcp_data_ready, + 410. TP_PROTO(struct rpc_xprt *xprt, int err, unsigned int total), + 411. + +drivers/base/cpu.c:416: error: DEAD_STORE + The value written to &retval (type int) is never used. + 414. { + 415. struct device *dev = NULL; + 416. > int retval = -ENODEV; + 417. + 418. dev = kzalloc(sizeof(*dev), GFP_KERNEL); + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +kernel/time/clockevents.c:417: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 415. + 416. raw_spin_lock(&clockevents_lock); + 417. > res = __clockevents_try_unbind(cu->ce, smp_processor_id()); + 418. if (res == -EAGAIN) + 419. res = clockevents_replace(cu->ce); + +lib/kfifo.c:419: error: DEAD_STORE + The value written to &recsize (type unsigned long) is never used. + 417. l = __KFIFO_PEEK(data, fifo->out, mask); + 418. + 419. > if (--recsize) + 420. l |= __KFIFO_PEEK(data, fifo->out + 1, mask) << 8; + 421. + +lib/genalloc.c:419: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 417. + 418. rcu_read_lock(); + 419. > list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) + 420. func(pool, chunk, data); + 421. rcu_read_unlock(); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +include/trace/events/sched.h:413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 411. ); + 412. + 413. > DEFINE_EVENT(sched_stat_runtime, sched_stat_runtime, + 414. TP_PROTO(struct task_struct *tsk, u64 runtime, u64 vruntime), + 415. TP_ARGS(tsk, runtime, vruntime)); + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +lib/iov_iter.c:421: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 419. + 420. if (!(i->type & (ITER_BVEC|ITER_KVEC))) { + 421. > iterate_iovec(i, bytes, v, iov, skip, ({ + 422. err = fault_in_pages_readable(v.iov_base, v.iov_len); + 423. if (unlikely(err)) + +net/compat.c:435: error: UNINITIALIZED_VALUE + The value read from ktime.tv_sec was never initialized. + 433. if (put_user(sizeof(*up), optlen) || + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. > __put_user(ktime.tv_sec, &up->tv_sec) || + 436. __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + +net/compat.c:436: error: UNINITIALIZED_VALUE + The value read from ktime.tv_usec was never initialized. + 434. !access_ok(VERIFY_WRITE, up, sizeof(*up)) || + 435. __put_user(ktime.tv_sec, &up->tv_sec) || + 436. > __put_user(ktime.tv_usec, &up->tv_usec)) + 437. err = -EFAULT; + 438. } + +kernel/pid.c:430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 428. task = task->group_leader; + 429. } + 430. > nr = pid_nr_ns(rcu_dereference(task->pids[type].pid), ns); + 431. } + 432. rcu_read_unlock(); + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:415: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 413. ); + 414. + 415. > DEFINE_EVENT(key_handle, rdev_add_key, + 416. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 417. bool pairwise, const u8 *mac_addr), + +drivers/gpu/drm/i915/i915_debugfs.c:537: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 535. * Therefore, we need to protect this ->comm access using RCU. + 536. */ + 537. > request = list_first_entry_or_null(&file_priv->mm.request_list, + 538. struct drm_i915_gem_request, + 539. client_link); + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.active was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.count was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.global was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.inactive was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.shared was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.total was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +drivers/gpu/drm/i915/i915_debugfs.c:544: error: UNINITIALIZED_VALUE + The value read from stats.unbound was never initialized. + 542. request->ctx->pid : file->pid, + 543. PIDTYPE_PID); + 544. > print_file_stats(m, task ? task->comm : "", stats); + 545. rcu_read_unlock(); + 546. + +net/netlabel/netlabel_domainhash.c:450: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 448. u32 bkt = netlbl_domhsh_hash(entry->domain); + 449. list_add_tail_rcu(&entry->list, + 450. > &rcu_dereference(netlbl_domhsh)->tbl[bkt]); + 451. } else { + 452. INIT_LIST_HEAD(&entry->list); + +net/ipv6/raw.c:430: error: NULL_DEREFERENCE + pointer `rp` last assigned on line 422 could be null and is dereferenced at line 430, column 7. + 428. } + 429. + 430. > if (!rp->checksum) + 431. skb->ip_summed = CHECKSUM_UNNECESSARY; + 432. + +kernel/time/posix-cpu-timers.c:424: error: DEAD_STORE + The value written to &head (type list_head*) is never used. + 422. cleanup_timers_list(head); + 423. cleanup_timers_list(++head); + 424. > cleanup_timers_list(++head); + 425. } + 426. + +crypto/jitterentropy.c:463: error: UNINITIALIZED_VALUE + The value read from mixer.u64 was never initialized. + 461. if ((entropy_collector->data >> i) & 1) + 462. mixer.u64 ^= constant.u64; + 463. > mixer.u64 = jent_rol64(mixer.u64, 1); + 464. } + 465. entropy_collector->data ^= mixer.u64; + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +include/trace/events/sched.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. * priority. + 420. */ + 421. > TRACE_EVENT(sched_pi_setprio, + 422. + 423. TP_PROTO(struct task_struct *tsk, struct task_struct *pi_task), + +kernel/events/core.c:428: error: DEAD_STORE + The value written to &tmp (type unsigned long long) is never used. + 426. tmp = div_u64(tmp, 100); + 427. if (!tmp) + 428. > tmp = 1; + 429. + 430. WRITE_ONCE(perf_sample_allowed_ns, tmp); + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 419. ); + 420. + 421. > DEFINE_EVENT(key_handle, rdev_get_key, + 422. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 423. bool pairwise, const u8 *mac_addr), + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +kernel/sched/clock.c:424: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 422. void sched_clock_idle_sleep_event(void) + 423. { + 424. > sched_clock_cpu(smp_processor_id()); + 425. } + 426. EXPORT_SYMBOL_GPL(sched_clock_idle_sleep_event); + +net/wireless/util.c:509: error: UNINITIALIZED_VALUE + The value read from payload.proto was never initialized. + 507. + 508. skb_copy_bits(skb, hdrlen, &payload, sizeof(payload)); + 509. > tmp.h_proto = payload.proto; + 510. + 511. if (likely((ether_addr_equal(payload.hdr, rfc1042_header) && + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:423: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 421. * block IO operation @bio. + 422. */ + 423. > DEFINE_EVENT(block_get_rq, block_getrq, + 424. + 425. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +drivers/gpu/drm/i915/intel_guc_ct.c:426: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 424. int intel_guc_enable_ct(struct intel_guc *guc) + 425. { + 426. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 427. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 428. int err; + +block/blk-merge.c:444: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced at line 444, column 3. + 442. (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1; + 443. + 444. > sg->length += pad_len; + 445. rq->extra_len += pad_len; + 446. } + +block/blk-merge.c:452: error: NULL_DEREFERENCE + pointer `sg` last assigned on line 429 could be null and is dereferenced by call to `sg_unmark_end()` at line 452, column 3. + 450. memset(q->dma_drain_buffer, 0, q->dma_drain_size); + 451. + 452. > sg_unmark_end(sg); + 453. sg = sg_next(sg); + 454. sg_set_page(sg, virt_to_page(q->dma_drain_buffer), + +net/ipv4/ip_output.c:440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 438. */ + 439. rcu_read_lock(); + 440. > inet_opt = rcu_dereference(inet->inet_opt); + 441. fl4 = &fl->u.ip4; + 442. rt = skb_rtable(skb); + +drivers/net/ethernet/intel/e1000e/80003es2lan.c:463: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 461. + 462. /* ...and verify the command was successful. */ + 463. > ret_val = e1000e_read_phy_reg_mdic(hw, page_select, &temp); + 464. + 465. if (((u16)offset >> GG82563_PAGE_SHIFT) != temp) { + +net/sunrpc/auth_gss/gss_rpc_xdr.c:437: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 435. if (unlikely(p == NULL)) + 436. return -ENOSPC; + 437. > count = be32_to_cpup(p++); + 438. for (i = 0; i < count; i++) { + 439. gssx_dec_name_attr(xdr, &dummy); + +net/wireless/mlme.c:435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 433. + 434. spin_lock_bh(&rdev->mlme_unreg_lock); + 435. > while ((reg = list_first_entry_or_null(&rdev->mlme_unreg, + 436. struct cfg80211_mgmt_registration, + 437. list))) { + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +net/wireless/trace.h:427: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 425. ); + 426. + 427. > DEFINE_EVENT(key_handle, rdev_del_key, + 428. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 429. bool pairwise, const u8 *mac_addr), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:428: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 426. ); + 427. + 428. > TRACE_EVENT(i915_gem_object_pwrite, + 429. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 430. TP_ARGS(obj, offset, len), + +drivers/scsi/scsi_logging.c:476: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 474. + 475. if (db_string) + 476. > off += scnprintf(logbuf + off, logbuf_len - off, + 477. "driverbyte=%s", db_string); + 478. else + +drivers/scsi/scsi_logging.c:479: error: DEAD_STORE + The value written to &off (type unsigned long) is never used. + 477. "driverbyte=%s", db_string); + 478. else + 479. > off += scnprintf(logbuf + off, logbuf_len - off, + 480. "driverbyte=0x%02x", driver_byte(cmd->result)); + 481. out_printk: + +lib/sbitmap.c:449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 447. wait_cnt = atomic_dec_return(&ws->wait_cnt); + 448. if (wait_cnt <= 0) { + 449. > wake_batch = READ_ONCE(sbq->wake_batch); + 450. /* + 451. * Pairs with the memory barrier in sbitmap_queue_resize() to + +net/ipv6/anycast.c:436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 434. + 435. state->idev = NULL; + 436. > for_each_netdev_rcu(net, state->dev) { + 437. struct inet6_dev *idev; + 438. idev = __in6_dev_get(state->dev); + +drivers/gpu/drm/i915/i915_pmu.c:457: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 455. + 456. if (!locked) + 457. > spin_unlock_irqrestore(&i915->pmu.lock, flags); + 458. } else { + 459. struct pci_dev *pdev = i915->drm.pdev; + +drivers/gpu/drm/i915/i915_pmu.c:490: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 488. + 489. if (!locked) + 490. > spin_unlock_irqrestore(&i915->pmu.lock, flags); + 491. } + 492. + +drivers/md/dm-io.c:460: error: UNINITIALIZED_VALUE + The value read from sio.error_bits was never initialized. + 458. + 459. if (error_bits) + 460. > *error_bits = sio.error_bits; + 461. + 462. return sio.error_bits ? -EIO : 0; + +drivers/gpu/drm/i915/intel_guc_submission.c:455: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 453. + 454. /* Free space is guaranteed. */ + 455. > wq_off = READ_ONCE(desc->tail); + 456. GEM_BUG_ON(CIRC_SPACE(wq_off, READ_ONCE(desc->head), + 457. GUC_WQ_SIZE) < wqi_size); + +drivers/md/md.c:440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 438. atomic_set(&mddev->flush_pending, 1); + 439. rcu_read_lock(); + 440. > rdev_for_each_rcu(rdev, mddev) + 441. if (rdev->raid_disk >= 0 && + 442. !test_bit(Faulty, &rdev->flags)) { + +net/wireless/trace.h:433: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +net/wireless/trace.h:433: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 431. ); + 432. + 433. > TRACE_EVENT(rdev_set_default_key, + 434. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index, + 435. bool unicast, bool multicast), + +lib/genalloc.c:442: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 440. + 441. rcu_read_lock(); + 442. > list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) { + 443. if (start >= chunk->start_addr && start <= chunk->end_addr) { + 444. if (end <= chunk->end_addr) { + +net/ipv4/udp.c:447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 445. result = NULL; + 446. badness = 0; + 447. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 448. score = compute_score(sk, net, saddr, sport, + 449. daddr, hnum, dif, sdif, exact_dif); + +net/ipv4/inet_hashtables.c:446: error: DEAD_STORE + The value written to &acookie (type unsigned long long) is never used. + 444. struct net *net = sock_net(sk); + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. > INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + +net/ipv4/inet_hashtables.c:447: error: DEAD_STORE + The value written to &ports (type unsigned int) is never used. + 445. int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. > const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + 448. unsigned int hash = inet_ehashfn(net, daddr, lport, + 449. saddr, inet->inet_dport); + +net/ipv4/inet_hashtables.c:445: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 443. int dif = sk->sk_bound_dev_if; + 444. struct net *net = sock_net(sk); + 445. > int sdif = l3mdev_master_ifindex_by_index(net, dif); + 446. INET_ADDR_COOKIE(acookie, saddr, daddr); + 447. const __portpair ports = INET_COMBINED_PORTS(inet->inet_dport, lport); + +drivers/cpuidle/sysfs.c:441: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 438 could be null and is dereferenced at line 441, column 18. + 439. int i; + 440. + 441. > for (i = 0; i < drv->state_count; i++) + 442. cpuidle_free_state_kobj(device, i); + 443. } + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 434. ); + 435. + 436. > DEFINE_EVENT(pm_qos_update, pm_qos_update_target, + 437. + 438. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +include/trace/events/rcu.h:437: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 435. * for irq/NMI will change the counter by two, otherwise by one. + 436. */ + 437. > TRACE_EVENT(rcu_dyntick, + 438. + 439. TP_PROTO(const char *polarity, long oldnesting, long newnesting, atomic_t dynticks), + +kernel/cgroup/freezer.c:442: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 440 could be null and is dereferenced at line 442, column 16. + 440. struct freezer *freezer = css_freezer(css); + 441. + 442. > return (bool)(freezer->state & CGROUP_FREEZING_SELF); + 443. } + 444. + +kernel/rcu/srcutree.c:450: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 448. smp_mb(); /* Order prior store to ->srcu_gp_seq_needed vs. GP start. */ + 449. rcu_seq_start(&sp->srcu_gp_seq); + 450. > state = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 451. WARN_ON_ONCE(state != SRCU_STATE_SCAN1); + 452. } + +lib/rhashtable.c:447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 445. int err; + 446. + 447. > old_tbl = rht_dereference_rcu(ht->tbl, ht); + 448. + 449. size = tbl->size; + +lib/rhashtable.c:477: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 475. fail: + 476. /* Do not fail the insert if someone else did a rehash. */ + 477. > if (likely(rcu_dereference_raw(tbl->future_tbl))) + 478. return 0; + 479. + +kernel/auditsc.c:452: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 450. unsigned int sessionid; + 451. + 452. > cred = rcu_dereference_check(tsk->cred, tsk == current || task_creation); + 453. + 454. for (i = 0; i < rule->field_count; i++) { + +kernel/auditsc.c:632: error: UNINITIALIZED_VALUE + The value read from sid was never initialized. + 630. need_sid = 0; + 631. } + 632. > result = security_audit_rule_match(sid, f->type, + 633. f->op, + 634. f->lsm_rule, + +kernel/rcu/tree.c:447: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 445. rcu_preempt_note_context_switch(preempt); + 446. /* Load rcu_urgent_qs before other flags. */ + 447. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) + 448. goto out; + 449. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + +kernel/rcu/tree.c:450: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 448. goto out; + 449. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 450. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) + 451. rcu_momentary_dyntick_idle(); + 452. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +net/netfilter/nf_conntrack_helper.c:449: error: NULL_DEREFERENCE + pointer `help` last assigned on line 442 could be null and is dereferenced at line 449, column 9. + 447. return true; + 448. + 449. > this = rcu_dereference_protected(help->helper, + 450. lockdep_is_held(&nf_conntrack_expect_lock)); + 451. return this == me; + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +include/trace/events/block.h:441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 439. * process goes to sleep waiting for request struct become available. + 440. */ + 441. > DEFINE_EVENT(block_get_rq, block_sleeprq, + 442. + 443. TP_PROTO(struct request_queue *q, struct bio *bio, int rw), + +net/ipv6/seg6.c:443: error: DEAD_STORE + The value written to &err (type int) is never used. + 441. int __init seg6_init(void) + 442. { + 443. > int err = -ENOMEM; + 444. + 445. err = genl_register_family(&seg6_genl_family); + +net/xfrm/xfrm_policy.c:456: error: DEAD_STORE + The value written to &odst (type hlist_head*) is never used. + 454. write_seqcount_begin(&xfrm_policy_hash_generation); + 455. + 456. > odst = rcu_dereference_protected(net->xfrm.policy_bydst[dir].table, + 457. lockdep_is_held(&net->xfrm.xfrm_policy_lock)); + 458. + +include/linux/tcp.h:445: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 443. { + 444. struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue; + 445. > int somaxconn = READ_ONCE(sock_net(sk)->core.sysctl_somaxconn); + 446. + 447. queue->fastopenq.max_qlen = min_t(unsigned int, backlog, somaxconn); + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +include/trace/events/power.h:443: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 441. ); + 442. + 443. > DEFINE_EVENT_PRINT(pm_qos_update, pm_qos_update_flags, + 444. + 445. TP_PROTO(enum pm_qos_req_action action, int prev_value, int curr_value), + +kernel/module.c:473: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 471. return true; + 472. + 473. > list_for_each_entry_rcu(mod, &modules, list) { + 474. struct symsearch arr[] = { + 475. { mod->syms, mod->syms + mod->num_syms, mod->crcs, + +net/ipv6/ip6_flowlabel.c:454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 452. + 453. rcu_read_lock_bh(); + 454. > for_each_sk_fl_rcu(np, sfl) + 455. count++; + 456. rcu_read_unlock_bh(); + +kernel/cgroup/freezer.c:450: error: NULL_DEREFERENCE + pointer `freezer` last assigned on line 448 could be null and is dereferenced at line 450, column 16. + 448. struct freezer *freezer = css_freezer(css); + 449. + 450. > return (bool)(freezer->state & CGROUP_FREEZING_PARENT); + 451. } + 452. + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +include/trace/events/sunrpc.h:446: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 444. { TCP_RPC_REPLY, "TCP_RPC_REPLY" }) + 445. + 446. > TRACE_EVENT(xs_tcp_data_recv, + 447. TP_PROTO(struct sock_xprt *xs), + 448. + +drivers/gpu/drm/i915/intel_guc_ct.c:449: error: DEAD_STORE + The value written to &dev_priv (type drm_i915_private*) is never used. + 447. void intel_guc_disable_ct(struct intel_guc *guc) + 448. { + 449. > struct drm_i915_private *dev_priv = guc_to_i915(guc); + 450. struct intel_guc_ct_channel *ctch = &guc->ct.host_channel; + 451. + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +drivers/gpu/drm/i915/i915_trace.h:448: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 446. ); + 447. + 448. > TRACE_EVENT(i915_gem_object_pread, + 449. TP_PROTO(struct drm_i915_gem_object *obj, u64 offset, u64 len), + 450. TP_ARGS(obj, offset, len), + +net/unix/af_unix.c:454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 452. rcu_read_lock(); + 453. if (unix_writable(sk)) { + 454. > wq = rcu_dereference(sk->sk_wq); + 455. if (skwq_has_sleeper(wq)) + 456. wake_up_interruptible_sync_poll(&wq->wait, + +drivers/gpu/drm/drm_ioc32.c:465: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 463. return err; + 464. + 465. > if (put_user(req32.count, &argp->count) + 466. || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:466: error: UNINITIALIZED_VALUE + The value read from req32.virtual was never initialized. + 464. + 465. if (put_user(req32.count, &argp->count) + 466. > || put_user(req32.virtual, &argp->virtual)) + 467. return -EFAULT; + 468. + +net/ipv6/mcast.c:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. } + 483. + 484. > for_each_pmc_rcu(inet6, pmc) { + 485. if (pmc->ifindex != gsf->gf_interface) + 486. continue; + +drivers/gpu/drm/i915/intel_sdvo.c:457: error: DEAD_STORE + The value written to &ret (type int) is never used. + 455. u8 *buf, status; + 456. struct i2c_msg *msgs; + 457. > int i, ret = true; + 458. + 459. /* Would be simpler to allocate both in one go ? */ + +kernel/time/timer.c:453: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 451. unsigned long round_jiffies_up(unsigned long j) + 452. { + 453. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 454. } + 455. EXPORT_SYMBOL_GPL(round_jiffies_up); + +kernel/time/timer.c:453: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 451. unsigned long round_jiffies_up(unsigned long j) + 452. { + 453. > return round_jiffies_common(j, raw_smp_processor_id(), true); + 454. } + 455. EXPORT_SYMBOL_GPL(round_jiffies_up); + +drivers/input/input.c:464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 462. + 463. rcu_read_lock(); + 464. > grab = rcu_dereference(dev->grab); + 465. if (!grab || grab == handle) + 466. input_handle_event(dev, type, code, value); + +net/ipv4/igmp.c:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. return skb; + 468. + 469. > mtu = READ_ONCE(dev->mtu); + 470. if (mtu < IPV4_MIN_MTU) + 471. return skb; + +drivers/gpu/drm/drm_plane.c:466: error: DEAD_STORE + The value written to &config (type drm_mode_config*) is never used. + 464. return -EINVAL; + 465. + 466. > config = &dev->mode_config; + 467. plane_ptr = u64_to_user_ptr(plane_resp->plane_id_ptr); + 468. + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +kernel/time/clockevents.c:463: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 461. if (!dev->cpumask) { + 462. WARN_ON(num_possible_cpus() > 1); + 463. > dev->cpumask = cpumask_of(smp_processor_id()); + 464. } + 465. + +net/sunrpc/xprtsock.c:485: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 483. + 484. rcu_read_lock(); + 485. > wq = rcu_dereference(sk->sk_wq); + 486. set_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags); + 487. rcu_read_unlock(); + +security/selinux/ss/conditional.c:466: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 464. return rc; + 465. + 466. > len = le32_to_cpu(buf[0]); + 467. + 468. rc = avtab_alloc(&(p->te_cond_avtab), p->te_avtab.nel); + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +include/trace/events/block.h:456: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 454. * the queue to improve throughput performance of the block device. + 455. */ + 456. > TRACE_EVENT(block_plug, + 457. + 458. TP_PROTO(struct request_queue *q), + +kernel/cgroup/cgroup.c:460: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 458. { + 459. if (ss) + 460. > return rcu_dereference_check(cgrp->subsys[ss->id], + 461. lockdep_is_held(&cgroup_mutex)); + 462. else + +net/core/neighbour.c:467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 465. + 466. rcu_read_lock_bh(); + 467. > nht = rcu_dereference_bh(tbl->nht); + 468. hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); + 469. + +net/core/neighbour.c:470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 468. hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); + 469. + 470. > for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 471. n != NULL; + 472. n = rcu_dereference_bh(n->next)) { + +net/core/neighbour.c:472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 470. for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); + 471. n != NULL; + 472. > n = rcu_dereference_bh(n->next)) { + 473. if (!memcmp(n->primary_key, pkey, key_len) && + 474. net_eq(dev_net(n->dev), net)) { + +net/wireless/trace.h:457: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/wireless/trace.h:457: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 455. ); + 456. + 457. > TRACE_EVENT(rdev_set_default_mgmt_key, + 458. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index), + 459. TP_ARGS(wiphy, netdev, key_index), + +net/ipv6/tcp_ipv6.c:489: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 487. opt = ireq->ipv6_opt; + 488. if (!opt) + 489. > opt = rcu_dereference(np->opt); + 490. err = ip6_xmit(sk, skb, fl6, sk->sk_mark, opt, np->tclass); + 491. rcu_read_unlock(); + +lib/genalloc.c:466: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 464. + 465. rcu_read_lock(); + 466. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) + 467. avail += atomic_long_read(&chunk->avail); + 468. rcu_read_unlock(); + +net/ipv6/addrlabel.c:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. + 468. rcu_read_lock(); + 469. > hlist_for_each_entry_rcu(p, &net->ipv6.ip6addrlbl_table.head, list) { + 470. if (idx >= s_idx) { + 471. err = ip6addrlbl_fill(skb, p, + +include/linux/cgroup.h:464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 462. static inline struct css_set *task_css_set(struct task_struct *task) + 463. { + 464. > return task_css_set_check(task, false); + 465. } + 466. + +kernel/softirq.c:469: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 467. local_irq_save(flags); + 468. t->next = NULL; + 469. > *__this_cpu_read(tasklet_vec.tail) = t; + 470. __this_cpu_write(tasklet_vec.tail, &(t->next)); + 471. raise_softirq_irqoff(TASKLET_SOFTIRQ); + +include/linux/tcp.h:470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 468. * This happens for listeners. + 469. */ + 470. > u16 user_mss = READ_ONCE(tp->rx_opt.user_mss); + 471. + 472. return (user_mss && user_mss < mss) ? user_mss : mss; + +kernel/time/timer.c:468: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 466. unsigned long round_jiffies_up_relative(unsigned long j) + 467. { + 468. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 469. } + 470. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +kernel/time/timer.c:468: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 466. unsigned long round_jiffies_up_relative(unsigned long j) + 467. { + 468. > return __round_jiffies_up_relative(j, raw_smp_processor_id()); + 469. } + 470. EXPORT_SYMBOL_GPL(round_jiffies_up_relative); + +drivers/gpu/drm/i915/i915_sysfs.c:483: error: UNINITIALIZED_VALUE + The value read from val was never initialized. + 481. BUG(); + 482. + 483. > return snprintf(buf, PAGE_SIZE, "%d\n", val); + 484. } + 485. + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/gpu/drm/i915/i915_trace.h:468: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 466. ); + 467. + 468. > TRACE_EVENT(i915_gem_object_fault, + 469. TP_PROTO(struct drm_i915_gem_object *obj, u64 index, bool gtt, bool write), + 470. TP_ARGS(obj, index, gtt, write), + +drivers/dma-buf/reservation.c:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. i = -1; + 483. + 484. > fence = rcu_dereference(obj->fence_excl); + 485. if (fence && !test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, &fence->flags)) { + 486. if (!dma_fence_get_rcu(fence)) + +drivers/dma-buf/reservation.c:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. if (wait_all) { + 499. struct reservation_object_list *fobj = + 500. > rcu_dereference(obj->fence); + 501. + 502. if (fobj) + +drivers/dma-buf/reservation.c:506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 504. + 505. for (i = 0; !fence && i < shared_count; ++i) { + 506. > struct dma_fence *lfence = rcu_dereference(fobj->shared[i]); + 507. + 508. if (test_bit(DMA_FENCE_FLAG_SIGNALED_BIT, + +drivers/iommu/dmar.c:475: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 473. + 474. rhsa = (struct acpi_dmar_rhsa *)header; + 475. > for_each_drhd_unit(drhd) { + 476. if (drhd->reg_base_addr == rhsa->base_address) { + 477. int node = acpi_map_pxm_to_node(rhsa->proximity_domain); + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +include/trace/events/rcu.h:469: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 467. * total number of callbacks queued. + 468. */ + 469. > TRACE_EVENT(rcu_callback, + 470. + 471. TP_PROTO(const char *rcuname, struct rcu_head *rhp, long qlen_lazy, + +net/ipv4/udp.c:512: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 510. result = NULL; + 511. badness = 0; + 512. > sk_for_each_rcu(sk, &hslot->head) { + 513. score = compute_score(sk, net, saddr, sport, + 514. daddr, hnum, dif, sdif, exact_dif); + +include/linux/cgroup.h:477: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 475. int subsys_id) + 476. { + 477. > return task_css_check(task, subsys_id, false); + 478. } + 479. + +kernel/rcu/tree.c:482: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 480. preempt_disable(); + 481. /* Load rcu_urgent_qs before other flags. */ + 482. > if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) { + 483. preempt_enable(); + 484. return; + +kernel/rcu/tree.c:478: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 476. unsigned long flags; + 477. + 478. > if (!raw_cpu_read(rcu_dynticks.rcu_urgent_qs)) + 479. return; + 480. preempt_disable(); + +kernel/rcu/tree.c:488: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 486. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false); + 487. barrier(); /* Avoid RCU read-side critical sections leaking down. */ + 488. > if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) { + 489. local_irq_save(flags); + 490. rcu_momentary_dyntick_idle(); + +kernel/rcu/tree.c:493: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 491. local_irq_restore(flags); + 492. } + 493. > if (unlikely(raw_cpu_read(rcu_sched_data.cpu_no_qs.b.exp))) + 494. rcu_sched_qs(); + 495. this_cpu_inc(rcu_dynticks.rcu_qs_ctr); + +kernel/trace/trace.c:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. return -ENOMEM; + 499. + 500. > pid_list->pid_max = READ_ONCE(pid_max); + 501. + 502. /* Only truncating will shrink pid_max */ + +net/wireless/trace.h:474: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +net/wireless/trace.h:474: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 472. ); + 473. + 474. > TRACE_EVENT(rdev_start_ap, + 475. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 476. struct cfg80211_ap_settings *settings), + +security/selinux/ss/services.c:536: error: UNINITIALIZED_VALUE + The value read from permission_names[_] was never initialized. + 534. audit_log_format(ab, "%s%s", + 535. need_comma ? "," : "", + 536. > permission_names[index] + 537. ? permission_names[index] : "????"); + 538. need_comma = true; + +kernel/softirq.c:482: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 480. local_irq_save(flags); + 481. t->next = NULL; + 482. > *__this_cpu_read(tasklet_hi_vec.tail) = t; + 483. __this_cpu_write(tasklet_hi_vec.tail, &(t->next)); + 484. raise_softirq_irqoff(HI_SOFTIRQ); + +drivers/gpu/drm/drm_ioc32.c:487: error: UNINITIALIZED_VALUE + The value read from req32.count was never initialized. + 485. return -EFAULT; + 486. + 487. > request.count = req32.count; + 488. request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:488: error: UNINITIALIZED_VALUE + The value read from req32.list was never initialized. + 486. + 487. request.count = req32.count; + 488. > request.list = compat_ptr(req32.list); + 489. return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); + 490. } + +net/ipv6/ip6_flowlabel.c:495: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 493. rcu_read_lock_bh(); + 494. + 495. > for_each_sk_fl_rcu(np, sfl) { + 496. if (sfl->fl->label == (np->flow_label & IPV6_FLOWLABEL_MASK)) { + 497. spin_lock_bh(&ip6_fl_lock); + +lib/assoc_array.c:643: error: UNINITIALIZED_VALUE + The value read from j was never initialized. + 641. } + 642. found_slot_for_multiple_occupancy: + 643. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 644. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 645. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +lib/assoc_array.c:643: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 641. } + 642. found_slot_for_multiple_occupancy: + 643. > pr_devel("same slot: %x %x [%02x]\n", i, j, slot); + 644. BUG_ON(i >= ASSOC_ARRAY_FAN_OUT); + 645. BUG_ON(j >= ASSOC_ARRAY_FAN_OUT + 1); + +lib/assoc_array.c:648: error: UNINITIALIZED_VALUE + The value read from slot was never initialized. + 646. BUG_ON(slot >= ASSOC_ARRAY_FAN_OUT); + 647. + 648. > new_n1->parent_slot = slot; + 649. + 650. /* Metadata pointers cannot change slot */ + +drivers/cpuidle/cpuidle.c:484: error: NULL_DEREFERENCE + pointer `drv` last assigned on line 482 could be null and is dereferenced at line 484, column 22. + 482. struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev); + 483. + 484. > if (!try_module_get(drv->owner)) + 485. return -EINVAL; + 486. + +kernel/trace/trace_events_trigger.c:486: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 484. list_for_each_entry(file, &tr->events, list) { + 485. struct event_trigger_data *data; + 486. > list_for_each_entry_rcu(data, &file->triggers, list) { + 487. trace_event_trigger_enable_disable(file, 0); + 488. if (data->ops->free) + +lib/genalloc.c:485: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 483. + 484. rcu_read_lock(); + 485. > list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) + 486. size += chunk_size(chunk); + 487. rcu_read_unlock(); + +kernel/sched/core.c:493: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 491. cpu = cpu_of(rq); + 492. + 493. > if (cpu == smp_processor_id()) { + 494. set_tsk_need_resched(curr); + 495. set_preempt_need_resched(); + +drivers/firmware/dmi_scan.c:502: error: DEAD_STORE + The value written to &c (type int) is never used. + 500. dmi_get_system_info(DMI_BIOS_VERSION)); + 501. c += scnprintf(buf + c, len - c, " "); + 502. > c += print_filtered(buf + c, len - c, + 503. dmi_get_system_info(DMI_BIOS_DATE)); + 504. } + +net/ipv6/exthdrs.c:496: error: DEAD_STORE + The value written to &accept_source_route (type int) is never used. + 494. idev = __in6_dev_get(skb->dev); + 495. if (idev && accept_source_route > idev->cnf.accept_source_route) + 496. > accept_source_route = idev->cnf.accept_source_route; + 497. + 498. if (!pskb_may_pull(skb, skb_transport_offset(skb) + 8) || + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +net/ipv4/ping.c:511: error: UNINITIALIZED_VALUE + The value read from family was never initialized. + 509. /* We assume the packet has already been checked by icmp_unreach */ + 510. + 511. > if (!ping_supported(family, icmph->type, icmph->code)) + 512. return; + 513. + +net/ipv4/ping.c:514: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 512. return; + 513. + 514. > pr_debug("ping_err(proto=0x%x,type=%d,code=%d,id=%04x,seq=%04x)\n", + 515. skb->protocol, type, code, ntohs(icmph->un.echo.id), + 516. ntohs(icmph->un.echo.sequence)); + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:484: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 482. ); + 483. + 484. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_add_request, + 485. + 486. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +kernel/time/tick-sched.c:486: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 484. int tick_nohz_tick_stopped(void) + 485. { + 486. > return __this_cpu_read(tick_cpu_sched.tick_stopped); + 487. } + 488. + +lib/idr.c:497: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 495. goto err; + 496. + 497. > bitmap = rcu_dereference_raw(*slot); + 498. if (radix_tree_exception(bitmap)) { + 499. btmp = (unsigned long *)slot; + +lib/idr.c:512: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 510. radix_tree_iter_tag_set(&ida->ida_rt, &iter, IDR_FREE); + 511. if (radix_tree_exception(bitmap)) { + 512. > if (rcu_dereference_raw(*slot) == + 513. (void *)RADIX_TREE_EXCEPTIONAL_ENTRY) + 514. radix_tree_iter_delete(&ida->ida_rt, &iter, slot); + +net/ipv6/esp6.c:508: error: UNINITIALIZED_VALUE + The value read from nexthdr[_] was never initialized. + 506. + 507. ret = -EINVAL; + 508. > padlen = nexthdr[0]; + 509. if (padlen + 2 + alen >= elen) { + 510. net_dbg_ratelimited("ipsec esp packet is garbage padlen=%d, elen=%d\n", + +net/ipv6/esp6.c:523: error: UNINITIALIZED_VALUE + The value read from nexthdr[_] was never initialized. + 521. pskb_trim(skb, skb->len - trimlen); + 522. + 523. > ret = nexthdr[1]; + 524. + 525. out: + +drivers/gpu/drm/i915/intel_guc_submission.c:499: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 497. * we also need to treat 0 as a reserved value. + 498. */ + 499. > cookie = READ_ONCE(db->cookie); + 500. WARN_ON_ONCE(xchg(&db->cookie, cookie + 1 ?: cookie + 2) != cookie); + 501. + +kernel/time/tick-common.c:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. trace_suspend_resume(TPS("timekeeping_freeze"), + 492. > smp_processor_id(), true); + 493. timekeeping_suspend(); + 494. } else { + +kernel/time/tick-common.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. tick_freeze_depth++; + 490. if (tick_freeze_depth == num_online_cpus()) { + 491. > trace_suspend_resume(TPS("timekeeping_freeze"), + 492. smp_processor_id(), true); + 493. timekeeping_suspend(); + +net/ipv6/route.c:497: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 495. return rt; + 496. + 497. > for (sprt = rt; sprt; sprt = rcu_dereference(sprt->rt6_next)) { + 498. struct net_device *dev = sprt->dst.dev; + 499. + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +kernel/time/tick-broadcast.c:491: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 489. return false; + 490. else + 491. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_mask); + 492. } + 493. + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:525: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 523. * only the first byte of the word is being modified + 524. */ + 525. > ret_val = e1000_read_eeprom(hw, last_word, 1, + 526. &eeprom_buff[last_word - first_word]); + 527. } + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +include/trace/events/sunrpc.h:487: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 485. { (1UL << RQ_BUSY), "RQ_BUSY"}) + 486. + 487. > TRACE_EVENT(svc_recv, + 488. TP_PROTO(struct svc_rqst *rqst, int status), + 489. + +lib/rhashtable.c:521: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 519. + 520. RCU_INIT_POINTER(list->next, plist); + 521. > head = rht_dereference_bucket(head->next, tbl, hash); + 522. RCU_INIT_POINTER(list->rhead.next, head); + 523. rcu_assign_pointer(*pprev, obj); + +lib/rhashtable.c:518: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 516. + 517. list = container_of(obj, struct rhlist_head, rhead); + 518. > plist = container_of(head, struct rhlist_head, rhead); + 519. + 520. RCU_INIT_POINTER(list->next, plist); + +net/ipv6/sit.c:492: error: DEAD_STORE + The value written to &code (type int) is never used. + 490. const struct iphdr *iph = (const struct iphdr *)skb->data; + 491. const int type = icmp_hdr(skb)->type; + 492. > const int code = icmp_hdr(skb)->code; + 493. unsigned int data_len = 0; + 494. struct ip_tunnel *t; + +net/ipv6/sit.c:490: error: DEAD_STORE + The value written to &iph (type iphdr const *) is never used. + 488. static int ipip6_err(struct sk_buff *skb, u32 info) + 489. { + 490. > const struct iphdr *iph = (const struct iphdr *)skb->data; + 491. const int type = icmp_hdr(skb)->type; + 492. const int code = icmp_hdr(skb)->code; + +drivers/pci/pcie/aer/aerdrv_core.c:491: error: DEAD_STORE + The value written to &result (type unsigned int) is never used. + 489. static void do_recovery(struct pci_dev *dev, int severity) + 490. { + 491. > pci_ers_result_t status, result = PCI_ERS_RESULT_RECOVERED; + 492. enum pci_channel_state state; + 493. + +include/linux/cgroup.h:502: error: UNINITIALIZED_VALUE + The value read from css was never initialized. + 500. } + 501. rcu_read_unlock(); + 502. > return css; + 503. } + 504. + +kernel/softirq.c:494: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 492. + 493. local_irq_disable(); + 494. > list = __this_cpu_read(tasklet_vec.head); + 495. __this_cpu_write(tasklet_vec.head, NULL); + 496. __this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head)); + +kernel/softirq.c:518: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 516. local_irq_disable(); + 517. t->next = NULL; + 518. > *__this_cpu_read(tasklet_vec.tail) = t; + 519. __this_cpu_write(tasklet_vec.tail, &(t->next)); + 520. __raise_softirq_irqoff(TASKLET_SOFTIRQ); + +kernel/softirq.c:494: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 492. + 493. local_irq_disable(); + 494. > list = __this_cpu_read(tasklet_vec.head); + 495. __this_cpu_write(tasklet_vec.head, NULL); + 496. __this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head)); + +drivers/tty/tty_buffer.c:511: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 509. * is advancing to the next buffer + 510. */ + 511. > next = smp_load_acquire(&head->next); + 512. /* paired w/ release in __tty_buffer_request_room() or in + 513. * tty_buffer_flush(); ensures we see the committed buffer data + +drivers/tty/tty_buffer.c:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. * tty_buffer_flush(); ensures we see the committed buffer data + 514. */ + 515. > count = smp_load_acquire(&head->commit) - head->read; + 516. if (!count) { + 517. if (next == NULL) + +drivers/gpu/drm/drm_lease.c:504: error: DEAD_STORE + The value written to &fd (type int) is never used. + 502. struct file *lessor_file = lessor_priv->filp; + 503. struct drm_file *lessee_priv; + 504. > int fd = -1; + 505. uint32_t *object_ids; + 506. + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:492: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 490. ); + 491. + 492. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_update_request, + 493. + 494. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +kernel/umh.c:535: error: UNINITIALIZED_VALUE + The value read from cap_array[_] was never initialized. + 533. */ + 534. for (i = 0; i < _KERNEL_CAPABILITY_U32S; i++) + 535. > new_cap.cap[i] = cap_array[i]; + 536. + 537. /* + +net/ipv4/route.c:496: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 494. u32 *p_tstamp = ip_tstamps + hash % IP_IDENTS_SZ; + 495. atomic_t *p_id = ip_idents + hash % IP_IDENTS_SZ; + 496. > u32 old = READ_ONCE(*p_tstamp); + 497. u32 now = (u32)jiffies; + 498. u32 new, delta = 0; + +kernel/locking/rwsem-xadd.c:504: error: DEAD_STORE + The value written to &count (type long) is never used. + 502. + 503. /* undo write bias from down_write operation, stop active locking */ + 504. > count = atomic_long_sub_return(RWSEM_ACTIVE_WRITE_BIAS, &sem->count); + 505. + 506. /* do optimistic spinning and steal lock if possible */ + +block/blk-core.c:535: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 535, column 33. + 533. */ + 534. if (drain_all) { + 535. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 536. drain |= !list_empty(&q->queue_head); + 537. for (i = 0; i < 2; i++) { + +drivers/usb/early/ehci-dbgp.c:572: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugInEndpoint was never initialized. + 570. } + 571. dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. > dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + 574. /* Move the device to 127 if it isn't already there */ + +drivers/usb/early/ehci-dbgp.c:571: error: UNINITIALIZED_VALUE + The value read from dbgp_desc.bDebugOutEndpoint was never initialized. + 569. goto err; + 570. } + 571. > dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint; + 572. dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint; + 573. + +drivers/gpu/drm/drm_ioc32.c:507: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 505. return -EFAULT; + 506. + 507. > request.ctx_id = req32.ctx_id; + 508. request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + +drivers/gpu/drm/drm_ioc32.c:508: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 506. + 507. request.ctx_id = req32.ctx_id; + 508. > request.handle = compat_ptr(req32.handle); + 509. return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, + 510. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +kernel/capability.c:504: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 502. const struct cred *cred; + 503. rcu_read_lock(); + 504. > cred = rcu_dereference(tsk->ptracer_cred); + 505. if (cred) + 506. ret = security_capable_noaudit(cred, ns, CAP_SYS_PTRACE); + +kernel/futex.c:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. tail = page; + 574. page = compound_head(page); + 575. > mapping = READ_ONCE(page->mapping); + 576. + 577. /* + +kernel/futex.c:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. } + 659. + 660. > inode = READ_ONCE(mapping->host); + 661. if (!inode) { + 662. rcu_read_unlock(); + +net/sched/ematch.c:529: error: UNINITIALIZED_VALUE + The value read from stack[_] was never initialized. + 527. pop_stack: + 528. if (stackp > 0) { + 529. > match_idx = stack[--stackp]; + 530. cur_match = tcf_em_get_match(tree, match_idx); + 531. + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/power.h:500: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 498. ); + 499. + 500. > DEFINE_EVENT(dev_pm_qos_request, dev_pm_qos_remove_request, + 501. + 502. TP_PROTO(const char *name, enum dev_pm_qos_req_type type, + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +include/trace/events/block.h:501: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 499. * on elements in the request queue. + 500. */ + 501. > DEFINE_EVENT(block_unplug, block_unplug, + 502. + 503. TP_PROTO(struct request_queue *q, unsigned int depth, bool explicit), + +net/ipv4/raw.c:527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 525. */ + 526. hdrincl = inet->hdrincl; + 527. > hdrincl = READ_ONCE(hdrincl); + 528. /* + 529. * Check the flags. + +net/ipv4/raw.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. + 588. rcu_read_lock(); + 589. > inet_opt = rcu_dereference(inet->inet_opt); + 590. if (inet_opt) { + 591. memcpy(&opt_copy, inet_opt, + +kernel/events/core.c:506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 504. void perf_sample_event_took(u64 sample_len_ns) + 505. { + 506. > u64 max_len = READ_ONCE(perf_sample_allowed_ns); + 507. u64 running_len; + 508. u64 avg_len; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +kernel/events/core.c:515: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 513. + 514. /* Decay the counter by 1 average sample. */ + 515. > running_len = __this_cpu_read(running_sample_length); + 516. running_len -= running_len/NR_ACCUMULATED_SAMPLES; + 517. running_len += sample_len_ns; + +kernel/trace/trace_events_trigger.c:509: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 507. bool set_cond = false; + 508. + 509. > list_for_each_entry_rcu(data, &file->triggers, list) { + 510. if (data->filter || event_command_post_trigger(data->cmd_ops) || + 511. event_command_needs_rec(data->cmd_ops)) { + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +include/trace/events/rcu.h:505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 503. * fifth argument is the total number of callbacks queued. + 504. */ + 505. > TRACE_EVENT(rcu_kfree_callback, + 506. + 507. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset, + +kernel/sched/core.c:511: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 509. + 510. raw_spin_lock_irqsave(&rq->lock, flags); + 511. > if (cpu_online(cpu) || cpu == smp_processor_id()) + 512. resched_curr(rq); + 513. raw_spin_unlock_irqrestore(&rq->lock, flags); + +kernel/rcu/update.c:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. int rcu_jiffies_till_stall_check(void) + 507. { + 508. > int till_stall_check = READ_ONCE(rcu_cpu_stall_timeout); + 509. + 510. /* + +net/socket.c:528: error: DEAD_STORE + The value written to &buffer (type char*) is never used. + 526. return -ERANGE; + 527. memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len); + 528. > buffer += len; + 529. } + 530. + +drivers/gpu/drm/i915/i915_gem_request.h:559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 557. struct drm_i915_gem_request *request; + 558. + 559. > request = rcu_dereference(active->request); + 560. if (!request || i915_gem_request_completed(request)) + 561. return NULL; + +drivers/gpu/drm/i915/i915_gem_request.h:604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 602. * rcu_assign_pointer(). + 603. */ + 604. > if (!request || request == rcu_access_pointer(active->request)) + 605. return rcu_pointer_handoff(request); + 606. + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:508: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 506. ); + 507. + 508. > DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush, + 509. TP_PROTO(struct drm_i915_gem_object *obj), + 510. TP_ARGS(obj) + +include/linux/dma-mapping.h:519: error: UNINITIALIZED_VALUE + The value read from cpu_addr was never initialized. + 517. + 518. if (dma_alloc_from_dev_coherent(dev, size, dma_handle, &cpu_addr)) + 519. > return cpu_addr; + 520. + 521. /* + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +kernel/smpboot.c:512: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 510. int oldstate; + 511. int newstate; + 512. > int cpu = smp_processor_id(); + 513. + 514. do { + +kernel/trace/trace_events.c:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. struct trace_array *tr = data; + 514. + 515. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 516. trace_filter_add_remove_task(pid_list, NULL, task); + 517. } + +arch/x86/events/intel/pt.c:513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 511. { + 512. struct pt *pt = this_cpu_ptr(&pt_ctx); + 513. > u64 ctl = READ_ONCE(event->hw.config); + 514. + 515. /* may be already stopped by a PMI */ + +kernel/time/tick-common.c:517: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 515. timekeeping_resume(); + 516. trace_suspend_resume(TPS("timekeeping_freeze"), + 517. > smp_processor_id(), false); + 518. } else { + 519. tick_resume_local(); + +kernel/time/tick-common.c:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. if (tick_freeze_depth == num_online_cpus()) { + 515. timekeeping_resume(); + 516. > trace_suspend_resume(TPS("timekeeping_freeze"), + 517. smp_processor_id(), false); + 518. } else { + +block/blk-mq-sched.c:513: error: DEAD_STORE + The value written to &set (type blk_mq_tag_set*) is never used. + 511. static void blk_mq_sched_tags_teardown(struct request_queue *q) + 512. { + 513. > struct blk_mq_tag_set *set = q->tag_set; + 514. struct blk_mq_hw_ctx *hctx; + 515. int i; + +include/linux/interrupt.h:514: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 512. static inline struct task_struct *this_cpu_ksoftirqd(void) + 513. { + 514. > return this_cpu_read(ksoftirqd); + 515. } + 516. + +include/linux/interrupt.h:514: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 512. static inline struct task_struct *this_cpu_ksoftirqd(void) + 513. { + 514. > return this_cpu_read(ksoftirqd); + 515. } + 516. + +include/net/sock.h:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. { + 514. if (unlikely(flags & MSG_PEEK)) { + 515. > return READ_ONCE(sk->sk_peek_off); + 516. } + 517. + +block/kyber-iosched.c:516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 514. void *key) + 515. { + 516. > struct blk_mq_hw_ctx *hctx = READ_ONCE(wait->private); + 517. + 518. list_del_init(&wait->entry); + +drivers/gpu/drm/drm_ioc32.c:524: error: UNINITIALIZED_VALUE + The value read from req32.ctx_id was never initialized. + 522. return -EFAULT; + 523. + 524. > req.ctx_id = req32.ctx_id; + 525. err = drm_ioctl_kernel(file, drm_legacy_getsareactx, &req, DRM_AUTH); + 526. if (err) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +drivers/gpu/drm/i915/i915_trace.h:513: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 511. ); + 512. + 513. > DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy, + 514. TP_PROTO(struct drm_i915_gem_object *obj), + 515. TP_ARGS(obj) + +include/linux/cgroup.h:515: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 513. static inline bool task_css_is_root(struct task_struct *task, int subsys_id) + 514. { + 515. > return task_css_check(task, subsys_id, true) == + 516. init_css_set.subsys[subsys_id]; + 517. } + +lib/bitmap.c:525: error: DEAD_STORE + The value written to &group_size (type unsigned int) is never used. + 523. totaldigits = c = 0; + 524. old_a = old_b = 0; + 525. > group_size = used_size = 0; + 526. bitmap_zero(maskp, nmaskbits); + 527. do { + +drivers/md/dm-stats.c:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. preempt_disable(); + 542. #endif + 543. > p = &s->stat_percpu[smp_processor_id()][entry]; + 544. + 545. if (!end) { + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +include/trace/events/sched.h:514: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 512. ); + 513. + 514. > TRACE_EVENT(sched_swap_numa, + 515. + 516. TP_PROTO(struct task_struct *src_tsk, int src_cpu, + +net/ipv6/ip6_flowlabel.c:563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 561. case IPV6_FL_A_RENEW: + 562. rcu_read_lock_bh(); + 563. > for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + +net/ipv6/ip6_flowlabel.c:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. err = -EEXIST; + 612. rcu_read_lock_bh(); + 613. > for_each_sk_fl_rcu(np, sfl) { + 614. if (sfl->fl->label == freq.flr_label) { + 615. if (freq.flr_flags&IPV6_FL_F_EXCL) { + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_expires was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +net/ipv6/ip6_flowlabel.c:574: error: UNINITIALIZED_VALUE + The value read from freq.flr_label was never initialized. + 572. if (freq.flr_share == IPV6_FL_S_NONE && + 573. ns_capable(net->user_ns, CAP_NET_ADMIN)) { + 574. > fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + +net/ipv6/ip6_flowlabel.c:565: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 563. for_each_sk_fl_rcu(np, sfl) { + 564. if (sfl->fl->label == freq.flr_label) { + 565. > err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); + 566. rcu_read_unlock_bh(); + 567. return err; + +net/ipv6/ip6_flowlabel.c:576: error: UNINITIALIZED_VALUE + The value read from freq.flr_linger was never initialized. + 574. fl = fl_lookup(net, freq.flr_label); + 575. if (fl) { + 576. > err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); + 577. fl_release(fl); + 578. return err; + +net/core/rtnetlink.c:520: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 518. const struct rtnl_af_ops *ops; + 519. + 520. > list_for_each_entry_rcu(ops, &rtnl_af_ops, list) { + 521. if (ops->family == family) + 522. return ops; + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: DEAD_STORE + The value written to &ret (type int) is never used. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +net/wireless/trace.h:516: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 514. ); + 515. + 516. > TRACE_EVENT(rdev_change_beacon, + 517. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 518. struct cfg80211_beacon_data *info), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +drivers/gpu/drm/i915/i915_trace.h:518: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 516. ); + 517. + 518. > TRACE_EVENT(i915_gem_evict, + 519. TP_PROTO(struct i915_address_space *vm, u64 size, u64 align, unsigned int flags), + 520. TP_ARGS(vm, size, align, flags), + +net/ipv6/ip6_fib.c:560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 558. e = 0; + 559. head = &net->ipv6.fib_table_hash[h]; + 560. > hlist_for_each_entry_rcu(tb, head, tb6_hlist) { + 561. if (e < s_e) + 562. goto next; + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +include/trace/events/block.h:519: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 517. * such as operation crossing device boundaries in a RAID system. + 518. */ + 519. > TRACE_EVENT(block_split, + 520. + 521. TP_PROTO(struct request_queue *q, struct bio *bio, + +kernel/trace/trace_events.c:527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 525. struct trace_array *tr = data; + 526. + 527. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 528. trace_filter_add_remove_task(pid_list, self, task); + 529. } + +net/ipv6/netfilter/nf_conntrack_reasm.c:554: error: UNINITIALIZED_VALUE + The value read from hdr.nexthdr was never initialized. + 552. prev_nhoff = start; + 553. + 554. > nexthdr = hdr.nexthdr; + 555. len -= hdrlen; + 556. start += hdrlen; + +net/ipv6/tcp_ipv6.c:557: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 555. + 556. if (ipv6_addr_v4mapped(&sin6->sin6_addr)) + 557. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr.s6_addr32[3], + 558. AF_INET, prefixlen, cmd.tcpm_key, + 559. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:561: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 559. cmd.tcpm_keylen, GFP_KERNEL); + 560. + 561. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin6->sin6_addr, + 562. AF_INET6, prefixlen, cmd.tcpm_key, + 563. cmd.tcpm_keylen, GFP_KERNEL); + +net/ipv6/tcp_ipv6.c:537: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 535. if (optname == TCP_MD5SIG_EXT && + 536. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 537. > prefixlen = cmd.tcpm_prefixlen; + 538. if (prefixlen > 128 || (ipv6_addr_v4mapped(&sin6->sin6_addr) && + 539. prefixlen > 32)) + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +kernel/panic.c:529: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 527. + 528. if (file) + 529. > pr_warn("WARNING: CPU: %d PID: %d at %s:%d %pS\n", + 530. raw_smp_processor_id(), current->pid, file, line, + 531. caller); + +kernel/panic.c:533: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 531. caller); + 532. else + 533. > pr_warn("WARNING: CPU: %d PID: %d at %pS\n", + 534. raw_smp_processor_id(), current->pid, caller); + 535. + +block/blk-flush.c:545: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 544 could be null and is dereferenced at line 545, column 2. + 543. + 544. bio = bio_alloc(gfp_mask, 0); + 545. > bio_set_dev(bio, bdev); + 546. bio->bi_opf = REQ_OP_WRITE | REQ_PREFLUSH; + 547. + +include/net/sock.h:526: error: DEAD_STORE + The value written to &off (type int) is never used. + 524. + 525. if (unlikely(off >= 0)) { + 526. > off = max_t(s32, off - val, 0); + 527. WRITE_ONCE(sk->sk_peek_off, off); + 528. } + +include/net/sock.h:523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 521. static inline void sk_peek_offset_bwd(struct sock *sk, int val) + 522. { + 523. > s32 off = READ_ONCE(sk->sk_peek_off); + 524. + 525. if (unlikely(off >= 0)) { + +usr/gen_init_cpio.c:568: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 568, column 9. + 566. } + 567. + 568. > while (fgets(line, LINE_SIZE, cpio_list)) { + 569. int type_idx; + 570. size_t slen = strlen(line); + +usr/gen_init_cpio.c:580: error: RESOURCE_LEAK + resource of type `_IO_FILE` acquired by call to `fopen()` at line 561, column 25 is not released after line 580, column 12. + 578. + 579. if (! (type = strtok(line, " \t"))) { + 580. > fprintf(stderr, + 581. "ERROR: incorrect format, could not locate file type line %d: '%s'\n", + 582. line_nr, line); + +drivers/gpu/drm/i915/intel_hotplug.c:535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 533. mutex_lock(&dev->mode_config.mutex); + 534. + 535. > enabled = READ_ONCE(dev_priv->hotplug.poll_enabled); + 536. + 537. drm_connector_list_iter_begin(dev, &conn_iter); + +include/linux/radix-tree.h:562: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 560. + 561. found: + 562. > if (unlikely(radix_tree_is_internal_node(rcu_dereference_raw(*slot)))) + 563. return __radix_tree_next_slot(slot, iter, flags); + 564. return slot; + +crypto/api.c:556: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 554. } + 555. + 556. > return ERR_PTR(err); + 557. } + 558. EXPORT_SYMBOL_GPL(crypto_alloc_tfm); + +kernel/softirq.c:530: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 528. + 529. local_irq_disable(); + 530. > list = __this_cpu_read(tasklet_hi_vec.head); + 531. __this_cpu_write(tasklet_hi_vec.head, NULL); + 532. __this_cpu_write(tasklet_hi_vec.tail, this_cpu_ptr(&tasklet_hi_vec.head)); + +kernel/softirq.c:554: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 552. local_irq_disable(); + 553. t->next = NULL; + 554. > *__this_cpu_read(tasklet_hi_vec.tail) = t; + 555. __this_cpu_write(tasklet_hi_vec.tail, &(t->next)); + 556. __raise_softirq_irqoff(HI_SOFTIRQ); + +kernel/softirq.c:530: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 528. + 529. local_irq_disable(); + 530. > list = __this_cpu_read(tasklet_hi_vec.head); + 531. __this_cpu_write(tasklet_hi_vec.head, NULL); + 532. __this_cpu_write(tasklet_hi_vec.tail, this_cpu_ptr(&tasklet_hi_vec.head)); + +kernel/rcu/srcutree.c:558: error: DEAD_STORE + The value written to &idxnext (type int) is never used. + 556. /* Initiate callback invocation as needed. */ + 557. idx = rcu_seq_ctr(gpseq) % ARRAY_SIZE(snp->srcu_have_cbs); + 558. > idxnext = (idx + 1) % ARRAY_SIZE(snp->srcu_have_cbs); + 559. rcu_for_each_node_breadth_first(sp, snp) { + 560. spin_lock_irq_rcu_node(snp); + +kernel/sched/core.c:535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 533. + 534. rcu_read_lock(); + 535. > for_each_domain(cpu, sd) { + 536. for_each_cpu(i, sched_domain_span(sd)) { + 537. if (cpu == i) + +kernel/sched/core.c:528: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 526. int get_nohz_timer_target(void) + 527. { + 528. > int i, cpu = smp_processor_id(); + 529. struct sched_domain *sd; + 530. + +kernel/sched/core.c:528: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 526. int get_nohz_timer_target(void) + 527. { + 528. > int i, cpu = smp_processor_id(); + 529. struct sched_domain *sd; + 530. + +net/netfilter/nf_conntrack_core.c:539: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 537. bucket = reciprocal_scale(hash, hsize); + 538. + 539. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[bucket], hnnode) { + 540. struct nf_conn *ct; + 541. + +drivers/tty/serial/serial_core.c:545: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 543. ret = 1; + 544. } + 545. > uart_port_unlock(port, flags); + 546. return ret; + 547. } + +block/blk-mq.c:549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 547. } + 548. + 549. > cpu = get_cpu(); + 550. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 551. shared = cpus_share_cache(cpu, ctx->cpu); + +block/blk-mq.c:549: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 547. } + 548. + 549. > cpu = get_cpu(); + 550. if (!test_bit(QUEUE_FLAG_SAME_FORCE, &rq->q->queue_flags)) + 551. shared = cpus_share_cache(cpu, ctx->cpu); + +net/sunrpc/svc_xprt.c:536: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 534. + 535. rcu_read_lock(); + 536. > list_for_each_entry_rcu(rqstp, &pool->sp_all_threads, rq_all) { + 537. /* skip any that aren't queued */ + 538. if (test_bit(RQ_BUSY, &rqstp->rq_flags)) + +net/wireless/scan.c:540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 538. return true; + 539. + 540. > ies = rcu_access_pointer(a->ies); + 541. if (!ies) + 542. return false; + +drivers/gpu/drm/i915/intel_hdmi.c:541: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 537 could be null and is dereferenced at line 541, column 13. + 539. i915_reg_t reg = VIDEO_DIP_CTL; + 540. u32 val = I915_READ(reg); + 541. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 542. + 543. assert_hdmi_port_disabled(intel_hdmi); + +kernel/power/swap.c:572: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 570. pr_info("Image saving done\n"); + 571. swsusp_show_speed(start, stop, nr_to_write, "Wrote"); + 572. > return ret; + 573. } + 574. + +security/keys/process_keys.c:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. + 612. rcu_read_lock(); + 613. > key = rcu_dereference(ctx.cred->session_keyring); + 614. __key_get(key); + 615. rcu_read_unlock(); + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +kernel/time/tick-sched.c:536: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 534. static void tick_nohz_stop_idle(struct tick_sched *ts, ktime_t now) + 535. { + 536. > update_ts_time_stats(smp_processor_id(), ts, now, NULL); + 537. ts->idle_active = 0; + 538. + +lib/idr.c:540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 538. + 539. radix_tree_for_each_slot(slot, &ida->ida_rt, &iter, 0) { + 540. > struct ida_bitmap *bitmap = rcu_dereference_raw(*slot); + 541. if (!radix_tree_exception(bitmap)) + 542. kfree(bitmap); + +lib/rhashtable.c:567: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 565. return ERR_PTR(-ENOMEM); + 566. + 567. > head = rht_dereference_bucket(*pprev, tbl, hash); + 568. + 569. RCU_INIT_POINTER(obj->next, head); + +lib/rhashtable.c:550: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 548. return ERR_CAST(data); + 549. + 550. > new_tbl = rcu_dereference(tbl->future_tbl); + 551. if (new_tbl) + 552. return new_tbl; + +net/sched/act_api.c:537: error: DEAD_STORE + The value written to &err (type int) is never used. + 535. tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) + 536. { + 537. > int err = -EINVAL; + 538. unsigned char *b = skb_tail_pointer(skb); + 539. struct nlattr *nest; + +drivers/gpu/drm/i915/intel_fbdev.c:633: error: DEAD_STORE + The value written to &intel_crtc (type intel_crtc*) is never used. + 631. /* Final pass to check if any active pipes don't have fbs */ + 632. for_each_crtc(dev, crtc) { + 633. > intel_crtc = to_intel_crtc(crtc); + 634. + 635. if (!crtc->state->active) + +kernel/tracepoint.c:542: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 540. if (!sys_tracepoint_refcount) { + 541. read_lock(&tasklist_lock); + 542. > for_each_process_thread(p, t) { + 543. set_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); + 544. } + +net/netfilter/nf_conntrack_expect.c:542: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 540. + 541. for (st->bucket = 0; st->bucket < nf_ct_expect_hsize; st->bucket++) { + 542. > n = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket])); + 543. if (n) + 544. return n; + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +kernel/stop_machine.c:549: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 547. + 548. BUG_ON(smpboot_register_percpu_thread(&cpu_stop_threads)); + 549. > stop_machine_unpark(raw_smp_processor_id()); + 550. stop_machine_initialized = true; + 551. return 0; + +kernel/trace/trace_events_trigger.c:544: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 542. int ret = 0; + 543. + 544. > list_for_each_entry_rcu(test, &file->triggers, list) { + 545. if (test->cmd_ops->trigger_type == data->cmd_ops->trigger_type) { + 546. ret = -EEXIST; + +lib/decompress_unlzma.c:592: error: UNINITIALIZED_VALUE + The value read from header.pos was never initialized. + 590. + 591. mi = 0; + 592. > lc = header.pos; + 593. while (lc >= 9) { + 594. mi++; + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:538: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 536. ); + 537. + 538. > DEFINE_EVENT(svc_rqst_event, svc_defer, + 539. TP_PROTO(struct svc_rqst *rqst), + 540. TP_ARGS(rqst)); + +net/ipv6/mcast.c:569: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 567. */ + 568. + 569. > for_each_pmc_rcu(inet6, pmc) { + 570. if (pmc->ifindex != gsf->gf_interface) + 571. continue; + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +include/trace/events/rcu.h:540: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 538. * the current RCU-callback batch limit. + 539. */ + 540. > TRACE_EVENT(rcu_batch_start, + 541. + 542. TP_PROTO(const char *rcuname, long qlen_lazy, long qlen, long blimit), + +drivers/gpu/drm/drm_ioc32.c:553: error: UNINITIALIZED_VALUE + The value read from res32.contexts was never initialized. + 551. + 552. res.count = res32.count; + 553. > res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + 555. if (err) + +drivers/gpu/drm/drm_ioc32.c:552: error: UNINITIALIZED_VALUE + The value read from res32.count was never initialized. + 550. return -EFAULT; + 551. + 552. > res.count = res32.count; + 553. res.contexts = compat_ptr(res32.contexts); + 554. err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); + +drivers/usb/core/config.c:701: error: UNINITIALIZED_VALUE + The value read from inums[_] was never initialized. + 699. j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. > dev_warn(ddev, "too many alternate settings for " + 702. "config %d interface %d: %d, " + 703. "using maximum allowed: %d\n", + +drivers/usb/core/config.c:750: error: UNINITIALIZED_VALUE + The value read from inums[_] was never initialized. + 748. } + 749. if (n >= intfc->num_altsetting) + 750. > dev_warn(ddev, "config %d interface %d has no " + 751. "altsetting %d\n", cfgno, inums[i], j); + 752. } + +drivers/usb/core/config.c:699: error: UNINITIALIZED_VALUE + The value read from nalts[_] was never initialized. + 697. /* Allocate the usb_interface_caches and altsetting arrays */ + 698. for (i = 0; i < nintf; ++i) { + 699. > j = nalts[i]; + 700. if (j > USB_MAXALTSETTING) { + 701. dev_warn(ddev, "too many alternate settings for " + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +kernel/time/tick-broadcast.c:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. int tick_check_broadcast_expired(void) + 542. { + 543. > return cpumask_test_cpu(smp_processor_id(), tick_broadcast_force_mask); + 544. } + 545. + +drivers/gpu/drm/drm_dp_helper.c:600: error: UNINITIALIZED_VALUE + The value read from rev[_] was never initialized. + 598. len = drm_dp_dpcd_read(aux, DP_BRANCH_SW_REV, rev, 2); + 599. if (len > 0) + 600. > seq_printf(m, "\t\tSW: %d.%d\n", rev[0], rev[1]); + 601. + 602. if (detailed_cap_info) { + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +include/trace/events/sunrpc.h:542: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 540. TP_ARGS(rqst)); + 541. + 542. > DEFINE_EVENT(svc_rqst_event, svc_drop, + 543. TP_PROTO(struct svc_rqst *rqst), + 544. TP_ARGS(rqst)); + +drivers/gpu/drm/i915/i915_gem_gtt.c:600: error: UNINITIALIZED_VALUE + The value read from addr was never initialized. + 598. + 599. vm->scratch_page.page = page; + 600. > vm->scratch_page.daddr = addr; + 601. vm->scratch_page.order = order; + 602. + +drivers/gpu/drm/i915/i915_gem_gtt.c:601: error: UNINITIALIZED_VALUE + The value read from order was never initialized. + 599. vm->scratch_page.page = page; + 600. vm->scratch_page.daddr = addr; + 601. > vm->scratch_page.order = order; + 602. + 603. return 0; + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/i915_trace.h:543: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 541. ); + 542. + 543. > TRACE_EVENT(i915_gem_evict_node, + 544. TP_PROTO(struct i915_address_space *vm, struct drm_mm_node *node, unsigned int flags), + 545. TP_ARGS(vm, node, flags), + +drivers/gpu/drm/i915/intel_guc_submission.c:568: error: DEAD_STORE + The value written to &cs (type unsigned int*) is never used. + 566. } + 567. *cs++ = MI_USER_INTERRUPT; + 568. > *cs++ = MI_NOOP; + 569. + 570. GEM_BUG_ON(!IS_ALIGNED(ring->size, + +net/ipv6/calipso.c:555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 553. + 554. rcu_read_lock(); + 555. > list_for_each_entry_rcu(iter_doi, &calipso_doi_list, list) + 556. if (refcount_read(&iter_doi->refcount) > 0) { + 557. if (doi_cnt++ < *skip_cnt) + +kernel/trace/trace_events.c:553: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 551. struct trace_pid_list *pid_list; + 552. + 553. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 554. + 555. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +net/netfilter/core.c:552: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 550. if (skb->_nfct) { + 551. rcu_read_lock(); + 552. > attach = rcu_dereference(ip_ct_attach); + 553. if (attach) + 554. attach(new, skb); + +net/sunrpc/auth.c:560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 558. + 559. rcu_read_lock(); + 560. > hlist_for_each_entry_rcu(entry, &cache->hashtable[nr], cr_hash) { + 561. if (!entry->cr_ops->crmatch(acred, entry, flags)) + 562. continue; + +kernel/exit.c:553: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 551. struct task_struct *t; + 552. + 553. > for_each_thread(p, t) { + 554. if (!(t->flags & PF_EXITING)) + 555. return t; + +net/netfilter/nf_conntrack_expect.c:554: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 552. struct ct_expect_iter_state *st = seq->private; + 553. + 554. > head = rcu_dereference(hlist_next_rcu(head)); + 555. while (head == NULL) { + 556. if (++st->bucket >= nf_ct_expect_hsize) + +net/netfilter/nf_conntrack_expect.c:558: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 556. if (++st->bucket >= nf_ct_expect_hsize) + 557. return NULL; + 558. > head = rcu_dereference(hlist_first_rcu(&nf_ct_expect_hash[st->bucket])); + 559. } + 560. return head; + +net/netfilter/nf_conntrack_ftp.c:557: error: NULL_DEREFERENCE + pointer `ftp` last assigned on line 551 could be null and is dereferenced at line 557, column 2. + 555. * failover breaks. + 556. */ + 557. > ftp->flags[IP_CT_DIR_ORIGINAL] |= NF_CT_FTP_SEQ_PICKUP; + 558. ftp->flags[IP_CT_DIR_REPLY] |= NF_CT_FTP_SEQ_PICKUP; + 559. return 0; + +security/keys/keyring.c:555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 553. struct keyring_search_context *ctx = iterator_data; + 554. const struct key *key = keyring_ptr_to_key(object); + 555. > unsigned long kflags = READ_ONCE(key->flags); + 556. short state = READ_ONCE(key->state); + 557. + +security/keys/keyring.c:556: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 554. const struct key *key = keyring_ptr_to_key(object); + 555. unsigned long kflags = READ_ONCE(key->flags); + 556. > short state = READ_ONCE(key->state); + 557. + 558. kenter("{%d}", key->serial); + +security/keys/keyring.c:568: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 566. /* skip invalidated, revoked and expired keys */ + 567. if (ctx->flags & KEYRING_SEARCH_DO_STATE_CHECK) { + 568. > time64_t expiry = READ_ONCE(key->expiry); + 569. + 570. if (kflags & ((1 << KEY_FLAG_INVALIDATED) | + +kernel/tracepoint.c:559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 557. if (!sys_tracepoint_refcount) { + 558. read_lock(&tasklist_lock); + 559. > for_each_process_thread(p, t) { + 560. clear_tsk_thread_flag(t, TIF_SYSCALL_TRACEPOINT); + 561. } + +net/ipv4/devinet.c:561: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 559. dev = dev_get_by_index_rcu(net, ifindex); + 560. if (dev) + 561. > in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 562. rcu_read_unlock(); + 563. return in_dev; + +drivers/gpu/drm/i915/i915_debugfs.c:565: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 563. int count, ret; + 564. + 565. > nobject = READ_ONCE(dev_priv->mm.object_count); + 566. objects = kvmalloc_array(nobject, sizeof(*objects), GFP_KERNEL); + 567. if (!objects) + +drivers/tty/serial/serial_core.c:591: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 589. + 590. __uart_start(tty); + 591. > uart_port_unlock(port, flags); + 592. return ret; + 593. } + +net/ipv4/inet_hashtables.c:562: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 560. kuid_t uid = sock_i_uid(sk); + 561. + 562. > sk_for_each_rcu(sk2, &ilb->head) { + 563. if (sk2 != sk && + 564. sk2->sk_family == sk->sk_family && + +net/core/rtnetlink.c:566: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 564. + 565. rcu_read_lock(); + 566. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 567. if (af_ops->get_link_af_size) { + 568. /* AF_* + nested data */ + +net/ipv6/udp.c:579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 577. + 578. /* if we're overly short, let UDP handle it */ + 579. > encap_rcv = READ_ONCE(up->encap_rcv); + 580. if (encap_rcv) { + 581. int ret; + +net/ipv6/udp.c:617: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 615. + 616. prefetch(&sk->sk_rmem_alloc); + 617. > if (rcu_access_pointer(sk->sk_filter) && + 618. udp_lib_checksum_complete(skb)) + 619. goto csum_error; + +security/selinux/ss/avtab.c:568: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 566. goto bad; + 567. } + 568. > nel = le32_to_cpu(buf[0]); + 569. if (!nel) { + 570. printk(KERN_ERR "SELinux: avtab: table is empty\n"); + +drivers/input/mouse/alps.c:586: error: DEAD_STORE + The value written to &z (type int) is never used. + 584. x = (s8)(((packet[0] & 0x20) << 2) | (packet[1] & 0x7f)); + 585. y = (s8)(((packet[0] & 0x10) << 3) | (packet[2] & 0x7f)); + 586. > z = (packet[4] & 0x7c) >> 2; + 587. + 588. /* + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +include/trace/events/sched.h:557: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 555. * Tracepoint for waking a polling cpu without an IPI. + 556. */ + 557. > TRACE_EVENT(sched_wake_idle_without_ipi, + 558. + 559. TP_PROTO(int cpu), + +drivers/ata/libata-sff.c:584: error: UNINITIALIZED_VALUE + The value read from pad[_] was never initialized. + 582. if (rw == READ) { + 583. ioread16_rep(data_addr, pad, 1); + 584. > *buf = pad[0]; + 585. } else { + 586. pad[0] = *buf; + +kernel/cgroup/cgroup.c:572: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 570. */ + 571. if (cft->ss) + 572. > return rcu_dereference_raw(cgrp->subsys[cft->ss->id]); + 573. else + 574. return &cgrp->self; + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +include/trace/events/block.h:559: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 557. * raw block device. + 558. */ + 559. > TRACE_EVENT(block_bio_remap, + 560. + 561. TP_PROTO(struct request_queue *q, struct bio *bio, dev_t dev, + +drivers/gpu/drm/i915/i915_pmu.c:595: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 591 could be null and is dereferenced at line 595, column 3. + 593. engine_event_instance(event)); + 594. GEM_BUG_ON(!engine); + 595. > engine->pmu.enable |= BIT(sample); + 596. + 597. GEM_BUG_ON(sample >= I915_PMU_SAMPLE_BITS); + +kernel/exit.c:565: error: NULL_DEREFERENCE + pointer `pid_ns` last assigned on line 564 could be null and is dereferenced at line 565, column 31. + 563. { + 564. struct pid_namespace *pid_ns = task_active_pid_ns(father); + 565. > struct task_struct *reaper = pid_ns->child_reaper; + 566. + 567. if (likely(reaper != father)) + +kernel/trace/trace_events.c:567: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 565. struct trace_pid_list *pid_list; + 566. + 567. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 568. + 569. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +block/scsi_ioctl.c:643: error: UNINITIALIZED_VALUE + The value read from cgc.buffer was never initialized. + 641. break; + 642. + 643. > hdr.dxferp = cgc.buffer; + 644. hdr.sbp = cgc.sense; + 645. if (hdr.sbp) + +block/scsi_ioctl.c:622: error: UNINITIALIZED_VALUE + The value read from cgc.buflen was never initialized. + 620. hdr.interface_id = 'S'; + 621. hdr.cmd_len = sizeof(cgc.cmd); + 622. > hdr.dxfer_len = cgc.buflen; + 623. err = 0; + 624. switch (cgc.data_direction) { + +block/scsi_ioctl.c:644: error: UNINITIALIZED_VALUE + The value read from cgc.sense was never initialized. + 642. + 643. hdr.dxferp = cgc.buffer; + 644. > hdr.sbp = cgc.sense; + 645. if (hdr.sbp) + 646. hdr.mx_sb_len = sizeof(struct request_sense); + +block/scsi_ioctl.c:618: error: UNINITIALIZED_VALUE + The value read from cgc.timeout was never initialized. + 616. if (copy_from_user(&cgc, arg, sizeof(cgc))) + 617. break; + 618. > cgc.timeout = clock_t_to_jiffies(cgc.timeout); + 619. memset(&hdr, 0, sizeof(hdr)); + 620. hdr.interface_id = 'S'; + +net/wireless/trace.h:561: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 559. ); + 560. + 561. > DECLARE_EVENT_CLASS(wiphy_netdev_evt, + 562. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 563. TP_ARGS(wiphy, netdev), + +kernel/workqueue.c:576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 574. return wq->dfl_pwq; + 575. + 576. > return rcu_dereference_raw(wq->numa_pwq_tbl[node]); + 577. } + 578. + +net/core/sock.c:566: error: DEAD_STORE + The value written to &ret (type int) is never used. + 564. int optlen) + 565. { + 566. > int ret = -ENOPROTOOPT; + 567. #ifdef CONFIG_NETDEVICES + 568. struct net *net = sock_net(sk); + +net/ipv4/route.c:570: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 568. + 569. rcu_read_lock(); + 570. > inet_opt = rcu_dereference(inet->inet_opt); + 571. if (inet_opt && inet_opt->opt.srr) + 572. daddr = inet_opt->opt.faddr; + +net/netfilter/core.c:568: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 566. + 567. rcu_read_lock(); + 568. > destroy = rcu_dereference(nf_ct_destroy); + 569. BUG_ON(destroy == NULL); + 570. destroy(nfct); + +net/wireless/scan.c:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. return b->channel->center_freq - a->channel->center_freq; + 574. + 575. > a_ies = rcu_access_pointer(a->ies); + 576. if (!a_ies) + 577. return -1; + +net/wireless/scan.c:578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 576. if (!a_ies) + 577. return -1; + 578. > b_ies = rcu_access_pointer(b->ies); + 579. if (!b_ies) + 580. return 1; + +kernel/sched/core.c:568: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 566. struct rq *rq = cpu_rq(cpu); + 567. + 568. > if (cpu == smp_processor_id()) + 569. return; + 570. + +drivers/ata/ata_piix.c:638: error: UNINITIALIZED_VALUE + The value read from slave_data was never initialized. + 636. pci_write_config_word(dev, master_port, master_data); + 637. if (is_slave) + 638. > pci_write_config_byte(dev, slave_port, slave_data); + 639. + 640. /* Ensure the UDMA bit is off - it will be turned back on if + +drivers/gpu/drm/i915/i915_gem_stolen.c:625: error: DEAD_STORE + The value written to &ret (type int) is never used. + 623. vma = i915_vma_instance(obj, &ggtt->base, NULL); + 624. if (IS_ERR(vma)) { + 625. > ret = PTR_ERR(vma); + 626. goto err_pages; + 627. } + +net/sched/act_api.c:570: error: DEAD_STORE + The value written to &err (type int) is never used. + 568. { + 569. struct tc_action *a; + 570. > int err = -EINVAL; + 571. struct nlattr *nest; + 572. + +net/ipv4/inet_connection_sock.c:578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 576. struct rtable *rt; + 577. + 578. > opt = rcu_dereference(ireq->ireq_opt); + 579. fl4 = &newinet->cork.fl.u.ip4; + 580. + +net/netfilter/nf_conntrack_proto.c:577: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 570 could be null and is dereferenced by call to `nf_ct_l4proto_register_sysctl()` at line 577, column 8. + 575. if (err < 0) + 576. return err; + 577. > err = nf_ct_l4proto_register_sysctl(net, + 578. pn, + 579. &nf_conntrack_l4proto_generic); + +arch/x86/events/intel/rapl.c:578: error: NULL_DEREFERENCE + pointer `pmu` last assigned on line 571 could be null and is dereferenced at line 578, column 2. + 576. return 0; + 577. + 578. > pmu->cpu = -1; + 579. /* Find a new cpu to collect rapl events */ + 580. target = cpumask_any_but(topology_core_cpumask(cpu), cpu); + +block/kyber-iosched.c:581: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 579. + 580. rqs = &khd->rqs[khd->cur_domain]; + 581. > rq = list_first_entry_or_null(rqs, struct request, queuelist); + 582. + 583. /* + +block/kyber-iosched.c:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. kyber_flush_busy_ctxs(khd, hctx); + 589. *flushed = true; + 590. > rq = list_first_entry_or_null(rqs, struct request, queuelist); + 591. } + 592. + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +include/trace/events/rcu.h:570: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 568. * a pointer to the RCU callback itself. + 569. */ + 570. > TRACE_EVENT(rcu_invoke_callback, + 571. + 572. TP_PROTO(const char *rcuname, struct rcu_head *rhp), + +kernel/cgroup/cpuset.c:577: error: MEMORY_LEAK + `pos_css` is not reachable after line 577, column 2. + 575. + 576. rcu_read_lock(); + 577. > cpuset_for_each_descendant_pre(cp, pos_css, root_cs) { + 578. /* skip the whole subtree if @cp doesn't have any CPU */ + 579. if (cpumask_empty(cp->cpus_allowed)) { + +drivers/gpu/drm/drm_vblank.c:657: error: UNINITIALIZED_VALUE + The value read from duration_ns was never initialized. + 655. + 656. /* Return upper bound of timestamp precision error. */ + 657. > *max_error = duration_ns; + 658. + 659. /* Convert scanout position into elapsed time at raw_time query + +drivers/gpu/drm/drm_vblank.c:674: error: UNINITIALIZED_VALUE + The value read from etime was never initialized. + 672. return true; + 673. + 674. > ts_etime = ktime_to_timespec64(etime); + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + +drivers/gpu/drm/drm_vblank.c:677: error: UNINITIALIZED_VALUE + The value read from hpos was never initialized. + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + 677. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 678. pipe, hpos, vpos, + 679. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/drm_vblank.c:677: error: UNINITIALIZED_VALUE + The value read from vpos was never initialized. + 675. ts_vblank_time = ktime_to_timespec64(*vblank_time); + 676. + 677. > DRM_DEBUG_VBL("crtc %u : v p(%d,%d)@ %lld.%06ld -> %lld.%06ld [e %d us, %d rep]\n", + 678. pipe, hpos, vpos, + 679. (u64)ts_etime.tv_sec, ts_etime.tv_nsec / 1000, + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +drivers/gpu/drm/i915/i915_trace.h:571: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 569. ); + 570. + 571. > TRACE_EVENT(i915_gem_evict_vm, + 572. TP_PROTO(struct i915_address_space *vm), + 573. TP_ARGS(vm), + +security/selinux/avc.c:579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 577. hvalue = avc_hash(ssid, tsid, tclass); + 578. head = &avc_cache.slots[hvalue]; + 579. > hlist_for_each_entry_rcu(node, head, list) { + 580. if (ssid == node->ae.ssid && + 581. tclass == node->ae.tclass && + +drivers/scsi/sg.c:668: error: UNINITIALIZED_VALUE + The value read from cmnd[_] was never initialized. + 666. */ + 667. if (hp->dxfer_direction == SG_DXFER_TO_FROM_DEV) { + 668. > printk_ratelimited(KERN_WARNING + 669. "sg_write: data in/out %d/%d bytes " + 670. "for SCSI command 0x%x-- guessing " + +drivers/scsi/sg.c:658: error: UNINITIALIZED_VALUE + The value read from old_hdr.pack_id was never initialized. + 656. hp->timeout = old_hdr.reply_len; /* structure abuse ... */ + 657. hp->flags = input_size; /* structure abuse ... */ + 658. > hp->pack_id = old_hdr.pack_id; + 659. hp->usr_ptr = NULL; + 660. if (__copy_from_user(cmnd, buf, cmd_size)) + +drivers/scsi/sg.c:632: error: UNINITIALIZED_VALUE + The value read from old_hdr.reply_len was never initialized. + 630. /* Determine buffer size. */ + 631. input_size = count - cmd_size; + 632. > mxsize = (input_size > old_hdr.reply_len) ? input_size : old_hdr.reply_len; + 633. mxsize -= SZ_SG_HEADER; + 634. input_size -= SZ_SG_HEADER; + +drivers/scsi/sg.c:656: error: UNINITIALIZED_VALUE + The value read from old_hdr.reply_len was never initialized. + 654. hp->dxferp = NULL; + 655. hp->sbp = NULL; + 656. > hp->timeout = old_hdr.reply_len; /* structure abuse ... */ + 657. hp->flags = input_size; /* structure abuse ... */ + 658. hp->pack_id = old_hdr.pack_id; + +drivers/dma-buf/reservation.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. + 588. struct reservation_object_list *fobj = + 589. > rcu_dereference(obj->fence); + 590. + 591. if (fobj) + +drivers/dma-buf/reservation.c:595: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 593. + 594. for (i = 0; i < shared_count; ++i) { + 595. > struct dma_fence *fence = rcu_dereference(fobj->shared[i]); + 596. + 597. ret = reservation_object_test_signaled_single(fence); + +drivers/dma-buf/reservation.c:609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 607. + 608. if (!shared_count) { + 609. > struct dma_fence *fence_excl = rcu_dereference(obj->fence_excl); + 610. + 611. if (fence_excl) { + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:573: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 571. ); + 572. + 573. > DEFINE_EVENT(svc_rqst_status, svc_process, + 574. TP_PROTO(struct svc_rqst *rqst, int status), + 575. TP_ARGS(rqst, status)); + +kernel/trace/trace_events.c:583: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 581. return; + 582. + 583. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 584. + 585. this_cpu_write(tr->trace_buffer.data->ignore_pid, + +kernel/trace/trace_events.c:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. + 579. /* Nothing to do if we are already tracing */ + 580. > if (!this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 581. return; + 582. + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +include/linux/cpufreq.h:582: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 580. */ + 581. return policy->dvfs_possible_from_any_cpu || + 582. > cpumask_test_cpu(smp_processor_id(), policy->cpus); + 583. } + 584. + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:575: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 573. ); + 574. + 575. > DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, + 576. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 577. TP_ARGS(wiphy, netdev) + +drivers/char/hpet.c:594: error: DEAD_STORE + The value written to &hpet (type hpet*) is never used. + 592. case HPET_IRQFREQ: + 593. timer = devp->hd_timer; + 594. > hpet = devp->hd_hpet; + 595. hpetp = devp->hd_hpets; + 596. break; + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +include/trace/events/sunrpc.h:577: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 575. TP_ARGS(rqst, status)); + 576. + 577. > DEFINE_EVENT(svc_rqst_status, svc_send, + 578. TP_PROTO(struct svc_rqst *rqst, int status), + 579. TP_ARGS(rqst, status)); + +kernel/sched/core.c:588: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 586. return true; /* Don't try to wake offline CPUs. */ + 587. if (tick_nohz_full_cpu(cpu)) { + 588. > if (cpu != smp_processor_id() || + 589. tick_nohz_tick_stopped()) + 590. tick_nohz_full_kick_cpu(cpu); + +net/sunrpc/auth_gss/gss_rpc_xdr.c:620: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 618. + 619. /* ctx->ctx_flags */ + 620. > p = xdr_encode_hyper(p, ctx->ctx_flags); + 621. + 622. /* ctx->locally_initiated */ + +arch/x86/events/amd/ibs.c:645: error: DEAD_STORE + The value written to &buf (type unsigned long long*) is never used. + 643. } + 644. if (ibs_caps & IBS_CAPS_OPDATA4) { + 645. > rdmsrl(MSR_AMD64_IBSOPDATA4, *buf++); + 646. size++; + 647. } + +drivers/char/hw_random/core.c:580: error: DEAD_STORE + The value written to &ret (type int) is never used. + 578. static int __init hwrng_modinit(void) + 579. { + 580. > int ret = -ENOMEM; + 581. + 582. /* kmalloc makes this safe for virt_to_page() in virtio_rng.c */ + +drivers/gpu/drm/drm_ioc32.c:602: error: UNINITIALIZED_VALUE + The value read from d.granted_count was never initialized. + 600. + 601. if (put_user(d.request_size, &argp->request_size) + 602. > || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + 604. + +drivers/gpu/drm/drm_ioc32.c:601: error: UNINITIALIZED_VALUE + The value read from d.request_size was never initialized. + 599. return err; + 600. + 601. > if (put_user(d.request_size, &argp->request_size) + 602. || put_user(d.granted_count, &argp->granted_count)) + 603. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:589: error: UNINITIALIZED_VALUE + The value read from d32.context was never initialized. + 587. return -EFAULT; + 588. + 589. > d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + +drivers/gpu/drm/drm_ioc32.c:593: error: UNINITIALIZED_VALUE + The value read from d32.flags was never initialized. + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. > d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + +drivers/gpu/drm/drm_ioc32.c:594: error: UNINITIALIZED_VALUE + The value read from d32.request_count was never initialized. + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. > d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + +drivers/gpu/drm/drm_ioc32.c:595: error: UNINITIALIZED_VALUE + The value read from d32.request_indices was never initialized. + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + 595. > d.request_indices = compat_ptr(d32.request_indices); + 596. d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + +drivers/gpu/drm/drm_ioc32.c:596: error: UNINITIALIZED_VALUE + The value read from d32.request_sizes was never initialized. + 594. d.request_count = d32.request_count; + 595. d.request_indices = compat_ptr(d32.request_indices); + 596. > d.request_sizes = compat_ptr(d32.request_sizes); + 597. err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); + 598. if (err) + +drivers/gpu/drm/drm_ioc32.c:590: error: UNINITIALIZED_VALUE + The value read from d32.send_count was never initialized. + 588. + 589. d.context = d32.context; + 590. > d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + +drivers/gpu/drm/drm_ioc32.c:591: error: UNINITIALIZED_VALUE + The value read from d32.send_indices was never initialized. + 589. d.context = d32.context; + 590. d.send_count = d32.send_count; + 591. > d.send_indices = compat_ptr(d32.send_indices); + 592. d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + +drivers/gpu/drm/drm_ioc32.c:592: error: UNINITIALIZED_VALUE + The value read from d32.send_sizes was never initialized. + 590. d.send_count = d32.send_count; + 591. d.send_indices = compat_ptr(d32.send_indices); + 592. > d.send_sizes = compat_ptr(d32.send_sizes); + 593. d.flags = d32.flags; + 594. d.request_count = d32.request_count; + +drivers/gpu/drm/i915/intel_fbc.c:582: error: DEAD_STORE + The value written to &compressed_llb (type drm_mm_node*) is never used. + 580. struct drm_i915_private *dev_priv = to_i915(crtc->base.dev); + 581. struct intel_fbc *fbc = &dev_priv->fbc; + 582. > struct drm_mm_node *uninitialized_var(compressed_llb); + 583. int size, fb_cpp, ret; + 584. + +kernel/module.c:594: error: UNINITIALIZED_VALUE + The value read from fsa.crc was never initialized. + 592. *owner = fsa.owner; + 593. if (crc) + 594. > *crc = fsa.crc; + 595. return fsa.sym; + 596. } + +kernel/module.c:592: error: UNINITIALIZED_VALUE + The value read from fsa.owner was never initialized. + 590. if (each_symbol_section(find_symbol_in_section, &fsa)) { + 591. if (owner) + 592. > *owner = fsa.owner; + 593. if (crc) + 594. *crc = fsa.crc; + +kernel/module.c:595: error: UNINITIALIZED_VALUE + The value read from fsa.sym was never initialized. + 593. if (crc) + 594. *crc = fsa.crc; + 595. > return fsa.sym; + 596. } + 597. + +kernel/time/posix-timers.c:587: error: MEMORY_LEAK + `return` is not reachable after line 587, column 3. + 585. if (copy_from_user(&event, timer_event_spec, sizeof (event))) + 586. return -EFAULT; + 587. > return do_timer_create(which_clock, &event, created_timer_id); + 588. } + 589. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:589: error: MEMORY_LEAK + `return` is not reachable after line 589, column 2. + 587. return do_timer_create(which_clock, &event, created_timer_id); + 588. } + 589. > return do_timer_create(which_clock, NULL, created_timer_id); + 590. } + 591. + +net/ipv4/tcp_minisocks.c:736: error: UNINITIALIZED_VALUE + The value read from tmp_opt.rcv_tsval was never initialized. + 734. + 735. if (tmp_opt.saw_tstamp && !after(TCP_SKB_CB(skb)->seq, tcp_rsk(req)->rcv_nxt)) + 736. > req->ts_recent = tmp_opt.rcv_tsval; + 737. + 738. if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn) { + +drivers/md/md-bitmap.c:588: error: DEAD_STORE + The value written to &err (type int) is never used. + 586. int nodes = 0; + 587. unsigned long sectors_reserved = 0; + 588. > int err = -EINVAL; + 589. struct page *sb_page; + 590. loff_t offset = bitmap->mddev->bitmap_info.offset; + +net/ipv4/igmp.c:588: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 586. if (!pmc) { + 587. rcu_read_lock(); + 588. > for_each_pmc_rcu(in_dev, pmc) { + 589. if (pmc->multiaddr == IGMP_ALL_HOSTS) + 590. continue; + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 578. ); + 579. + 580. > DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, + 581. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 582. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +kernel/time/tick-broadcast.c:583: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 581. void tick_check_oneshot_broadcast_this_cpu(void) + 582. { + 583. > if (cpumask_test_cpu(smp_processor_id(), tick_broadcast_oneshot_mask)) { + 584. struct tick_device *td = this_cpu_ptr(&tick_cpu_device); + 585. + +kernel/trace/trace_events_trigger.c:589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 587. bool unregistered = false; + 588. + 589. > list_for_each_entry_rcu(data, &file->triggers, list) { + 590. if (data->cmd_ops->trigger_type == test->cmd_ops->trigger_type) { + 591. unregistered = true; + +sound/core/pcm_native.c:609: error: DEAD_STORE + The value written to &old_interval (type snd_interval) is never used. + 607. if (trace_hw_interval_param_enabled()) { + 608. if (hw_is_interval(*v)) + 609. > old_interval = *hw_param_interval(params, *v); + 610. } + 611. if (*v != SNDRV_PCM_HW_PARAM_BUFFER_SIZE) + +sound/core/pcm_native.c:605: error: DEAD_STORE + The value written to &old_mask (type snd_mask) is never used. + 603. if (trace_hw_mask_param_enabled()) { + 604. if (hw_is_mask(*v)) + 605. > old_mask = *hw_param_mask(params, *v); + 606. } + 607. if (trace_hw_interval_param_enabled()) { + +include/net/sch_generic.h:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. for (i = 0; i < dev->num_tx_queues; i++) { + 589. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + 590. > if (rcu_access_pointer(txq->qdisc) != txq->qdisc_sleeping) + 591. return true; + 592. } + +ipc/mqueue.c:623: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 621. spin_unlock(&info->lock); + 622. out: + 623. > return retval; + 624. } + 625. + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:585: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 583. ); + 584. + 585. > DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, + 586. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 587. TP_ARGS(wiphy, netdev) + +include/linux/sched/signal.h:588: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 586. static inline struct task_struct *next_thread(const struct task_struct *p) + 587. { + 588. > return list_entry_rcu(p->thread_group.next, + 589. struct task_struct, thread_group); + 590. } + +lib/rhashtable.c:595: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 593. void *data; + 594. + 595. > tbl = rcu_dereference(ht->tbl); + 596. + 597. /* All insertions must grab the oldest table containing + +lib/rhashtable.c:609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 607. + 608. spin_unlock_bh(lock); + 609. > tbl = rcu_dereference(tbl->future_tbl); + 610. } + 611. + +lib/rhashtable.c:612: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 610. } + 611. + 612. > data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 613. new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 614. if (PTR_ERR(new_tbl) != -EEXIST) + +lib/rhashtable.c:613: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 611. + 612. data = rhashtable_lookup_one(ht, tbl, hash, key, obj); + 613. > new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data); + 614. if (PTR_ERR(new_tbl) != -EEXIST) + 615. data = ERR_CAST(new_tbl); + +drivers/hid/usbhid/hiddev.c:748: error: UNINITIALIZED_VALUE + The value read from finfo.report_id was never initialized. + 746. + 747. rinfo.report_type = finfo.report_type; + 748. > rinfo.report_id = finfo.report_id; + 749. + 750. report = hiddev_lookup_report(hid, &rinfo); + +drivers/hid/usbhid/hiddev.c:747: error: UNINITIALIZED_VALUE + The value read from finfo.report_type was never initialized. + 745. } + 746. + 747. > rinfo.report_type = finfo.report_type; + 748. rinfo.report_id = finfo.report_id; + 749. + +net/netfilter/nf_conntrack_proto.c:592: error: NULL_DEREFERENCE + pointer `pn` last assigned on line 589 could be null and is dereferenced at line 592, column 2. + 590. &nf_conntrack_l4proto_generic); + 591. + 592. > pn->users--; + 593. nf_ct_l4proto_unregister_sysctl(net, + 594. pn, + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +drivers/gpu/drm/i915/i915_trace.h:588: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 586. ); + 587. + 588. > TRACE_EVENT(i915_gem_ring_sync_to, + 589. TP_PROTO(struct drm_i915_gem_request *to, + 590. struct drm_i915_gem_request *from), + +include/linux/pagemap.h:609: error: DEAD_STORE + The value written to &c (type char) is never used. + 607. if (((unsigned long)uaddr & PAGE_MASK) == + 608. ((unsigned long)end & PAGE_MASK)) { + 609. > return __get_user(c, end); + 610. } + 611. + +kernel/trace/trace_events.c:599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 597. return; + 598. + 599. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 600. + 601. /* Set tracing if current is enabled */ + +kernel/trace/trace_events.c:596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 594. + 595. /* Nothing to do if we are not tracing */ + 596. > if (this_cpu_read(tr->trace_buffer.data->ignore_pid)) + 597. return; + 598. + +net/ipv6/ip6_fib.c:642: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 640. /* remove null_entry in the root node */ + 641. } else if (fn->fn_flags & RTN_TL_ROOT && + 642. > rcu_access_pointer(fn->leaf) == + 643. net->ipv6.ip6_null_entry) { + 644. RCU_INIT_POINTER(fn->leaf, NULL); + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:590: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 588. ); + 589. + 590. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, + 591. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 592. TP_ARGS(wiphy, netdev) + +drivers/usb/host/ohci-q.c:682: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 680. && cnt < urb_priv->length) { + 681. td_fill (ohci, info, 0, 0, urb, cnt); + 682. > cnt++; + 683. } + 684. /* maybe kickstart bulk list */ + +drivers/usb/host/ohci-q.c:706: error: DEAD_STORE + The value written to &cnt (type int) is never used. + 704. ? TD_CC | TD_DP_IN | TD_T_DATA1 + 705. : TD_CC | TD_DP_OUT | TD_T_DATA1; + 706. > td_fill (ohci, info, data, 0, urb, cnt++); + 707. /* maybe kickstart control list */ + 708. wmb (); + +net/netlabel/netlabel_domainhash.c:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. if (entry->valid) { + 602. entry->valid = 0; + 603. > if (entry == rcu_dereference(netlbl_domhsh_def_ipv4)) + 604. RCU_INIT_POINTER(netlbl_domhsh_def_ipv4, NULL); + 605. else if (entry == rcu_dereference(netlbl_domhsh_def_ipv6)) + +net/netlabel/netlabel_domainhash.c:605: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 603. if (entry == rcu_dereference(netlbl_domhsh_def_ipv4)) + 604. RCU_INIT_POINTER(netlbl_domhsh_def_ipv4, NULL); + 605. > else if (entry == rcu_dereference(netlbl_domhsh_def_ipv6)) + 606. RCU_INIT_POINTER(netlbl_domhsh_def_ipv6, NULL); + 607. else + +net/ipv4/route.c:596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 594. struct rtable *rt; + 595. + 596. > rt = rcu_dereference(fnhe->fnhe_rth_input); + 597. if (rt) { + 598. RCU_INIT_POINTER(fnhe->fnhe_rth_input, NULL); + +net/ipv4/route.c:602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 600. dst_release(&rt->dst); + 601. } + 602. > rt = rcu_dereference(fnhe->fnhe_rth_output); + 603. if (rt) { + 604. RCU_INIT_POINTER(fnhe->fnhe_rth_output, NULL); + +net/netfilter/nf_conntrack_expect.c:625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 623. seq_printf(s, "%sUSERSPACE", delim); + 624. + 625. > helper = rcu_dereference(nfct_help(expect->master)->helper); + 626. if (helper) { + 627. seq_printf(s, "%s%s", expect->flags ? " " : "", helper->name); + +drivers/dma/dmaengine.c:595: error: DEAD_STORE + The value written to &err (type int) is never used. + 593. struct dma_chan *dma_get_slave_channel(struct dma_chan *chan) + 594. { + 595. > int err = -EBUSY; + 596. + 597. /* lock against __dma_request_channel */ + +kernel/time/posix-timers.c:602: error: MEMORY_LEAK + `return` is not reachable after line 602, column 3. + 600. if (get_compat_sigevent(&event, timer_event_spec)) + 601. return -EFAULT; + 602. > return do_timer_create(which_clock, &event, created_timer_id); + 603. } + 604. return do_timer_create(which_clock, NULL, created_timer_id); + +kernel/time/posix-timers.c:604: error: MEMORY_LEAK + `return` is not reachable after line 604, column 2. + 602. return do_timer_create(which_clock, &event, created_timer_id); + 603. } + 604. > return do_timer_create(which_clock, NULL, created_timer_id); + 605. } + 606. #endif + +kernel/sched/cputime.c:624: error: DEAD_STORE + The value written to &utime (type unsigned long long) is never used. + 622. */ + 623. if (stime == 0) { + 624. > utime = rtime; + 625. goto update; + 626. } + +drivers/tty/serial/serial_core.c:604: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 602. port = uart_port_lock(state, flags); + 603. ret = uart_circ_chars_free(&state->xmit); + 604. > uart_port_unlock(port, flags); + 605. return ret; + 606. } + +net/ipv4/ip_sockglue.c:1021: error: UNINITIALIZED_VALUE + The value read from greq.gr_interface was never initialized. + 1019. memset(&mreq, 0, sizeof(mreq)); + 1020. mreq.imr_multiaddr = psin->sin_addr; + 1021. > mreq.imr_ifindex = greq.gr_interface; + 1022. + 1023. if (optname == MCAST_JOIN_GROUP) + +net/ipv4/ip_sockglue.c:1068: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1066. mreq.imr_multiaddr = psin->sin_addr; + 1067. mreq.imr_address.s_addr = 0; + 1068. > mreq.imr_ifindex = greqs.gsr_interface; + 1069. err = ip_mc_join_group(sk, &mreq); + 1070. if (err && err != -EADDRINUSE) + +net/ipv4/ip_sockglue.c:1079: error: UNINITIALIZED_VALUE + The value read from greqs.gsr_interface was never initialized. + 1077. add = 0; + 1078. } + 1079. > err = ip_mc_source(add, omode, sk, &mreqs, + 1080. greqs.gsr_interface); + 1081. break; + +net/ipv4/ip_sockglue.c:885: error: UNINITIALIZED_VALUE + The value read from mreq.imr_ifindex was never initialized. + 883. mreq.imr_ifindex = dev->ifindex; + 884. } else + 885. > dev = dev_get_by_index(sock_net(sk), mreq.imr_ifindex); + 886. + 887. + +net/ipv4/ip_sockglue.c:902: error: UNINITIALIZED_VALUE + The value read from mreq.imr_ifindex was never initialized. + 900. break; + 901. + 902. > inet->mc_index = mreq.imr_ifindex; + 903. inet->mc_addr = mreq.imr_address.s_addr; + 904. err = 0; + +net/ipv4/ip_sockglue.c:990: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_interface was never initialized. + 988. + 989. mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 990. > mreq.imr_address.s_addr = mreqs.imr_interface; + 991. mreq.imr_ifindex = 0; + 992. err = ip_mc_join_group(sk, &mreq); + +net/ipv4/ip_sockglue.c:989: error: UNINITIALIZED_VALUE + The value read from mreqs.imr_multiaddr was never initialized. + 987. struct ip_mreqn mreq; + 988. + 989. > mreq.imr_multiaddr.s_addr = mreqs.imr_multiaddr; + 990. mreq.imr_address.s_addr = mreqs.imr_interface; + 991. mreq.imr_ifindex = 0; + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:595: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 593. ); + 594. + 595. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, + 596. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 597. TP_ARGS(wiphy, netdev) + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +include/trace/events/sunrpc.h:596: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 594. { (1UL << XPT_LOCAL), "XPT_LOCAL"}) + 595. + 596. > TRACE_EVENT(svc_xprt_do_enqueue, + 597. TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst), + 598. + +lib/iov_iter.c:608: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 606. if (iter_is_iovec(i)) + 607. might_fault(); + 608. > iterate_all_kinds(i, bytes, v, ({ + 609. if (copyin((to += v.iov_len) - v.iov_len, + 610. v.iov_base, v.iov_len)) + +net/sunrpc/clnt.c:606: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 604. err = -ENOMEM; + 605. rcu_read_lock(); + 606. > xprt = xprt_get(rcu_dereference(clnt->cl_xprt)); + 607. xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 608. rcu_read_unlock(); + +net/sunrpc/clnt.c:607: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 605. rcu_read_lock(); + 606. xprt = xprt_get(rcu_dereference(clnt->cl_xprt)); + 607. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 608. rcu_read_unlock(); + 609. if (xprt == NULL || xps == NULL) { + +drivers/ata/libata-scsi.c:639: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 637. scsi_cmd[0] = ATA_16; + 638. + 639. > scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + +drivers/ata/libata-scsi.c:641: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 639. scsi_cmd[4] = args[2]; + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. > scsi_cmd[6] = args[3]; + 642. scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + +drivers/ata/libata-scsi.c:642: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 640. if (args[0] == ATA_CMD_SMART) { /* hack -- ide driver does this too */ + 641. scsi_cmd[6] = args[3]; + 642. > scsi_cmd[8] = args[1]; + 643. scsi_cmd[10] = 0x4f; + 644. scsi_cmd[12] = 0xc2; + +drivers/ata/libata-scsi.c:646: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 644. scsi_cmd[12] = 0xc2; + 645. } else { + 646. > scsi_cmd[6] = args[1]; + 647. } + 648. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:648: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 646. scsi_cmd[6] = args[1]; + 647. } + 648. > scsi_cmd[14] = args[0]; + 649. + 650. /* Good values for timeout and retries? Values below + +include/net/sch_generic.h:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. for (i = 0; i < dev->num_tx_queues; i++) { + 602. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + 603. > if (rcu_access_pointer(txq->qdisc) != &noop_qdisc) + 604. return false; + 605. } + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +include/trace/events/rcu.h:599: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 597. * data structure. + 598. */ + 599. > TRACE_EVENT(rcu_invoke_kfree_callback, + 600. + 601. TP_PROTO(const char *rcuname, struct rcu_head *rhp, unsigned long offset), + +drivers/gpu/drm/drm_dp_mst_topology.c:620: error: DEAD_STORE + The value written to &idx (type int) is never used. + 618. msg->u.conn_stat.input_port = (raw->msg[idx] >> 3) & 0x1; + 619. msg->u.conn_stat.peer_device_type = (raw->msg[idx] & 0x7); + 620. > idx++; + 621. return true; + 622. fail_len: + +lib/radix-tree.c:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. struct radix_tree_node **nodep, unsigned long *maxindex) + 602. { + 603. > struct radix_tree_node *node = rcu_dereference_raw(root->rnode); + 604. + 605. *nodep = node; + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:600: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 598. ); + 599. + 600. > DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, + 601. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 602. TP_ARGS(wiphy, netdev) + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +kernel/time/tick-broadcast.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. * delivered immediately in tick_do_broadcast() ! + 633. */ + 634. > cpumask_clear_cpu(smp_processor_id(), tick_broadcast_pending_mask); + 635. + 636. /* Take care of enforced broadcast requests */ + +net/ipv4/devinet.c:609: error: DEAD_STORE + The value written to &err (type int) is never used. + 607. struct ifaddrmsg *ifm; + 608. struct in_ifaddr *ifa, **ifap; + 609. > int err = -EINVAL; + 610. + 611. ASSERT_RTNL(); + +net/ipv4/udp.c:608: error: DEAD_STORE + The value written to &code (type int) is never used. + 606. struct udphdr *uh = (struct udphdr *)(skb->data+(iph->ihl<<2)); + 607. const int type = icmp_hdr(skb)->type; + 608. > const int code = icmp_hdr(skb)->code; + 609. struct sock *sk; + 610. int harderr; + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +include/trace/events/block.h:603: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 601. * the original sector. + 602. */ + 603. > TRACE_EVENT(block_rq_remap, + 604. + 605. TP_PROTO(struct request_queue *q, struct request *rq, dev_t dev, + +net/ipv4/ip_options.c:654: error: UNINITIALIZED_VALUE + The value read from nexthop was never initialized. + 652. if (srrptr <= srrspace) { + 653. opt->srr_is_hit = 1; + 654. > opt->nexthop = nexthop; + 655. opt->is_changed = 1; + 656. } + +crypto/drbg.c:607: error: DEAD_STORE + The value written to &ret (type int) is never used. + 605. int reseed) + 606. { + 607. > int ret = -EFAULT; + 608. int i = 0; + 609. struct drbg_string seed1, seed2, vdata; + +lib/vsprintf.c:624: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 622. rcu_read_lock(); + 623. for (i = 0; i < depth; i++, d = p) { + 624. > p = READ_ONCE(d->d_parent); + 625. array[i] = READ_ONCE(d->d_name.name); + 626. if (p == d) { + +lib/vsprintf.c:625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 623. for (i = 0; i < depth; i++, d = p) { + 624. p = READ_ONCE(d->d_parent); + 625. > array[i] = READ_ONCE(d->d_name.name); + 626. if (p == d) { + 627. if (i) + +lib/vsprintf.c:633: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 631. } + 632. } + 633. > s = array[--i]; + 634. for (n = 0; n != spec.precision; n++, buf++) { + 635. char c = *s++; + +lib/vsprintf.c:640: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 638. break; + 639. c = '/'; + 640. > s = array[--i]; + 641. } + 642. if (buf < end) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +net/wireless/trace.h:605: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 603. ); + 604. + 605. > DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, + 606. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), + 607. TP_ARGS(wiphy, netdev) + +kernel/module.c:614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 612. module_assert_mutex_or_preempt(); + 613. + 614. > list_for_each_entry_rcu(mod, &modules, list) { + 615. if (!even_unformed && mod->state == MODULE_STATE_UNFORMED) + 616. continue; + +drivers/tty/serial/serial_core.c:617: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 615. port = uart_port_lock(state, flags); + 616. ret = uart_circ_chars_pending(&state->xmit); + 617. > uart_port_unlock(port, flags); + 618. return ret; + 619. } + +kernel/sched/core.c:610: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 608. static inline bool got_nohz_idle_kick(void) + 609. { + 610. > int cpu = smp_processor_id(); + 611. + 612. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +kernel/sched/core.c:610: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 608. static inline bool got_nohz_idle_kick(void) + 609. { + 610. > int cpu = smp_processor_id(); + 611. + 612. if (!test_bit(NOHZ_BALANCE_KICK, nohz_flags(cpu))) + +drivers/gpu/drm/i915/i915_gem_request.c:651: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 649. + 650. /* Move the oldest request to the slab-cache (if not in use!) */ + 651. > req = list_first_entry_or_null(&engine->timeline->requests, + 652. typeof(*req), link); + 653. if (req && i915_gem_request_completed(req)) + +drivers/pcmcia/ds.c:614: error: DEAD_STORE + The value written to &ret (type int) is never used. + 612. cistpl_longlink_mfc_t mfc; + 613. unsigned int no_funcs, i, no_chains; + 614. > int ret = -EAGAIN; + 615. + 616. mutex_lock(&s->ops_mutex); + +drivers/pcmcia/ds.c:655: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 653. + 654. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) + 655. > no_funcs = mfc.nfn; + 656. else + 657. no_funcs = 1; + +net/ipv4/route.c:614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 612. struct fib_nh_exception *fnhe, *oldest; + 613. + 614. > oldest = rcu_dereference(hash->chain); + 615. for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe; + 616. fnhe = rcu_dereference(fnhe->fnhe_next)) { + +net/ipv4/route.c:615: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 613. + 614. oldest = rcu_dereference(hash->chain); + 615. > for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe; + 616. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 617. if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp)) + +net/ipv4/route.c:616: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 614. oldest = rcu_dereference(hash->chain); + 615. for (fnhe = rcu_dereference(oldest->fnhe_next); fnhe; + 616. > fnhe = rcu_dereference(fnhe->fnhe_next)) { + 617. if (time_before(fnhe->fnhe_stamp, oldest->fnhe_stamp)) + 618. oldest = fnhe; + +net/ipv6/mcast.c:619: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 617. + 618. rcu_read_lock(); + 619. > for_each_pmc_rcu(np, mc) { + 620. if (ipv6_addr_equal(&mc->addr, mc_addr)) + 621. break; + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +net/wireless/trace.h:610: error: DEAD_STORE + The value written to &ret (type int) is never used. + 608. ); + 609. + 610. > DECLARE_EVENT_CLASS(station_add_change, + 611. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 612. struct station_parameters *params), + +drivers/gpu/drm/i915/i915_pmu.c:635: error: NULL_DEREFERENCE + pointer `engine` last assigned on line 625 could be null and is dereferenced at line 635, column 7. + 633. * bitmask when the last listener on an event goes away. + 634. */ + 635. > if (--engine->pmu.enable_count[sample] == 0) + 636. engine->pmu.enable &= ~BIT(sample); + 637. } + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 611. ); + 612. + 613. > TRACE_EVENT(i915_gem_request_queue, + 614. TP_PROTO(struct drm_i915_gem_request *req, u32 flags), + 615. TP_ARGS(req, flags), + +net/netfilter/nf_conntrack_core.c:624: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 622. unsigned int sequence; + 623. + 624. > zone = nf_ct_zone(ct); + 625. + 626. local_bh_disable(); + +drivers/tty/pty.c:617: error: DEAD_STORE + The value written to &fd (type int) is never used. + 615. int ptm_open_peer(struct file *master, struct tty_struct *tty, int flags) + 616. { + 617. > int fd = -1; + 618. struct file *filp; + 619. int retval = -EINVAL; + +drivers/tty/pty.c:619: error: DEAD_STORE + The value written to &retval (type int) is never used. + 617. int fd = -1; + 618. struct file *filp; + 619. > int retval = -EINVAL; + 620. struct path path; + 621. + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.act_mask was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_nr was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.buf_size was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.end_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.pid was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +kernel/trace/blktrace.c:626: error: UNINITIALIZED_VALUE + The value read from cbuts.start_lba was never initialized. + 624. return -EFAULT; + 625. + 626. > buts = (struct blk_user_trace_setup) { + 627. .act_mask = cbuts.act_mask, + 628. .buf_size = cbuts.buf_size, + +include/linux/rhashtable.h:628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 626. unsigned int hash; + 627. + 628. > tbl = rht_dereference_rcu(ht->tbl, ht); + 629. restart: + 630. hash = rht_key_hashfn(ht, tbl, key, params); + +include/linux/rhashtable.h:631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 629. restart: + 630. hash = rht_key_hashfn(ht, tbl, key, params); + 631. > rht_for_each_rcu(he, tbl, hash) { + 632. if (params.obj_cmpfn ? + 633. params.obj_cmpfn(&arg, rht_obj(ht, he)) : + +include/linux/rhashtable.h:642: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 640. smp_rmb(); + 641. + 642. > tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 643. if (unlikely(tbl)) + 644. goto restart; + +include/linux/sched/signal.h:622: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 620. unsigned int limit) + 621. { + 622. > return READ_ONCE(tsk->signal->rlim[limit].rlim_cur); + 623. } + 624. + +kernel/trace/trace_events_filter.c:641: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 639. * n_preds, root and filter->preds are protect with preemption disabled. + 640. */ + 641. > root = rcu_dereference_sched(filter->root); + 642. if (!root) + 643. return 1; + +kernel/trace/trace_events_filter.c:645: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 643. return 1; + 644. + 645. > data.preds = preds = rcu_dereference_sched(filter->preds); + 646. ret = walk_pred_tree(preds, root, filter_match_preds_cb, &data); + 647. WARN_ON(ret); + +lib/radix-tree.c:632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 630. maxshift += RADIX_TREE_MAP_SHIFT; + 631. + 632. > entry = rcu_dereference_raw(root->rnode); + 633. if (!entry && (!is_idr(root) || root_tag_get(root, IDR_FREE))) + 634. goto out; + +net/sunrpc/svc_xprt.c:649: error: DEAD_STORE + The value written to &i (type int) is never used. + 647. } + 648. rqstp->rq_page_end = &rqstp->rq_pages[i]; + 649. > rqstp->rq_pages[i++] = NULL; /* this might be seen in nfs_read_actor */ + 650. + 651. /* Make arg->head point to first page and arg->pages point to rest */ + +drivers/gpu/drm/i915/intel_breadcrumbs.c:644: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 642. */ + 643. rcu_read_lock(); + 644. > request = rcu_dereference(b->first_signal); + 645. if (request) + 646. request = i915_gem_request_get_rcu(request); + +drivers/gpu/drm/i915/intel_breadcrumbs.c:671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 669. * the oldest before picking the next one. + 670. */ + 671. > if (request == rcu_access_pointer(b->first_signal)) { + 672. struct rb_node *rb = + 673. rb_next(&request->signaling.node); + +drivers/tty/serial/serial_core.c:644: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 642. if (port->ops->flush_buffer) + 643. port->ops->flush_buffer(port); + 644. > uart_port_unlock(port, flags); + 645. tty_port_tty_wakeup(&state->port); + 646. } + +net/core/sock.c:624: error: DEAD_STORE + The value written to &ret (type int) is never used. + 622. int __user *optlen, int len) + 623. { + 624. > int ret = -ENOPROTOOPT; + 625. #ifdef CONFIG_NETDEVICES + 626. struct net *net = sock_net(sk); + +net/netfilter/nfnetlink_log.c:687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 685. size += nla_total_size(sizeof(u_int32_t)); + 686. if (inst->flags & NFULNL_CFG_F_CONNTRACK) { + 687. > nfnl_ct = rcu_dereference(nfnl_ct_hook); + 688. if (nfnl_ct != NULL) { + 689. ct = nfnl_ct->get_ct(skb, &ctinfo); + +drivers/md/dm-stats.c:655: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 653. + 654. got_precise_time = false; + 655. > list_for_each_entry_rcu(s, &stats->list, list_entry) { + 656. if (s->stat_flags & STAT_PRECISE_TIMESTAMPS && !got_precise_time) { + 657. if (!end) + +net/netlabel/netlabel_kapi.c:624: error: DEAD_STORE + The value written to &iter (type netlbl_lsm_catmap*) is never used. + 622. int netlbl_catmap_walk(struct netlbl_lsm_catmap *catmap, u32 offset) + 623. { + 624. > struct netlbl_lsm_catmap *iter = catmap; + 625. u32 idx; + 626. u32 bit; + +net/ipv4/cipso_ipv4.c:632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 630. + 631. rcu_read_lock(); + 632. > list_for_each_entry_rcu(iter_doi, &cipso_v4_doi_list, list) + 633. if (refcount_read(&iter_doi->refcount) > 0) { + 634. if (doi_cnt++ < *skip_cnt) + +drivers/gpu/drm/i915/intel_guc_submission.c:631: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 629. &data->preempt_ctx_report[engine->guc_id]; + 630. + 631. > WARN_ON(wait_for_atomic(report->report_return_status == + 632. INTEL_GUC_REPORT_STATUS_COMPLETE, + 633. GUC_PREEMPT_POSTPROCESS_DELAY_MS)); + +drivers/gpu/drm/i915/intel_guc_submission.c:631: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 629. &data->preempt_ctx_report[engine->guc_id]; + 630. + 631. > WARN_ON(wait_for_atomic(report->report_return_status == + 632. INTEL_GUC_REPORT_STATUS_COMPLETE, + 633. GUC_PREEMPT_POSTPROCESS_DELAY_MS)); + +net/wireless/util.c:645: error: UNINITIALIZED_VALUE + The value read from eth.h_proto was never initialized. + 643. + 644. skb_copy_bits(skb, offset, ð, sizeof(eth)); + 645. > len = ntohs(eth.h_proto); + 646. subframe_len = sizeof(struct ethhdr) + len; + 647. padding = (4 - subframe_len) & 0x3; + +include/linux/sched/signal.h:628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 626. unsigned int limit) + 627. { + 628. > return READ_ONCE(tsk->signal->rlim[limit].rlim_max); + 629. } + 630. + +kernel/audit.c:641: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 639. + 640. rcu_read_lock(); + 641. > ac = rcu_dereference(auditd_conn); + 642. if (!ac) { + 643. rcu_read_unlock(); + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +kernel/stop_machine.c:634: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 632. + 633. /* Local CPU must be inactive and CPU hotplug in progress. */ + 634. > BUG_ON(cpu_active(raw_smp_processor_id())); + 635. msdata.num_threads = num_active_cpus() + 1; /* +1 for local */ + 636. + +net/ipv4/inet_hashtables.c:644: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 642. goto unlock; + 643. + 644. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 645. reuseport_detach_sock(sk); + 646. if (ilb) { + +include/net/sch_generic.h:630: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 628. { + 629. #ifdef CONFIG_NET_SCHED + 630. > struct qdisc_size_table *stab = rcu_dereference_bh(sch->stab); + 631. + 632. if (stab) + +drivers/gpu/drm/drm_dp_mst_topology.c:643: error: DEAD_STORE + The value written to &idx (type int) is never used. + 641. + 642. msg->u.resource_stat.available_pbn = (raw->msg[idx] << 8) | (raw->msg[idx + 1]); + 643. > idx++; + 644. return true; + 645. fail_len: + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +kernel/smp.c:630: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 628. void *info, bool wait) + 629. { + 630. > int cpu = get_cpu(); + 631. + 632. smp_call_function_many(mask, func, info, wait); + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +include/trace/events/rcu.h:632: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 630. * rcu_is_callbacks_kthread(). + 631. */ + 632. > TRACE_EVENT(rcu_batch_end, + 633. + 634. TP_PROTO(const char *rcuname, int callbacks_invoked, + +drivers/char/random.c:643: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 641. + 642. retry: + 643. > entropy_count = orig = READ_ONCE(r->entropy_count); + 644. if (nfrac < 0) { + 645. /* Debit */ + +sound/core/info.c:635: error: DEAD_STORE + The value written to &c (type int) is never used. + 633. int snd_info_get_line(struct snd_info_buffer *buffer, char *line, int len) + 634. { + 635. > int c = -1; + 636. + 637. if (snd_BUG_ON(!buffer || !buffer->buffer)) + +net/ipv4/ipconfig.c:709: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 707. } + 708. + 709. > *e++ = 255; /* End of the list */ + 710. } + 711. + +drivers/usb/core/message.c:658: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 656. break; + 657. } + 658. > return result; + 659. } + 660. EXPORT_SYMBOL_GPL(usb_get_descriptor); + +net/ipv4/igmp.c:681: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 679. + 680. /* change recs */ + 681. > for_each_pmc_rcu(in_dev, pmc) { + 682. spin_lock_bh(&pmc->lock); + 683. if (pmc->sfcount[MCAST_EXCLUDE]) { + +drivers/gpu/drm/drm_ioc32.c:652: error: UNINITIALIZED_VALUE + The value read from info.agp_version_major was never initialized. + 650. return err; + 651. + 652. > i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + +drivers/gpu/drm/drm_ioc32.c:653: error: UNINITIALIZED_VALUE + The value read from info.agp_version_minor was never initialized. + 651. + 652. i32.agp_version_major = info.agp_version_major; + 653. > i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + +drivers/gpu/drm/drm_ioc32.c:655: error: UNINITIALIZED_VALUE + The value read from info.aperture_base was never initialized. + 653. i32.agp_version_minor = info.agp_version_minor; + 654. i32.mode = info.mode; + 655. > i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + +drivers/gpu/drm/drm_ioc32.c:656: error: UNINITIALIZED_VALUE + The value read from info.aperture_size was never initialized. + 654. i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. > i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + +drivers/gpu/drm/drm_ioc32.c:660: error: UNINITIALIZED_VALUE + The value read from info.id_device was never initialized. + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. > i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + 662. return -EFAULT; + +drivers/gpu/drm/drm_ioc32.c:659: error: UNINITIALIZED_VALUE + The value read from info.id_vendor was never initialized. + 657. i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. > i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + 661. if (copy_to_user(argp, &i32, sizeof(i32))) + +drivers/gpu/drm/drm_ioc32.c:657: error: UNINITIALIZED_VALUE + The value read from info.memory_allowed was never initialized. + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + 657. > i32.memory_allowed = info.memory_allowed; + 658. i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + +drivers/gpu/drm/drm_ioc32.c:658: error: UNINITIALIZED_VALUE + The value read from info.memory_used was never initialized. + 656. i32.aperture_size = info.aperture_size; + 657. i32.memory_allowed = info.memory_allowed; + 658. > i32.memory_used = info.memory_used; + 659. i32.id_vendor = info.id_vendor; + 660. i32.id_device = info.id_device; + +drivers/gpu/drm/drm_ioc32.c:654: error: UNINITIALIZED_VALUE + The value read from info.mode was never initialized. + 652. i32.agp_version_major = info.agp_version_major; + 653. i32.agp_version_minor = info.agp_version_minor; + 654. > i32.mode = info.mode; + 655. i32.aperture_base = info.aperture_base; + 656. i32.aperture_size = info.aperture_size; + +include/linux/atomic.h:653: error: UNINITIALIZED_VALUE + The value read from dec was never initialized. + 651. c = old; + 652. } + 653. > return dec; + 654. } + 655. #endif + +net/netfilter/nf_conntrack_sip.c:662: error: UNINITIALIZED_VALUE + The value read from end was never initialized. + 660. return 0; + 661. if (endp) + 662. > *endp = end; + 663. return 1; + 664. } + +net/sunrpc/auth_gss/gss_rpc_xdr.c:683: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 681. + 682. /* ctx->ctx_flags */ + 683. > p = xdr_decode_hyper(p, &ctx->ctx_flags); + 684. + 685. /* ctx->locally_initiated */ + +security/keys/keyring.c:706: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 704. * slots 1-15). + 705. */ + 706. > ptr = READ_ONCE(keyring->keys.root); + 707. if (!ptr) + 708. goto not_this_keyring; + +security/keys/keyring.c:719: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 717. goto not_this_keyring; + 718. + 719. > ptr = READ_ONCE(shortcut->next_node); + 720. node = assoc_array_ptr_to_node(ptr); + 721. goto begin_node; + +security/keys/keyring.c:736: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 734. if (assoc_array_ptr_is_shortcut(ptr)) { + 735. shortcut = assoc_array_ptr_to_shortcut(ptr); + 736. > ptr = READ_ONCE(shortcut->next_node); + 737. BUG_ON(!assoc_array_ptr_is_node(ptr)); + 738. } + +security/keys/keyring.c:747: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 745. /* Go through the slots in a node */ + 746. for (; slot < ASSOC_ARRAY_FAN_OUT; slot++) { + 747. > ptr = READ_ONCE(node->slots[slot]); + 748. + 749. if (assoc_array_ptr_is_meta(ptr) && node->back_pointer) + +security/keys/keyring.c:785: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 783. * to ascend to the parent and continue processing there. + 784. */ + 785. > ptr = READ_ONCE(node->back_pointer); + 786. slot = node->parent_slot; + 787. + +security/keys/keyring.c:790: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 788. if (ptr && assoc_array_ptr_is_shortcut(ptr)) { + 789. shortcut = assoc_array_ptr_to_shortcut(ptr); + 790. > ptr = READ_ONCE(shortcut->back_pointer); + 791. slot = shortcut->parent_slot; + 792. } + +drivers/gpu/drm/i915/i915_gem_request.h:644: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 642. i915_gem_active_isset(const struct i915_gem_active *active) + 643. { + 644. > return rcu_access_pointer(active->request); + 645. } + 646. + +net/netlabel/netlabel_unlabeled.c:665: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 663. iface = netlbl_unlhsh_search_iface(dev->ifindex); + 664. } else + 665. > iface = rcu_dereference(netlbl_unlhsh_def); + 666. if (iface == NULL) { + 667. ret_val = -ENOENT; + +block/blk-merge.c:651: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 649. int cpu; + 650. + 651. > cpu = part_stat_lock(); + 652. part = req->part; + 653. + +block/blk-merge.c:651: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 649. int cpu; + 650. + 651. > cpu = part_stat_lock(); + 652. part = req->part; + 653. + +kernel/relay.c:685: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 683. } + 684. + 685. > curr_cpu = get_cpu(); + 686. /* + 687. * The CPU hotplug notifier ran before us and created buffers with + +kernel/relay.c:685: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 683. } + 684. + 685. > curr_cpu = get_cpu(); + 686. /* + 687. * The CPU hotplug notifier ran before us and created buffers with + +net/ipv4/route.c:662: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 660. spin_lock_bh(&fnhe_lock); + 661. + 662. > hash = rcu_dereference(nh->nh_exceptions); + 663. if (!hash) { + 664. hash = kzalloc(FNHE_HASH_SIZE * sizeof(*hash), GFP_ATOMIC); + +net/ipv4/route.c:673: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 671. + 672. depth = 0; + 673. > for (fnhe = rcu_dereference(hash->chain); fnhe; + 674. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 675. if (fnhe->fnhe_daddr == daddr) + +net/ipv4/route.c:674: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 672. depth = 0; + 673. for (fnhe = rcu_dereference(hash->chain); fnhe; + 674. > fnhe = rcu_dereference(fnhe->fnhe_next)) { + 675. if (fnhe->fnhe_daddr == daddr) + 676. break; + +net/ipv4/route.c:691: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 689. fnhe->fnhe_expires = max(1UL, expires); + 690. /* Update all cached dsts too */ + 691. > rt = rcu_dereference(fnhe->fnhe_rth_input); + 692. if (rt) + 693. fill_route_from_fnhe(rt, fnhe); + +net/ipv4/route.c:694: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 692. if (rt) + 693. fill_route_from_fnhe(rt, fnhe); + 694. > rt = rcu_dereference(fnhe->fnhe_rth_output); + 695. if (rt) + 696. fill_route_from_fnhe(rt, fnhe); + +net/ipv4/route.c:719: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 717. * applies to them. + 718. */ + 719. > rt = rcu_dereference(nh->nh_rth_input); + 720. if (rt) + 721. rt->dst.obsolete = DST_OBSOLETE_KILL; + +net/ipv4/route.c:726: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 724. struct rtable __rcu **prt; + 725. prt = per_cpu_ptr(nh->nh_pcpu_rth_output, i); + 726. > rt = rcu_dereference(*prt); + 727. if (rt) + 728. rt->dst.obsolete = DST_OBSOLETE_KILL; + +kernel/locking/mutex.c:653: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 651. { + 652. struct ww_mutex *ww = container_of(lock, struct ww_mutex, base); + 653. > struct ww_acquire_ctx *hold_ctx = READ_ONCE(ww->ctx); + 654. struct mutex_waiter *cur; + 655. + +net/sunrpc/rpcb_clnt.c:652: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 650. { + 651. struct rpc_clnt *parent = clnt->cl_parent; + 652. > struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch); + 653. + 654. while (parent != clnt) { + +net/sunrpc/rpcb_clnt.c:655: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 653. + 654. while (parent != clnt) { + 655. > if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps) + 656. break; + 657. if (clnt->cl_autobind) + +drivers/gpu/drm/i915/intel_guc_submission.c:663: error: DEAD_STORE + The value written to &count (type unsigned int) is never used. + 661. rq = port_unpack(&port[n], &count); + 662. if (rq && count == 0) { + 663. > port_set(&port[n], port_pack(rq, ++count)); + 664. + 665. flush_ggtt_writes(rq->ring->vma); + +drivers/gpu/drm/i915/intel_sdvo.c:661: error: UNINITIALIZED_VALUE + The value read from response.input0_trained was never initialized. + 659. return false; + 660. + 661. > *input_1 = response.input0_trained; + 662. *input_2 = response.input1_trained; + 663. return true; + +drivers/gpu/drm/i915/intel_sdvo.c:662: error: UNINITIALIZED_VALUE + The value read from response.input1_trained was never initialized. + 660. + 661. *input_1 = response.input0_trained; + 662. > *input_2 = response.input1_trained; + 663. return true; + 664. } + +net/ipv4/devinet.c:666: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 664. + 665. rcu_read_lock(); + 666. > hlist_for_each_entry_rcu(ifa, &inet_addr_lst[i], hash) { + 667. unsigned long age; + 668. + +net/sunrpc/xprtsock.c:746: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 744. } + 745. + 746. > return status; + 747. } + 748. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/softirq.c:655: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 653. static int ksoftirqd_should_run(unsigned int cpu) + 654. { + 655. > return local_softirq_pending(); + 656. } + 657. + +kernel/time/tick-sched.c:655: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 653. static inline bool local_timer_softirq_pending(void) + 654. { + 655. > return local_softirq_pending() & TIMER_SOFTIRQ; + 656. } + 657. + +drivers/iommu/dmar.c:661: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 659. + 660. while (dev) { + 661. > for_each_active_dev_scope(devices, cnt, index, tmp) + 662. if (dev_is_pci(tmp) && dev == to_pci_dev(tmp)) + 663. return 1; + +block/bio.c:699: error: NULL_DEREFERENCE + pointer `bio->bi_io_vec` last assigned on line 684 could be null and is dereferenced at line 699, column 3. + 697. break; + 698. case REQ_OP_WRITE_SAME: + 699. > bio->bi_io_vec[bio->bi_vcnt++] = bio_src->bi_io_vec[0]; + 700. break; + 701. default: + +net/sunrpc/svcauth_unix.c:662: error: DEAD_STORE + The value written to &cred (type svc_cred*) is never used. + 660. struct ip_map *ipm; + 661. struct group_info *gi; + 662. > struct svc_cred *cred = &rqstp->rq_cred; + 663. struct svc_xprt *xprt = rqstp->rq_xprt; + 664. struct net *net = xprt->xpt_net; + +drivers/gpu/drm/i915/intel_ringbuffer.h:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. { + 659. /* Ensure that the compiler doesn't optimize away the load. */ + 660. > return READ_ONCE(engine->status_page.page_addr[reg]); + 661. } + 662. + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:656: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 654. ); + 655. + 656. > DEFINE_EVENT(svc_xprt_event, svc_xprt_dequeue, + 657. TP_PROTO(struct svc_xprt *xprt), + 658. TP_ARGS(xprt)); + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from code was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +net/ipv4/ping.c:694: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 692. } + 693. + 694. > if (!ping_supported(family, type, code)) + 695. return -EINVAL; + 696. + +kernel/softirq.c:661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 659. { + 660. local_irq_disable(); + 661. > if (local_softirq_pending()) { + 662. /* + 663. * We can safely run softirq on inline stack, as we are not deep + +kernel/time/tick-sched.c:661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 659. ktime_t now, int cpu) + 660. { + 661. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 662. u64 basemono, next_tick, next_tmr, next_rcu, delta, expires; + 663. unsigned long seq, basejiff; + +kernel/time/tick-sched.c:661: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 659. ktime_t now, int cpu) + 660. { + 661. > struct clock_event_device *dev = __this_cpu_read(tick_cpu_device.evtdev); + 662. u64 basemono, next_tick, next_tmr, next_rcu, delta, expires; + 663. unsigned long seq, basejiff; + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/trace/events/sunrpc.h:660: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 658. TP_ARGS(xprt)); + 659. + 660. > DEFINE_EVENT(svc_xprt_event, svc_xprt_no_write_space, + 661. TP_PROTO(struct svc_xprt *xprt), + 662. TP_ARGS(xprt)); + +include/linux/netdevice.h:669: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 667. + 668. /* We only give a hint, preemption can change CPU under us */ + 669. > val |= raw_smp_processor_id(); + 670. + 671. if (table->ents[index] != val) + +kernel/exit.c:676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 674. reaper = find_new_reaper(father, reaper); + 675. list_for_each_entry(p, &father->children, sibling) { + 676. > for_each_thread(p, t) { + 677. t->real_parent = reaper; + 678. BUG_ON((!t->ptrace) != (t->parent == father)); + +drivers/base/core.c:671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 669. * never change once they are set, so they don't need special care. + 670. */ + 671. > drv = READ_ONCE(dev->driver); + 672. return drv ? drv->name : + 673. (dev->bus ? dev->bus->name : + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +include/trace/events/sunrpc.h:664: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 662. TP_ARGS(xprt)); + 663. + 664. > TRACE_EVENT(svc_wake_up, + 665. TP_PROTO(int pid), + 666. + +lib/iov_iter.c:673: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 671. if (unlikely(i->count < bytes)) + 672. return false; + 673. > iterate_all_kinds(i, bytes, v, ({ + 674. if (__copy_from_user_inatomic_nocache((to += v.iov_len) - v.iov_len, + 675. v.iov_base, v.iov_len)) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:667: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 665. ); + 666. + 667. > DEFINE_EVENT(i915_gem_request, i915_gem_request_add, + 668. TP_PROTO(struct drm_i915_gem_request *req), + 669. TP_ARGS(req) + +kernel/rcu/tree.c:688: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 686. if (rsp == NULL) + 687. return; + 688. > *flags = READ_ONCE(rsp->gp_flags); + 689. *gpnum = READ_ONCE(rsp->gpnum); + 690. *completed = READ_ONCE(rsp->completed); + +kernel/rcu/tree.c:689: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 687. return; + 688. *flags = READ_ONCE(rsp->gp_flags); + 689. > *gpnum = READ_ONCE(rsp->gpnum); + 690. *completed = READ_ONCE(rsp->completed); + 691. } + +kernel/rcu/tree.c:690: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 688. *flags = READ_ONCE(rsp->gp_flags); + 689. *gpnum = READ_ONCE(rsp->gpnum); + 690. > *completed = READ_ONCE(rsp->completed); + 691. } + 692. EXPORT_SYMBOL_GPL(rcutorture_get_gp_data); + +drivers/md/dm-stats.c:676: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 674. + 675. local_irq_disable(); + 676. > p = &s->stat_percpu[smp_processor_id()][x]; + 677. dm_stat_round(s, shared, p); + 678. local_irq_enable(); + +ipc/sem.c:717: error: DEAD_STORE + The value written to &result (type int) is never used. + 715. curr = &sma->sems[sop->sem_num]; + 716. sem_op = sop->sem_op; + 717. > result = curr->semval; + 718. + 719. if (sop->sem_flg & SEM_UNDO) { + +kernel/cpu.c:674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 672. { + 673. BUG_ON(smpboot_register_percpu_thread(&cpuhp_threads)); + 674. > kthread_unpark(this_cpu_read(cpuhp_state.thread)); + 675. } + 676. + +drivers/iommu/dmar.c:681: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 679. + 680. rcu_read_lock(); + 681. > for_each_drhd_unit(dmaru) { + 682. drhd = container_of(dmaru->hdr, + 683. struct acpi_dmar_hardware_unit, + +kernel/kexec_core.c:759: error: DEAD_STORE + The value written to &addr (type unsigned long) is never used. + 757. continue; + 758. } + 759. > addr = old_addr; + 760. page = old_page; + 761. break; + +drivers/gpu/drm/drm_ioc32.c:685: error: UNINITIALIZED_VALUE + The value read from req32.size was never initialized. + 683. return -EFAULT; + 684. + 685. > request.size = req32.size; + 686. request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:686: error: UNINITIALIZED_VALUE + The value read from req32.type was never initialized. + 684. + 685. request.size = req32.size; + 686. > request.type = req32.type; + 687. err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, + 688. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +drivers/gpu/drm/drm_ioc32.c:692: error: UNINITIALIZED_VALUE + The value read from request.handle was never initialized. + 690. return err; + 691. + 692. > req32.handle = request.handle; + 693. req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + +drivers/gpu/drm/drm_ioc32.c:693: error: UNINITIALIZED_VALUE + The value read from request.physical was never initialized. + 691. + 692. req32.handle = request.handle; + 693. > req32.physical = request.physical; + 694. if (copy_to_user(argp, &req32, sizeof(req32))) { + 695. drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +include/trace/events/rcu.h:674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 672. */ + 673. #define RCUTORTURENAME_LEN 8 + 674. > TRACE_EVENT(rcu_torture_read, + 675. + 676. TP_PROTO(const char *rcutorturename, struct rcu_head *rhp, + +net/ipv6/af_inet6.c:700: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 698. + 699. rcu_read_lock(); + 700. > final_p = fl6_update_dst(&fl6, rcu_dereference(np->opt), + 701. &final); + 702. rcu_read_unlock(); + +net/ipv4/inet_connection_sock.c:720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 718. } + 719. } + 720. > defer_accept = READ_ONCE(queue->rskq_defer_accept); + 721. if (defer_accept) + 722. max_retries = defer_accept; + +net/ipv6/udp.c:687: error: DEAD_STORE + The value written to &dif (type int) is never used. + 685. unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. > int dif = inet6_iif(skb); + 688. struct hlist_node *node; + 689. struct sk_buff *nskb; + +net/ipv6/udp.c:685: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 683. unsigned short hnum = ntohs(uh->dest); + 684. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 685. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 686. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 687. int dif = inet6_iif(skb); + +net/ipv6/udp.c:697: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 695. start_lookup: + 696. hslot = &udptable->hash2[hash2]; + 697. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 698. } + 699. + +net/ipv6/udp.c:700: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 698. } + 699. + 700. > sk_for_each_entry_offset_rcu(sk, node, &hslot->head, offset) { + 701. if (!__udp_v6_is_mcast_sock(net, sk, uh->dest, daddr, + 702. uh->source, saddr, dif, hnum)) + +drivers/gpu/drm/i915/intel_runtime_pm.c:683: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 682 could be null and is dereferenced at line 683, column 6. + 681. + 682. power_well = lookup_power_well(dev_priv, BXT_DPIO_CMN_A); + 683. > if (power_well->count > 0) + 684. bxt_ddi_phy_verify_state(dev_priv, power_well->bxt.phy); + 685. + +drivers/gpu/drm/i915/intel_runtime_pm.c:687: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 686 could be null and is dereferenced at line 687, column 6. + 685. + 686. power_well = lookup_power_well(dev_priv, BXT_DPIO_CMN_BC); + 687. > if (power_well->count > 0) + 688. bxt_ddi_phy_verify_state(dev_priv, power_well->bxt.phy); + 689. + +lib/decompress_bunzip2.c:686: error: DEAD_STORE + The value written to &i (type int) is never used. + 684. { + 685. struct bunzip_data *bd; + 686. > int i = -1; + 687. unsigned char *inbuf; + 688. + +drivers/pcmcia/ds.c:707: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 705. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 706. &mfc)) + 707. > new_funcs = mfc.nfn; + 708. else + 709. new_funcs = 1; + +net/ipv6/addrconf.c:698: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 696. cb->seq = atomic_read(&net->ipv6.dev_addr_genid) ^ + 697. net->dev_base_seq; + 698. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 699. if (idx < s_idx) + 700. goto cont; + +drivers/md/dm.c:684: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 682. *srcu_idx = srcu_read_lock(&md->io_barrier); + 683. + 684. > return srcu_dereference(md->map, &md->io_barrier); + 685. } + 686. + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +include/trace/events/sunrpc.h:680: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 678. ); + 679. + 680. > TRACE_EVENT(svc_handle_xprt, + 681. TP_PROTO(struct svc_xprt *xprt, int len), + 682. + +kernel/module.c:687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 685. preempt_disable(); + 686. + 687. > list_for_each_entry_rcu(mod, &modules, list) { + 688. if (mod->state == MODULE_STATE_UNFORMED) + 689. continue; + +lib/radix-tree.c:686: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 684. + 685. for (;;) { + 686. > struct radix_tree_node *node = rcu_dereference_raw(root->rnode); + 687. struct radix_tree_node *child; + 688. + +lib/radix-tree.c:700: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 698. if (node->count != 1) + 699. break; + 700. > child = rcu_dereference_raw(node->slots[0]); + 701. if (!child) + 702. break; + +drivers/gpu/drm/i915/intel_hdmi.c:692: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 688 could be null and is dereferenced at line 692, column 13. + 690. i915_reg_t reg = TVIDEO_DIP_CTL(intel_crtc->pipe); + 691. u32 val = I915_READ(reg); + 692. > u32 port = VIDEO_DIP_PORT(intel_dig_port->base.port); + 693. + 694. assert_hdmi_port_disabled(intel_hdmi); + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +kernel/time/tick-broadcast.c:691: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 689. */ + 690. if (bc->features & CLOCK_EVT_FEAT_HRTIMER) { + 691. > if (broadcast_needs_cpu(bc, smp_processor_id())) + 692. return; + 693. if (dev->next_event < bc->next_event) + +drivers/usb/core/message.c:704: error: UNINITIALIZED_VALUE + The value read from result was never initialized. + 702. break; + 703. } + 704. > return result; + 705. } + 706. + +kernel/cgroup/cgroup-v1.c:700: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 698 could be null and is dereferenced at line 700, column 7. + 698. for_each_subsys(ss, i) + 699. seq_printf(m, "%s\t%d\t%d\t%d\n", + 700. > ss->legacy_name, ss->root->hierarchy_id, + 701. atomic_read(&ss->root->nr_cgrps), + 702. cgroup_ssid_enabled(i)); + +kernel/cpu.c:703: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 701. WARN_ON(cpu_online(cpu)); + 702. rcu_read_lock(); + 703. > for_each_process(p) { + 704. struct task_struct *t; + 705. + +drivers/iommu/intel-iommu.c:694: error: DEAD_STORE + The value written to &agaw (type int) is never used. + 692. { + 693. unsigned long sagaw; + 694. > int agaw = -1; + 695. + 696. sagaw = cap_sagaw(iommu->cap); + +drivers/md/md.c:695: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 693. struct md_rdev *rdev; + 694. + 695. > rdev_for_each_rcu(rdev, mddev) + 696. if (rdev->desc_nr == nr) + 697. return rdev; + +net/core/net-sysfs.c:705: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 703. + 704. rcu_read_lock(); + 705. > map = rcu_dereference(queue->rps_map); + 706. if (map) + 707. for (i = 0; i < map->len; i++) + +net/ipv4/ip_fragment.c:712: error: UNINITIALIZED_VALUE + The value read from iph.tot_len was never initialized. + 710. return skb; + 711. + 712. > len = ntohs(iph.tot_len); + 713. if (skb->len < netoff + len || len < (iph.ihl * 4)) + 714. return skb; + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:728: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 726. * However, extensive testing shows that this can take longer. + 727. */ + 728. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 729. LCPLL_CD_SOURCE_FCLK_DONE, 100)) + 730. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_cdclk.c:759: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 757. I915_WRITE(LCPLL_CTL, val); + 758. + 759. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 760. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 761. DRM_ERROR("Switching back to LCPLL failed\n"); + +sound/pci/hda/hda_proc.c:699: error: DEAD_STORE + The value written to &curr (type int) is never used. + 697. struct hda_codec *codec, hda_nid_t nid) + 698. { + 699. > int i, curr = -1; + 700. u8 dev_list[AC_MAX_DEV_LIST_LEN]; + 701. int devlist_len; + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +net/wireless/trace.h:698: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 696. ); + 697. + 698. > DEFINE_EVENT(station_add_change, rdev_add_station, + 699. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 700. struct station_parameters *params), + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +kernel/time/tick-broadcast.c:716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 714. raw_spin_lock(&tick_broadcast_lock); + 715. bc = tick_broadcast_device.evtdev; + 716. > cpu = smp_processor_id(); + 717. + 718. if (state == TICK_BROADCAST_ENTER) { + +drivers/iommu/dmar.c:711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 709. struct acpi_dmar_pci_path *path; + 710. + 711. > for_each_drhd_unit(dmaru) { + 712. drhd = container_of(dmaru->hdr, + 713. struct acpi_dmar_hardware_unit, + +drivers/iommu/dmar.c:728: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 726. dev_name(&adev->dev), dmaru->reg_base_addr, + 727. scope->bus, path->device, path->function); + 728. > for_each_dev_scope(dmaru->devices, dmaru->devices_cnt, i, tmp) + 729. if (tmp == NULL) { + 730. dmaru->devices[i].bus = scope->bus; + +kernel/sched/core.c:713: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 711. if (ret) + 712. goto out; + 713. > list_for_each_entry_rcu(child, &parent->children, siblings) { + 714. parent = child; + 715. goto down; + +net/ipv4/ping.c:763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 761. + 762. rcu_read_lock(); + 763. > inet_opt = rcu_dereference(inet->inet_opt); + 764. if (inet_opt) { + 765. memcpy(&opt_copy, inet_opt, + +net/ipv4/ping.c:827: error: UNINITIALIZED_VALUE + The value read from user_icmph.code was never initialized. + 825. + 826. pfh.icmph.type = user_icmph.type; /* already checked */ + 827. > pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + 829. pfh.icmph.un.echo.id = inet->inet_sport; + +net/ipv4/ping.c:826: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 824. lock_sock(sk); + 825. + 826. > pfh.icmph.type = user_icmph.type; /* already checked */ + 827. pfh.icmph.code = user_icmph.code; /* ditto */ + 828. pfh.icmph.checksum = 0; + +net/ipv4/ping.c:848: error: UNINITIALIZED_VALUE + The value read from user_icmph.type was never initialized. + 846. kfree(ipc.opt); + 847. if (!err) { + 848. > icmp_out_count(sock_net(sk), user_icmph.type); + 849. return len; + 850. } + +net/ipv6/ndisc.c:720: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 720, column 3. + 718. __func__, target); + 719. } + 720. > ndisc_send_ns(dev, target, target, saddr, 0); + 721. } else if ((probes -= NEIGH_VAR(neigh->parms, APP_PROBES)) < 0) { + 722. neigh_app_ns(neigh); + +net/ipv6/ndisc.c:725: error: NULL_DEREFERENCE + pointer `saddr` last assigned on line 703 could be null and is dereferenced by call to `ndisc_send_ns()` at line 725, column 3. + 723. } else { + 724. addrconf_addr_solict_mult(target, &mcaddr); + 725. > ndisc_send_ns(dev, target, &mcaddr, saddr, 0); + 726. } + 727. } + +drivers/md/dm.c:705: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 703. { + 704. rcu_read_lock(); + 705. > return rcu_dereference(md->map); + 706. } + 707. + +net/sunrpc/auth_gss/gss_rpc_xdr.c:711: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 709. if (!p) + 710. return -ENOSPC; + 711. > p = xdr_encode_hyper(p, cb->initiator_addrtype); + 712. + 713. /* cb->initiator_address */ + +net/sunrpc/auth_gss/gss_rpc_xdr.c:722: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 720. if (!p) + 721. return -ENOSPC; + 722. > p = xdr_encode_hyper(p, cb->acceptor_addrtype); + 723. + 724. /* cb->acceptor_address */ + +drivers/ata/libata-scsi.c:726: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 724. scsi_cmd[1] = (3 << 1); /* Non-data */ + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. > scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + +drivers/ata/libata-scsi.c:727: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 725. scsi_cmd[2] = 0x20; /* cc but no off.line or data xfer */ + 726. scsi_cmd[4] = args[1]; + 727. > scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + +drivers/ata/libata-scsi.c:728: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 726. scsi_cmd[4] = args[1]; + 727. scsi_cmd[6] = args[2]; + 728. > scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + +drivers/ata/libata-scsi.c:729: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 727. scsi_cmd[6] = args[2]; + 728. scsi_cmd[8] = args[3]; + 729. > scsi_cmd[10] = args[4]; + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + +drivers/ata/libata-scsi.c:730: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 728. scsi_cmd[8] = args[3]; + 729. scsi_cmd[10] = args[4]; + 730. > scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. scsi_cmd[14] = args[0]; + +drivers/ata/libata-scsi.c:732: error: UNINITIALIZED_VALUE + The value read from args[_] was never initialized. + 730. scsi_cmd[12] = args[5]; + 731. scsi_cmd[13] = args[6] & 0x4f; + 732. > scsi_cmd[14] = args[0]; + 733. + 734. /* Good values for timeout and retries? Values below + +net/ipv6/ip6_flowlabel.c:711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 709. + 710. for (state->bucket = 0; state->bucket <= FL_HASH_MASK; ++state->bucket) { + 711. > for_each_fl_rcu(state->bucket, fl) { + 712. if (net_eq(fl->fl_net, net)) + 713. goto out; + +net/netlabel/netlabel_cipso_v4.c:706: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 704. static int netlbl_cipsov4_remove(struct sk_buff *skb, struct genl_info *info) + 705. { + 706. > int ret_val = -EINVAL; + 707. struct netlbl_domhsh_walk_arg cb_arg; + 708. struct netlbl_audit audit_info; + +net/sunrpc/svcsock.c:739: error: DEAD_STORE + The value written to &err (type int) is never used. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:739: error: UNINITIALIZED_VALUE + The value read from level was never initialized. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/sunrpc/svcsock.c:739: error: UNINITIALIZED_VALUE + The value read from optname was never initialized. + 737. BUG(); + 738. } + 739. > err = kernel_setsockopt(svsk->sk_sock, level, optname, + 740. (char *)&one, sizeof(one)); + 741. dprintk("svc: kernel_setsockopt returned %d\n", err); + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +net/wireless/trace.h:704: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 702. ); + 703. + 704. > DEFINE_EVENT(station_add_change, rdev_change_station, + 705. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, + 706. struct station_parameters *params), + +kernel/softirq.c:714: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 712. /* Find end, append list for that CPU. */ + 713. if (&per_cpu(tasklet_vec, cpu).head != per_cpu(tasklet_vec, cpu).tail) { + 714. > *__this_cpu_read(tasklet_vec.tail) = per_cpu(tasklet_vec, cpu).head; + 715. this_cpu_write(tasklet_vec.tail, per_cpu(tasklet_vec, cpu).tail); + 716. per_cpu(tasklet_vec, cpu).head = NULL; + +kernel/softirq.c:722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 720. + 721. if (&per_cpu(tasklet_hi_vec, cpu).head != per_cpu(tasklet_hi_vec, cpu).tail) { + 722. > *__this_cpu_read(tasklet_hi_vec.tail) = per_cpu(tasklet_hi_vec, cpu).head; + 723. __this_cpu_write(tasklet_hi_vec.tail, per_cpu(tasklet_hi_vec, cpu).tail); + 724. per_cpu(tasklet_hi_vec, cpu).head = NULL; + +net/ipv6/route.c:721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 719. match = NULL; + 720. cont = NULL; + 721. > for (rt = rr_head; rt; rt = rcu_dereference(rt->rt6_next)) { + 722. if (rt->rt6i_metric != metric) { + 723. cont = rt; + +net/ipv6/route.c:731: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 729. + 730. for (rt = leaf; rt && rt != rr_head; + 731. > rt = rcu_dereference(rt->rt6_next)) { + 732. if (rt->rt6i_metric != metric) { + 733. cont = rt; + +net/ipv6/route.c:743: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 741. return match; + 742. + 743. > for (rt = cont; rt; rt = rcu_dereference(rt->rt6_next)) + 744. match = find_match(rt, oif, strict, &mpri, match, do_rr); + 745. + +net/wireless/trace.h:710: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 708. ); + 709. + 710. > DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, + 711. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 712. TP_ARGS(wiphy, netdev, mac), + +drivers/md/md.c:718: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 716. struct md_rdev *rdev; + 717. + 718. > rdev_for_each_rcu(rdev, mddev) + 719. if (rdev->bdev->bd_dev == dev) + 720. return rdev; + +net/ipv4/ipconfig.c:742: error: DEAD_STORE + The value written to &e (type unsigned char*) is never used. + 740. *e++ = 150; + 741. + 742. > *e++ = 255; /* End of the list */ + 743. } + 744. + +drivers/gpu/drm/i915/i915_gem_gtt.c:719: error: DEAD_STORE + The value written to &ret (type int) is never used. + 717. { + 718. struct i915_page_directory_pointer *pdp; + 719. > int ret = -ENOMEM; + 720. + 721. WARN_ON(!use_4lvl(vm)); + +arch/x86/events/intel/p4.c:724: error: NULL_DEREFERENCE + pointer `bind` last assigned on line 723 could be null and is dereferenced at line 724, column 9. + 722. config = p4_general_events[hw_event]; + 723. bind = p4_config_get_bind(config); + 724. > esel = P4_OPCODE_ESEL(bind->opcode); + 725. config |= p4_config_pack_cccr(P4_CCCR_ESEL(esel)); + 726. + +drivers/md/dm-stats.c:730: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 728. __dm_stat_init_temporary_percpu_totals(shared, s, x); + 729. local_irq_disable(); + 730. > p = &s->stat_percpu[smp_processor_id()][x]; + 731. p->sectors[READ] -= shared->tmp.sectors[READ]; + 732. p->sectors[WRITE] -= shared->tmp.sectors[WRITE]; + +drivers/md/dm-stats.c:748: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 746. for (i = 0; i < s->n_histogram_entries + 1; i++) { + 747. local_irq_disable(); + 748. > p = &s->stat_percpu[smp_processor_id()][x]; + 749. p->histogram[i] -= shared->tmp.histogram[i]; + 750. local_irq_enable(); + +kernel/rcu/tree.c:725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 723. + 724. lockdep_assert_irqs_disabled(); + 725. > return READ_ONCE(*fp); + 726. } + 727. + +drivers/cpufreq/cpufreq.c:719: error: UNINITIALIZED_VALUE + The value read from new_policy.min was never initialized. + 717. } + 718. + 719. > store_one(scaling_min_freq, min); + 720. store_one(scaling_max_freq, max); + 721. + +kernel/auditsc.c:725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 723. + 724. rcu_read_lock(); + 725. > list_for_each_entry_rcu(e, &audit_filter_list[AUDIT_FILTER_TASK], list) { + 726. if (audit_filter_rules(tsk, &e->rule, NULL, NULL, + 727. &state, true)) { + +kernel/trace/trace_events_trigger.c:744: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 742. goto out; + 743. assign: + 744. > tmp = rcu_access_pointer(data->filter); + 745. + 746. rcu_assign_pointer(data->filter, filter); + +kernel/trace/trace_events_trigger.c:760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 758. data->filter_str = kstrdup(filter_str, GFP_KERNEL); + 759. if (!data->filter_str) { + 760. > free_event_filter(rcu_access_pointer(data->filter)); + 761. data->filter = NULL; + 762. ret = -ENOMEM; + +drivers/cpufreq/cpufreq.c:720: error: UNINITIALIZED_VALUE + The value read from new_policy.max was never initialized. + 718. + 719. store_one(scaling_min_freq, min); + 720. > store_one(scaling_max_freq, max); + 721. + 722. /** + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +kernel/cpu.c:724: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 722. struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state); + 723. enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE); + 724. > int err, cpu = smp_processor_id(); + 725. int ret; + 726. + +kernel/signal.c:723: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 721. { + 722. const struct cred *cred = current_cred(); + 723. > const struct cred *tcred = __task_cred(t); + 724. + 725. if (uid_eq(cred->euid, tcred->suid) || + +drivers/gpu/drm/drm_ioc32.c:731: error: UNINITIALIZED_VALUE + The value read from req32.handle was never initialized. + 729. return -EFAULT; + 730. + 731. > request.handle = req32.handle; + 732. request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + +drivers/gpu/drm/drm_ioc32.c:732: error: UNINITIALIZED_VALUE + The value read from req32.offset was never initialized. + 730. + 731. request.handle = req32.handle; + 732. > request.offset = req32.offset; + 733. return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, + 734. DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); + +net/ipv6/ip6_flowlabel.c:726: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 724. struct net *net = seq_file_net(seq); + 725. + 726. > for_each_fl_continue_rcu(fl) { + 727. if (net_eq(fl->fl_net, net)) + 728. goto out; + +net/ipv6/ip6_flowlabel.c:733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 731. try_again: + 732. if (++state->bucket <= FL_HASH_MASK) { + 733. > for_each_fl_rcu(state->bucket, fl) { + 734. if (net_eq(fl->fl_net, net)) + 735. goto out; + +net/netfilter/nf_conntrack_core.c:746: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 744. return NF_ACCEPT; + 745. + 746. > zone = nf_ct_zone(ct); + 747. local_bh_disable(); + 748. + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +include/trace/events/rcu.h:722: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 720. * is the count of remaining callbacks, and "done" is the piggybacking count. + 721. */ + 722. > TRACE_EVENT(rcu_barrier, + 723. + 724. TP_PROTO(const char *rcuname, const char *s, int cpu, int cnt, unsigned long done), + +lib/rhashtable.c:737: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 735. + 736. if (!iter->walker.tbl && !iter->end_of_table) { + 737. > iter->walker.tbl = rht_dereference_rcu(ht->tbl, ht); + 738. return -EAGAIN; + 739. } + +include/linux/rhashtable.h:784: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 782. + 783. RCU_INIT_POINTER(list->next, plist); + 784. > head = rht_dereference_bucket(head->next, tbl, hash); + 785. RCU_INIT_POINTER(list->rhead.next, head); + 786. rcu_assign_pointer(*pprev, obj); + +include/linux/rhashtable.h:801: error: DEAD_STORE + The value written to &head (type rhash_head*) is never used. + 799. goto slow_path; + 800. + 801. > head = rht_dereference_bucket(*pprev, tbl, hash); + 802. + 803. RCU_INIT_POINTER(obj->next, head); + +include/linux/rhashtable.h:781: error: DEAD_STORE + The value written to &plist (type rhlist_head*) is never used. + 779. + 780. list = container_of(obj, struct rhlist_head, rhead); + 781. > plist = container_of(head, struct rhlist_head, rhead); + 782. + 783. RCU_INIT_POINTER(list->next, plist); + +include/linux/rhashtable.h:743: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 741. rcu_read_lock(); + 742. + 743. > tbl = rht_dereference_rcu(ht->tbl, ht); + 744. hash = rht_head_hashfn(ht, tbl, obj, params); + 745. lock = rht_bucket_lock(tbl, hash); + +net/wireless/trace.h:727: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 725. ); + 726. + 727. > DECLARE_EVENT_CLASS(station_del, + 728. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 729. struct station_del_parameters *params), + +drivers/usb/host/ohci-hcd.c:791: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 789. + 790. /* find the last TD processed by the controller. */ + 791. > head = hc32_to_cpu(ohci, READ_ONCE(ed->hwHeadP)) & TD_MASK; + 792. td_start = td; + 793. td_next = list_prepare_entry(td, &ed->td_list, td_list); + +kernel/cgroup/cgroup-v1.c:749: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 747. */ + 748. rcu_read_lock(); + 749. > cgrp = rcu_dereference(*(void __rcu __force **)&kn->priv); + 750. if (!cgrp || cgroup_is_dead(cgrp)) { + 751. rcu_read_unlock(); + +arch/x86/events/amd/ibs.c:738: error: DEAD_STORE + The value written to &attr (type attribute**) is never used. + 736. if (ibs_caps & IBS_CAPS_OPCNT) { + 737. perf_ibs_op.config_mask |= IBS_OP_CNT_CTL; + 738. > *attr++ = &format_attr_cnt_ctl.attr; + 739. } + 740. perf_ibs_pmu_init(&perf_ibs_op, "ibs_op"); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:733: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 731. ); + 732. + 733. > DEFINE_EVENT(svc_deferred_event, svc_drop_deferred, + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + +kernel/rcu/tree.c:745: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 743. if (!rcu_segcblist_restempty(&rdp->cblist, RCU_NEXT_READY_TAIL)) + 744. return true; /* Yes, CPU has newly registered callbacks. */ + 745. > if (rcu_segcblist_future_gp_needed(&rdp->cblist, + 746. READ_ONCE(rsp->completed))) + 747. return true; /* Yes, CBs for future grace period. */ + +kernel/smp.c:739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 737. preempt_disable(); + 738. for_each_online_cpu(cpu) { + 739. > if (cpu == smp_processor_id()) + 740. continue; + 741. + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +include/trace/events/sunrpc.h:736: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 734. TP_PROTO(struct svc_deferred_req *dr), + 735. TP_ARGS(dr)); + 736. > DEFINE_EVENT(svc_deferred_event, svc_revisit_deferred, + 737. TP_PROTO(struct svc_deferred_req *dr), + 738. TP_ARGS(dr)); + +drivers/iommu/intel-iommu.c:761: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 759. /* No hardware attached; use lowest common denominator */ + 760. rcu_read_lock(); + 761. > for_each_active_iommu(iommu, drhd) { + 762. if (!ecap_coherent(iommu->ecap)) { + 763. domain->iommu_coherency = 0; + +drivers/pcmcia/ti113x.h:780: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 778. default: + 779. if (operation == HOOK_POWER_PRE) + 780. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + +drivers/pcmcia/ti113x.h:782: error: DEAD_STORE + The value written to &mfunc (type unsigned int) is never used. + 780. mfunc = (mfunc & ~TI122X_MFUNC3_MASK); + 781. else + 782. > mfunc = (mfunc & ~TI122X_MFUNC3_MASK) | TI122X_MFUNC3_IRQSER; + 783. } + 784. + +drivers/pcmcia/ds.c:776: error: UNINITIALIZED_VALUE + The value read from mfc.nfn was never initialized. + 774. if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + 775. &mfc)) + 776. > new_funcs = mfc.nfn; + 777. + 778. if (old_funcs != new_funcs) + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/i915_trace.h:747: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 745. #endif + 746. + 747. > TRACE_EVENT(intel_engine_notify, + 748. TP_PROTO(struct intel_engine_cs *engine, bool waiters), + 749. TP_ARGS(engine, waiters), + +drivers/gpu/drm/i915/intel_crt.c:820: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 818. out: + 819. intel_display_power_put(dev_priv, intel_encoder->power_domain); + 820. > return status; + 821. } + 822. + +drivers/video/fbdev/core/fbmem.c:795: error: DEAD_STORE + The value written to &dst (type unsigned char*) is never used. + 793. dst = buffer; + 794. fb_memcpy_fromfb(dst, src, c); + 795. > dst += c; + 796. src += c; + 797. + +sound/core/control.c:759: error: UNINITIALIZED_VALUE + The value read from list.offset was never initialized. + 757. if (copy_from_user(&list, _list, sizeof(list))) + 758. return -EFAULT; + 759. > offset = list.offset; + 760. space = list.space; + 761. + +sound/core/control.c:760: error: UNINITIALIZED_VALUE + The value read from list.space was never initialized. + 758. return -EFAULT; + 759. offset = list.offset; + 760. > space = list.space; + 761. + 762. down_read(&card->controls_rwsem); + +net/ipv4/tcp_metrics.c:762: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 760. + 761. rcu_read_lock(); + 762. > for (col = 0, tm = rcu_dereference(hb->chain); tm; + 763. tm = rcu_dereference(tm->tcpm_next), col++) { + 764. if (!net_eq(tm_net(tm), net)) + +net/ipv4/tcp_metrics.c:763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 761. rcu_read_lock(); + 762. for (col = 0, tm = rcu_dereference(hb->chain); tm; + 763. > tm = rcu_dereference(tm->tcpm_next), col++) { + 764. if (!net_eq(tm_net(tm), net)) + 765. continue; + +net/ipv6/route.c:752: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 750. int oif, int strict) + 751. { + 752. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 753. struct rt6_info *match, *rt0; + 754. bool do_rr = false; + +net/ipv6/route.c:760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 758. return net->ipv6.ip6_null_entry; + 759. + 760. > rt0 = rcu_dereference(fn->rr_ptr); + 761. if (!rt0) + 762. rt0 = leaf; + +net/ipv6/route.c:781: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 779. + 780. if (do_rr) { + 781. > struct rt6_info *next = rcu_dereference(rt0->rt6_next); + 782. + 783. /* no entries matched; do round-robin */ + +scripts/asn1_compiler.c:769: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 769, column 3. + 767. types = type_list = calloc(nr + 1, sizeof(type_list[0])); + 768. if (!type_list) { + 769. > perror(NULL); + 770. exit(1); + 771. } + +scripts/asn1_compiler.c:774: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 774, column 3. + 772. type_index = calloc(nr, sizeof(type_index[0])); + 773. if (!type_index) { + 774. > perror(NULL); + 775. exit(1); + 776. } + +net/ipv6/icmp.c:784: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 782. */ + 783. + 784. > ipprot = rcu_dereference(inet6_protos[nexthdr]); + 785. if (ipprot && ipprot->err_handler) + 786. ipprot->err_handler(skb, NULL, type, code, inner_offset, info); + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +net/wireless/trace.h:751: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 749. ); + 750. + 751. > DEFINE_EVENT(station_del, rdev_del_station, + 752. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 753. struct station_del_parameters *params), + +lib/radix-tree.c:764: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 762. if (node->count) { + 763. if (node_to_entry(node) == + 764. > rcu_dereference_raw(root->rnode)) + 765. deleted |= radix_tree_shrink(root, + 766. update_node); + +net/ipv4/icmp.c:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. raw_icmp_error(skb, protocol, info); + 768. + 769. > ipprot = rcu_dereference(inet_protos[protocol]); + 770. if (ipprot && ipprot->err_handler) + 771. ipprot->err_handler(skb, info); + +lib/rhashtable.c:760: error: DEAD_STORE + The value written to &p (type rhash_head*) is never used. + 758. struct rhlist_head *list = iter->list; + 759. struct rhashtable *ht = iter->ht; + 760. > struct rhash_head *p = iter->p; + 761. bool rhlist = ht->rhlist; + 762. + +lib/rhashtable.c:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. int skip = iter->skip; + 768. + 769. > rht_for_each_rcu(p, tbl, iter->slot) { + 770. if (rhlist) { + 771. list = container_of(p, struct rhlist_head, + +lib/rhashtable.c:777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 775. goto next; + 776. skip--; + 777. > list = rcu_dereference(list->next); + 778. } while (list); + 779. + +lib/rhashtable.c:803: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 801. smp_rmb(); + 802. + 803. > iter->walker.tbl = rht_dereference_rcu(tbl->future_tbl, ht); + 804. if (iter->walker.tbl) { + 805. iter->slot = 0; + +drivers/gpu/drm/i915/i915_vma.c:800: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 798. __i915_vma_unpin(vma); + 799. if (ret) + 800. > return ret; + 801. } + 802. GEM_BUG_ON(i915_vma_is_active(vma)); + +drivers/scsi/scsi_transport_spi.c:812: error: UNINITIALIZED_VALUE + The value read from retval was never initialized. + 810. } + 811. } + 812. > return retval; + 813. } + 814. + +net/sched/cls_api.c:769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 767. reclassify: + 768. #endif + 769. > for (; tp; tp = rcu_dereference_bh(tp->next)) { + 770. int err; + 771. + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:757: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 755. ); + 756. + 757. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, + 758. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 759. TP_ARGS(wiphy, netdev, mac) + +drivers/gpu/drm/i915/i915_gem_userptr.c:821: error: UNINITIALIZED_VALUE + The value read from handle was never initialized. + 819. return ret; + 820. + 821. > args->handle = handle; + 822. return 0; + 823. } + +kernel/auditsc.c:771: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 769. rcu_read_lock(); + 770. if (!list_empty(list)) { + 771. > list_for_each_entry_rcu(e, list, list) { + 772. if (audit_in_mask(&e->rule, ctx->major) && + 773. audit_filter_rules(tsk, &e->rule, ctx, NULL, + +kernel/printk/printk.c:813: error: DEAD_STORE + The value written to &len (type unsigned long) is never used. + 811. facility = LOG_FACILITY(u); + 812. endp++; + 813. > len -= endp - line; + 814. line = endp; + 815. } + +net/core/dev.c:766: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 764. struct hlist_head *head = dev_name_hash(net, name); + 765. + 766. > hlist_for_each_entry_rcu(dev, head, name_hlist) + 767. if (!strncmp(dev->name, name, IFNAMSIZ)) + 768. return dev; + +net/sunrpc/clnt.c:768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 766. + 767. rcu_read_lock(); + 768. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 769. rcu_read_unlock(); + 770. if (xps == NULL) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:762: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 760. ); + 761. + 762. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, + 763. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 764. TP_ARGS(wiphy, netdev, mac) + +arch/x86/events/intel/pt.c:769: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 765 could be null and is dereferenced at line 769, column 9. + 767. + 768. /* offset of the first region in this table from the beginning of buf */ + 769. > base = buf->cur->offset + buf->output_off; + 770. + 771. /* offset of the current output region within this table */ + +arch/x86/events/perf_event.h:767: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 765. u64 enable_mask) + 766. { + 767. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 768. + 769. if (hwc->extra_reg.reg) + +arch/x86/events/perf_event.h:767: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 765. u64 enable_mask) + 766. { + 767. > u64 disable_mask = __this_cpu_read(cpu_hw_events.perf_ctr_virt_mask); + 768. + 769. if (hwc->extra_reg.reg) + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +kernel/trace/trace_uprobe.c:771: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 769. int cpu; + 770. + 771. > cpu = raw_smp_processor_id(); + 772. ucb = per_cpu_ptr(uprobe_cpu_buffer, cpu); + 773. + +drivers/i2c/busses/i2c-i801.c:813: error: UNINITIALIZED_VALUE + The value read from hostc was never initialized. + 811. && read_write == I2C_SMBUS_WRITE) { + 812. /* restore saved configuration register value */ + 813. > pci_write_config_byte(priv->pci_dev, SMBHSTCFG, hostc); + 814. } + 815. return result; + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/wireless/trace.h:767: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 765. ); + 766. + 767. > DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer, + 768. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), + 769. TP_ARGS(wiphy, netdev, mac) + +net/ipv4/tcp_input.c:793: error: DEAD_STORE + The value written to &rate (type unsigned long long) is never used. + 791. + 792. if (likely(tp->srtt_us)) + 793. > do_div(rate, tp->srtt_us); + 794. + 795. /* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:770: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 768. ); + 769. + 770. > DEFINE_EVENT(i915_gem_request, i915_gem_request_retire, + 771. TP_PROTO(struct drm_i915_gem_request *req), + 772. TP_ARGS(req) + +drivers/iommu/intel-iommu.c:777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 775. + 776. rcu_read_lock(); + 777. > for_each_active_iommu(iommu, drhd) { + 778. if (iommu != skip) { + 779. if (!ecap_sc_support(iommu->ecap)) { + +net/wireless/trace.h:772: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +net/wireless/trace.h:772: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 770. ); + 771. + 772. > TRACE_EVENT(rdev_dump_station, + 773. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 774. u8 *mac), + +lib/iov_iter.c:786: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 784. return 0; + 785. } + 786. > iterate_all_kinds(i, bytes, v, + 787. copyin((p += v.iov_len) - v.iov_len, v.iov_base, v.iov_len), + 788. memcpy_from_page((p += v.bv_len) - v.bv_len, v.bv_page, + +net/ipv4/icmp.c:779: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 777. + 778. rcu_read_lock(); + 779. > ok = rcu_dereference(inet_protos[proto])->icmp_strict_tag_validation; + 780. rcu_read_unlock(); + 781. return ok; + +net/wireless/util.c:778: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 776. const struct cfg80211_bss_ies *ies; + 777. + 778. > ies = rcu_dereference(bss->ies); + 779. if (!ies) + 780. return NULL; + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +drivers/gpu/drm/i915/i915_trace.h:775: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 773. ); + 774. + 775. > TRACE_EVENT(i915_gem_request_wait_begin, + 776. TP_PROTO(struct drm_i915_gem_request *req, unsigned int flags), + 777. TP_ARGS(req, flags), + +net/core/net-sysfs.c:782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 780. + 781. rcu_read_lock(); + 782. > flow_table = rcu_dereference(queue->rps_flow_table); + 783. if (flow_table) + 784. val = (unsigned long)flow_table->mask + 1; + +drivers/ata/ahci.c:830: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 828. + 829. DPRINTK("EXIT, rc=%d, class=%u\n", rc, *class); + 830. > return rc; + 831. } + 832. + +net/ipv4/fib_semantics.c:861: error: UNINITIALIZED_VALUE + The value read from res.scope was never initialized. + 859. goto out; + 860. } + 861. > nh->nh_scope = res.scope; + 862. nh->nh_oif = FIB_RES_OIF(res); + 863. nh->nh_dev = dev = FIB_RES_DEV(res); + +kernel/time/timer.c:786: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 784. timer->entry.pprev = NULL; + 785. timer->function = func; + 786. > timer->flags = flags | raw_smp_processor_id(); + 787. lockdep_init_map(&timer->lockdep_map, name, key, 0); + 788. } + +drivers/gpu/drm/i915/intel_lrc.c:836: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 834. + 835. head = execlists->csb_head; + 836. > tail = READ_ONCE(buf[write_idx]); + 837. } + 838. GEM_TRACE("%s cs-irq head=%d [%d], tail=%d [%d]\n", + +drivers/gpu/drm/i915/intel_lrc.c:868: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 866. */ + 867. + 868. > status = READ_ONCE(buf[2 * head]); /* maybe mmio! */ + 869. GEM_TRACE("%s csb[%d]: status=0x%08x:0x%08x, active=0x%x\n", + 870. engine->name, head, + +net/wireless/sme.c:850: error: DEAD_STORE + The value written to &next (type unsigned char*) is never used. + 848. ev->cr.pmkid = next; + 849. memcpy((void *)ev->cr.pmkid, params->pmkid, WLAN_PMKID_LEN); + 850. > next += WLAN_PMKID_LEN; + 851. } + 852. ev->cr.update_erp_next_seq_num = params->update_erp_next_seq_num; + +drivers/ata/libata-scsi.c:789: error: DEAD_STORE + The value written to &rc (type int) is never used. + 787. { + 788. unsigned long val; + 789. > int rc = -EINVAL; + 790. unsigned long flags; + 791. + +drivers/input/serio/i8042.c:787: error: DEAD_STORE + The value written to &retval (type int) is never used. + 785. static int __init i8042_check_aux(void) + 786. { + 787. > int retval = -1; + 788. bool irq_registered = false; + 789. bool aux_loop_broken = false; + +tools/lib/subcmd/parse-options.c:788: error: DEAD_STORE + The value written to &o (type option const *) is never used. + 786. { + 787. int nr_opts = 0, len; + 788. > const struct option *o = opts; + 789. struct option *ordered; + 790. + +drivers/gpu/drm/drm_dp_mst_topology.c:796: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 794. * provided by the wake_up/wait_event pair are enough. + 795. */ + 796. > state = READ_ONCE(txmsg->state); + 797. return (state == DRM_DP_SIDEBAND_TX_RX || + 798. state == DRM_DP_SIDEBAND_TX_TIMEOUT); + +net/ipv4/fib_frontend.c:807: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 805. e = 0; + 806. head = &net->ipv4.fib_table_hash[h]; + 807. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 808. if (e < s_e) + 809. goto next; + +drivers/char/agp/frontend.c:795: error: UNINITIALIZED_VALUE + The value read from mode.agp_mode was never initialized. + 793. return -EFAULT; + 794. + 795. > agp_enable(agp_bridge, mode.agp_mode); + 796. return 0; + 797. } + +drivers/gpu/drm/i915/intel_breadcrumbs.c:800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 798. + 799. if (!RB_EMPTY_NODE(&request->signaling.node)) { + 800. > if (request == rcu_access_pointer(b->first_signal)) { + 801. struct rb_node *rb = + 802. rb_next(&request->signaling.node); + +kernel/trace/trace.c:794: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 792. + 793. /* If this is the temp buffer, we need to commit fully */ + 794. > if (this_cpu_read(trace_buffered_event) == event) { + 795. /* Length is in event->array[0] */ + 796. ring_buffer_write(buffer, event->array[0], &event->array[1]); + +kernel/auditsc.c:800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 798. return 0; + 799. + 800. > list_for_each_entry_rcu(e, list, list) { + 801. if (audit_in_mask(&e->rule, ctx->major) && + 802. audit_filter_rules(tsk, &e->rule, ctx, n, &state, false)) { + +drivers/iommu/intel-iommu.c:802: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 800. /* set iommu_superpage to the smallest common denominator */ + 801. rcu_read_lock(); + 802. > for_each_active_iommu(iommu, drhd) { + 803. if (iommu != skip) { + 804. mask &= cap_super_page_val(iommu->cap); + +drivers/md/md.c:814: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 810 could be null and is dereferenced at line 814, column 2. + 812. atomic_inc(&rdev->nr_pending); + 813. + 814. > bio_set_dev(bio, rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev); + 815. bio->bi_iter.bi_sector = sector; + 816. bio_add_page(bio, page, size, 0); + +net/core/fib_rules.c:816: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 814. + 815. if (rule->action == FR_ACT_GOTO && + 816. > rcu_access_pointer(rule->ctarget) == NULL) + 817. frh->flags |= FIB_RULE_UNRESOLVED; + 818. + +net/wireless/trace.h:793: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +net/wireless/trace.h:793: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 791. ); + 792. + 793. > TRACE_EVENT(rdev_return_int_station_info, + 794. TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), + 795. TP_ARGS(wiphy, ret, sinfo), + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +arch/x86/events/amd/ibs.c:807: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 805. + 806. if (!(val & IBSCTL_LVT_OFFSET_VALID)) { + 807. > pr_err(FW_BUG "cpu %d, invalid IBS interrupt offset %d (MSR%08X=0x%016llx)\n", + 808. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 809. goto out; + +arch/x86/events/amd/ibs.c:813: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 811. + 812. if (!get_eilvt(offset)) { + 813. > pr_err(FW_BUG "cpu %d, IBS interrupt offset %d not available (MSR%08X=0x%016llx)\n", + 814. smp_processor_id(), offset, MSR_AMD64_IBSCTL, val); + 815. goto out; + +arch/x86/pci/mmconfig-shared.c:804: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 802. + 803. mutex_lock(&pci_mmcfg_lock); + 804. > list_for_each_entry_rcu(cfg, &pci_mmcfg_list, list) + 805. if (cfg->segment == seg && cfg->start_bus == start && + 806. cfg->end_bus == end) { + +drivers/char/agp/frontend.c:812: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 810. return -EFAULT; + 811. + 812. > client = agp_find_client_by_pid(reserve.pid); + 813. + 814. if (reserve.seg_count == 0) { + +drivers/char/agp/frontend.c:816: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 814. if (reserve.seg_count == 0) { + 815. /* remove a client */ + 816. > client_priv = agp_find_private(reserve.pid); + 817. + 818. if (client_priv != NULL) { + +drivers/char/agp/frontend.c:826: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 824. return 0; + 825. } + 826. > return agp_remove_client(reserve.pid); + 827. } else { + 828. struct agp_segment *segment; + +drivers/char/agp/frontend.c:848: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 846. if (client == NULL) { + 847. /* Create the client and add the segment */ + 848. > client = agp_create_client(reserve.pid); + 849. + 850. if (client == NULL) { + +drivers/char/agp/frontend.c:854: error: UNINITIALIZED_VALUE + The value read from reserve.pid was never initialized. + 852. return -ENOMEM; + 853. } + 854. > client_priv = agp_find_private(reserve.pid); + 855. + 856. if (client_priv != NULL) { + +drivers/usb/mon/mon_bin.c:849: error: DEAD_STORE + The value written to &buf (type char*) is never used. + 847. } + 848. nbytes -= step_len; + 849. > buf += step_len; + 850. rp->b_read += step_len; + 851. done += step_len; + +drivers/usb/mon/mon_bin.c:848: error: DEAD_STORE + The value written to &nbytes (type unsigned long) is never used. + 846. return -EFAULT; + 847. } + 848. > nbytes -= step_len; + 849. buf += step_len; + 850. rp->b_read += step_len; + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +arch/x86/events/intel/p4.c:803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 801. static int p4_hw_config(struct perf_event *event) + 802. { + 803. > int cpu = get_cpu(); + 804. int rc = 0; + 805. u32 escr, cccr; + +drivers/gpu/drm/i915/i915_pmu.c:805: error: DEAD_STORE + The value written to &pmu (type i915_pmu*) is never used. + 803. static int i915_pmu_cpu_online(unsigned int cpu, struct hlist_node *node) + 804. { + 805. > struct i915_pmu *pmu = hlist_entry_safe(node, typeof(*pmu), node); + 806. + 807. GEM_BUG_ON(!pmu->base.event_init); + +kernel/resource.c:824: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 822. } + 823. + 824. > for (next = first; ; next = next->sibling) { + 825. /* Partial overlap? Bad, and unfixable */ + 826. if (next->start < new->start || next->end > new->end) + +kernel/resource.c:836: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 834. new->parent = parent; + 835. new->sibling = next->sibling; + 836. > new->child = first; + 837. + 838. next->sibling = NULL; + +kernel/resource.c:839: error: UNINITIALIZED_VALUE + The value read from first was never initialized. + 837. + 838. next->sibling = NULL; + 839. > for (next = first; next; next = next->sibling) + 840. next->parent = new; + 841. + +drivers/base/power/wakeup.c:814: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 812. + 813. srcuidx = srcu_read_lock(&wakeup_srcu); + 814. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) { + 815. if (ws->active) { + 816. pr_debug("active wakeup source: %s\n", ws->name); + +kernel/time/posix-cpu-timers.c:832: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 830. tsk_expires->virt_exp = expires; + 831. + 832. > tsk_expires->sched_exp = check_timers_list(++timers, firing, + 833. tsk->se.sum_exec_runtime); + 834. + +arch/x86/events/intel/pt.c:832: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 832, column 32. + 830. */ + 831. if (!pt_cap_get(PT_CAP_topa_multiple_entries) || + 832. > buf->output_off == sizes(TOPA_ENTRY(buf->cur, buf->cur_idx)->size)) { + 833. perf_aux_output_flag(&pt->handle, + 834. PERF_AUX_FLAG_TRUNCATED); + +arch/x86/events/intel/pt.c:843: error: NULL_DEREFERENCE + pointer `buf` last assigned on line 811 could be null and is dereferenced at line 843, column 52. + 841. * before the output reaches its output region's boundary. + 842. */ + 843. > if (!pt_cap_get(PT_CAP_topa_multiple_entries) && !buf->snapshot && + 844. pt_buffer_region_size(buf) - buf->output_off <= TOPA_PMI_MARGIN) { + 845. void *head = pt_buffer_region(buf); + +net/netfilter/nf_conntrack_netlink.c:817: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 815. struct hlist_nulls_node *n; + 816. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 817. > u_int8_t l3proto = nfmsg->nfgen_family; + 818. struct nf_conn *nf_ct_evict[8]; + 819. int res, i; + +net/netfilter/nf_conntrack_netlink.c:812: error: DEAD_STORE + The value written to &net (type net*) is never used. + 810. ctnetlink_dump_table(struct sk_buff *skb, struct netlink_callback *cb) + 811. { + 812. > struct net *net = sock_net(skb->sk); + 813. struct nf_conn *ct, *last; + 814. struct nf_conntrack_tuple_hash *h; + +net/wireless/trace.h:810: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 808. ); + 809. + 810. > DECLARE_EVENT_CLASS(mpath_evt, + 811. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 812. u8 *next_hop), + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +drivers/gpu/drm/i915/i915_trace.h:811: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 809. ); + 810. + 811. > DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end, + 812. TP_PROTO(struct drm_i915_gem_request *req), + 813. TP_ARGS(req) + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +kernel/cpu.c:816: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 814. + 815. BUG_ON(st->state != CPUHP_AP_OFFLINE); + 816. > rcu_report_dead(smp_processor_id()); + 817. st->state = CPUHP_AP_IDLE_DEAD; + 818. /* + +lib/radix-tree.c:832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 830. return error; + 831. shift = error; + 832. > child = rcu_dereference_raw(root->rnode); + 833. } + 834. + +kernel/signal.c:830: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 828. siginitset(&flush, sigmask(SIGCONT)); + 829. flush_sigqueue_mask(&flush, &signal->shared_pending); + 830. > for_each_thread(p, t) + 831. flush_sigqueue_mask(&flush, &t->pending); + 832. } else if (sig == SIGCONT) { + +kernel/signal.c:839: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 837. siginitset(&flush, SIG_KERNEL_STOP_MASK); + 838. flush_sigqueue_mask(&flush, &signal->shared_pending); + 839. > for_each_thread(p, t) { + 840. flush_sigqueue_mask(&flush, &t->pending); + 841. task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING); + +net/wireless/scan.c:822: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 820. u32 n_entries = 0; + 821. + 822. > ies = rcu_access_pointer(new->pub.beacon_ies); + 823. if (WARN_ON(!ies)) + 824. return false; + +net/wireless/scan.c:856: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 854. if (bss->pub.scan_width != new->pub.scan_width) + 855. continue; + 856. > if (rcu_access_pointer(bss->pub.beacon_ies)) + 857. continue; + 858. ies = rcu_access_pointer(bss->pub.ies); + +net/wireless/scan.c:858: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 856. if (rcu_access_pointer(bss->pub.beacon_ies)) + 857. continue; + 858. > ies = rcu_access_pointer(bss->pub.ies); + 859. if (!ies) + 860. continue; + +drivers/video/fbdev/core/fbmem.c:873: error: DEAD_STORE + The value written to &src (type unsigned char*) is never used. + 871. fb_memcpy_tofb(dst, src, c); + 872. dst += c; + 873. > src += c; + 874. *ppos += c; + 875. buf += c; + +net/xfrm/xfrm_state.c:826: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 824. struct xfrm_state *x; + 825. + 826. > hlist_for_each_entry_rcu(x, net->xfrm.state_byspi + h, byspi) { + 827. if (x->props.family != family || + 828. x->id.spi != spi || + +drivers/net/ethernet/intel/e1000e/ich8lan.c:891: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 889. + 890. data &= ~I82579_LPI_100_PLL_SHUT; + 891. > ret_val = e1000_write_emi_reg_locked(hw, I82579_LPI_PLL_SHUT, + 892. data); + 893. } + +net/netfilter/nfnetlink_log.c:860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 858. + 859. if ((flags & NFULNL_CFG_F_CONNTRACK) && + 860. > !rcu_access_pointer(nfnl_ct_hook)) { + 861. #ifdef CONFIG_MODULES + 862. nfnl_unlock(NFNL_SUBSYS_ULOG); + +net/netfilter/nfnetlink_log.c:865: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 863. request_module("ip_conntrack_netlink"); + 864. nfnl_lock(NFNL_SUBSYS_ULOG); + 865. > if (rcu_access_pointer(nfnl_ct_hook)) { + 866. ret = -EAGAIN; + 867. goto out_put; + +drivers/gpu/drm/i915/intel_ringbuffer.h:832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 830. * a hint and nothing more. + 831. */ + 832. > return READ_ONCE(engine->timeline->seqno); + 833. } + 834. + +kernel/kprobes.c:838: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 836. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 837. head = &kprobe_table[i]; + 838. > hlist_for_each_entry_rcu(p, head, hlist) + 839. if (!kprobe_disabled(p)) + 840. optimize_kprobe(p); + +net/ipv4/tcp_metrics.c:856: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 854. ret = -ESRCH; + 855. rcu_read_lock(); + 856. > for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 857. tm = rcu_dereference(tm->tcpm_next)) { + 858. if (addr_same(&tm->tcpm_daddr, &daddr) && + +net/ipv4/tcp_metrics.c:857: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 855. rcu_read_lock(); + 856. for (tm = rcu_dereference(tcp_metrics_hash[hash].chain); tm; + 857. > tm = rcu_dereference(tm->tcpm_next)) { + 858. if (addr_same(&tm->tcpm_daddr, &daddr) && + 859. (!src || addr_same(&tm->tcpm_saddr, &saddr)) && + +drivers/scsi/scsi_sysfs.c:826: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 824. }; + 825. + 826. > sdev_vpd_pg_attr(pg83); + 827. sdev_vpd_pg_attr(pg80); + 828. + +drivers/scsi/scsi_sysfs.c:827: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 825. + 826. sdev_vpd_pg_attr(pg83); + 827. > sdev_vpd_pg_attr(pg80); + 828. + 829. static ssize_t show_inquiry(struct file *filep, struct kobject *kobj, + +lib/rhashtable.c:835: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 833. + 834. if (p) { + 835. > if (!rhlist || !(list = rcu_dereference(list->next))) { + 836. p = rcu_dereference(p->next); + 837. list = container_of(p, struct rhlist_head, rhead); + +lib/rhashtable.c:836: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 834. if (p) { + 835. if (!rhlist || !(list = rcu_dereference(list->next))) { + 836. > p = rcu_dereference(p->next); + 837. list = container_of(p, struct rhlist_head, rhead); + 838. } + +kernel/trace/trace_uprobe.c:840: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 838. + 839. rcu_read_lock(); + 840. > list_for_each_entry_rcu(link, &tu->tp.files, list) + 841. __uprobe_trace_func(tu, 0, regs, ucb, dsize, link->file); + 842. rcu_read_unlock(); + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/wireless/trace.h:831: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 829. ); + 830. + 831. > DEFINE_EVENT(mpath_evt, rdev_add_mpath, + 832. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 833. u8 *next_hop), + +net/core/dev.c:840: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 838. struct hlist_head *head = dev_index_hash(net, ifindex); + 839. + 840. > hlist_for_each_entry_rcu(dev, head, index_hlist) + 841. if (dev->ifindex == ifindex) + 842. return dev; + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +net/wireless/trace.h:837: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 835. ); + 836. + 837. > DEFINE_EVENT(mpath_evt, rdev_change_mpath, + 838. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 839. u8 *next_hop), + +drivers/md/md.c:846: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 842 could be null and is dereferenced at line 846, column 3. + 844. + 845. if (metadata_op && rdev->meta_bdev) + 846. > bio_set_dev(bio, rdev->meta_bdev); + 847. else + 848. bio_set_dev(bio, rdev->bdev); + +drivers/md/md.c:848: error: NULL_DEREFERENCE + pointer `bio` last assigned on line 842 could be null and is dereferenced at line 848, column 3. + 846. bio_set_dev(bio, rdev->meta_bdev); + 847. else + 848. > bio_set_dev(bio, rdev->bdev); + 849. bio_set_op_attrs(bio, op, op_flags); + 850. if (metadata_op) + +net/netfilter/nf_conntrack_core.c:851: error: DEAD_STORE + The value written to &zone (type nf_conntrack_zone const *) is never used. + 849. struct nf_conn *ct; + 850. + 851. > zone = nf_ct_zone(ignored_conntrack); + 852. + 853. rcu_read_lock(); + +net/netfilter/nf_conntrack_core.c:858: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 856. hash = __hash_conntrack(net, tuple, hsize); + 857. + 858. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[hash], hnnode) { + 859. ct = nf_ct_tuplehash_to_ctrack(h); + 860. + +scripts/asn1_compiler.c:843: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `perror()` at line 843, column 3. + 841. struct element *e = calloc(1, sizeof(*e)); + 842. if (!e) { + 843. > perror(NULL); + 844. exit(1); + 845. } + +net/netfilter/nf_conntrack_sip.c:913: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 911. + 912. if (direct_rtp) { + 913. > hooks = rcu_dereference(nf_nat_sip_hooks); + 914. if (hooks && + 915. !hooks->sdp_port(skb, protoff, dataoff, dptr, datalen, + +net/netfilter/nf_conntrack_sip.c:935: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 933. IPPROTO_UDP, NULL, &rtcp_port); + 934. + 935. > hooks = rcu_dereference(nf_nat_sip_hooks); + 936. if (hooks && ct->status & IPS_NAT_MASK && !direct_rtp) + 937. ret = hooks->sdp_media(skb, protoff, dataoff, dptr, + +kernel/time/time.c:854: error: UNINITIALIZED_VALUE + The value read from kts.tv_nsec was never initialized. + 852. + 853. ts->tv_sec = kts.tv_sec; + 854. > ts->tv_nsec = kts.tv_nsec; + 855. + 856. return 0; + +kernel/time/time.c:853: error: UNINITIALIZED_VALUE + The value read from kts.tv_sec was never initialized. + 851. return -EFAULT; + 852. + 853. > ts->tv_sec = kts.tv_sec; + 854. ts->tv_nsec = kts.tv_nsec; + 855. + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/wireless/trace.h:843: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 841. ); + 842. + 843. > DEFINE_EVENT(mpath_evt, rdev_get_mpath, + 844. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, + 845. u8 *next_hop), + +net/xfrm/xfrm_state.c:851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 849. struct xfrm_state *x; + 850. + 851. > hlist_for_each_entry_rcu(x, net->xfrm.state_bysrc + h, bysrc) { + 852. if (x->props.family != family || + 853. x->id.proto != proto || + +net/ipv4/udp.c:946: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 944. + 945. rcu_read_lock(); + 946. > inet_opt = rcu_dereference(inet->inet_opt); + 947. if (inet_opt) { + 948. memcpy(&opt_copy, inet_opt, + +net/sunrpc/rpcb_clnt.c:858: error: NULL_DEREFERENCE + pointer `p` last assigned on line 858 could be null and is dereferenced at line 858, column 2. + 856. + 857. p = xdr_reserve_space(xdr, RPCB_mappingargs_sz << 2); + 858. > *p++ = cpu_to_be32(rpcb->r_prog); + 859. *p++ = cpu_to_be32(rpcb->r_vers); + 860. *p++ = cpu_to_be32(rpcb->r_prot); + +kernel/trace/trace_uprobe.c:854: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 852. + 853. rcu_read_lock(); + 854. > list_for_each_entry_rcu(link, &tu->tp.files, list) + 855. __uprobe_trace_func(tu, func, regs, ucb, dsize, link->file); + 856. rcu_read_unlock(); + +drivers/pci/pci-sysfs.c:915: error: DEAD_STORE + The value written to &off (type long long) is never used. + 913. pci_user_read_config_byte(dev, off, &val); + 914. data[off - init_off] = val; + 915. > off++; + 916. --size; + 917. } + +drivers/pci/pci-sysfs.c:916: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 914. data[off - init_off] = val; + 915. off++; + 916. > --size; + 917. } + 918. + +kernel/kprobes.c:865: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 863. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 864. head = &kprobe_table[i]; + 865. > hlist_for_each_entry_rcu(p, head, hlist) { + 866. if (!kprobe_disabled(p)) + 867. unoptimize_kprobe(p, false); + +drivers/char/agp/generic.c:867: error: DEAD_STORE + The value written to &size (type int) is never used. + 865. i = bridge->aperture_size_idx; + 866. temp = bridge->current_size; + 867. > size = page_order = num_entries = 0; + 868. + 869. if (bridge->driver->size_type != FIXED_APER_SIZE) { + +drivers/char/agp/generic.c:873: error: DEAD_STORE + The value written to &size (type int) is never used. + 871. switch (bridge->driver->size_type) { + 872. case U8_APER_SIZE: + 873. > size = A_SIZE_8(temp)->size; + 874. page_order = + 875. A_SIZE_8(temp)->page_order; + +drivers/char/agp/generic.c:880: error: DEAD_STORE + The value written to &size (type int) is never used. + 878. break; + 879. case U16_APER_SIZE: + 880. > size = A_SIZE_16(temp)->size; + 881. page_order = A_SIZE_16(temp)->page_order; + 882. num_entries = A_SIZE_16(temp)->num_entries; + +drivers/char/agp/generic.c:885: error: DEAD_STORE + The value written to &size (type int) is never used. + 883. break; + 884. case U32_APER_SIZE: + 885. > size = A_SIZE_32(temp)->size; + 886. page_order = A_SIZE_32(temp)->page_order; + 887. num_entries = A_SIZE_32(temp)->num_entries; + +drivers/char/agp/generic.c:893: error: DEAD_STORE + The value written to &size (type int) is never used. + 891. case LVL2_APER_SIZE: + 892. default: + 893. > size = page_order = num_entries = 0; + 894. break; + 895. } + +drivers/char/agp/generic.c:923: error: DEAD_STORE + The value written to &size (type int) is never used. + 921. } while (!table && (i < bridge->driver->num_aperture_sizes)); + 922. } else { + 923. > size = ((struct aper_size_info_fixed *) temp)->size; + 924. page_order = ((struct aper_size_info_fixed *) temp)->page_order; + 925. num_entries = ((struct aper_size_info_fixed *) temp)->num_entries; + +net/wireless/trace.h:849: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +net/wireless/trace.h:849: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 847. ); + 848. + 849. > TRACE_EVENT(rdev_dump_mpath, + 850. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 851. u8 *dst, u8 *next_hop), + +block/blk-mq.c:867: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 865. while (true) { + 866. start = read_seqcount_begin(&rq->gstate_seq); + 867. > gstate = READ_ONCE(rq->gstate); + 868. deadline = blk_rq_deadline(rq); + 869. if (!read_seqcount_retry(&rq->gstate_seq, start)) + +block/blk-mq.c:881: error: UNINITIALIZED_VALUE + The value read from deadline was never initialized. + 879. hctx->nr_expired++; + 880. } else if (!data->next_set || time_after(data->next, deadline)) { + 881. > data->next = deadline; + 882. data->next_set = 1; + 883. } + +block/blk-mq.c:877: error: UNINITIALIZED_VALUE + The value read from gstate was never initialized. + 875. if ((gstate & MQ_RQ_STATE_MASK) == MQ_RQ_IN_FLIGHT && + 876. time_after_eq(jiffies, deadline)) { + 877. > blk_mq_rq_update_aborted_gstate(rq, gstate); + 878. data->nr_expired++; + 879. hctx->nr_expired++; + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +drivers/gpu/drm/i915/i915_trace.h:852: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 850. ); + 851. + 852. > TRACE_EVENT_CONDITION(i915_reg_rw, + 853. TP_PROTO(bool write, i915_reg_t reg, u64 val, int len, bool trace), + 854. + +kernel/time/tick-sched.c:884: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 882. return false; + 883. + 884. > if (unlikely(local_softirq_pending() && cpu_online(cpu))) { + 885. static int ratelimit; + 886. + +kernel/time/tick-sched.c:888: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 886. + 887. if (ratelimit < 10 && + 888. > (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +kernel/time/tick-sched.c:889: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 887. if (ratelimit < 10 && + 888. (local_softirq_pending() & SOFTIRQ_STOP_IDLE_MASK)) { + 889. > pr_warn("NOHZ: local_softirq_pending %02x\n", + 890. (unsigned int) local_softirq_pending()); + 891. ratelimit++; + +net/ipv4/ip_output.c:1095: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1093. cork->length -= length; + 1094. IP_INC_STATS(sock_net(sk), IPSTATS_MIB_OUTDISCARDS); + 1095. > return err; + 1096. } + 1097. + +drivers/usb/host/ehci-hub.c:1108: error: DEAD_STORE + The value written to &temp1 (type unsigned int) is never used. + 1106. // status may be from integrated TT + 1107. if (ehci->has_hostpc) { + 1108. > temp1 = ehci_readl(ehci, hostpc_reg); + 1109. status |= ehci_port_speed(ehci, temp1); + 1110. } else + +drivers/iommu/intel-iommu.c:893: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 891. + 892. rcu_read_lock(); + 893. > for_each_active_iommu(iommu, drhd) { + 894. if (pdev && segment != drhd->segment) + 895. continue; + +drivers/iommu/intel-iommu.c:897: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 895. continue; + 896. + 897. > for_each_active_dev_scope(drhd->devices, + 898. drhd->devices_cnt, i, tmp) { + 899. if (tmp == dev) { + +kernel/sys.c:866: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 864. + 865. rcu_read_lock(); + 866. > pid = task_tgid_vnr(rcu_dereference(current->real_parent)); + 867. rcu_read_unlock(); + 868. + +drivers/usb/class/usblp.c:899: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 897. set_current_state(TASK_RUNNING); + 898. remove_wait_queue(&usblp->wwait, &waita); + 899. > return rc; + 900. } + 901. + +net/core/fib_rules.c:873: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 871. + 872. rcu_read_lock(); + 873. > list_for_each_entry_rcu(rule, &ops->rules_list, list) { + 874. if (idx < cb->args[1]) + 875. goto skip; + +net/ipv6/ip6_fib.c:1053: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1051. iter->rt6i_node = NULL; + 1052. fib6_purge_rt(iter, fn, info->nl_net); + 1053. > if (rcu_access_pointer(fn->rr_ptr) == iter) + 1054. fn->rr_ptr = NULL; + 1055. rt6_release(iter); + +net/ipv6/ip6_fib.c:1069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1067. iter->rt6i_node = NULL; + 1068. fib6_purge_rt(iter, fn, info->nl_net); + 1069. > if (rcu_access_pointer(fn->rr_ptr) == iter) + 1070. fn->rr_ptr = NULL; + 1071. rt6_release(iter); + +net/sunrpc/clnt.c:884: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 882. rpc_free_iostats(clnt->cl_metrics); + 883. clnt->cl_metrics = NULL; + 884. > xprt_put(rcu_dereference_raw(clnt->cl_xprt)); + 885. xprt_iter_destroy(&clnt->cl_xpi); + 886. rpciod_down(); + +lib/radix-tree.c:877: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 875. + 876. for (;;) { + 877. > void *entry = rcu_dereference_raw(child->slots[offset]); + 878. if (radix_tree_is_internal_node(entry) && + 879. !is_sibling_entry(child, entry)) { + +drivers/gpu/drm/drm_ioc32.c:892: error: UNINITIALIZED_VALUE + The value read from req64.fb_id was never initialized. + 890. return err; + 891. + 892. > if (put_user(req64.fb_id, &argp->fb_id)) + 893. return -EFAULT; + 894. + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +kernel/time/tick-broadcast.c:874: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 872. static void tick_broadcast_setup_oneshot(struct clock_event_device *bc) + 873. { + 874. > int cpu = smp_processor_id(); + 875. + 876. if (!bc) + +kernel/sched/topology.c:903: error: NULL_DEREFERENCE + pointer `last` last assigned on line 876 could be null and is dereferenced at line 903, column 2. + 901. last = sg; + 902. } + 903. > last->next = first; + 904. sd->groups = first; + 905. + +net/wireless/trace.h:873: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +net/wireless/trace.h:873: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 871. ); + 872. + 873. > TRACE_EVENT(rdev_get_mpp, + 874. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 875. u8 *dst, u8 *mpp), + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.pg_count was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +drivers/char/agp/frontend.c:886: error: UNINITIALIZED_VALUE + The value read from alloc.type was never initialized. + 884. return -EINVAL; + 885. + 886. > memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); + 887. + 888. if (memory == NULL) + +net/ipv6/udp.c:888: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 886. struct sock *sk; + 887. + 888. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 889. if (sk->sk_state == TCP_ESTABLISHED && + 890. INET6_MATCH(sk, net, rmt_addr, loc_addr, ports, dif, sdif)) + +kernel/workqueue.c:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. + 893. /* this can only happen on the local cpu */ + 894. > if (WARN_ON_ONCE(pool->cpu != raw_smp_processor_id())) + 895. return NULL; + 896. + +kernel/sched/sched.h:881: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 879. static inline u64 __rq_clock_broken(struct rq *rq) + 880. { + 881. > return READ_ONCE(rq->clock); + 882. } + 883. + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +drivers/gpu/drm/i915/i915_trace.h:880: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 878. ); + 879. + 880. > TRACE_EVENT(intel_gpu_freq_change, + 881. TP_PROTO(u32 freq), + 882. TP_ARGS(freq), + +kernel/time/timer.c:893: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 891. return; + 892. + 893. > jnow = READ_ONCE(jiffies); + 894. base->must_forward_clk = base->is_idle; + 895. if ((long)(jnow - base->clk) < 2) + +net/ipv6/route.c:887: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 885. if (fn->fn_flags & RTN_TL_ROOT) + 886. return NULL; + 887. > pn = rcu_dereference(fn->parent); + 888. sn = FIB6_SUBTREE(pn); + 889. if (sn && sn != fn) + +drivers/gpu/drm/i915/intel_breadcrumbs.c:888: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 886. WARN_ON(READ_ONCE(b->irq_wait)); + 887. WARN_ON(!RB_EMPTY_ROOT(&b->waiters)); + 888. > WARN_ON(rcu_access_pointer(b->first_signal)); + 889. WARN_ON(!RB_EMPTY_ROOT(&b->signals)); + 890. + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +kernel/irq/chip.c:899: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 897. trace_irq_handler_exit(irq, action, res); + 898. } else { + 899. > unsigned int cpu = smp_processor_id(); + 900. bool enabled = cpumask_test_cpu(cpu, desc->percpu_enabled); + 901. + +net/wireless/scan.c:900: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 898. spin_lock_bh(&rdev->bss_lock); + 899. + 900. > if (WARN_ON(!rcu_access_pointer(tmp->pub.ies))) { + 901. spin_unlock_bh(&rdev->bss_lock); + 902. return NULL; + +net/wireless/scan.c:909: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 907. if (found) { + 908. /* Update IEs */ + 909. > if (rcu_access_pointer(tmp->pub.proberesp_ies)) { + 910. const struct cfg80211_bss_ies *old; + 911. + +net/wireless/scan.c:912: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 910. const struct cfg80211_bss_ies *old; + 911. + 912. > old = rcu_access_pointer(found->pub.proberesp_ies); + 913. + 914. rcu_assign_pointer(found->pub.proberesp_ies, + +net/wireless/scan.c:922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 920. kfree_rcu((struct cfg80211_bss_ies *)old, + 921. rcu_head); + 922. > } else if (rcu_access_pointer(tmp->pub.beacon_ies)) { + 923. const struct cfg80211_bss_ies *old; + 924. struct cfg80211_internal_bss *bss; + +net/wireless/scan.c:940: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 938. */ + 939. + 940. > f = rcu_access_pointer(tmp->pub.beacon_ies); + 941. kfree_rcu((struct cfg80211_bss_ies *)f, + 942. rcu_head); + +net/wireless/scan.c:946: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 944. } + 945. + 946. > old = rcu_access_pointer(found->pub.beacon_ies); + 947. + 948. rcu_assign_pointer(found->pub.beacon_ies, + +net/wireless/scan.c:952: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 950. + 951. /* Override IEs if they were from a beacon before */ + 952. > if (old == rcu_access_pointer(found->pub.ies)) + 953. rcu_assign_pointer(found->pub.ies, + 954. tmp->pub.beacon_ies); + +net/wireless/scan.c:961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 959. const struct cfg80211_bss_ies *ies; + 960. + 961. > ies = rcu_access_pointer(bss->pub.beacon_ies); + 962. WARN_ON(ies != old); + 963. + +net/wireless/scan.c:1001: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 999. GFP_ATOMIC); + 1000. if (!new) { + 1001. > ies = (void *)rcu_dereference(tmp->pub.beacon_ies); + 1002. if (ies) + 1003. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:1004: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1002. if (ies) + 1003. kfree_rcu(ies, rcu_head); + 1004. > ies = (void *)rcu_dereference(tmp->pub.proberesp_ies); + 1005. if (ies) + 1006. kfree_rcu(ies, rcu_head); + +net/wireless/scan.c:1013: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1011. INIT_LIST_HEAD(&new->hidden_list); + 1012. + 1013. > if (rcu_access_pointer(tmp->pub.proberesp_ies)) { + 1014. hidden = rb_find_bss(rdev, tmp, BSS_CMP_HIDE_ZLEN); + 1015. if (!hidden) + +net/sunrpc/cache.c:894: error: DEAD_STORE + The value written to &ret (type long) is never used. + 892. struct page *page; + 893. char *kaddr; + 894. > ssize_t ret = -ENOMEM; + 895. + 896. if (count >= PAGE_SIZE) + +kernel/cgroup/cgroup-v1.c:897: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 895 could be null and is dereferenced at line 897, column 25. + 895. for_each_subsys(ss, ssid) + 896. if (root->subsys_mask & (1 << ssid)) + 897. > seq_show_option(seq, ss->legacy_name, NULL); + 898. if (root->flags & CGRP_ROOT_NOPREFIX) + 899. seq_puts(seq, ",noprefix"); + +net/netfilter/nf_conntrack_core.c:899: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 897. struct nf_conn *tmp; + 898. + 899. > hlist_nulls_for_each_entry_rcu(h, n, head, hnnode) { + 900. tmp = nf_ct_tuplehash_to_ctrack(h); + 901. + +net/core/fib_rules.c:911: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 909. + 910. rcu_read_lock(); + 911. > list_for_each_entry_rcu(ops, &net->rules_ops, list) { + 912. if (idx < cb->args[0] || !try_module_get(ops->owner)) + 913. goto skip; + +drivers/net/ethernet/intel/e1000e/82571.c:919: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 917. } else { + 918. data &= ~IGP02E1000_PM_D0_LPLU; + 919. > ret_val = e1e_wphy(hw, IGP02E1000_PHY_POWER_MGMT, data); + 920. /* LPLU and SmartSpeed are mutually exclusive. LPLU is used + 921. * during Dx states where the power conservation is most + +kernel/trace/ring_buffer.c:907: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 905. val &= ~RB_FLAG_MASK; + 906. + 907. > ret = cmpxchg((unsigned long *)&list->next, + 908. val | old_flag, val | new_flag); + 909. + +net/wireless/trace.h:894: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +net/wireless/trace.h:894: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 892. ); + 893. + 894. > TRACE_EVENT(rdev_dump_mpp, + 895. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx, + 896. u8 *dst, u8 *mpp), + +drivers/gpu/drm/i915/intel_breadcrumbs.c:909: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 907. } + 908. + 909. > if (rcu_access_pointer(b->first_signal)) { + 910. wake_up_process(b->signaler); + 911. busy = true; + +drivers/hid/hid-ntrig.c:956: error: DEAD_STORE + The value written to &ret (type int) is never used. + 954. ntrig_report_version(hdev); + 955. + 956. > ret = sysfs_create_group(&hdev->dev.kobj, + 957. &ntrig_attribute_group); + 958. + +net/ipv4/igmp.c:910: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 908. + 909. rcu_read_lock(); + 910. > for_each_pmc_rcu(in_dev, im) { + 911. if (im->multiaddr == group) { + 912. igmp_stop_timer(im); + +net/ipv6/udp.c:926: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 924. skb->sk = sk; + 925. skb->destructor = sock_efree; + 926. > dst = READ_ONCE(sk->sk_rx_dst); + 927. + 928. if (dst) + +net/ipv4/tcp_output.c:933: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 931. + 932. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 933. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 934. if (nval != oval) + 935. continue; + +net/ipv4/tcp_output.c:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. goto out; + 924. + 925. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 926. struct tsq_tasklet *tsq; + 927. bool empty; + +drivers/gpu/drm/drm_plane.c:915: error: DEAD_STORE + The value written to &ret (type int) is never used. + 913. u32 target_vblank = page_flip->sequence; + 914. struct drm_modeset_acquire_ctx ctx; + 915. > int ret = -EINVAL; + 916. + 917. if (!drm_core_check_feature(dev, DRIVER_MODESET)) + +net/ipv4/tcp_ipv4.c:920: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 918. + 919. /* caller either holds rcu_read_lock() or socket lock */ + 920. > md5sig = rcu_dereference_check(tp->md5sig_info, + 921. lockdep_sock_is_held(sk)); + 922. if (!md5sig) + +net/ipv4/tcp_ipv4.c:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. return NULL; + 924. + 925. > hlist_for_each_entry_rcu(key, &md5sig->head, node) { + 926. if (key->family != family) + 927. continue; + +net/sunrpc/rpcb_clnt.c:920: error: NULL_DEREFERENCE + pointer `p` last assigned on line 919 could be null and is dereferenced by call to `xdr_encode_opaque()` at line 920, column 2. + 918. len = maxstrlen; + 919. p = xdr_reserve_space(xdr, 4 + len); + 920. > xdr_encode_opaque(p, string, len); + 921. } + 922. + +net/netfilter/x_tables.c:929: error: UNINITIALIZED_VALUE + The value read from compat_tmp.num_counters was never initialized. + 927. + 928. memcpy(info->name, compat_tmp.name, sizeof(info->name) - 1); + 929. > info->num_counters = compat_tmp.num_counters; + 930. user += sizeof(compat_tmp); + 931. } else + +include/net/sock.h:913: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 911. static inline void sk_incoming_cpu_update(struct sock *sk) + 912. { + 913. > int cpu = raw_smp_processor_id(); + 914. + 915. if (unlikely(sk->sk_incoming_cpu != cpu)) + +include/net/sock.h:913: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 911. static inline void sk_incoming_cpu_update(struct sock *sk) + 912. { + 913. > int cpu = raw_smp_processor_id(); + 914. + 915. if (unlikely(sk->sk_incoming_cpu != cpu)) + +kernel/time/posix-cpu-timers.c:947: error: DEAD_STORE + The value written to &timers (type list_head*) is never used. + 945. prof_expires = check_timers_list(timers, firing, ptime); + 946. virt_expires = check_timers_list(++timers, firing, utime); + 947. > sched_expires = check_timers_list(++timers, firing, sum_sched_runtime); + 948. + 949. /* + +drivers/usb/early/ehci-dbgp.c:954: error: DEAD_STORE + The value written to &ret (type int) is never used. + 952. } + 953. if (chunk > 0) { + 954. > ret = dbgp_bulk_write(USB_DEBUG_DEVNUM, + 955. dbgp_endpoint_out, buf, chunk); + 956. } + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +kernel/time/tick-sched.c:917: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 915. { + 916. ktime_t now, expires; + 917. > int cpu = smp_processor_id(); + 918. + 919. now = tick_nohz_start_idle(ts); + +net/core/ethtool.c:926: error: UNINITIALIZED_VALUE + The value read from info.sset_mask was never initialized. + 924. + 925. /* store copy of mask, because we zero struct later on */ + 926. > sset_mask = info.sset_mask; + 927. if (!sset_mask) + 928. return 0; + +drivers/char/agp/frontend.c:924: error: UNINITIALIZED_VALUE + The value read from bind_info.key was never initialized. + 922. return -EFAULT; + 923. + 924. > memory = agp_find_mem_by_key(bind_info.key); + 925. + 926. if (memory == NULL) + +drivers/char/agp/frontend.c:929: error: UNINITIALIZED_VALUE + The value read from bind_info.pg_start was never initialized. + 927. return -EINVAL; + 928. + 929. > return agp_bind_memory(memory, bind_info.pg_start); + 930. } + 931. + +net/ipv6/route.c:928: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 926. fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); + 927. restart: + 928. > rt = rcu_dereference(fn->leaf); + 929. if (!rt) { + 930. rt = net->ipv6.ip6_null_entry; + +kernel/cgroup/cgroup-v1.c:922: error: DEAD_STORE + The value written to &mask (type unsigned short) is never used. + 920. char *token, *o = data; + 921. bool all_ss = false, one_ss = false; + 922. > u16 mask = U16_MAX; + 923. struct cgroup_subsys *ss; + 924. int nr_opts = 0; + +net/wireless/trace.h:918: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +net/wireless/trace.h:918: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 916. ); + 917. + 918. > TRACE_EVENT(rdev_return_int_mpath_info, + 919. TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), + 920. TP_ARGS(wiphy, ret, pinfo), + +include/net/sock.h:925: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 923. + 924. rcu_read_lock(); + 925. > sock_flow_table = rcu_dereference(rps_sock_flow_table); + 926. rps_record_sock_flow(sock_flow_table, hash); + 927. rcu_read_unlock(); + +drivers/gpu/drm/i915/intel_ringbuffer.h:923: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 921. static inline bool intel_engine_has_waiter(const struct intel_engine_cs *engine) + 922. { + 923. > return READ_ONCE(engine->breadcrumbs.irq_wait); + 924. } + 925. + +kernel/time/timer.c:934: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 932. * and spin_lock(). + 933. */ + 934. > tf = READ_ONCE(timer->flags); + 935. + 936. if (!(tf & TIMER_MIGRATING)) { + +net/ipv4/igmp.c:1008: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1006. */ + 1007. rcu_read_lock(); + 1008. > for_each_pmc_rcu(in_dev, im) { + 1009. int changed; + 1010. + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:922: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 920. ) + 921. + 922. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create, + 923. TP_PROTO(struct i915_address_space *vm), + 924. TP_ARGS(vm) + +net/ipv4/ipconfig.c:982: error: DEAD_STORE + The value written to &h (type iphdr*) is never used. + 980. + 981. b = (struct bootp_pkt *)skb_network_header(skb); + 982. > h = &b->iph; + 983. + 984. /* One reply at a time, please. */ + +net/sunrpc/rpcb_clnt.c:936: error: NULL_DEREFERENCE + pointer `p` last assigned on line 936 could be null and is dereferenced at line 936, column 2. + 934. + 935. p = xdr_reserve_space(xdr, (RPCB_program_sz + RPCB_version_sz) << 2); + 936. > *p++ = cpu_to_be32(rpcb->r_prog); + 937. *p = cpu_to_be32(rpcb->r_vers); + 938. + +drivers/pci/pci-sysfs.c:976: error: DEAD_STORE + The value written to &off (type long long) is never used. + 974. if (size) { + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. > off++; + 977. --size; + 978. } + +drivers/pci/pci-sysfs.c:977: error: DEAD_STORE + The value written to &size (type unsigned int) is never used. + 975. pci_user_write_config_byte(dev, off, data[off - init_off]); + 976. off++; + 977. > --size; + 978. } + 979. + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +arch/x86/events/amd/ibs.c:936: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 934. return; + 935. failed: + 936. > pr_warn("perf: IBS APIC setup failed on cpu #%d\n", + 937. smp_processor_id()); + 938. } + +drivers/i2c/i2c-core-base.c:949: error: DEAD_STORE + The value written to &blank (type char*) is never used. + 947. + 948. /* Parse remaining parameters, reject extra parameters */ + 949. > res = sscanf(++blank, "%hi%c", &info.addr, &end); + 950. if (res < 1) { + 951. dev_err(dev, "%s: Can't parse I2C address\n", "new_device"); + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/gpu/drm/i915/i915_trace.h:927: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 925. ); + 926. + 927. > DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release, + 928. TP_PROTO(struct i915_address_space *vm), + 929. TP_ARGS(vm) + +drivers/iommu/iommu.c:945: error: UNINITIALIZED_VALUE + The value read from data.group was never initialized. + 943. */ + 944. if (pci_for_each_dma_alias(pdev, get_pci_alias_or_group, &data)) + 945. > return data.group; + 946. + 947. pdev = data.pdev; + +drivers/iommu/iommu.c:947: error: UNINITIALIZED_VALUE + The value read from data.pdev was never initialized. + 945. return data.group; + 946. + 947. > pdev = data.pdev; + 948. + 949. /* + +drivers/usb/class/usblp.c:951: error: UNINITIALIZED_VALUE + The value read from rc was never initialized. + 949. set_current_state(TASK_RUNNING); + 950. remove_wait_queue(&usblp->rwait, &waita); + 951. > return rc; + 952. } + 953. + +net/xfrm/xfrm_state.c:953: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 951. rcu_read_lock(); + 952. h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, encap_family); + 953. > hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h, bydst) { + 954. if (x->props.family == encap_family && + 955. x->props.reqid == tmpl->reqid && + +net/xfrm/xfrm_state.c:969: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 967. + 968. h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, encap_family); + 969. > hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h_wildcard, bydst) { + 970. if (x->props.family == encap_family && + 971. x->props.reqid == tmpl->reqid && + +drivers/char/agp/frontend.c:941: error: UNINITIALIZED_VALUE + The value read from unbind.key was never initialized. + 939. return -EFAULT; + 940. + 941. > memory = agp_find_mem_by_key(unbind.key); + 942. + 943. if (memory == NULL) + +drivers/gpu/drm/i915/intel_dpio_phy.c:943: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 940 could be null and is dereferenced at line 943, column 6. + 941. struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + 942. + 943. > if (dport->release_cl2_override) { + 944. chv_phy_powergate_ch(dev_priv, DPIO_PHY0, DPIO_CH1, false); + 945. dport->release_cl2_override = false; + +drivers/net/ethernet/broadcom/tg3.c:955: error: DEAD_STORE + The value written to &apedata (type unsigned int) is never used. + 953. APE_HOST_SEG_LEN_MAGIC); + 954. apedata = tg3_ape_read32(tp, TG3_APE_HOST_INIT_COUNT); + 955. > tg3_ape_write32(tp, TG3_APE_HOST_INIT_COUNT, ++apedata); + 956. tg3_ape_write32(tp, TG3_APE_HOST_DRIVER_ID, + 957. APE_HOST_DRIVER_ID_MAGIC(TG3_MAJ_NUM, TG3_MIN_NUM)); + +net/ipv4/fib_trie.c:948: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 946. do { + 947. pn = n; + 948. > n = get_child_rcu(n, index); + 949. + 950. if (!n) + +net/core/dev.c:951: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 949. struct net_device *dev; + 950. + 951. > for_each_netdev_rcu(net, dev) + 952. if (dev->type == type && + 953. !memcmp(dev->dev_addr, ha, dev->addr_len)) + +net/ipv4/devinet.c:958: error: DEAD_STORE + The value written to &ret (type int) is never used. + 956. struct net_device *dev; + 957. char *colon; + 958. > int ret = -EFAULT; + 959. int tryaddrmatch = 0; + 960. + +net/ipv4/tcp_ipv4.c:960: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 958. + 959. /* caller either holds rcu_read_lock() or socket lock */ + 960. > md5sig = rcu_dereference_check(tp->md5sig_info, + 961. lockdep_sock_is_held(sk)); + 962. if (!md5sig) + +net/ipv4/tcp_ipv4.c:968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 966. size = sizeof(struct in6_addr); + 967. #endif + 968. > hlist_for_each_entry_rcu(key, &md5sig->head, node) { + 969. if (key->family != family) + 970. continue; + +drivers/usb/core/hub.c:959: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 958 could be null and is dereferenced at line 959, column 9. + 957. return -EINVAL; + 958. hub = usb_hub_to_struct_hub(udev->parent); + 959. > intf = to_usb_interface(hub->intfdev); + 960. + 961. usb_autopm_get_interface(intf); + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +kernel/kexec_core.c:960: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 958. * may stop each other. To exclude them, we use panic_cpu here too. + 959. */ + 960. > this_cpu = raw_smp_processor_id(); + 961. old_cpu = atomic_cmpxchg(&panic_cpu, PANIC_CPU_INVALID, this_cpu); + 962. if (old_cpu == PANIC_CPU_INVALID) { + +net/netlabel/netlabel_domainhash.c:965: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 963. rcu_read_lock(); + 964. for (iter_bkt = *skip_bkt; + 965. > iter_bkt < rcu_dereference(netlbl_domhsh)->size; + 966. iter_bkt++, chain_cnt = 0) { + 967. iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + +net/netlabel/netlabel_domainhash.c:967: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 965. iter_bkt < rcu_dereference(netlbl_domhsh)->size; + 966. iter_bkt++, chain_cnt = 0) { + 967. > iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + 968. list_for_each_entry_rcu(iter_entry, iter_list, list) + 969. if (iter_entry->valid) { + +net/netlabel/netlabel_domainhash.c:968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 966. iter_bkt++, chain_cnt = 0) { + 967. iter_list = &rcu_dereference(netlbl_domhsh)->tbl[iter_bkt]; + 968. > list_for_each_entry_rcu(iter_entry, iter_list, list) + 969. if (iter_entry->valid) { + 970. if (chain_cnt++ < *skip_chain) + +net/ipv4/tcp_output.c:968: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 966. + 967. nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED | TCPF_TSQ_DEFERRED; + 968. > nval = cmpxchg(&sk->sk_tsq_flags, oval, nval); + 969. if (nval != oval) + 970. continue; + +net/ipv4/tcp_output.c:960: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 958. unsigned long nval, oval; + 959. + 960. > for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) { + 961. struct tsq_tasklet *tsq; + 962. bool empty; + +net/wireless/trace.h:956: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/wireless/trace.h:956: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 954. ); + 955. + 956. > TRACE_EVENT(rdev_return_int_mesh_config, + 957. TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), + 958. TP_ARGS(wiphy, ret, conf), + +net/ipv4/netfilter/ip_tables.c:984: error: DEAD_STORE + The value written to &ret (type int) is never used. + 982. + 983. if (compat) { + 984. > ret = compat_table_info(private, &tmp); + 985. xt_compat_flush_offsets(AF_INET); + 986. private = &tmp; + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 959. ) + 960. + 961. > DEFINE_EVENT(i915_context, i915_context_create, + 962. TP_PROTO(struct i915_gem_context *ctx), + 963. TP_ARGS(ctx) + +net/netfilter/nfnetlink_log.c:976: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 974. + 975. if (!hlist_empty(head)) + 976. > return rcu_dereference_bh(hlist_first_rcu(head)); + 977. } + 978. return NULL; + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/gpu/drm/i915/i915_trace.h:966: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 964. ); + 965. + 966. > DEFINE_EVENT(i915_context, i915_context_free, + 967. TP_PROTO(struct i915_gem_context *ctx), + 968. TP_ARGS(ctx) + +drivers/usb/core/sysfs.c:977: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 975. + 976. intf = to_usb_interface(dev); + 977. > string = READ_ONCE(intf->cur_altsetting->string); + 978. if (!string) + 979. return 0; + +net/core/skbuff.c:1000: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 998. uarg->len++; + 999. uarg->bytelen = bytelen; + 1000. > atomic_set(&sk->sk_zckey, ++next); + 1001. sock_zerocopy_get(uarg); + 1002. return uarg; + +net/core/dev.c:978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 976. + 977. rcu_read_lock(); + 978. > for_each_netdev_rcu(net, dev) + 979. if (dev->type == type) { + 980. dev_hold(dev); + +net/wireless/trace.h:973: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +net/wireless/trace.h:973: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 971. ); + 972. + 973. > TRACE_EVENT(rdev_update_mesh_config, + 974. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, + 975. const struct mesh_config *conf), + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +lib/iov_iter.c:984: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 982. return size; + 983. } + 984. > iterate_all_kinds(i, size, v, + 985. (res |= (unsigned long)v.iov_base | v.iov_len, 0), + 986. res |= v.bv_offset | v.bv_len, + +net/ipv6/netfilter/ip6_tables.c:1001: error: DEAD_STORE + The value written to &ret (type int) is never used. + 999. + 1000. if (compat) { + 1001. > ret = compat_table_info(private, &tmp); + 1002. xt_compat_flush_offsets(AF_INET6); + 1003. private = &tmp; + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +drivers/gpu/drm/i915/i915_trace.h:978: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 976. * called only if full ppgtt is enabled. + 977. */ + 978. > TRACE_EVENT(switch_mm, + 979. TP_PROTO(struct intel_engine_cs *engine, struct i915_gem_context *to), + 980. + +net/netfilter/nf_conntrack_sip.c:996: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 994. int ret = NF_ACCEPT; + 995. + 996. > hooks = rcu_dereference(nf_nat_sip_hooks); + 997. + 998. /* Find beginning of session description */ + +net/netfilter/nf_conntrack_sip.c:1079: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1077. + 1078. /* Update session connection and owner addresses */ + 1079. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1080. if (hooks && ct->status & IPS_NAT_MASK) + 1081. ret = hooks->sdp_session(skb, protoff, dataoff, + +ipc/msg.c:1099: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1097. * signal) it will either see the message and continue ... + 1098. */ + 1099. > msg = READ_ONCE(msr_d.r_msg); + 1100. if (msg != ERR_PTR(-EAGAIN)) + 1101. goto out_unlock1; + +net/netfilter/nfnetlink_log.c:984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 982. struct hlist_node *h) + 983. { + 984. > h = rcu_dereference_bh(hlist_next_rcu(h)); + 985. while (!h) { + 986. struct nfnl_log_net *log; + +net/netfilter/nfnetlink_log.c:994: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 992. log = nfnl_log_pernet(net); + 993. head = &log->instance_table[st->bucket]; + 994. > h = rcu_dereference_bh(hlist_first_rcu(head)); + 995. } + 996. return h; + +drivers/gpu/drm/i915/intel_dpio_phy.c:990: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 989 could be null and is dereferenced by call to `vlv_dport_to_channel()` at line 990, column 27. + 988. struct intel_crtc *intel_crtc = to_intel_crtc(encoder->base.crtc); + 989. struct intel_digital_port *dport = enc_to_dig_port(&encoder->base); + 990. > enum dpio_channel port = vlv_dport_to_channel(dport); + 991. enum pipe pipe = intel_crtc->pipe; + 992. + +drivers/usb/core/sysfs.c:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. intf = to_usb_interface(dev); + 992. udev = interface_to_usbdev(intf); + 993. > alt = READ_ONCE(intf->cur_altsetting); + 994. + 995. return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" + +drivers/usb/mon/mon_bin.c:1067: error: UNINITIALIZED_VALUE + The value read from getb.alloc was never initialized. + 1065. if (getb.alloc > 0x10000000) /* Want to cast to u32 */ + 1066. return -EINVAL; + 1067. > ret = mon_bin_get_event(file, rp, getb.hdr, + 1068. (cmd == MON_IOCX_GET)? PKT_SZ_API0: PKT_SZ_API1, + 1069. getb.data, (unsigned int)getb.alloc); + +drivers/usb/mon/mon_bin.c:1090: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch was never initialized. + 1088. return -EFAULT; + 1089. } + 1090. > ret = mon_bin_fetch(file, rp, mfetch.offvec, mfetch.nfetch); + 1091. if (ret < 0) + 1092. return ret; + +drivers/usb/mon/mon_bin.c:1084: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush was never initialized. + 1082. + 1083. if (mfetch.nflush) { + 1084. > ret = mon_bin_flush(rp, mfetch.nflush); + 1085. if (ret < 0) + 1086. return ret; + +drivers/md/dm.c:996: error: DEAD_STORE + The value written to &offset (type unsigned long) is never used. + 994. offset = dm_target_offset(ti, sector); + 995. if (unlikely(ti->max_io_len & (ti->max_io_len - 1))) + 996. > max_len = sector_div(offset, ti->max_io_len); + 997. else + 998. max_len = offset & (ti->max_io_len - 1); + +drivers/cdrom/cdrom.c:1025: error: UNINITIALIZED_VALUE + The value read from entry.cdte_ctrl was never initialized. + 1023. tracks->audio++; + 1024. } + 1025. > cd_dbg(CD_COUNT_TRACKS, "track %d: format=%d, ctrl=%d\n", + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + +drivers/cdrom/cdrom.c:1009: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk0 was never initialized. + 1007. /* check what type of tracks are on this disc */ + 1008. entry.cdte_format = CDROM_MSF; + 1009. > for (i = header.cdth_trk0; i <= header.cdth_trk1; i++) { + 1010. entry.cdte_track = i; + 1011. if (cdi->ops->audio_ioctl(cdi, CDROMREADTOCENTRY, &entry)) { + +drivers/cdrom/cdrom.c:1028: error: UNINITIALIZED_VALUE + The value read from header.cdth_trk1 was never initialized. + 1026. i, entry.cdte_format, entry.cdte_ctrl); + 1027. } + 1028. > cd_dbg(CD_COUNT_TRACKS, "disc has %d tracks: %d=audio %d=data %d=Cd-I %d=XA\n", + 1029. header.cdth_trk1, tracks->audio, tracks->data, + 1030. tracks->cdi, tracks->xa); + +kernel/trace/ring_buffer.c:1000: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 998. val |= RB_PAGE_HEAD; + 999. + 1000. > ret = cmpxchg(ptr, val, (unsigned long)&new->list); + 1001. + 1002. return ret == val; + +kernel/relay.c:996: error: DEAD_STORE + The value written to &consumed (type unsigned long) is never used. + 994. size_t n_subbufs = buf->chan->n_subbufs; + 995. size_t produced = buf->subbufs_produced; + 996. > size_t consumed = buf->subbufs_consumed; + 997. + 998. relay_file_read_consume(buf, read_pos, 0); + +kernel/trace/trace_events.c:995: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 993. { + 994. struct trace_array *tr = m->private; + 995. > struct trace_pid_list *pid_list = rcu_dereference_sched(tr->filtered_pids); + 996. + 997. return trace_pid_next(pid_list, v, pos); + +net/ipv4/tcp_output.c:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. static bool tcp_needs_internal_pacing(const struct sock *sk) + 992. { + 993. > return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED; + 994. } + 995. + +net/netfilter/nf_conntrack_core.c:1005: error: DEAD_STORE + The value written to &nf_conntrack_max95 (type unsigned int) is never used. + 1003. i = gc_work->last_bucket; + 1004. if (gc_work->early_drop) + 1005. > nf_conntrack_max95 = nf_conntrack_max / 100u * 95u; + 1006. + 1007. do { + +net/netfilter/nf_conntrack_core.c:1021: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1019. i = 0; + 1020. + 1021. > hlist_nulls_for_each_entry_rcu(h, n, &ct_hash[i], hnnode) { + 1022. struct net *net; + 1023. + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +lib/iov_iter.c:1003: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1001. } + 1002. + 1003. > iterate_all_kinds(i, size, v, + 1004. (res |= (!res ? 0 : (unsigned long)v.iov_base) | + 1005. (size != v.iov_len ? size : 0), 0), + +net/wireless/trace.h:993: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +net/wireless/trace.h:993: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 991. ); + 992. + 993. > TRACE_EVENT(rdev_join_mesh, + 994. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 995. const struct mesh_config *conf, + +security/selinux/ss/policydb.c:1006: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1004. + 1005. rc = -EINVAL; + 1006. > items = le32_to_cpu(buf[0]); + 1007. if (items > ARRAY_SIZE(buf)) { + 1008. printk(KERN_ERR "SELinux: mls: range overflow\n"); + +security/selinux/ss/policydb.c:1018: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1016. } + 1017. + 1018. > r->level[0].sens = le32_to_cpu(buf[0]); + 1019. if (items > 1) + 1020. r->level[1].sens = le32_to_cpu(buf[1]); + +security/selinux/ss/policydb.c:1020: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1018. r->level[0].sens = le32_to_cpu(buf[0]); + 1019. if (items > 1) + 1020. > r->level[1].sens = le32_to_cpu(buf[1]); + 1021. else + 1022. r->level[1].sens = r->level[0].sens; + +kernel/trace/trace_events.c:1015: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1013. rcu_read_lock_sched(); + 1014. + 1015. > pid_list = rcu_dereference_sched(tr->filtered_pids); + 1016. + 1017. if (!pid_list) + +net/ipv6/ipv6_sockglue.c:1289: error: UNINITIALIZED_VALUE + The value read from freq.flr_flags was never initialized. + 1287. + 1288. len = sizeof(freq); + 1289. > flags = freq.flr_flags; + 1290. + 1291. memset(&freq, 0, sizeof(freq)); + +security/selinux/avc.c:1022: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1020. node = avc_lookup(ssid, tsid, tclass); + 1021. if (unlikely(!node)) { + 1022. > node = avc_compute_av(ssid, tsid, tclass, &avd, xp_node); + 1023. } else { + 1024. memcpy(&avd, &node->ae.avd, sizeof(avd)); + +security/selinux/avc.c:1049: error: UNINITIALIZED_VALUE + The value read from avd.seqno was never initialized. + 1047. &local_xpd); + 1048. rcu_read_lock(); + 1049. > avc_update_node(AVC_CALLBACK_ADD_XPERMS, requested, driver, xperm, + 1050. ssid, tsid, tclass, avd.seqno, &local_xpd, 0); + 1051. } else { + +drivers/video/fbdev/core/fbmon.c:1074: error: UNINITIALIZED_VALUE + The value read from svd[_] was never initialized. + 1072. + 1073. for (i = specs->modedb_len + num; i < specs->modedb_len + num + svd_n; i++) { + 1074. > int idx = svd[i - specs->modedb_len - num]; + 1075. if (!idx || idx >= ARRAY_SIZE(cea_modes)) { + 1076. pr_warn("Reserved SVD code %d\n", idx); + +drivers/pci/pci.c:1028: error: DEAD_STORE + The value written to &i (type int) is never used. + 1026. pcie_capability_read_word(dev, PCI_EXP_DEVCTL2, &cap[i++]); + 1027. pcie_capability_read_word(dev, PCI_EXP_LNKCTL2, &cap[i++]); + 1028. > pcie_capability_read_word(dev, PCI_EXP_SLTCTL2, &cap[i++]); + 1029. + 1030. return 0; + +arch/x86/events/core.c:1013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1011. + 1012. hwc->idx = cpuc->assign[i]; + 1013. > hwc->last_cpu = smp_processor_id(); + 1014. hwc->last_tag = ++cpuc->tags[i]; + 1015. + +arch/x86/events/core.c:1013: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1011. + 1012. hwc->idx = cpuc->assign[i]; + 1013. > hwc->last_cpu = smp_processor_id(); + 1014. hwc->last_tag = ++cpuc->tags[i]; + 1015. + +net/wireless/trace.h:1012: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +net/wireless/trace.h:1012: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1010. ); + 1011. + 1012. > TRACE_EVENT(rdev_change_bss, + 1013. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1014. struct bss_parameters *params), + +drivers/gpu/drm/i915/i915_gem_gtt.c:1066: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1064. kunmap_atomic(vaddr); + 1065. + 1066. > return ret; + 1067. } + 1068. + +kernel/fork.c:1023: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1021. * this mm -- see comment above for justification. + 1022. */ + 1023. > old_exe_file = rcu_dereference_raw(mm->exe_file); + 1024. + 1025. if (new_exe_file) + +kernel/trace/trace_kprobe.c:1022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1020. struct event_file_link *link; + 1021. + 1022. > list_for_each_entry_rcu(link, &tk->tp.files, list) + 1023. __kprobe_trace_func(tk, regs, link->file); + 1024. } + +arch/x86/events/intel/ds.c:1067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1065. if (!kernel_ip(ip)) { + 1066. int bytes; + 1067. > u8 *buf = this_cpu_read(insn_buffer); + 1068. + 1069. /* 'size' must fit our buffer, see above */ + +arch/x86/events/intel/ds.c:1067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1065. if (!kernel_ip(ip)) { + 1066. int bytes; + 1067. > u8 *buf = this_cpu_read(insn_buffer); + 1068. + 1069. /* 'size' must fit our buffer, see above */ + +net/ipv4/ping.c:1027: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1025. struct sock *sk; + 1026. struct ping_iter_state *state = seq->private; + 1027. > struct net *net = seq_file_net(seq); + 1028. + 1029. for (state->bucket = start; state->bucket < PING_HTABLE_SIZE; + +net/xfrm/xfrm_user.c:1026: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1024. u32 pid, unsigned int group) + 1025. { + 1026. > struct sock *nlsk = rcu_dereference(net->xfrm.nlsk); + 1027. + 1028. if (nlsk) + +drivers/gpu/drm/i915/intel_dp.c:1130: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1128. + 1129. if ((status & DP_AUX_CH_CTL_DONE) == 0) { + 1130. > DRM_ERROR("dp_aux_ch not done status 0x%08x\n", status); + 1131. ret = -EBUSY; + 1132. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1140: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1138. */ + 1139. if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) { + 1140. > DRM_ERROR("dp_aux_ch receive error status 0x%08x\n", status); + 1141. ret = -EIO; + 1142. goto out; + +drivers/gpu/drm/i915/intel_dp.c:1148: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 1146. * "normal" -- don't fill the kernel log with these */ + 1147. if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) { + 1148. > DRM_DEBUG_KMS("dp_aux_ch timeout status 0x%08x\n", status); + 1149. ret = -ETIMEDOUT; + 1150. goto out; + +drivers/nvmem/core.c:1045: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1043. + 1044. /* setup the first byte with lsb bits from nvmem */ + 1045. > rc = nvmem_reg_read(nvmem, cell->offset, &v, 1); + 1046. *b++ |= GENMASK(bit_offset - 1, 0) & v; + 1047. + +drivers/nvmem/core.c:1062: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1060. if ((nbits + bit_offset) % BITS_PER_BYTE) { + 1061. /* setup the last byte with msb bits from nvmem */ + 1062. > rc = nvmem_reg_read(nvmem, + 1063. cell->offset + cell->bytes - 1, &v, 1); + 1064. *p |= GENMASK(7, (nbits + bit_offset) % BITS_PER_BYTE) & v; + +lib/vsprintf.c:1059: error: UNINITIALIZED_VALUE + The value read from zerolength[_] was never initialized. + 1057. for (i = 0; i < range; i++) { + 1058. if (zerolength[i] > longest) { + 1059. > longest = zerolength[i]; + 1060. colonpos = i; + 1061. } + +include/linux/rhashtable.h:1065: error: DEAD_STORE + The value written to &list (type rhlist_head*) is never used. + 1063. continue; + 1064. + 1065. > list = rht_dereference_bucket(list->next, tbl, hash); + 1066. RCU_INIT_POINTER(*lpprev, list); + 1067. err = 0; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1067: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1065. if ((hw->mac_type == e1000_82545_rev_3) || + 1066. (hw->mac_type == e1000_82546_rev_3)) { + 1067. > ret_val = + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:1070: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1068. e1000_read_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, &phy_data); + 1069. phy_data |= 0x00000008; + 1070. > ret_val = + 1071. e1000_write_phy_reg(hw, M88E1000_PHY_SPEC_CTRL, phy_data); + 1072. } + +arch/x86/events/core.c:1035: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1033. { + 1034. return hwc->idx == cpuc->assign[i] && + 1035. > hwc->last_cpu == smp_processor_id() && + 1036. hwc->last_tag == cpuc->tags[i]; + 1037. } + +drivers/pci/pci.c:1050: error: DEAD_STORE + The value written to &i (type int) is never used. + 1048. pcie_capability_write_word(dev, PCI_EXP_DEVCTL2, cap[i++]); + 1049. pcie_capability_write_word(dev, PCI_EXP_LNKCTL2, cap[i++]); + 1050. > pcie_capability_write_word(dev, PCI_EXP_SLTCTL2, cap[i++]); + 1051. } + 1052. + +drivers/base/power/wakeup.c:1046: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1044. + 1045. srcuidx = srcu_read_lock(&wakeup_srcu); + 1046. > list_for_each_entry_rcu(ws, &wakeup_sources, entry) + 1047. print_wakeup_source_stats(m, ws); + 1048. srcu_read_unlock(&wakeup_srcu, srcuidx); + +drivers/gpu/drm/i915/intel_dpio_phy.c:1050: error: DEAD_STORE + The value written to &val (type unsigned int) is never used. + 1048. + 1049. /* Enable clock channels for this port */ + 1050. > val = vlv_dpio_read(dev_priv, pipe, VLV_PCS01_DW8(port)); + 1051. val = 0; + 1052. if (pipe) + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1040 could be null and is dereferenced at line 1043, column 17. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +drivers/gpu/drm/i915/intel_ddi.c:1043: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 1039 could be null and is dereferenced at line 1043, column 2. + 1041. enc_to_dig_port(&encoder->base); + 1042. + 1043. > intel_dp->DP = intel_dig_port->saved_port_bits | + 1044. DDI_BUF_CTL_ENABLE | DDI_BUF_TRANS_SELECT(0); + 1045. intel_dp->DP |= DDI_PORT_WIDTH(intel_dp->lane_count); + +kernel/fork.c:1043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1041. + 1042. rcu_read_lock(); + 1043. > exe_file = rcu_dereference(mm->exe_file); + 1044. if (exe_file && !get_file_rcu(exe_file)) + 1045. exe_file = NULL; + +net/ipv6/tcp_ipv6.c:1072: error: DEAD_STORE + The value written to &newinet (type inet_sock*) is never used. + 1070. inet_sk(newsk)->pinet6 = &newtcp6sk->inet6; + 1071. + 1072. > newinet = inet_sk(newsk); + 1073. newnp = inet6_sk(newsk); + 1074. newtp = tcp_sk(newsk); + +net/ipv6/tcp_ipv6.c:1179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1177. opt = ireq->ipv6_opt; + 1178. if (!opt) + 1179. > opt = rcu_dereference(np->opt); + 1180. if (opt) { + 1181. opt = ipv6_dup_options(newsk, opt); + +net/wireless/trace.h:1042: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/wireless/trace.h:1042: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1040. ); + 1041. + 1042. > TRACE_EVENT(rdev_set_txq_params, + 1043. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1044. struct ieee80211_txq_params *params), + +net/ipv6/route.c:1061: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1060 could be null and is dereferenced by call to `dev_net()` at line 1061, column 23. + 1059. rcu_read_lock(); + 1060. dev = ip6_rt_get_dev_rcu(ort); + 1061. > rt = __ip6_dst_alloc(dev_net(dev), dev, 0); + 1062. rcu_read_unlock(); + 1063. if (!rt) + +net/ipv4/inet_connection_sock.c:1058: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1056. + 1057. rcu_read_lock(); + 1058. > inet_opt = rcu_dereference(inet->inet_opt); + 1059. if (inet_opt && inet_opt->opt.srr) + 1060. daddr = inet_opt->opt.faddr; + +kernel/exit.c:1055: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1053. int state, status; + 1054. pid_t pid = task_pid_vnr(p); + 1055. > uid_t uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1056. struct waitid_info *infop; + 1057. + +drivers/gpu/drm/i915/i915_gem_request.c:1067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1065. * stop busywaiting, see busywait_stop(). + 1066. */ + 1067. > *cpu = get_cpu(); + 1068. t = local_clock() >> 10; + 1069. put_cpu(); + +drivers/gpu/drm/i915/i915_gem_request.c:1067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1065. * stop busywaiting, see busywait_stop(). + 1066. */ + 1067. > *cpu = get_cpu(); + 1068. t = local_clock() >> 10; + 1069. put_cpu(); + +security/selinux/ss/policydb.c:1066: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1064. goto out; + 1065. } + 1066. > c->user = le32_to_cpu(buf[0]); + 1067. c->role = le32_to_cpu(buf[1]); + 1068. c->type = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1067: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1065. } + 1066. c->user = le32_to_cpu(buf[0]); + 1067. > c->role = le32_to_cpu(buf[1]); + 1068. c->type = le32_to_cpu(buf[2]); + 1069. if (p->policyvers >= POLICYDB_VERSION_MLS) { + +security/selinux/ss/policydb.c:1068: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1066. c->user = le32_to_cpu(buf[0]); + 1067. c->role = le32_to_cpu(buf[1]); + 1068. > c->type = le32_to_cpu(buf[2]); + 1069. if (p->policyvers >= POLICYDB_VERSION_MLS) { + 1070. rc = mls_read_range_helper(&c->range, fp); + +kernel/time/tick-sched.c:1071: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1069. + 1070. if (ts->idle_active) + 1071. > tick_nohz_stop_idle(ts, now); + 1072. + 1073. if (ts->tick_stopped) { + +kernel/time/tick-sched.c:1074: error: UNINITIALIZED_VALUE + The value read from now was never initialized. + 1072. + 1073. if (ts->tick_stopped) { + 1074. > tick_nohz_restart_sched_tick(ts, now); + 1075. tick_nohz_account_idle_ticks(ts); + 1076. } + +drivers/dma-buf/dma-buf.c:1097: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1095. seq = read_seqcount_begin(&robj->seq); + 1096. rcu_read_lock(); + 1097. > fobj = rcu_dereference(robj->fence); + 1098. shared_count = fobj ? fobj->shared_count : 0; + 1099. fence = rcu_dereference(robj->fence_excl); + +drivers/dma-buf/dma-buf.c:1099: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1097. fobj = rcu_dereference(robj->fence); + 1098. shared_count = fobj ? fobj->shared_count : 0; + 1099. > fence = rcu_dereference(robj->fence_excl); + 1100. if (!read_seqcount_retry(&robj->seq, seq)) + 1101. break; + +drivers/dma-buf/dma-buf.c:1111: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1109. dma_fence_is_signaled(fence) ? "" : "un"); + 1110. for (i = 0; i < shared_count; i++) { + 1111. > fence = rcu_dereference(fobj->shared[i]); + 1112. if (!dma_fence_get_rcu(fence)) + 1113. continue; + +drivers/gpu/drm/i915/i915_gem.c:1113: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1111. * page_length = bytes to copy for this page + 1112. */ + 1113. > u32 page_base = node.start; + 1114. unsigned page_offset = offset_in_page(offset); + 1115. unsigned page_length = PAGE_SIZE - page_offset; + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1068: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1066. if (unlikely(i->type & ITER_PIPE)) + 1067. return pipe_get_pages(i, pages, maxsize, maxpages, start); + 1068. > iterate_all_kinds(i, maxsize, v, ({ + 1069. unsigned long addr = (unsigned long)v.iov_base; + 1070. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/input/evdev.c:1140: error: UNINITIALIZED_VALUE + The value read from mask.codes_ptr was never initialized. + 1138. return -EFAULT; + 1139. + 1140. > codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + +drivers/input/evdev.c:1152: error: UNINITIALIZED_VALUE + The value read from mask.codes_ptr was never initialized. + 1150. return -EFAULT; + 1151. + 1152. > codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + +drivers/input/evdev.c:1141: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1139. + 1140. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. > return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + 1143. compat_mode); + +drivers/input/evdev.c:1153: error: UNINITIALIZED_VALUE + The value read from mask.codes_size was never initialized. + 1151. + 1152. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. > return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + 1155. compat_mode); + +drivers/input/evdev.c:1141: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1139. + 1140. codes_ptr = (void __user *)(unsigned long)mask.codes_ptr; + 1141. > return evdev_get_mask(client, + 1142. mask.type, codes_ptr, mask.codes_size, + 1143. compat_mode); + +drivers/input/evdev.c:1153: error: UNINITIALIZED_VALUE + The value read from mask.type was never initialized. + 1151. + 1152. codes_ptr = (const void __user *)(unsigned long)mask.codes_ptr; + 1153. > return evdev_set_mask(client, + 1154. mask.type, codes_ptr, mask.codes_size, + 1155. compat_mode); + +kernel/trace/trace_kprobe.c:1072: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1070. struct event_file_link *link; + 1071. + 1072. > list_for_each_entry_rcu(link, &tk->tp.files, list) + 1073. __kretprobe_trace_func(tk, ri, regs, link->file); + 1074. } + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequest was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.bRequestType was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.data was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1094: error: UNINITIALIZED_VALUE + The value read from ctrl.timeout was never initialized. + 1092. goto done; + 1093. } + 1094. > tmo = ctrl.timeout; + 1095. snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + +drivers/usb/core/devio.c:1078: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1076. if (copy_from_user(&ctrl, arg, sizeof(ctrl))) + 1077. return -EFAULT; + 1078. > ret = check_ctrlrecip(ps, ctrl.bRequestType, ctrl.bRequest, + 1079. ctrl.wIndex); + 1080. if (ret) + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wIndex was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1082: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1080. if (ret) + 1081. return ret; + 1082. > wLength = ctrl.wLength; /* To suppress 64k PAGE_SIZE warning */ + 1083. if (wLength > PAGE_SIZE) + 1084. return -EINVAL; + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1101: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1099. ctrl.wIndex, ctrl.wLength); + 1100. if (ctrl.bRequestType & 0x80) { + 1101. > if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data, + 1102. ctrl.wLength)) { + 1103. ret = -EINVAL; + +drivers/usb/core/devio.c:1107: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1105. } + 1106. pipe = usb_rcvctrlpipe(dev, 0); + 1107. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, NULL, 0); + 1108. + 1109. usb_unlock_device(dev); + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1124: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1122. } else { + 1123. if (ctrl.wLength) { + 1124. > if (copy_from_user(tbuf, ctrl.data, ctrl.wLength)) { + 1125. ret = -EFAULT; + 1126. goto done; + +drivers/usb/core/devio.c:1130: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1128. } + 1129. pipe = usb_sndctrlpipe(dev, 0); + 1130. > snoop_urb(dev, NULL, pipe, ctrl.wLength, tmo, SUBMIT, + 1131. tbuf, ctrl.wLength); + 1132. + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1141: error: UNINITIALIZED_VALUE + The value read from ctrl.wLength was never initialized. + 1139. } + 1140. if (i < 0 && i != -EPIPE) { + 1141. > dev_printk(KERN_DEBUG, &dev->dev, "usbfs: USBDEVFS_CONTROL " + 1142. "failed cmd %s rqt %u rq %u len %u ret %d\n", + 1143. current->comm, ctrl.bRequestType, ctrl.bRequest, + +drivers/usb/core/devio.c:1095: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1093. } + 1094. tmo = ctrl.timeout; + 1095. > snoop(&dev->dev, "control urb: bRequestType=%02x " + 1096. "bRequest=%02x wValue=%04x " + 1097. "wIndex=%04x wLength=%04x\n", + +drivers/usb/core/devio.c:1110: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1108. + 1109. usb_unlock_device(dev); + 1110. > i = usb_control_msg(dev, pipe, ctrl.bRequest, + 1111. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1112. tbuf, ctrl.wLength, tmo); + +drivers/usb/core/devio.c:1134: error: UNINITIALIZED_VALUE + The value read from ctrl.wValue was never initialized. + 1132. + 1133. usb_unlock_device(dev); + 1134. > i = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), ctrl.bRequest, + 1135. ctrl.bRequestType, ctrl.wValue, ctrl.wIndex, + 1136. tbuf, ctrl.wLength, tmo); + +kernel/sched/sched.h:1073: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1071. struct sched_domain *sd, *hsd = NULL; + 1072. + 1073. > for_each_domain(cpu, sd) { + 1074. if (!(sd->flags & flag)) + 1075. break; + +net/ipv4/tcp_ipv4.c:1099: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_keylen was never initialized. + 1097. return -EINVAL; + 1098. + 1099. > return tcp_md5_do_add(sk, (union tcp_md5_addr *)&sin->sin_addr.s_addr, + 1100. AF_INET, prefixlen, cmd.tcpm_key, cmd.tcpm_keylen, + 1101. GFP_KERNEL); + +net/ipv4/tcp_ipv4.c:1087: error: UNINITIALIZED_VALUE + The value read from cmd.tcpm_prefixlen was never initialized. + 1085. if (optname == TCP_MD5SIG_EXT && + 1086. cmd.tcpm_flags & TCP_MD5SIG_FLAG_PREFIX) { + 1087. > prefixlen = cmd.tcpm_prefixlen; + 1088. if (prefixlen > 32) + 1089. return -EINVAL; + +net/wireless/trace.h:1069: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +net/wireless/trace.h:1069: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1067. ); + 1068. + 1069. > TRACE_EVENT(rdev_libertas_set_mesh_channel, + 1070. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1071. struct ieee80211_channel *chan), + +drivers/gpu/drm/drm_dp_mst_topology.c:1079: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1077. case DP_PEER_DEVICE_SST_SINK: + 1078. /* add i2c over sideband */ + 1079. > ret = drm_dp_mst_register_i2c_bus(&port->aux); + 1080. break; + 1081. case DP_PEER_DEVICE_MST_BRANCHING: + +drivers/md/dm-raid1.c:1142: error: DEAD_STORE + The value written to &argv (type char**) is never used. + 1140. goto err_destroy_wq; + 1141. + 1142. > argv += args_used; + 1143. argc -= args_used; + 1144. + +kernel/kprobes.c:1075: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1073. struct kprobe *kp; + 1074. + 1075. > list_for_each_entry_rcu(kp, &p->list, list) { + 1076. if (kp->pre_handler && likely(!kprobe_disabled(kp))) { + 1077. set_kprobe_instance(kp); + +net/ipv4/cipso_ipv4.c:1105: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 1103. + 1104. for (iter = 0; array_cnt > 0;) { + 1105. > *((__be16 *)&net_cat[iter]) = htons(array[--array_cnt]); + 1106. iter += 2; + 1107. array_cnt--; + +net/ipv4/cipso_ipv4.c:1109: error: UNINITIALIZED_VALUE + The value read from array[_] was never initialized. + 1107. array_cnt--; + 1108. if (array[array_cnt] != 0) { + 1109. > *((__be16 *)&net_cat[iter]) = htons(array[array_cnt]); + 1110. iter += 2; + 1111. } + +net/sunrpc/svc.c:1083: error: DEAD_STORE + The value written to &error (type int) is never used. + 1081. */ + 1082. if (error == -EPROTONOSUPPORT) + 1083. > error = rpcb_register(net, program, version, 0, 0); + 1084. + 1085. dprintk("svc: %s(%sv%u), error %d\n", + +drivers/tty/vt/vt_ioctl.c:1091: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 1089. op->width = 8; + 1090. op->height = cfdarg.charheight; + 1091. > op->charcount = cfdarg.charcount; + 1092. op->data = compat_ptr(cfdarg.chardata); + 1093. return con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:1099: error: UNINITIALIZED_VALUE + The value read from cfdarg.charcount was never initialized. + 1097. op->width = 8; + 1098. op->height = cfdarg.charheight; + 1099. > op->charcount = cfdarg.charcount; + 1100. op->data = compat_ptr(cfdarg.chardata); + 1101. i = con_font_op(vc_cons[fg_console].d, op); + +drivers/tty/vt/vt_ioctl.c:1092: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1090. op->height = cfdarg.charheight; + 1091. op->charcount = cfdarg.charcount; + 1092. > op->data = compat_ptr(cfdarg.chardata); + 1093. return con_font_op(vc_cons[fg_console].d, op); + 1094. case GIO_FONTX: + +drivers/tty/vt/vt_ioctl.c:1100: error: UNINITIALIZED_VALUE + The value read from cfdarg.chardata was never initialized. + 1098. op->height = cfdarg.charheight; + 1099. op->charcount = cfdarg.charcount; + 1100. > op->data = compat_ptr(cfdarg.chardata); + 1101. i = con_font_op(vc_cons[fg_console].d, op); + 1102. if (i) + +drivers/tty/vt/vt_ioctl.c:1090: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 1088. op->flags = KD_FONT_FLAG_OLD; + 1089. op->width = 8; + 1090. > op->height = cfdarg.charheight; + 1091. op->charcount = cfdarg.charcount; + 1092. op->data = compat_ptr(cfdarg.chardata); + +drivers/tty/vt/vt_ioctl.c:1098: error: UNINITIALIZED_VALUE + The value read from cfdarg.charheight was never initialized. + 1096. op->flags = KD_FONT_FLAG_OLD; + 1097. op->width = 8; + 1098. > op->height = cfdarg.charheight; + 1099. op->charcount = cfdarg.charcount; + 1100. op->data = compat_ptr(cfdarg.chardata); + +drivers/iommu/intel-iommu.c:1078: error: DEAD_STORE + The value written to &large_page (type unsigned int) is never used. + 1076. unsigned long last_pfn) + 1077. { + 1078. > unsigned int large_page = 1; + 1079. struct dma_pte *first_pte, *pte; + 1080. + +drivers/pci/pci.c:1087: error: DEAD_STORE + The value written to &i (type int) is never used. + 1085. cap = (u16 *)&save_state->cap.data[0]; + 1086. + 1087. > pci_write_config_word(dev, pos + PCI_X_CMD, cap[i++]); + 1088. } + 1089. + +drivers/gpu/drm/i915/intel_dsi.c:1152: error: DEAD_STORE + The value written to &vbp (type unsigned short) is never used. + 1150. vfp = I915_READ(MIPI_VFP_COUNT(port)); + 1151. vsync = I915_READ(MIPI_VSYNC_PADDING_COUNT(port)); + 1152. > vbp = I915_READ(MIPI_VBP_COUNT(port)); + 1153. + 1154. adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp; + +block/elevator.c:1091: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `elevator_switch()` at line 1091, column 10. + 1089. */ + 1090. if (q->mq_ops && !strncmp(name, "none", 4)) + 1091. > return elevator_switch(q, NULL); + 1092. + 1093. strlcpy(elevator_name, name, sizeof(elevator_name)); + +net/xfrm/xfrm_policy.c:1103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1101. priority = ~0U; + 1102. ret = NULL; + 1103. > hlist_for_each_entry_rcu(pol, chain, bydst) { + 1104. err = xfrm_policy_match(pol, fl, type, family, dir); + 1105. if (err) { + +net/xfrm/xfrm_policy.c:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. } + 1118. chain = &net->xfrm.policy_inexact[dir]; + 1119. > hlist_for_each_entry_rcu(pol, chain, bydst) { + 1120. if ((pol->priority >= priority) && ret) + 1121. break; + +net/netlink/genetlink.c:1087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1085. int err; + 1086. + 1087. > for_each_net_rcu(net) { + 1088. if (prev) { + 1089. tmp = skb_clone(skb, flags); + +kernel/sched/sched.h:1086: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1084. struct sched_domain *sd; + 1085. + 1086. > for_each_domain(cpu, sd) { + 1087. if (sd->flags & flag) + 1088. break; + +kernel/irq/irqdomain.c:1090: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1089 could be null and is dereferenced at line 1090, column 9. + 1088. for (i = 0; i < nr_irqs; i++) { + 1089. irq_data = irq_get_irq_data(virq + i); + 1090. > tmp = irq_data->parent_data; + 1091. irq_data->parent_data = NULL; + 1092. irq_data->domain = NULL; + +security/commoncap.c:1090: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1088. + 1089. rcu_read_lock(); + 1090. > is_subset = cap_issubset(__task_cred(p)->cap_permitted, + 1091. current_cred()->cap_permitted); + 1092. if (!is_subset && !ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) + +security/commoncap.c:1092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1090. is_subset = cap_issubset(__task_cred(p)->cap_permitted, + 1091. current_cred()->cap_permitted); + 1092. > if (!is_subset && !ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) + 1093. ret = -EPERM; + 1094. rcu_read_unlock(); + +kernel/kprobes.c:1092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1090. struct kprobe *kp; + 1091. + 1092. > list_for_each_entry_rcu(kp, &p->list, list) { + 1093. if (kp->post_handler && likely(!kprobe_disabled(kp))) { + 1094. set_kprobe_instance(kp); + +net/netfilter/nf_conntrack_sip.c:1099: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1094 could be null and is dereferenced at line 1099, column 11. + 1097. (code >= 200 && code <= 299)) + 1098. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1099. > else if (ct_sip_info->invite_cseq == cseq) + 1100. flush_expectations(ct, true); + 1101. return NF_ACCEPT; + +net/wireless/trace.h:1087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1085. ); + 1086. + 1087. > TRACE_EVENT(rdev_set_monitor_channel, + 1088. TP_PROTO(struct wiphy *wiphy, + 1089. struct cfg80211_chan_def *chandef), + +net/ipv6/route.c:1095: error: NULL_DEREFERENCE + pointer `dev` last assigned on line 1094 could be null and is dereferenced by call to `dev_net()` at line 1095, column 28. + 1093. rcu_read_lock(); + 1094. dev = ip6_rt_get_dev_rcu(rt); + 1095. > pcpu_rt = __ip6_dst_alloc(dev_net(dev), dev, rt->dst.flags); + 1096. rcu_read_unlock(); + 1097. if (!pcpu_rt) + +drivers/video/fbdev/core/fbmem.c:1188: error: UNINITIALIZED_VALUE + The value read from con2fb.framebuffer was never initialized. + 1186. return -EINVAL; + 1187. if (!registered_fb[con2fb.framebuffer]) + 1188. > request_module("fb%d", con2fb.framebuffer); + 1189. if (!registered_fb[con2fb.framebuffer]) { + 1190. ret = -EINVAL; + +drivers/gpu/drm/drm_dp_mst_topology.c:1102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1100. if (!drm_dp_validate_guid(mstb->mgr, mstb->guid)) { + 1101. if (mstb->port_parent) { + 1102. > ret = drm_dp_send_dpcd_write( + 1103. mstb->mgr, + 1104. mstb->port_parent, + +drivers/gpu/drm/drm_dp_mst_topology.c:1110: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1108. } else { + 1109. + 1110. > ret = drm_dp_dpcd_write( + 1111. mstb->mgr->aux, + 1112. DP_GUID, + +kernel/rcu/srcutree.c:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. * by the prior grace period. + 1109. */ + 1110. > idx = rcu_seq_state(smp_load_acquire(&sp->srcu_gp_seq)); /* ^^^ */ + 1111. if (idx == SRCU_STATE_IDLE) { + 1112. spin_lock_irq_rcu_node(sp); + +kernel/rcu/srcutree.c:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. return; + 1118. } + 1119. > idx = rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)); + 1120. if (idx == SRCU_STATE_IDLE) + 1121. srcu_gp_start(sp); + +kernel/rcu/srcutree.c:1129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1127. } + 1128. + 1129. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN1) { + 1130. idx = 1 ^ (sp->srcu_idx & 1); + 1131. if (!try_check_zero(sp, idx, 1)) { + +kernel/rcu/srcutree.c:1139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1137. } + 1138. + 1139. > if (rcu_seq_state(READ_ONCE(sp->srcu_gp_seq)) == SRCU_STATE_SCAN2) { + 1140. + 1141. /* + +net/ipv4/ipmr.c:1107: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1107, column 5. + 1105. + 1106. if (__ipmr_fill_mroute(mrt, skb, c, nlmsg_data(nlh)) > 0) { + 1107. > nlh->nlmsg_len = skb_tail_pointer(skb) - + 1108. (u8 *)nlh; + 1109. } else { + +net/ipv4/ipmr.c:1110: error: NULL_DEREFERENCE + pointer `nlh` last assigned on line 1103 could be null and is dereferenced at line 1110, column 5. + 1108. (u8 *)nlh; + 1109. } else { + 1110. > nlh->nlmsg_type = NLMSG_ERROR; + 1111. nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr)); + 1112. skb_trim(skb, nlh->nlmsg_len); + +security/selinux/avc.c:1110: error: DEAD_STORE + The value written to &node (type avc_node*) is never used. + 1108. node = avc_lookup(ssid, tsid, tclass); + 1109. if (unlikely(!node)) + 1110. > node = avc_compute_av(ssid, tsid, tclass, avd, &xp_node); + 1111. else + 1112. memcpy(avd, &node->ae.avd, sizeof(*avd)); + +drivers/input/mouse/alps.c:1113: error: DEAD_STORE + The value written to &z (type int) is never used. + 1111. y = (packet[3] & 0x07) | (packet[4] & 0xb8) | + 1112. ((packet[3] & 0x20) << 1); + 1113. > z = (packet[5] & 0x3f) | ((packet[3] & 0x80) >> 1); + 1114. + 1115. left = (packet[1] & 0x01); + +drivers/gpu/drm/i915/intel_ddi.c:1102: error: DEAD_STORE + The value written to &refclk (type int) is never used. + 1100. i915_reg_t reg) + 1101. { + 1102. > int refclk = LC_FREQ; + 1103. int n, p, r; + 1104. u32 wrpll; + +net/core/sock.c:1376: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1374. #ifdef CONFIG_NET_RX_BUSY_POLL + 1375. case SO_INCOMING_NAPI_ID: + 1376. > v.val = READ_ONCE(sk->sk_napi_id); + 1377. + 1378. /* aggregate non-NAPI IDs down to 0 */ + +include/linux/rhashtable.h:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. rcu_read_lock(); + 1109. + 1110. > tbl = rht_dereference_rcu(ht->tbl, ht); + 1111. + 1112. /* Because we have already taken (and released) the bucket + +include/linux/rhashtable.h:1119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1117. while ((err = __rhashtable_remove_fast_one(ht, tbl, obj, params, + 1118. rhlist)) && + 1119. > (tbl = rht_dereference_rcu(tbl->future_tbl, ht))) + 1120. ; + 1121. + +kernel/irq/irqdomain.c:1112: error: NULL_DEREFERENCE + pointer `irq_data` last assigned on line 1111 could be null and is dereferenced at line 1112, column 3. + 1110. for (i = 0; i < nr_irqs; i++) { + 1111. irq_data = irq_get_irq_data(virq + i); + 1112. > irq_data->domain = domain; + 1113. + 1114. for (parent = domain->parent; parent; parent = parent->parent) { + +kernel/kprobes.c:1105: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1103. int trapnr) + 1104. { + 1105. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1106. + 1107. /* + +kernel/kprobes.c:1105: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1103. int trapnr) + 1104. { + 1105. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1106. + 1107. /* + +drivers/char/random.c:1113: error: DEAD_STORE + The value written to &idx (type unsigned int) is never used. + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + 1113. > ptr += idx++; + 1114. WRITE_ONCE(f->reg_idx, idx); + 1115. return *ptr; + +drivers/char/random.c:1110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1108. if (regs == NULL) + 1109. return 0; + 1110. > idx = READ_ONCE(f->reg_idx); + 1111. if (idx >= sizeof(struct pt_regs) / sizeof(__u32)) + 1112. idx = 0; + +net/wireless/trace.h:1103: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +net/wireless/trace.h:1103: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1101. ); + 1102. + 1103. > TRACE_EVENT(rdev_auth, + 1104. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1105. struct cfg80211_auth_request *req), + +scripts/kconfig/confdata.c:1114: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1109 could be null and is dereferenced at line 1114, column 2. + 1112. * Set all non-assinged choice values to no + 1113. */ + 1114. > expr_list_for_each_sym(prop->expr, e, sym) { + 1115. if (!sym_has_value(sym)) + 1116. sym->def[S_DEF_USER].tri = no; + +net/netfilter/nf_conntrack_sip.c:1116: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1111 could be null and is dereferenced at line 1116, column 11. + 1114. (code >= 200 && code <= 299)) + 1115. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1116. > else if (ct_sip_info->invite_cseq == cseq) + 1117. flush_expectations(ct, true); + 1118. return NF_ACCEPT; + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +arch/x86/events/intel/pt.c:1116: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1114. + 1115. if (cpu == -1) + 1116. > cpu = raw_smp_processor_id(); + 1117. node = cpu_to_node(cpu); + 1118. + +net/ipv4/netfilter/ip_tables.c:1135: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1133. tmp.name[sizeof(tmp.name)-1] = 0; + 1134. + 1135. > newinfo = xt_alloc_table_info(tmp.size); + 1136. if (!newinfo) + 1137. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1140: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1138. + 1139. loc_cpu_entry = newinfo->entries; + 1140. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1141. tmp.size) != 0) { + 1142. ret = -EFAULT; + +security/selinux/ss/policydb.c:1133: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1131. goto bad; + 1132. + 1133. > len = le32_to_cpu(buf[0]); + 1134. perdatum->value = le32_to_cpu(buf[1]); + 1135. + +security/selinux/ss/policydb.c:1134: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1132. + 1133. len = le32_to_cpu(buf[0]); + 1134. > perdatum->value = le32_to_cpu(buf[1]); + 1135. + 1136. rc = str_read(&key, GFP_KERNEL, fp, len); + +arch/x86/events/core.c:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. left = x86_pmu.limit_period(event, left); + 1156. + 1157. > per_cpu(pmc_prev_left[idx], smp_processor_id()) = left; + 1158. + 1159. if (!(hwc->flags & PERF_X86_EVENT_AUTO_RELOAD) || + +kernel/kprobes.c:1121: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1119. static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs) + 1120. { + 1121. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1122. int ret = 0; + 1123. + +kernel/kprobes.c:1121: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1119. static int aggr_break_handler(struct kprobe *p, struct pt_regs *regs) + 1120. { + 1121. > struct kprobe *cur = __this_cpu_read(kprobe_instance); + 1122. int ret = 0; + 1123. + +net/ipv6/route.c:1133: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1131. dst_hold(&pcpu_rt->dst); + 1132. p = this_cpu_ptr(rt->rt6i_pcpu); + 1133. > prev = cmpxchg(p, NULL, pcpu_rt); + 1134. BUG_ON(prev); + 1135. + +security/keys/keyctl.c:1138: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `keyctl_instantiate_key_common()` at line 1138, column 9. + 1136. } + 1137. + 1138. > return keyctl_instantiate_key_common(id, NULL, ringid); + 1139. } + 1140. + +net/netfilter/nf_conntrack_sip.c:1133: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1128 could be null and is dereferenced at line 1133, column 11. + 1131. (code >= 200 && code <= 299)) + 1132. return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1133. > else if (ct_sip_info->invite_cseq == cseq) + 1134. flush_expectations(ct, true); + 1135. return NF_ACCEPT; + +drivers/pci/msi.c:1129: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1129, column 9. + 1127. int minvec, int maxvec) + 1128. { + 1129. > return __pci_enable_msix_range(dev, entries, minvec, maxvec, NULL); + 1130. } + 1131. EXPORT_SYMBOL(pci_enable_msix_range); + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.alloc32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1146: error: UNINITIALIZED_VALUE + The value read from getb.data32 was never initialized. + 1144. ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. > compat_ptr(getb.data32), getb.alloc32); + 1147. if (ret < 0) + 1148. return ret; + +drivers/usb/mon/mon_bin.c:1144: error: UNINITIALIZED_VALUE + The value read from getb.hdr32 was never initialized. + 1142. return -EFAULT; + 1143. + 1144. > ret = mon_bin_get_event(file, rp, compat_ptr(getb.hdr32), + 1145. (cmd == MON_IOCX_GET32)? PKT_SZ_API0: PKT_SZ_API1, + 1146. compat_ptr(getb.data32), getb.alloc32); + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.nfetch32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +drivers/usb/mon/mon_bin.c:1163: error: UNINITIALIZED_VALUE + The value read from mfetch.nflush32 was never initialized. + 1161. + 1162. if (mfetch.nflush32) { + 1163. > ret = mon_bin_flush(rp, mfetch.nflush32); + 1164. if (ret < 0) + 1165. return ret; + +drivers/usb/mon/mon_bin.c:1169: error: UNINITIALIZED_VALUE + The value read from mfetch.offvec32 was never initialized. + 1167. return -EFAULT; + 1168. } + 1169. > ret = mon_bin_fetch(file, rp, compat_ptr(mfetch.offvec32), + 1170. mfetch.nfetch32); + 1171. if (ret < 0) + +net/wireless/trace.h:1127: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/wireless/trace.h:1127: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1125. ); + 1126. + 1127. > TRACE_EVENT(rdev_assoc, + 1128. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1129. struct cfg80211_assoc_request *req), + +net/ipv4/ipmr.c:1184: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1182. + 1183. rcu_read_lock(); + 1184. > mroute_sk = rcu_dereference(mrt->mroute_sk); + 1185. if (!mroute_sk) { + 1186. rcu_read_unlock(); + +net/ipv6/ip6_fib.c:1135: error: DEAD_STORE + The value written to &err (type int) is never used. + 1133. struct fib6_table *table = rt->rt6i_table; + 1134. struct fib6_node *fn, *pn = NULL; + 1135. > int err = -ENOMEM; + 1136. int allow_create = 1; + 1137. int replace_required = 0; + +net/ipv6/ip6_fib.c:1164: error: DEAD_STORE + The value written to &pn (type fib6_node*) is never used. + 1162. } + 1163. + 1164. > pn = fn; + 1165. + 1166. #ifdef CONFIG_IPV6_SUBTREES + +net/ipv6/ip6_fib.c:1291: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1289. (!(fn->fn_flags & (RTN_RTINFO|RTN_ROOT)) || + 1290. (fn->fn_flags & RTN_TL_ROOT && + 1291. > !rcu_access_pointer(fn->leaf)))) + 1292. fib6_repair_tree(info->nl_net, table, fn); + 1293. /* Always release dst as dst->__refcnt is guaranteed + +net/ipv6/netfilter/ip6_tables.c:1153: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1151. tmp.name[sizeof(tmp.name)-1] = 0; + 1152. + 1153. > newinfo = xt_alloc_table_info(tmp.size); + 1154. if (!newinfo) + 1155. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1158: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1156. + 1157. loc_cpu_entry = newinfo->entries; + 1158. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1159. tmp.size) != 0) { + 1160. ret = -EFAULT; + +kernel/kprobes.c:1140: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1138. p->nmissed++; + 1139. } else { + 1140. > list_for_each_entry_rcu(kp, &p->list, list) + 1141. kp->nmissed++; + 1142. } + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &maxsize (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +lib/iov_iter.c:1145: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1143. if (unlikely(i->type & ITER_PIPE)) + 1144. return pipe_get_pages_alloc(i, pages, maxsize, start); + 1145. > iterate_all_kinds(i, maxsize, v, ({ + 1146. unsigned long addr = (unsigned long)v.iov_base; + 1147. size_t len = v.iov_len + (*start = addr & (PAGE_SIZE - 1)); + +drivers/gpu/drm/i915/intel_tv.c:1194: error: DEAD_STORE + The value written to &type (type int) is never used. + 1192. intel_wait_for_vblank(dev_priv, intel_crtc->pipe); + 1193. + 1194. > type = -1; + 1195. tv_dac = I915_READ(TV_DAC); + 1196. DRM_DEBUG_KMS("TV detected: %x, %x\n", tv_ctl, tv_dac); + +lib/rhashtable.c:1148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1146. union nested_table *ntbl; + 1147. + 1148. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1149. ntbl = rht_dereference_bucket_rcu(ntbl[index].table, tbl, hash); + 1150. subhash >>= tbl->nest; + +lib/rhashtable.c:1149: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1147. + 1148. ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1149. > ntbl = rht_dereference_bucket_rcu(ntbl[index].table, tbl, hash); + 1150. subhash >>= tbl->nest; + 1151. + +lib/rhashtable.c:1154: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1152. while (ntbl && size > (1 << shift)) { + 1153. index = subhash & ((1 << shift) - 1); + 1154. > ntbl = rht_dereference_bucket_rcu(ntbl[index].table, + 1155. tbl, hash); + 1156. size >>= shift; + +kernel/audit.c:1404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1402. unsigned int t; + 1403. + 1404. > t = READ_ONCE(current->signal->audit_tty); + 1405. s.enabled = t & AUDIT_TTY_ENABLE; + 1406. s.log_passwd = !!(t & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1423. + 1424. if (err) + 1425. > t = READ_ONCE(current->signal->audit_tty); + 1426. else { + 1427. t = s.enabled | (-s.log_passwd & AUDIT_TTY_LOG_PASSWD); + +kernel/audit.c:1255: error: UNINITIALIZED_VALUE + The value read from s.backlog_limit was never initialized. + 1253. } + 1254. if (s.mask & AUDIT_STATUS_BACKLOG_LIMIT) { + 1255. > err = audit_set_backlog_limit(s.backlog_limit); + 1256. if (err < 0) + 1257. return err; + +kernel/audit.c:1264: error: UNINITIALIZED_VALUE + The value read from s.backlog_wait_time was never initialized. + 1262. if (s.backlog_wait_time > 10*AUDIT_BACKLOG_WAIT_TIME) + 1263. return -EINVAL; + 1264. > err = audit_set_backlog_wait_time(s.backlog_wait_time); + 1265. if (err < 0) + 1266. return err; + +kernel/audit.c:1180: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1178. memcpy(&s, data, min_t(size_t, sizeof(s), nlmsg_len(nlh))); + 1179. if (s.mask & AUDIT_STATUS_ENABLED) { + 1180. > err = audit_set_enabled(s.enabled); + 1181. if (err < 0) + 1182. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.enabled was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1185: error: UNINITIALIZED_VALUE + The value read from s.failure was never initialized. + 1183. } + 1184. if (s.mask & AUDIT_STATUS_FAILURE) { + 1185. > err = audit_set_failure(s.failure); + 1186. if (err < 0) + 1187. return err; + +kernel/audit.c:1434: error: UNINITIALIZED_VALUE + The value read from s.log_passwd was never initialized. + 1432. + 1433. audit_log_common_recv_msg(&ab, AUDIT_CONFIG_CHANGE); + 1434. > audit_log_format(ab, " op=tty_set old-enabled=%d new-enabled=%d" + 1435. " old-log_passwd=%d new-log_passwd=%d res=%d", + 1436. old.enabled, s.enabled, old.log_passwd, + +kernel/audit.c:1196: error: UNINITIALIZED_VALUE + The value read from s.pid was never initialized. + 1194. * run auditd from the initial pid namespace, but + 1195. * something to keep in mind if this changes */ + 1196. > pid_t new_pid = s.pid; + 1197. pid_t auditd_pid; + 1198. struct pid *req_pid = task_tgid(current); + +kernel/audit.c:1250: error: UNINITIALIZED_VALUE + The value read from s.rate_limit was never initialized. + 1248. } + 1249. if (s.mask & AUDIT_STATUS_RATE_LIMIT) { + 1250. > err = audit_set_rate_limit(s.rate_limit); + 1251. if (err < 0) + 1252. return err; + +kernel/audit.c:1351: error: UNINITIALIZED_VALUE + The value read from sizes[_] was never initialized. + 1349. bufp += 2 * sizeof(u32); + 1350. msglen -= 2 * sizeof(u32); + 1351. > old = audit_unpack_string(&bufp, &msglen, sizes[0]); + 1352. if (IS_ERR(old)) { + 1353. err = PTR_ERR(old); + +kernel/audit.c:1356: error: UNINITIALIZED_VALUE + The value read from sizes[_] was never initialized. + 1354. break; + 1355. } + 1356. > new = audit_unpack_string(&bufp, &msglen, sizes[1]); + 1357. if (IS_ERR(new)) { + 1358. err = PTR_ERR(new); + +net/netfilter/nf_conntrack_sip.c:1151: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1145 could be null and is dereferenced at line 1151, column 3. + 1149. ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq); + 1150. if (ret == NF_ACCEPT) + 1151. > ct_sip_info->invite_cseq = cseq; + 1152. return ret; + 1153. } + +drivers/tty/vt/vt_ioctl.c:1155: error: UNINITIALIZED_VALUE + The value read from tmp.entries was never initialized. + 1153. if (copy_from_user(&tmp, user_ud, sizeof tmp)) + 1154. return -EFAULT; + 1155. > tmp_entries = compat_ptr(tmp.entries); + 1156. switch (cmd) { + 1157. case PIO_UNIMAP: + +drivers/tty/vt/vt_ioctl.c:1160: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1158. if (!perm) + 1159. return -EPERM; + 1160. > return con_set_unimap(vc, tmp.entry_ct, tmp_entries); + 1161. case GIO_UNIMAP: + 1162. if (!perm && fg_console != vc->vc_num) + +drivers/tty/vt/vt_ioctl.c:1164: error: UNINITIALIZED_VALUE + The value read from tmp.entry_ct was never initialized. + 1162. if (!perm && fg_console != vc->vc_num) + 1163. return -EPERM; + 1164. > return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries); + 1165. } + 1166. return 0; + +kernel/cgroup/cpuset.c:1165: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 1156 could be null and is dereferenced at line 1165, column 16. + 1163. */ + 1164. if (is_in_v2_mode() && nodes_empty(*new_mems)) + 1165. > *new_mems = parent->effective_mems; + 1166. + 1167. /* Skip the whole subtree if the nodemask remains the same. */ + +kernel/rcu/tree.c:1151: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1149. static int rcu_is_cpu_rrupt_from_idle(void) + 1150. { + 1151. > return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 0 && + 1152. __this_cpu_read(rcu_dynticks.dynticks_nmi_nesting) <= 1; + 1153. } + +kernel/rcu/tree.c:1152: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1150. { + 1151. return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 0 && + 1152. > __this_cpu_read(rcu_dynticks.dynticks_nmi_nesting) <= 1; + 1153. } + 1154. + +net/sunrpc/svc.c:1163: error: DEAD_STORE + The value written to &rpc_stat (type unsigned int) is never used. + 1161. __be32 *reply_statp; + 1162. + 1163. > rpc_stat = rpc_success; + 1164. + 1165. if (argv->iov_len < 6*4) + +security/selinux/ss/policydb.c:1166: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1164. goto bad; + 1165. + 1166. > len = le32_to_cpu(buf[0]); + 1167. comdatum->value = le32_to_cpu(buf[1]); + 1168. + +security/selinux/ss/policydb.c:1167: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1165. + 1166. len = le32_to_cpu(buf[0]); + 1167. > comdatum->value = le32_to_cpu(buf[1]); + 1168. + 1169. rc = symtab_init(&comdatum->permissions, PERM_SYMTAB_SIZE); + +security/selinux/ss/policydb.c:1172: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1170. if (rc) + 1171. goto bad; + 1172. > comdatum->permissions.nprim = le32_to_cpu(buf[2]); + 1173. nel = le32_to_cpu(buf[3]); + 1174. + +security/selinux/ss/policydb.c:1173: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1171. goto bad; + 1172. comdatum->permissions.nprim = le32_to_cpu(buf[2]); + 1173. > nel = le32_to_cpu(buf[3]); + 1174. + 1175. rc = str_read(&key, GFP_KERNEL, fp, len); + +crypto/drbg.c:1153: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1151. static inline int drbg_alloc_state(struct drbg_state *drbg) + 1152. { + 1153. > int ret = -ENOMEM; + 1154. unsigned int sb_size = 0; + 1155. + +drivers/pci/msi.c:1167: error: NULL_DEREFERENCE + pointer `affd` last assigned on line 1163 could be null and is dereferenced by call to `__pci_enable_msix_range()` at line 1167, column 10. + 1165. + 1166. if (flags & PCI_IRQ_MSIX) { + 1167. > vecs = __pci_enable_msix_range(dev, NULL, min_vecs, max_vecs, + 1168. affd); + 1169. if (vecs > 0) + +scripts/asn1_compiler.c:1207: error: UNINITIALIZED_VALUE + The value read from children was never initialized. + 1205. + 1206. *_cursor = cursor; + 1207. > return children; + 1208. + 1209. overrun_error: + +drivers/usb/core/devio.c:1190: error: UNINITIALIZED_VALUE + The value read from bulk.data was never initialized. + 1188. tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. > if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + 1191. ret = -EINVAL; + 1192. goto done; + +drivers/usb/core/devio.c:1165: error: UNINITIALIZED_VALUE + The value read from bulk.ep was never initialized. + 1163. if (copy_from_user(&bulk, arg, sizeof(bulk))) + 1164. return -EFAULT; + 1165. > ret = findintfep(ps->dev, bulk.ep); + 1166. if (ret < 0) + 1167. return ret; + +drivers/usb/core/devio.c:1177: error: UNINITIALIZED_VALUE + The value read from bulk.len was never initialized. + 1175. if (!usb_maxpacket(dev, pipe, !(bulk.ep & USB_DIR_IN))) + 1176. return -EINVAL; + 1177. > len1 = bulk.len; + 1178. if (len1 >= (INT_MAX - sizeof(struct urb))) + 1179. return -EINVAL; + +drivers/usb/core/devio.c:1188: error: UNINITIALIZED_VALUE + The value read from bulk.timeout was never initialized. + 1186. goto done; + 1187. } + 1188. > tmo = bulk.timeout; + 1189. if (bulk.ep & 0x80) { + 1190. if (len1 && !access_ok(VERIFY_WRITE, bulk.data, len1)) { + +net/wireless/trace.h:1157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/wireless/trace.h:1157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1155. ); + 1156. + 1157. > TRACE_EVENT(rdev_deauth, + 1158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1159. struct cfg80211_deauth_request *req), + +net/sunrpc/auth_gss/svcauth_gss.c:1167: error: DEAD_STORE + The value written to &status (type int) is never used. + 1165. struct gss_api_mech *gm = NULL; + 1166. time_t expiry; + 1167. > int status = -EINVAL; + 1168. + 1169. memset(&rsci, 0, sizeof(rsci)); + +net/sunrpc/auth_gss/svcauth_gss.c:1205: error: DEAD_STORE + The value written to &status (type int) is never used. + 1203. rsci.cred.cr_gss_mech = gm; + 1204. + 1205. > status = -EINVAL; + 1206. /* mech-specific data: */ + 1207. status = gss_import_sec_context(ud->out_handle.data, + +net/core/rtnetlink.c:1265: error: UNINITIALIZED_VALUE + The value read from vf_stats.broadcast was never initialized. + 1263. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1264. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1265. > nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1266. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1267. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + +net/core/rtnetlink.c:1267: error: UNINITIALIZED_VALUE + The value read from vf_stats.multicast was never initialized. + 1265. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + 1266. vf_stats.broadcast, IFLA_VF_STATS_PAD) || + 1267. > nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + 1268. vf_stats.multicast, IFLA_VF_STATS_PAD) || + 1269. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + +net/core/rtnetlink.c:1261: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_bytes was never initialized. + 1259. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1260. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1261. > nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1262. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1263. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + +net/core/rtnetlink.c:1269: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_dropped was never initialized. + 1267. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST, + 1268. vf_stats.multicast, IFLA_VF_STATS_PAD) || + 1269. > nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + 1270. vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || + 1271. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, + +net/core/rtnetlink.c:1257: error: UNINITIALIZED_VALUE + The value read from vf_stats.rx_packets was never initialized. + 1255. if (!vfstats) + 1256. goto nla_put_vf_failure; + 1257. > if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1258. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1259. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + +net/core/rtnetlink.c:1263: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_bytes was never initialized. + 1261. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + 1262. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) || + 1263. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES, + 1264. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) || + 1265. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST, + +net/core/rtnetlink.c:1271: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_dropped was never initialized. + 1269. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED, + 1270. vf_stats.rx_dropped, IFLA_VF_STATS_PAD) || + 1271. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED, + 1272. vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) { + 1273. nla_nest_cancel(skb, vfstats); + +net/core/rtnetlink.c:1259: error: UNINITIALIZED_VALUE + The value read from vf_stats.tx_packets was never initialized. + 1257. if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS, + 1258. vf_stats.rx_packets, IFLA_VF_STATS_PAD) || + 1259. > nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS, + 1260. vf_stats.tx_packets, IFLA_VF_STATS_PAD) || + 1261. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES, + +net/sched/act_api.c:1168: error: DEAD_STORE + The value written to &t (type tcamsg*) is never used. + 1166. struct tc_action_ops *a_o; + 1167. int ret = 0; + 1168. > struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); + 1169. struct nlattr *tb[TCA_ROOT_MAX + 1]; + 1170. struct nlattr *count_attr = NULL; + +net/xfrm/xfrm_policy.c:1168: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1166. rcu_read_lock(); + 1167. again: + 1168. > pol = rcu_dereference(sk->sk_policy[dir]); + 1169. if (pol != NULL) { + 1170. bool match; + +net/ipv6/ip6_output.c:1217: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1215. v6_cork->tclass = ipc6->tclass; + 1216. if (rt->dst.flags & DST_XFRM_TUNNEL) + 1217. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1218. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1219. else + +net/ipv6/ip6_output.c:1220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1218. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(&rt->dst); + 1219. else + 1220. > mtu = np->pmtudisc >= IPV6_PMTUDISC_PROBE ? + 1221. READ_ONCE(rt->dst.dev->mtu) : dst_mtu(xfrm_dst_path(&rt->dst)); + 1222. if (np->frag_size < mtu) { + +lib/rhashtable.c:1179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1177. unsigned int nhash; + 1178. + 1179. > ntbl = (union nested_table *)rcu_dereference_raw(tbl->buckets[0]); + 1180. hash >>= tbl->nest; + 1181. nhash = index; + +drivers/usb/host/uhci-q.c:1182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1180. int len; + 1181. + 1182. > ctrlstat = td_status(uhci, td); + 1183. status = uhci_status_bits(ctrlstat); + 1184. if (status & TD_CTRL_ACTIVE) + +net/netfilter/nf_conntrack_sip.c:1265: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1178 could be null and is dereferenced at line 1265, column 3. + 1263. store_cseq: + 1264. if (ret == NF_ACCEPT) + 1265. > ct_sip_info->register_cseq = cseq; + 1266. return ret; + 1267. } + +net/netfilter/nf_conntrack_sip.c:1250: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1248. exp->flags = NF_CT_EXPECT_PERMANENT | NF_CT_EXPECT_INACTIVE; + 1249. + 1250. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1251. if (hooks && ct->status & IPS_NAT_MASK) + 1252. ret = hooks->expect(skb, protoff, dataoff, dptr, datalen, + +net/sunrpc/clnt.c:1180: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1178. + 1179. rcu_read_lock(); + 1180. > xprt = rcu_dereference(clnt->cl_xprt); + 1181. + 1182. bytes = xprt->addrlen; + +drivers/tty/serial/serial_core.c:1224: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1222. uart_port_deref(uport); + 1223. + 1224. > return ret; + 1225. } + 1226. + +net/netlabel/netlabel_unlabeled.c:1196: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1194. rcu_read_lock(); + 1195. for (iter_bkt = skip_bkt; + 1196. > iter_bkt < rcu_dereference(netlbl_unlhsh)->size; + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + +net/netlabel/netlabel_unlabeled.c:1198: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1196. iter_bkt < rcu_dereference(netlbl_unlhsh)->size; + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. > iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + 1199. list_for_each_entry_rcu(iface, iter_list, list) { + 1200. if (!iface->valid || + +net/netlabel/netlabel_unlabeled.c:1199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1197. iter_bkt++, iter_chain = 0, iter_addr4 = 0, iter_addr6 = 0) { + 1198. iter_list = &rcu_dereference(netlbl_unlhsh)->tbl[iter_bkt]; + 1199. > list_for_each_entry_rcu(iface, iter_list, list) { + 1200. if (!iface->valid || + 1201. iter_chain++ < skip_chain) + +net/wireless/trace.h:1178: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +net/wireless/trace.h:1178: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1176. ); + 1177. + 1178. > TRACE_EVENT(rdev_disassoc, + 1179. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1180. struct cfg80211_disassoc_request *req), + +drivers/net/ethernet/broadcom/tg3.c:1213: error: DEAD_STORE + The value written to &frame_val (type unsigned int) is never used. + 1211. if ((frame_val & MI_COM_BUSY) == 0) { + 1212. udelay(5); + 1213. > frame_val = tr32(MAC_MI_COM); + 1214. break; + 1215. } + +lib/radix-tree.c:1185: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1183. radix_tree_update_node_t update_node) + 1184. { + 1185. > void *old = rcu_dereference_raw(*slot); + 1186. int exceptional = !!radix_tree_exceptional_entry(item) - + 1187. !!radix_tree_exceptional_entry(old); + +net/ipv4/tcp.c:1426: error: UNINITIALIZED_VALUE + The value read from size_goal was never initialized. + 1424. if (copied) { + 1425. tcp_tx_timestamp(sk, sockc.tsflags); + 1426. > tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1427. } + 1428. out_nopush: + +net/ipv4/tcp.c:1425: error: UNINITIALIZED_VALUE + The value read from sockc.tsflags was never initialized. + 1423. out: + 1424. if (copied) { + 1425. > tcp_tx_timestamp(sk, sockc.tsflags); + 1426. tcp_push(sk, flags, mss_now, tp->nonagle, size_goal); + 1427. } + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1226: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1224. *batch++ = lower_32_bits(addr); + 1225. *batch++ = upper_32_bits(addr); + 1226. > *batch++ = upper_32_bits(target_offset); + 1227. } else { + 1228. *batch++ = (MI_STORE_DWORD_IMM_GEN4 | (1 << 21)) + 1; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1232: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1230. *batch++ = upper_32_bits(addr); + 1231. *batch++ = lower_32_bits(target_offset); + 1232. > *batch++ = upper_32_bits(target_offset); + 1233. } + 1234. } else if (gen >= 6) { + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1238: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1236. *batch++ = 0; + 1237. *batch++ = addr; + 1238. > *batch++ = target_offset; + 1239. } else if (gen >= 4) { + 1240. *batch++ = MI_STORE_DWORD_IMM_GEN4 | MI_USE_GGTT; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1243: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1241. *batch++ = 0; + 1242. *batch++ = addr; + 1243. > *batch++ = target_offset; + 1244. } else { + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1247: error: DEAD_STORE + The value written to &batch (type unsigned int*) is never used. + 1245. *batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL; + 1246. *batch++ = addr; + 1247. > *batch++ = target_offset; + 1248. } + 1249. + +arch/x86/events/core.c:1187: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1185. void x86_pmu_enable_event(struct perf_event *event) + 1186. { + 1187. > if (__this_cpu_read(cpu_hw_events.enabled)) + 1188. __x86_pmu_enable_event(&event->hw, + 1189. ARCH_PERFMON_EVENTSEL_ENABLE); + +net/sunrpc/auth_gss/auth_gss.c:1194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1192. { + 1193. struct gss_auth *gss_auth; + 1194. > struct rpc_xprt_switch *xps = rcu_access_pointer(clnt->cl_xpi.xpi_xpswitch); + 1195. + 1196. while (clnt != clnt->cl_parent) { + +net/sunrpc/auth_gss/auth_gss.c:1199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1197. struct rpc_clnt *parent = clnt->cl_parent; + 1198. /* Find the original parent for this transport */ + 1199. > if (rcu_access_pointer(parent->cl_xpi.xpi_xpswitch) != xps) + 1200. break; + 1201. clnt = parent; + +arch/x86/pci/irq.c:1197: error: DEAD_STORE + The value written to &msg (type char*) is never used. + 1195. pci_read_config_byte(dev, PCI_INTERRUPT_PIN, &pin); + 1196. if (pin && !pcibios_lookup_irq(dev, 1)) { + 1197. > char *msg = ""; + 1198. + 1199. if (!io_apic_assign_pci_irqs && dev->irq) + +kernel/relay.c:1203: error: DEAD_STORE + The value written to &pos (type unsigned long long) is never used. + 1201. uint64_t pos = (uint64_t) *ppos; + 1202. uint32_t alloc_size = (uint32_t) rbuf->chan->alloc_size; + 1203. > size_t read_start = (size_t) do_div(pos, alloc_size); + 1204. size_t read_subbuf = read_start / subbuf_size; + 1205. size_t padding = rbuf->padding[read_subbuf]; + +net/ipv4/af_inet.c:1208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1206. /* Reroute. */ + 1207. rcu_read_lock(); + 1208. > inet_opt = rcu_dereference(inet->inet_opt); + 1209. daddr = inet->inet_daddr; + 1210. if (inet_opt && inet_opt->opt.srr) + +drivers/gpu/drm/i915/intel_lrc.c:1197: error: DEAD_STORE + The value written to &ce (type intel_context*) is never used. + 1195. { + 1196. struct intel_engine_cs *engine = request->engine; + 1197. > struct intel_context *ce = &request->ctx->engine[engine->id]; + 1198. int ret; + 1199. + +net/netfilter/nf_conntrack_netlink.c:1251: error: DEAD_STORE + The value written to &err (type int) is never used. + 1249. ct = nf_ct_tuplehash_to_ctrack(h); + 1250. + 1251. > err = -ENOMEM; + 1252. skb2 = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); + 1253. if (skb2 == NULL) { + +net/netfilter/nf_conntrack_core.c:1249: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1247. + 1248. if (timeout_ext) + 1249. > nf_ct_timeout_ext_add(ct, rcu_dereference(timeout_ext->timeout), + 1250. GFP_ATOMIC); + 1251. + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +net/rfkill/core.c:1230: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1228. if (rfkill->type == ev.type || + 1229. ev.type == RFKILL_TYPE_ALL) + 1230. > rfkill_set_block(rfkill, ev.soft); + 1231. ret = 0; + 1232. break; + +net/rfkill/core.c:1238: error: UNINITIALIZED_VALUE + The value read from ev.soft was never initialized. + 1236. (rfkill->type == ev.type || + 1237. ev.type == RFKILL_TYPE_ALL)) + 1238. > rfkill_set_block(rfkill, ev.soft); + 1239. ret = 0; + 1240. break; + +net/rfkill/core.c:1226: error: UNINITIALIZED_VALUE + The value read from ev.type was never initialized. + 1224. switch (ev.op) { + 1225. case RFKILL_OP_CHANGE_ALL: + 1226. > rfkill_update_global_state(ev.type, ev.soft); + 1227. list_for_each_entry(rfkill, &rfkill_list, node) + 1228. if (rfkill->type == ev.type || + +drivers/iommu/intel-iommu.c:1244: error: DEAD_STORE + The value written to &last_pte (type dma_pte*) is never used. + 1242. if (first_pte) + 1243. domain_flush_cache(domain, first_pte, + 1244. > (void *)++last_pte - (void *)first_pte); + 1245. + 1246. return freelist; + +security/selinux/ss/policydb.c:1213: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1211. if (rc < 0) + 1212. return -EINVAL; + 1213. > t->flags = le32_to_cpu(buf[0]); + 1214. + 1215. return 0; + +net/sunrpc/clnt.c:1206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1204. struct rpc_xprt *xprt; + 1205. + 1206. > xprt = rcu_dereference(clnt->cl_xprt); + 1207. + 1208. if (xprt->address_strings[format] != NULL) + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +arch/x86/events/intel/p4.c:1210: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1208. unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)]; + 1209. unsigned long escr_mask[BITS_TO_LONGS(P4_ESCR_MSR_TABLE_SIZE)]; + 1210. > int cpu = smp_processor_id(); + 1211. struct hw_perf_event *hwc; + 1212. struct p4_event_bind *bind; + +net/wireless/trace.h:1206: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/wireless/trace.h:1206: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1204. ); + 1205. + 1206. > TRACE_EVENT(rdev_mgmt_tx_cancel_wait, + 1207. TP_PROTO(struct wiphy *wiphy, + 1208. struct wireless_dev *wdev, u64 cookie), + +net/ipv6/calipso.c:1216: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1212 could be null and is dereferenced at line 1216, column 6. + 1214. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1215. + 1216. > if (req_inet->ipv6_opt && req_inet->ipv6_opt->hopopt) + 1217. old = req_inet->ipv6_opt->hopopt; + 1218. else + +drivers/base/power/main.c:1218: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1216. idx = device_links_read_lock(); + 1217. + 1218. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1219. link->supplier->power.must_resume = true; + 1220. + +net/core/net-sysfs.c:1230: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1228. + 1229. rcu_read_lock(); + 1230. > dev_maps = rcu_dereference(dev->xps_maps); + 1231. if (dev_maps) { + 1232. for_each_possible_cpu(cpu) { + +net/core/net-sysfs.c:1236: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1234. struct xps_map *map; + 1235. + 1236. > map = rcu_dereference(dev_maps->cpu_map[tci]); + 1237. if (!map) + 1238. continue; + +kernel/exit.c:1241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1239. *p_code = 0; + 1240. + 1241. > uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1242. unlock_sig: + 1243. spin_unlock_irq(&p->sighand->siglock); + +net/ipv6/addrconf.c:1260: error: UNINITIALIZED_VALUE + The value read from expires was never initialized. + 1258. + 1259. if (action != CLEANUP_PREFIX_RT_NOP) { + 1260. > cleanup_prefix_route(ifp, expires, + 1261. action == CLEANUP_PREFIX_RT_DEL); + 1262. } + +net/socket.c:1265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1263. * Otherwise module support will break! + 1264. */ + 1265. > if (rcu_access_pointer(net_families[family]) == NULL) + 1266. request_module("net-pf-%d", family); + 1267. #endif + +net/socket.c:1270: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1268. + 1269. rcu_read_lock(); + 1270. > pf = rcu_dereference(net_families[family]); + 1271. err = -EAFNOSUPPORT; + 1272. if (!pf) + +security/selinux/ss/policydb.c:1243: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1241. if (rc) + 1242. return rc; + 1243. > c->permissions = le32_to_cpu(buf[0]); + 1244. nexpr = le32_to_cpu(buf[1]); + 1245. le = NULL; + +security/selinux/ss/policydb.c:1244: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1242. return rc; + 1243. c->permissions = le32_to_cpu(buf[0]); + 1244. > nexpr = le32_to_cpu(buf[1]); + 1245. le = NULL; + 1246. depth = -1; + +security/selinux/ss/policydb.c:1260: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1258. if (rc) + 1259. return rc; + 1260. > e->expr_type = le32_to_cpu(buf[0]); + 1261. e->attr = le32_to_cpu(buf[1]); + 1262. e->op = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1261: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1259. return rc; + 1260. e->expr_type = le32_to_cpu(buf[0]); + 1261. > e->attr = le32_to_cpu(buf[1]); + 1262. e->op = le32_to_cpu(buf[2]); + 1263. + +security/selinux/ss/policydb.c:1262: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1260. e->expr_type = le32_to_cpu(buf[0]); + 1261. e->attr = le32_to_cpu(buf[1]); + 1262. > e->op = le32_to_cpu(buf[2]); + 1263. + 1264. switch (e->expr_type) { + +kernel/time/tick-sched.c:1238: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1236. u64 offset = ktime_to_ns(tick_period) >> 1; + 1237. do_div(offset, num_possible_cpus()); + 1238. > offset *= smp_processor_id(); + 1239. hrtimer_add_expires_ns(&ts->sched_timer, offset); + 1240. } + +net/ipv4/igmp.c:1237: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1235. /* clear dead sources, too */ + 1236. rcu_read_lock(); + 1237. > for_each_pmc_rcu(in_dev, pmc) { + 1238. struct ip_sf_list *psf, *psf_next; + 1239. + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &next (type unsigned int) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +lib/iov_iter.c:1234: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1232. if (unlikely(i->count < bytes)) + 1233. return false; + 1234. > iterate_all_kinds(i, bytes, v, ({ + 1235. int err = 0; + 1236. next = csum_and_copy_from_user(v.iov_base, + +drivers/net/ethernet/intel/e1000/e1000_ethtool.c:1241: error: DEAD_STORE + The value written to &ctrl_reg (type unsigned int) is never used. + 1239. } + 1240. + 1241. > ctrl_reg = er32(CTRL); + 1242. + 1243. /* force 1000, set loopback */ + +net/wireless/trace.h:1224: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +net/wireless/trace.h:1224: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1222. ); + 1223. + 1224. > TRACE_EVENT(rdev_set_power_mgmt, + 1225. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1226. bool enabled, int timeout), + +include/linux/sched.h:1231: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1229. rcu_read_lock(); + 1230. if (pid_alive(tsk)) + 1231. > pid = task_tgid_nr_ns(rcu_dereference(tsk->real_parent), ns); + 1232. rcu_read_unlock(); + 1233. + +kernel/events/uprobes.c:1234: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1232. + 1233. /* Pairs with xol_add_vma() smp_store_release() */ + 1234. > area = READ_ONCE(mm->uprobes_state.xol_area); /* ^^^ */ + 1235. return area; + 1236. } + +net/core/ethtool.c:1250: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1248. if (copy_from_user(&rxfh, useraddr, sizeof(rxfh))) + 1249. return -EFAULT; + 1250. > user_indir_size = rxfh.indir_size; + 1251. user_key_size = rxfh.key_size; + 1252. + +net/core/ethtool.c:1251: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1249. return -EFAULT; + 1250. user_indir_size = rxfh.indir_size; + 1251. > user_key_size = rxfh.key_size; + 1252. + 1253. /* Check that reserved fields are 0 for now */ + +drivers/scsi/scsi_transport_spi.c:1235: error: DEAD_STORE + The value written to &msg (type unsigned char*) is never used. + 1233. if (cmd->flags & SCMD_TAGGED) { + 1234. *msg++ = SIMPLE_QUEUE_TAG; + 1235. > *msg++ = cmd->request->tag; + 1236. return 2; + 1237. } + +drivers/tty/serial/serial_core.c:1257: error: UNINITIALIZED_VALUE + The value read from cnow.brk was never initialized. + 1255. icount->overrun = cnow.overrun; + 1256. icount->parity = cnow.parity; + 1257. > icount->brk = cnow.brk; + 1258. icount->buf_overrun = cnow.buf_overrun; + 1259. + +drivers/tty/serial/serial_core.c:1258: error: UNINITIALIZED_VALUE + The value read from cnow.buf_overrun was never initialized. + 1256. icount->parity = cnow.parity; + 1257. icount->brk = cnow.brk; + 1258. > icount->buf_overrun = cnow.buf_overrun; + 1259. + 1260. return 0; + +drivers/tty/serial/serial_core.c:1248: error: UNINITIALIZED_VALUE + The value read from cnow.cts was never initialized. + 1246. uart_port_deref(uport); + 1247. + 1248. > icount->cts = cnow.cts; + 1249. icount->dsr = cnow.dsr; + 1250. icount->rng = cnow.rng; + +drivers/tty/serial/serial_core.c:1251: error: UNINITIALIZED_VALUE + The value read from cnow.dcd was never initialized. + 1249. icount->dsr = cnow.dsr; + 1250. icount->rng = cnow.rng; + 1251. > icount->dcd = cnow.dcd; + 1252. icount->rx = cnow.rx; + 1253. icount->tx = cnow.tx; + +drivers/tty/serial/serial_core.c:1249: error: UNINITIALIZED_VALUE + The value read from cnow.dsr was never initialized. + 1247. + 1248. icount->cts = cnow.cts; + 1249. > icount->dsr = cnow.dsr; + 1250. icount->rng = cnow.rng; + 1251. icount->dcd = cnow.dcd; + +drivers/tty/serial/serial_core.c:1254: error: UNINITIALIZED_VALUE + The value read from cnow.frame was never initialized. + 1252. icount->rx = cnow.rx; + 1253. icount->tx = cnow.tx; + 1254. > icount->frame = cnow.frame; + 1255. icount->overrun = cnow.overrun; + 1256. icount->parity = cnow.parity; + +drivers/tty/serial/serial_core.c:1255: error: UNINITIALIZED_VALUE + The value read from cnow.overrun was never initialized. + 1253. icount->tx = cnow.tx; + 1254. icount->frame = cnow.frame; + 1255. > icount->overrun = cnow.overrun; + 1256. icount->parity = cnow.parity; + 1257. icount->brk = cnow.brk; + +drivers/tty/serial/serial_core.c:1256: error: UNINITIALIZED_VALUE + The value read from cnow.parity was never initialized. + 1254. icount->frame = cnow.frame; + 1255. icount->overrun = cnow.overrun; + 1256. > icount->parity = cnow.parity; + 1257. icount->brk = cnow.brk; + 1258. icount->buf_overrun = cnow.buf_overrun; + +drivers/tty/serial/serial_core.c:1250: error: UNINITIALIZED_VALUE + The value read from cnow.rng was never initialized. + 1248. icount->cts = cnow.cts; + 1249. icount->dsr = cnow.dsr; + 1250. > icount->rng = cnow.rng; + 1251. icount->dcd = cnow.dcd; + 1252. icount->rx = cnow.rx; + +drivers/tty/serial/serial_core.c:1252: error: UNINITIALIZED_VALUE + The value read from cnow.rx was never initialized. + 1250. icount->rng = cnow.rng; + 1251. icount->dcd = cnow.dcd; + 1252. > icount->rx = cnow.rx; + 1253. icount->tx = cnow.tx; + 1254. icount->frame = cnow.frame; + +drivers/tty/serial/serial_core.c:1253: error: UNINITIALIZED_VALUE + The value read from cnow.tx was never initialized. + 1251. icount->dcd = cnow.dcd; + 1252. icount->rx = cnow.rx; + 1253. > icount->tx = cnow.tx; + 1254. icount->frame = cnow.frame; + 1255. icount->overrun = cnow.overrun; + +net/ipv4/devinet.c:1279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1277. in dev_base list. + 1278. */ + 1279. > for_each_netdev_rcu(net, dev) { + 1280. if (l3mdev_master_ifindex_rcu(dev) != master_idx) + 1281. continue; + +drivers/gpu/drm/i915/i915_debugfs.c:1307: error: UNINITIALIZED_VALUE + The value read from acthd[_] was never initialized. + 1305. spin_unlock_irq(&b->rb_lock); + 1306. + 1307. > seq_printf(m, "\tACTHD = 0x%08llx [current 0x%08llx]\n", + 1308. (long long)engine->hangcheck.acthd, + 1309. (long long)acthd[id]); + +drivers/gpu/drm/i915/i915_debugfs.c:1288: error: UNINITIALIZED_VALUE + The value read from seqno[_] was never initialized. + 1286. + 1287. seq_printf(m, "%s:\n", engine->name); + 1288. > seq_printf(m, "\tseqno = %x [current %x, last %x], inflight %d\n", + 1289. engine->hangcheck.seqno, seqno[id], + 1290. intel_engine_last_submit(engine), + +net/ipv6/ip6_output.c:1541: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 1539. cork->length -= length; + 1540. IP6_INC_STATS(sock_net(sk), rt->rt6i_idev, IPSTATS_MIB_OUTDISCARDS); + 1541. > return err; + 1542. } + 1543. + +net/ipv6/route.c:1252: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1250. *bucket += hval; + 1251. + 1252. > hlist_for_each_entry_rcu(rt6_ex, &(*bucket)->chain, hlist) { + 1253. struct rt6_info *rt6 = rt6_ex->rt6i; + 1254. bool matched = ipv6_addr_equal(daddr, &rt6->rt6i_dst.addr); + +drivers/ata/libahci.c:1258: error: DEAD_STORE + The value written to &tmp (type unsigned int) is never used. + 1256. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1257. writel(tmp | HOST_IRQ_EN, mmio + HOST_CTL); + 1258. > tmp = readl(mmio + HOST_CTL); + 1259. VPRINTK("HOST_CTL 0x%x\n", tmp); + 1260. } + +kernel/signal.c:1254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1252. local_irq_save(*flags); + 1253. rcu_read_lock(); + 1254. > sighand = rcu_dereference(tsk->sighand); + 1255. if (unlikely(sighand == NULL)) { + 1256. rcu_read_unlock(); + +kernel/signal.c:1281: error: UNINITIALIZED_VALUE + The value read from sighand was never initialized. + 1279. } + 1280. + 1281. > return sighand; + 1282. } + 1283. + +drivers/gpu/drm/i915/i915_gem.c:1316: error: UNINITIALIZED_VALUE + The value read from node.start was never initialized. + 1314. * page_length = bytes to copy for this page + 1315. */ + 1316. > u32 page_base = node.start; + 1317. unsigned int page_offset = offset_in_page(offset); + 1318. unsigned int page_length = PAGE_SIZE - page_offset; + +net/wireless/trace.h:1245: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +net/wireless/trace.h:1245: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1243. ); + 1244. + 1245. > TRACE_EVENT(rdev_connect, + 1246. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1247. struct cfg80211_connect_params *sme), + +kernel/events/core.c:1257: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1255. again: + 1256. rcu_read_lock(); + 1257. > ctx = READ_ONCE(event->ctx); + 1258. if (!atomic_inc_not_zero(&ctx->refcount)) { + 1259. rcu_read_unlock(); + +net/ipv6/calipso.c:1257: error: NULL_DEREFERENCE + pointer `req_inet` last assigned on line 1252 could be null and is dereferenced at line 1257, column 7. + 1255. struct sock *sk = sk_to_full_sk(req_to_sk(req)); + 1256. + 1257. > if (!req_inet->ipv6_opt || !req_inet->ipv6_opt->hopopt) + 1258. return; + 1259. + +include/linux/sched.h:1253: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1251. static inline unsigned int task_state_index(struct task_struct *tsk) + 1252. { + 1253. > unsigned int tsk_state = READ_ONCE(tsk->state); + 1254. unsigned int state = (tsk_state | tsk->exit_state) & TASK_REPORT; + 1255. + +net/core/filter.c:1263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1261. if (err) + 1262. return err; + 1263. > } else if (!rcu_access_pointer(sk->sk_reuseport_cb)) { + 1264. /* The socket wasn't bound with SO_REUSEPORT */ + 1265. return -EINVAL; + +net/ipv4/af_inet.c:1303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1301. } + 1302. + 1303. > ops = rcu_dereference(inet_offloads[proto]); + 1304. if (likely(ops && ops->callbacks.gso_segment)) + 1305. segs = ops->callbacks.gso_segment(skb, features); + +drivers/char/random.c:1267: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1265. /* Can we pull enough? */ + 1266. retry: + 1267. > entropy_count = orig = READ_ONCE(r->entropy_count); + 1268. ibytes = nbytes; + 1269. /* never pull more than available */ + +net/netlabel/netlabel_unlabeled.c:1274: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1272. + 1273. rcu_read_lock(); + 1274. > iface = rcu_dereference(netlbl_unlhsh_def); + 1275. if (iface == NULL || !iface->valid) + 1276. goto unlabel_staticlistdef_return; + +kernel/trace/trace.h:1263: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1261. struct ring_buffer_event *event) + 1262. { + 1263. > if (this_cpu_read(trace_buffered_event) == event) { + 1264. /* Simply release the temp buffer */ + 1265. this_cpu_dec(trace_buffered_event_cnt); + +scripts/kconfig/symbol.c:1273: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1272 could be null and is dereferenced at line 1273, column 2. + 1271. + 1272. prop = sym_get_choice_prop(choice); + 1273. > expr_list_for_each_sym(prop->expr, e, sym) + 1274. sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED); + 1275. + +drivers/gpu/drm/i915/intel_tv.c:1302: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 1300. + 1301. if (status == connector_status_connected) { + 1302. > intel_tv->type = type; + 1303. intel_tv_find_better_format(connector); + 1304. } + +net/ipv4/tcp_ipv4.c:1273: error: DEAD_STORE + The value written to &net (type net*) is never used. + 1271. { + 1272. struct inet_request_sock *ireq = inet_rsk(req); + 1273. > struct net *net = sock_net(sk_listener); + 1274. + 1275. sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr); + +net/netfilter/nf_conntrack_sip.c:1293: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1276 could be null and is dereferenced at line 1293, column 6. + 1291. * request and compare it here. + 1292. */ + 1293. > if (ct_sip_info->register_cseq != cseq) + 1294. return NF_ACCEPT; + 1295. + +net/ipv6/addrconf.c:1327: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1325. * idev->desync_factor if it's larger + 1326. */ + 1327. > cnf_temp_preferred_lft = READ_ONCE(idev->cnf.temp_prefered_lft); + 1328. max_desync_factor = min_t(__u32, + 1329. idev->cnf.max_desync_factor, + +kernel/time/hrtimer.c:1277: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1275. + 1276. do { + 1277. > base = READ_ONCE(timer->base); + 1278. seq = raw_read_seqcount_begin(&base->seq); + 1279. + +net/ipv4/route.c:1289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1287. return mtu; + 1288. + 1289. > mtu = READ_ONCE(dst->dev->mtu); + 1290. + 1291. if (unlikely(ip_mtu_locked(dst))) { + +net/wireless/trace.h:1280: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +net/wireless/trace.h:1280: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1278. ); + 1279. + 1280. > TRACE_EVENT(rdev_update_connect_params, + 1281. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1282. struct cfg80211_connect_params *sme, u32 changed), + +block/bio.c:1312: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1310. + 1311. if (unlikely(offs & queue_dma_alignment(q))) { + 1312. > ret = -EINVAL; + 1313. j = 0; + 1314. } else { + +kernel/exit.c:1302: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1300. if (!unlikely(wo->wo_flags & WNOWAIT)) + 1301. p->signal->flags &= ~SIGNAL_STOP_CONTINUED; + 1302. > uid = from_kuid_munged(current_user_ns(), task_uid(p)); + 1303. spin_unlock_irq(&p->sighand->siglock); + 1304. + +drivers/usb/core/devio.c:1291: error: UNINITIALIZED_VALUE + The value read from gd.interface was never initialized. + 1289. if (copy_from_user(&gd, arg, sizeof(gd))) + 1290. return -EFAULT; + 1291. > intf = usb_ifnum_to_if(ps->dev, gd.interface); + 1292. if (!intf || !intf->dev.driver) + 1293. ret = -ENODATA; + +net/netfilter/nf_conntrack_netlink.c:1293: error: DEAD_STORE + The value written to &l3proto (type unsigned char) is never used. + 1291. struct hlist_nulls_node *n; + 1292. struct nfgenmsg *nfmsg = nlmsg_data(cb->nlh); + 1293. > u_int8_t l3proto = nfmsg->nfgen_family; + 1294. int res; + 1295. int cpu; + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +kernel/trace/ring_buffer.c:1328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1326. goto fail_free_cpumask; + 1327. + 1328. > cpu = raw_smp_processor_id(); + 1329. cpumask_set_cpu(cpu, buffer->cpumask); + 1330. buffer->buffers[cpu] = rb_allocate_cpu_buffer(buffer, nr_pages, cpu); + +net/sunrpc/auth_gss/svcauth_gss.c:1298: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1296. + 1297. WARN_ON_ONCE(type != 0 && type != 1); + 1298. > ret = cmpxchg(&sn->use_gss_proxy, -1, type); + 1299. if (ret != -1 && ret != type) + 1300. return -EBUSY; + +drivers/net/ethernet/marvell/sky2.c:1312: error: UNINITIALIZED_VALUE + The value read from rss_key[_] was never initialized. + 1310. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 1311. for (i = 0; i < nkeys; i++) + 1312. > sky2_write32(hw, SK_REG(sky2->port, RSS_KEY + i * 4), + 1313. rss_key[i]); + 1314. + +kernel/cgroup/cgroup-v1.c:1311: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 1310 could be null and is dereferenced at line 1311, column 22. + 1309. + 1310. for_each_subsys(ss, i) { + 1311. > if (strcmp(token, ss->name) && + 1312. strcmp(token, ss->legacy_name)) + 1313. continue; + +net/ipv4/fib_trie.c:1314: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1312. cindex = 0; + 1313. + 1314. > n = get_child_rcu(pn, cindex); + 1315. if (!n) + 1316. return -EAGAIN; + +net/ipv4/fib_trie.c:1355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1353. } + 1354. + 1355. > n = get_child_rcu(n, index); + 1356. if (unlikely(!n)) + 1357. goto backtrace; + +net/ipv4/fib_trie.c:1381: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1379. */ + 1380. + 1381. > while ((n = rcu_dereference(*cptr)) == NULL) { + 1382. backtrace: + 1383. #ifdef CONFIG_IP_FIB_TRIE_STATS + +net/ipv4/fib_trie.c:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. #endif + 1404. /* Get Child's index */ + 1405. > pn = node_parent_rcu(pn); + 1406. cindex = get_index(pkey, pn); + 1407. } + +net/ipv4/fib_trie.c:1422: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1420. + 1421. /* Step 3: Process the leaf, if that fails fall back to backtracing */ + 1422. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) { + 1423. struct fib_info *fi = fa->fa_info; + 1424. int nhsel, err; + +net/core/ethtool.c:1355: error: UNINITIALIZED_VALUE + The value read from rxfh.indir_size was never initialized. + 1353. rxfh.indir_size != ETH_RXFH_INDIR_NO_CHANGE) { + 1354. indir = (u32 *)rss_config; + 1355. > ret = ethtool_copy_validate_indir(indir, + 1356. useraddr + rss_cfg_offset, + 1357. &rx_rings, + +net/core/ethtool.c:1369: error: UNINITIALIZED_VALUE + The value read from rxfh.key_size was never initialized. + 1367. if (rxfh.key_size) { + 1368. hkey = rss_config + indir_bytes; + 1369. > if (copy_from_user(hkey, + 1370. useraddr + rss_cfg_offset + indir_bytes, + 1371. rxfh.key_size)) { + +net/core/dev.c:1304: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1302. + 1303. rcu_read_lock(); + 1304. > alias = rcu_dereference(dev->ifalias); + 1305. if (alias) + 1306. ret = snprintf(name, len, "%s", alias->ifalias); + +net/wireless/trace.h:1298: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +net/wireless/trace.h:1298: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1296. ); + 1297. + 1298. > TRACE_EVENT(rdev_set_cqm_rssi_config, + 1299. TP_PROTO(struct wiphy *wiphy, + 1300. struct net_device *netdev, s32 rssi_thold, + +scripts/kconfig/symbol.c:1318: error: NULL_DEREFERENCE + pointer `prop` last assigned on line 1317 could be null and is dereferenced by call to `prop_get_symbol()` at line 1318, column 25. + 1316. dep_stack_insert(&stack, sym); + 1317. prop = sym_get_choice_prop(sym); + 1318. > sym2 = sym_check_deps(prop_get_symbol(prop)); + 1319. dep_stack_remove(); + 1320. } else if (sym_is_choice(sym)) { + +net/ipv4/route.c:1303: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1301. static struct fib_nh_exception *find_exception(struct fib_nh *nh, __be32 daddr) + 1302. { + 1303. > struct fnhe_hash_bucket *hash = rcu_dereference(nh->nh_exceptions); + 1304. struct fib_nh_exception *fnhe; + 1305. u32 hval; + +net/ipv4/route.c:1312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1310. hval = fnhe_hashfun(daddr); + 1311. + 1312. > for (fnhe = rcu_dereference(hash[hval].chain); fnhe; + 1313. fnhe = rcu_dereference(fnhe->fnhe_next)) { + 1314. if (fnhe->fnhe_daddr == daddr) + +net/ipv4/route.c:1313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1311. + 1312. for (fnhe = rcu_dereference(hash[hval].chain); fnhe; + 1313. > fnhe = rcu_dereference(fnhe->fnhe_next)) { + 1314. if (fnhe->fnhe_daddr == daddr) + 1315. return fnhe; + +drivers/base/regmap/regmap.c:1313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1311. kfree(map->work_buf); + 1312. while (!list_empty(&map->async_free)) { + 1313. > async = list_first_entry_or_null(&map->async_free, + 1314. struct regmap_async, + 1315. list); + +block/blk-mq.c:1326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1324. * handle dispatched requests to this hctx + 1325. */ + 1326. > if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + +block/blk-mq.c:1329: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + 1329. > raw_smp_processor_id(), + 1330. cpumask_empty(hctx->cpumask) ? "inactive": "active"); + 1331. dump_stack(); + +block/blk-mq.c:1326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1324. * handle dispatched requests to this hctx + 1325. */ + 1326. > if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + +block/blk-mq.c:1328: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1326. if (!cpumask_test_cpu(raw_smp_processor_id(), hctx->cpumask) && + 1327. cpu_online(hctx->next_cpu)) { + 1328. > printk(KERN_WARNING "run queue from wrong CPU %d, hctx %s\n", + 1329. raw_smp_processor_id(), + 1330. cpumask_empty(hctx->cpumask) ? "inactive": "active"); + +kernel/signal.c:1313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1311. success = 0; + 1312. retval = -ESRCH; + 1313. > do_each_pid_task(pgrp, PIDTYPE_PGID, p) { + 1314. int err = group_send_sig_info(sig, info, p); + 1315. success |= !err; + +lib/vsprintf.c:1316: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 1314. bool uc = false; + 1315. + 1316. > switch (*(++fmt)) { + 1317. case 'L': + 1318. uc = true; /* fall-through */ + +drivers/usb/host/ehci-hub.c:1313: error: DEAD_STORE + The value written to &portnum (type int) is never used. + 1311. if (ehci_is_TDI(ehci)) + 1312. return; + 1313. > set_owner(ehci, --portnum, PORT_OWNER); + 1314. } + 1315. + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &size (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +lib/iov_iter.c:1329: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1327. if (npages >= maxpages) + 1328. return maxpages; + 1329. > } else iterate_all_kinds(i, size, v, ({ + 1330. unsigned long p = (unsigned long)v.iov_base; + 1331. npages += DIV_ROUND_UP(p + v.iov_len, PAGE_SIZE) + +net/ipv6/ip6_fib.c:1330: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1328. dir = addr_bit_set(args->addr, fn->fn_bit); + 1329. + 1330. > next = dir ? rcu_dereference(fn->right) : + 1331. rcu_dereference(fn->left); + 1332. + +net/ipv6/ip6_fib.c:1331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1329. + 1330. next = dir ? rcu_dereference(fn->right) : + 1331. > rcu_dereference(fn->left); + 1332. + 1333. if (next) { + +net/ipv6/ip6_fib.c:1344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1342. + 1343. if (subtree || fn->fn_flags & RTN_RTINFO) { + 1344. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 1345. struct rt6key *key; + 1346. + +net/ipv6/ip6_fib.c:1370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1368. break; + 1369. + 1370. > fn = rcu_dereference(fn->parent); + 1371. } + 1372. + +kernel/rcu/tree.c:1321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1319. WRITE_ONCE(rsp->jiffies_stall, j + j1); + 1320. rsp->jiffies_resched = j + j1 / 2; + 1321. > rsp->n_force_qs_gpstart = READ_ONCE(rsp->n_force_qs); + 1322. } + 1323. + +block/genhd.c:1332: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1330. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1331. while ((hd = disk_part_iter_next(&piter))) { + 1332. > cpu = part_stat_lock(); + 1333. part_round_stats(gp->queue, cpu, hd); + 1334. part_stat_unlock(); + +block/genhd.c:1332: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1330. disk_part_iter_init(&piter, gp, DISK_PITER_INCL_EMPTY_PART0); + 1331. while ((hd = disk_part_iter_next(&piter))) { + 1332. > cpu = part_stat_lock(); + 1333. part_round_stats(gp->queue, cpu, hd); + 1334. part_stat_unlock(); + +security/selinux/ss/policydb.c:1331: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1329. goto bad; + 1330. + 1331. > len = le32_to_cpu(buf[0]); + 1332. len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1332: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1330. + 1331. len = le32_to_cpu(buf[0]); + 1332. > len2 = le32_to_cpu(buf[1]); + 1333. cladatum->value = le32_to_cpu(buf[2]); + 1334. + +security/selinux/ss/policydb.c:1333: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1331. len = le32_to_cpu(buf[0]); + 1332. len2 = le32_to_cpu(buf[1]); + 1333. > cladatum->value = le32_to_cpu(buf[2]); + 1334. + 1335. rc = symtab_init(&cladatum->permissions, PERM_SYMTAB_SIZE); + +security/selinux/ss/policydb.c:1338: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1336. if (rc) + 1337. goto bad; + 1338. > cladatum->permissions.nprim = le32_to_cpu(buf[3]); + 1339. nel = le32_to_cpu(buf[4]); + 1340. + +security/selinux/ss/policydb.c:1339: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1337. goto bad; + 1338. cladatum->permissions.nprim = le32_to_cpu(buf[3]); + 1339. > nel = le32_to_cpu(buf[4]); + 1340. + 1341. ncons = le32_to_cpu(buf[5]); + +security/selinux/ss/policydb.c:1341: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1339. nel = le32_to_cpu(buf[4]); + 1340. + 1341. > ncons = le32_to_cpu(buf[5]); + 1342. + 1343. rc = str_read(&key, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:1374: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1372. if (rc) + 1373. goto bad; + 1374. > ncons = le32_to_cpu(buf[0]); + 1375. rc = read_cons_helper(p, &cladatum->validatetrans, + 1376. ncons, 1, fp); + +security/selinux/ss/policydb.c:1386: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1384. goto bad; + 1385. + 1386. > cladatum->default_user = le32_to_cpu(buf[0]); + 1387. cladatum->default_role = le32_to_cpu(buf[1]); + 1388. cladatum->default_range = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1387: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1385. + 1386. cladatum->default_user = le32_to_cpu(buf[0]); + 1387. > cladatum->default_role = le32_to_cpu(buf[1]); + 1388. cladatum->default_range = le32_to_cpu(buf[2]); + 1389. } + +security/selinux/ss/policydb.c:1388: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1386. cladatum->default_user = le32_to_cpu(buf[0]); + 1387. cladatum->default_role = le32_to_cpu(buf[1]); + 1388. > cladatum->default_range = le32_to_cpu(buf[2]); + 1389. } + 1390. + +security/selinux/ss/policydb.c:1395: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1393. if (rc) + 1394. goto bad; + 1395. > cladatum->default_type = le32_to_cpu(buf[0]); + 1396. } + 1397. + +kernel/auditfilter.c:1325: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1323. if (list_empty(&audit_filter_list[listtype])) + 1324. goto unlock_and_return; + 1325. > list_for_each_entry_rcu(e, &audit_filter_list[listtype], list) { + 1326. int i, result = 0; + 1327. + +net/ipv4/route.c:1336: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1334. else + 1335. porig = &fnhe->fnhe_rth_output; + 1336. > orig = rcu_dereference(*porig); + 1337. + 1338. if (fnhe->fnhe_genid != genid) { + +net/wireless/trace.h:1321: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/wireless/trace.h:1321: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1319. ); + 1320. + 1321. > TRACE_EVENT(rdev_set_cqm_rssi_range_config, + 1322. TP_PROTO(struct wiphy *wiphy, + 1323. struct net_device *netdev, s32 low, s32 high), + +net/xfrm/xfrm_policy.c:1332: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1330. rcu_read_lock(); + 1331. for (i = 0; i < 2; i++) { + 1332. > p = rcu_dereference(osk->sk_policy[i]); + 1333. if (p) { + 1334. np = clone_policy(p, i); + +net/ipv4/tcp_ipv4.c:1365: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1363. newsk->sk_bound_dev_if = ireq->ir_iif; + 1364. newinet->inet_saddr = ireq->ir_loc_addr; + 1365. > inet_opt = rcu_dereference(ireq->ireq_opt); + 1366. RCU_INIT_POINTER(newinet->inet_opt, inet_opt); + 1367. newinet->mc_index = inet_iif(skb); + +ipc/sem.c:1361: error: DEAD_STORE + The value written to &err (type int) is never used. + 1359. goto out_rcu_wakeup; + 1360. + 1361. > err = -EACCES; + 1362. switch (cmd) { + 1363. case GETALL: + +kernel/exit.c:1342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1340. * can't confuse the checks below. + 1341. */ + 1342. > int exit_state = READ_ONCE(p->exit_state); + 1343. int ret; + 1344. + +kernel/sched/core.c:1425: error: UNINITIALIZED_VALUE + The value read from ncsw was never initialized. + 1423. } + 1424. + 1425. > return ncsw; + 1426. } + 1427. + +kernel/rcu/tree.c:1343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1341. + 1342. j = jiffies; + 1343. > gpa = READ_ONCE(rsp->gp_activity); + 1344. if (j - gpa > 2 * HZ) { + 1345. pr_err("%s kthread starved for %ld jiffies! g%lu c%lu f%#x %s(%d) ->state=%#lx ->cpu=%d\n", + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +kernel/workqueue.c:1353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1351. return cpu; + 1352. + 1353. > new_cpu = __this_cpu_read(wq_rr_cpu_last); + 1354. new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask); + 1355. if (unlikely(new_cpu >= nr_cpu_ids)) { + +arch/x86/events/intel/p4.c:1347: error: DEAD_STORE + The value written to &high (type unsigned int) is never used. + 1345. BUILD_BUG_ON(ARCH_P4_MAX_CCCR > INTEL_PMC_MAX_GENERIC); + 1346. + 1347. > rdmsr(MSR_IA32_MISC_ENABLE, low, high); + 1348. if (!(low & (1 << 7))) { + 1349. pr_cont("unsupported Netburst CPU model %d ", + +net/sunrpc/clnt.c:1349: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1347. + 1348. rcu_read_lock(); + 1349. > xprt = rcu_dereference(clnt->cl_xprt); + 1350. salen = xprt->addrlen; + 1351. memcpy(sap, &xprt->addr, salen); + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.altsetting was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +drivers/usb/core/devio.c:1349: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1347. if (copy_from_user(&setintf, arg, sizeof(setintf))) + 1348. return -EFAULT; + 1349. > ret = checkintf(ps, setintf.interface); + 1350. if (ret) + 1351. return ret; + +drivers/usb/core/devio.c:1353: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1351. return ret; + 1352. + 1353. > destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. return usb_set_interface(ps->dev, setintf.interface, + +drivers/usb/core/devio.c:1355: error: UNINITIALIZED_VALUE + The value read from setintf.interface was never initialized. + 1353. destroy_async_on_interface(ps, setintf.interface); + 1354. + 1355. > return usb_set_interface(ps->dev, setintf.interface, + 1356. setintf.altsetting); + 1357. } + +net/ipv4/devinet.c:1352: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1350. + 1351. rcu_read_lock(); + 1352. > for_each_netdev_rcu(net, dev) { + 1353. in_dev = __in_dev_get_rcu(dev); + 1354. if (in_dev) { + +net/wireless/trace.h:1343: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +net/wireless/trace.h:1343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1341. ); + 1342. + 1343. > TRACE_EVENT(rdev_set_cqm_txe_config, + 1344. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, + 1345. u32 pkts, u32 intvl), + +kernel/sys.c:1356: error: UNINITIALIZED_VALUE + The value read from r32.rlim_cur was never initialized. + 1354. r.rlim_cur = RLIM_INFINITY; + 1355. else + 1356. > r.rlim_cur = r32.rlim_cur; + 1357. if (r32.rlim_max == COMPAT_RLIM_INFINITY) + 1358. r.rlim_max = RLIM_INFINITY; + +kernel/sys.c:1360: error: UNINITIALIZED_VALUE + The value read from r32.rlim_max was never initialized. + 1358. r.rlim_max = RLIM_INFINITY; + 1359. else + 1360. > r.rlim_max = r32.rlim_max; + 1361. return do_prlimit(current, resource, &r, NULL); + 1362. } + +net/ipv4/tcp_input.c:1473: error: DEAD_STORE + The value written to &pcount (type int) is never used. + 1471. len = skb->len; + 1472. if (skb_shift(prev, skb, len)) { + 1473. > pcount += tcp_skb_pcount(skb); + 1474. tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb), + 1475. len, mss, 0); + +net/ipv4/af_inet.c:1374: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1372. + 1373. rcu_read_lock(); + 1374. > ops = rcu_dereference(inet_offloads[proto]); + 1375. if (!ops || !ops->callbacks.gro_receive) + 1376. goto out_unlock; + +net/packet/af_packet.c:1355: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1353. unsigned int num) + 1354. { + 1355. > return smp_processor_id() % num; + 1356. } + 1357. + +kernel/signal.c:1355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1353. struct task_struct *target) + 1354. { + 1355. > const struct cred *pcred = __task_cred(target); + 1356. if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) && + 1357. !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid)) + +kernel/events/core.c:1370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1368. local_irq_save(*flags); + 1369. rcu_read_lock(); + 1370. > ctx = rcu_dereference(task->perf_event_ctxp[ctxn]); + 1371. if (ctx) { + 1372. /* + +kernel/events/core.c:1383: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1381. */ + 1382. raw_spin_lock(&ctx->lock); + 1383. > if (ctx != rcu_dereference(task->perf_event_ctxp[ctxn])) { + 1384. raw_spin_unlock(&ctx->lock); + 1385. rcu_read_unlock(); + +drivers/cpufreq/intel_pstate.c:1361: error: DEAD_STORE + The value written to &pstate (type int) is never used. + 1359. + 1360. update_turbo_state(); + 1361. > pstate = intel_pstate_get_base_pstate(cpu); + 1362. pstate = max(cpu->pstate.min_pstate, cpu->max_perf_ratio); + 1363. intel_pstate_set_pstate(cpu, pstate); + +net/netlink/af_netlink.c:1364: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1362. + 1363. rcu_read_lock(); + 1364. > listeners = rcu_dereference(nl_table[sk->sk_protocol].listeners); + 1365. + 1366. if (listeners && group - 1 < nl_table[sk->sk_protocol].groups) + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +kernel/workqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1388. retry: + 1389. if (req_cpu == WORK_CPU_UNBOUND) + 1390. > cpu = wq_select_unbound_cpu(raw_smp_processor_id()); + 1391. + 1392. /* pwq which will be used unless @work is executing elsewhere */ + +net/sunrpc/clnt.c:1371: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1369. + 1370. rcu_read_lock(); + 1371. > xprt = rcu_dereference(clnt->cl_xprt); + 1372. if (xprt->ops->set_buffer_size) + 1373. xprt->ops->set_buffer_size(xprt, sndsize, rcvsize); + +net/sunrpc/auth_gss/auth_gss.c:1376: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1374. + 1375. rcu_read_lock(); + 1376. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1377. if (!ctx) + 1378. goto out; + +net/sunrpc/auth_gss/auth_gss.c:1392: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1390. + 1391. rcu_read_lock(); + 1392. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1393. + 1394. /* did the ctx disappear or was it replaced by one with no acceptor? */ + +net/wireless/trace.h:1366: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/wireless/trace.h:1366: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1364. ); + 1365. + 1366. > TRACE_EVENT(rdev_disconnect, + 1367. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1368. u16 reason_code), + +net/ipv4/route.c:1383: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1381. */ + 1382. dst_hold(&rt->dst); + 1383. > prev = cmpxchg(p, orig, rt); + 1384. if (prev == orig) { + 1385. if (orig) { + +drivers/usb/host/uhci-q.c:1385: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1383. uhci_remove_tds_from_frame(uhci, qh->iso_frame); + 1384. + 1385. > ctrlstat = td_status(uhci, td); + 1386. if (ctrlstat & TD_CTRL_ACTIVE) { + 1387. status = -EXDEV; /* TD was added too late? */ + +ipc/mqueue.c:1391: error: UNINITIALIZED_VALUE + The value read from v.mq_curmsgs was never initialized. + 1389. attr->mq_maxmsg = v.mq_maxmsg; + 1390. attr->mq_msgsize = v.mq_msgsize; + 1391. > attr->mq_curmsgs = v.mq_curmsgs; + 1392. return 0; + 1393. } + +ipc/mqueue.c:1388: error: UNINITIALIZED_VALUE + The value read from v.mq_flags was never initialized. + 1386. + 1387. memset(attr, 0, sizeof(*attr)); + 1388. > attr->mq_flags = v.mq_flags; + 1389. attr->mq_maxmsg = v.mq_maxmsg; + 1390. attr->mq_msgsize = v.mq_msgsize; + +ipc/mqueue.c:1389: error: UNINITIALIZED_VALUE + The value read from v.mq_maxmsg was never initialized. + 1387. memset(attr, 0, sizeof(*attr)); + 1388. attr->mq_flags = v.mq_flags; + 1389. > attr->mq_maxmsg = v.mq_maxmsg; + 1390. attr->mq_msgsize = v.mq_msgsize; + 1391. attr->mq_curmsgs = v.mq_curmsgs; + +ipc/mqueue.c:1390: error: UNINITIALIZED_VALUE + The value read from v.mq_msgsize was never initialized. + 1388. attr->mq_flags = v.mq_flags; + 1389. attr->mq_maxmsg = v.mq_maxmsg; + 1390. > attr->mq_msgsize = v.mq_msgsize; + 1391. attr->mq_curmsgs = v.mq_curmsgs; + 1392. return 0; + +kernel/sched/rt.c:1394: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1392. + 1393. rcu_read_lock(); + 1394. > curr = READ_ONCE(rq->curr); /* unlocked access */ + 1395. + 1396. /* + +net/sunrpc/clnt.c:1388: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1386. + 1387. rcu_read_lock(); + 1388. > ret = rcu_dereference(clnt->cl_xprt)->xprt_net; + 1389. rcu_read_unlock(); + 1390. return ret; + +net/core/net-sysfs.c:1405: error: DEAD_STORE + The value written to &txq (type int) is never used. + 1403. if (error) + 1404. goto error; + 1405. > txq = real_tx; + 1406. + 1407. return 0; + +net/wireless/trace.h:1384: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +net/wireless/trace.h:1384: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1382. ); + 1383. + 1384. > TRACE_EVENT(rdev_join_ibss, + 1385. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1386. struct cfg80211_ibss_params *params), + +kernel/rcu/tree.c:1391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1389. if (!rcu_kick_kthreads) + 1390. return; + 1391. > j = READ_ONCE(rsp->jiffies_kick_kthreads); + 1392. if (time_after(jiffies, j) && rsp->gp_kthread && + 1393. (rcu_gp_in_progress(rsp) || READ_ONCE(rsp->gp_flags))) { + +arch/x86/events/intel/ds.c:1485: error: UNINITIALIZED_VALUE + The value read from counts[_] was never initialized. + 1483. + 1484. if (counts[bit]) { + 1485. > __intel_pmu_pebs_event(event, iregs, base, + 1486. top, bit, counts[bit]); + 1487. } + +arch/x86/events/intel/ds.c:1478: error: UNINITIALIZED_VALUE + The value read from error[_] was never initialized. + 1476. /* log dropped samples number */ + 1477. if (error[bit]) { + 1478. > perf_log_lost_samples(event, error[bit]); + 1479. + 1480. if (perf_event_account_interrupt(event)) + +drivers/gpu/drm/i915/intel_overlay.c:1429: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1427. if (IS_ERR(vma)) { + 1428. DRM_ERROR("failed to pin overlay register bo\n"); + 1429. > ret = PTR_ERR(vma); + 1430. goto out_free_bo; + 1431. } + +net/ipv6/route.c:1397: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1395. struct rt6_info *res = NULL; + 1396. + 1397. > bucket = rcu_dereference(rt->rt6i_exception_bucket); + 1398. + 1399. #ifdef CONFIG_IPV6_SUBTREES + +drivers/md/dm.c:1399: error: NULL_DEREFERENCE + pointer `tio` last assigned on line 1398 could be null and is dereferenced at line 1399, column 2. + 1397. + 1398. tio = alloc_tio(ci, ti, 0, GFP_NOIO); + 1399. > tio->len_ptr = len; + 1400. r = clone_bio(tio, bio, sector, *len); + 1401. if (r < 0) { + +scripts/kconfig/symbol.c:1403: error: NULL_DEREFERENCE + pointer `sym2` last assigned on line 1402 could be null and is dereferenced at line 1403, column 14. + 1401. for_all_properties(sym, prop, P_ENV) { + 1402. sym2 = prop_get_symbol(prop); + 1403. > if (strcmp(sym2->name, env)) + 1404. menu_warn(current_entry, "redefining environment symbol from %s", + 1405. sym2->name); + +net/ipv6/udp.c:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. if (static_key_false(&udpv6_encap_needed) && up->encap_type) { + 1404. void (*encap_destroy)(struct sock *sk); + 1405. > encap_destroy = READ_ONCE(up->encap_destroy); + 1406. if (encap_destroy) + 1407. encap_destroy(sk); + +block/blk-mq.c:1409: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1407. + 1408. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1409. > int cpu = get_cpu(); + 1410. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1411. __blk_mq_run_hw_queue(hctx); + +block/blk-mq.c:1409: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1407. + 1408. if (!async && !(hctx->flags & BLK_MQ_F_BLOCKING)) { + 1409. > int cpu = get_cpu(); + 1410. if (cpumask_test_cpu(cpu, hctx->cpumask)) { + 1411. __blk_mq_run_hw_queue(hctx); + +net/netfilter/nf_conntrack_netlink.c:1407: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1405. int err; + 1406. + 1407. > parse_nat_setup = rcu_dereference(nfnetlink_parse_nat_setup_hook); + 1408. if (!parse_nat_setup) { + 1409. #ifdef CONFIG_MODULES + +net/netfilter/nf_conntrack_sip.c:1423: error: NULL_DEREFERENCE + pointer `ct_sip_info` last assigned on line 1405 could be null and is dereferenced at line 1423, column 3. + 1421. port != ct->tuplehash[dir].tuple.src.u.udp.port && + 1422. nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3)) + 1423. > ct_sip_info->forced_dport = port; + 1424. + 1425. for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) { + +drivers/md/dm-raid1.c:1422: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1420. (unsigned long long)ms->nr_regions, buffer); + 1421. + 1422. > sz += log->type->status(log, type, result+sz, maxlen-sz); + 1423. + 1424. break; + +drivers/md/dm-raid1.c:1441: error: DEAD_STORE + The value written to &sz (type unsigned int) is never used. + 1439. DMEMIT(" handle_errors"); + 1440. if (keep_log(ms)) + 1441. > DMEMIT(" keep_log"); + 1442. } + 1443. + +net/sunrpc/clnt.c:1408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1406. + 1407. rcu_read_lock(); + 1408. > ret = rcu_dereference(clnt->cl_xprt)->max_payload; + 1409. rcu_read_unlock(); + 1410. return ret; + +drivers/gpu/drm/i915/i915_debugfs.c:1415: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1413. + 1414. for_each_fw_domain(fw_domain, i915, tmp) + 1415. > seq_printf(m, "%s.wake_count = %u\n", + 1416. intel_uncore_forcewake_domain_to_str(fw_domain->id), + 1417. READ_ONCE(fw_domain->wake_count)); + +drivers/gpu/vga/vgaarb.c:1468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1466. + 1467. if (!vga_default_device()) { + 1468. > vgadev = list_first_entry_or_null(&vga_list, + 1469. struct vga_device, list); + 1470. if (vgadev) { + +net/wireless/trace.h:1405: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +net/wireless/trace.h:1405: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1403. ); + 1404. + 1405. > TRACE_EVENT(rdev_join_ocb, + 1406. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1407. const struct ocb_setup *setup), + +kernel/fork.c:1411: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1409. unsigned long cpu_limit; + 1410. + 1411. > cpu_limit = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur); + 1412. if (cpu_limit != RLIM_INFINITY) { + 1413. sig->cputime_expires.prof_exp = cpu_limit * NSEC_PER_SEC; + +kernel/rcu/tree.c:1474: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1472. } else { + 1473. j = jiffies; + 1474. > gpa = READ_ONCE(rsp->gp_activity); + 1475. pr_err("All QSes seen, last %s kthread activity %ld (%ld-%ld), jiffies_till_next_fqs=%ld, root ->qsmask %#lx\n", + 1476. rsp->name, j - gpa, j, gpa, + +kernel/rcu/tree.c:1460: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1458. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1459. cpu)->cblist); + 1460. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1461. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1462. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +kernel/rcu/tree.c:1460: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1458. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda, + 1459. cpu)->cblist); + 1460. > pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n", + 1461. smp_processor_id(), (long)(jiffies - rsp->gp_start), + 1462. (long)rsp->gpnum, (long)rsp->completed, totqlen); + +kernel/signal.c:1430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1428. struct task_struct * p; + 1429. + 1430. > for_each_process(p) { + 1431. if (task_pid_vnr(p) > 1 && + 1432. !same_thread_group(p, current)) { + +security/selinux/ss/policydb.c:1427: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1425. goto bad; + 1426. + 1427. > len = le32_to_cpu(buf[0]); + 1428. role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +security/selinux/ss/policydb.c:1428: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1426. + 1427. len = le32_to_cpu(buf[0]); + 1428. > role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1430. role->bounds = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1430: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1428. role->value = le32_to_cpu(buf[1]); + 1429. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1430. > role->bounds = le32_to_cpu(buf[2]); + 1431. + 1432. rc = str_read(&key, GFP_KERNEL, fp, len); + +net/packet/af_packet.c:1419: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1417. + 1418. rcu_read_lock(); + 1419. > prog = rcu_dereference(f->bpf_prog); + 1420. if (prog) + 1421. ret = bpf_prog_run_clear_cb(prog, skb) % num; + +drivers/net/ethernet/broadcom/tg3.c:1421: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 1420 could be null and is dereferenced at line 1421, column 10. + 1419. + 1420. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 1421. > switch (phydev->drv->phy_id & phydev->drv->phy_id_mask) { + 1422. case PHY_ID_BCM50610: + 1423. case PHY_ID_BCM50610M: + +net/ipv6/ip6_fib.c:1425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1423. + 1424. for (fn = root; fn ; ) { + 1425. > struct rt6_info *leaf = rcu_dereference(fn->leaf); + 1426. struct rt6key *key; + 1427. + +net/ipv6/ip6_fib.c:1455: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1453. */ + 1454. if (addr_bit_set(addr, fn->fn_bit)) + 1455. > fn = rcu_dereference(fn->right); + 1456. else + 1457. fn = rcu_dereference(fn->left); + +net/ipv6/ip6_fib.c:1457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1455. fn = rcu_dereference(fn->right); + 1456. else + 1457. > fn = rcu_dereference(fn->left); + 1458. } + 1459. out: + +net/ipv6/route.c:1430: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1428. return -EINVAL; + 1429. + 1430. > if (!rcu_access_pointer(from->rt6i_exception_bucket)) + 1431. return -ENOENT; + 1432. + +net/sunrpc/clnt.c:1424: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1422. + 1423. rcu_read_lock(); + 1424. > xprt = rcu_dereference(clnt->cl_xprt); + 1425. ret = xprt->ops->bc_maxpayload(xprt); + 1426. rcu_read_unlock(); + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1434: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1432. return -EFAULT; + 1433. + 1434. > result = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, oldlen, + 1435. tmp.newval, tmp.newlen); + 1436. + +kernel/sysctl_binary.c:1431: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1429. return -EFAULT; + 1430. + 1431. > if (tmp.oldlenp && get_user(oldlen, tmp.oldlenp)) + 1432. return -EFAULT; + 1433. + +kernel/sysctl_binary.c:1442: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1440. } + 1441. + 1442. > if (tmp.oldlenp && put_user(oldlen, tmp.oldlenp)) + 1443. return -EFAULT; + 1444. + +drivers/gpu/drm/i915/intel_tv.c:1432: error: NULL_DEREFERENCE + pointer `old_state` last assigned on line 1429 could be null and is dereferenced at line 1432, column 6. + 1430. new_crtc_state = drm_atomic_get_new_crtc_state(new_state->state, new_state->crtc); + 1431. + 1432. > if (old_state->tv.mode != new_state->tv.mode || + 1433. old_state->tv.margins.left != new_state->tv.margins.left || + 1434. old_state->tv.margins.right != new_state->tv.margins.right || + +net/wireless/trace.h:1421: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/wireless/trace.h:1421: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1419. ); + 1420. + 1421. > TRACE_EVENT(rdev_set_wiphy_params, + 1422. TP_PROTO(struct wiphy *wiphy, u32 changed), + 1423. TP_ARGS(wiphy, changed), + +net/sunrpc/auth_gss/auth_gss.c:1434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1432. + 1433. rcu_read_lock(); + 1434. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1435. if (!ctx || time_after(timeout, ctx->gc_expiry)) + 1436. ret = -EACCES; + +drivers/block/loop.c:1442: error: UNINITIALIZED_VALUE + The value read from info.lo_device was never initialized. + 1440. memset(info64, 0, sizeof(*info64)); + 1441. info64->lo_number = info.lo_number; + 1442. > info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + +drivers/block/loop.c:1448: error: UNINITIALIZED_VALUE + The value read from info.lo_encrypt_key_size was never initialized. + 1446. info64->lo_sizelimit = 0; + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. > info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. info64->lo_flags = info.lo_flags; + 1450. info64->lo_init[0] = info.lo_init[0]; + +drivers/block/loop.c:1447: error: UNINITIALIZED_VALUE + The value read from info.lo_encrypt_type was never initialized. + 1445. info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + 1447. > info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. info64->lo_flags = info.lo_flags; + +drivers/block/loop.c:1449: error: UNINITIALIZED_VALUE + The value read from info.lo_flags was never initialized. + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + 1448. info64->lo_encrypt_key_size = info.lo_encrypt_key_size; + 1449. > info64->lo_flags = info.lo_flags; + 1450. info64->lo_init[0] = info.lo_init[0]; + 1451. info64->lo_init[1] = info.lo_init[1]; + +drivers/block/loop.c:1443: error: UNINITIALIZED_VALUE + The value read from info.lo_inode was never initialized. + 1441. info64->lo_number = info.lo_number; + 1442. info64->lo_device = info.lo_device; + 1443. > info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + 1445. info64->lo_offset = info.lo_offset; + +drivers/block/loop.c:1441: error: UNINITIALIZED_VALUE + The value read from info.lo_number was never initialized. + 1439. + 1440. memset(info64, 0, sizeof(*info64)); + 1441. > info64->lo_number = info.lo_number; + 1442. info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + +drivers/block/loop.c:1445: error: UNINITIALIZED_VALUE + The value read from info.lo_offset was never initialized. + 1443. info64->lo_inode = info.lo_inode; + 1444. info64->lo_rdevice = info.lo_rdevice; + 1445. > info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + 1447. info64->lo_encrypt_type = info.lo_encrypt_type; + +drivers/block/loop.c:1444: error: UNINITIALIZED_VALUE + The value read from info.lo_rdevice was never initialized. + 1442. info64->lo_device = info.lo_device; + 1443. info64->lo_inode = info.lo_inode; + 1444. > info64->lo_rdevice = info.lo_rdevice; + 1445. info64->lo_offset = info.lo_offset; + 1446. info64->lo_sizelimit = 0; + +net/packet/af_packet.c:1436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1434. { + 1435. struct packet_fanout *f = pt->af_packet_priv; + 1436. > unsigned int num = READ_ONCE(f->num_members); + 1437. struct net *net = read_pnet(&f->net); + 1438. struct packet_sock *po; + +net/sunrpc/clnt.c:1440: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1438. if (clnt->cl_autobind) { + 1439. rcu_read_lock(); + 1440. > xprt_clear_bound(rcu_dereference(clnt->cl_xprt)); + 1441. rcu_read_unlock(); + 1442. } + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1436: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1434. ); + 1435. + 1436. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, + 1437. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1438. TP_ARGS(wiphy, wdev) + +drivers/base/regmap/regmap.c:1533: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1531. + 1532. spin_lock_irqsave(&map->async_lock, flags); + 1533. > async = list_first_entry_or_null(&map->async_free, + 1534. struct regmap_async, + 1535. list); + +kernel/sched/core.c:1447: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1445. preempt_disable(); + 1446. cpu = task_cpu(p); + 1447. > if ((cpu != smp_processor_id()) && task_curr(p)) + 1448. smp_send_reschedule(cpu); + 1449. preempt_enable(); + +net/wireless/trace.h:1441: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/wireless/trace.h:1441: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1439. ); + 1440. + 1441. > TRACE_EVENT(rdev_set_tx_power, + 1442. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1443. enum nl80211_tx_power_setting type, int mbm), + +net/sunrpc/auth_gss/auth_gss.c:1453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1451. /* Don't match with creds that have expired. */ + 1452. rcu_read_lock(); + 1453. > ctx = rcu_dereference(gss_cred->gc_ctx); + 1454. if (!ctx || time_after(jiffies, ctx->gc_expiry)) { + 1455. rcu_read_unlock(); + +net/ipv4/ipmr.c:1467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1465. } + 1466. if (optname != MRT_INIT) { + 1467. > if (sk != rcu_access_pointer(mrt->mroute_sk) && + 1468. !ns_capable(net->user_ns, CAP_NET_ADMIN)) { + 1469. ret = -EACCES; + +net/ipv4/ipmr.c:1496: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1494. break; + 1495. case MRT_DONE: + 1496. > if (sk != rcu_access_pointer(mrt->mroute_sk)) { + 1497. ret = -EACCES; + 1498. } else { + +net/ipv4/ipmr.c:1542: error: UNINITIALIZED_VALUE + The value read from mfc.mfcc_parent was never initialized. + 1540. } + 1541. if (parent == 0) + 1542. > parent = mfc.mfcc_parent; + 1543. if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY) + 1544. ret = ipmr_mfc_delete(mrt, &mfc, parent); + +net/ipv4/ipmr.c:1521: error: UNINITIALIZED_VALUE + The value read from vif.vifc_vifi was never initialized. + 1519. sk == rtnl_dereference(mrt->mroute_sk)); + 1520. } else { + 1521. > ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL); + 1522. } + 1523. break; + +net/ipv4/devinet.c:1466: error: DEAD_STORE + The value written to &in_dev (type in_device*) is never used. + 1464. /* Re-enabling IP */ + 1465. if (inetdev_valid_mtu(dev->mtu)) + 1466. > in_dev = inetdev_init(dev); + 1467. } + 1468. goto out; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &bytes (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +lib/iov_iter.c:1459: error: DEAD_STORE + The value written to &skip (type unsigned long) is never used. + 1457. return 0; + 1458. + 1459. > iterate_all_kinds(i, bytes, v, -EINVAL, ({ + 1460. w.iov_base = kmap(v.bv_page) + v.bv_offset; + 1461. w.iov_len = v.bv_len; + +drivers/gpu/drm/i915/i915_debugfs.c:1463: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1461. int count = 0; + 1462. + 1463. > forcewake_count = READ_ONCE(dev_priv->uncore.fw_domain[FW_DOMAIN_ID_RENDER].wake_count); + 1464. if (forcewake_count) { + 1465. seq_puts(m, "RC information inaccurate because somebody " + +net/netfilter/nf_conntrack_sip.c:1468: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1466. + 1467. if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) { + 1468. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1469. if (hooks && !hooks->msg(skb, protoff, dataoff, + 1470. dptr, datalen)) { + +kernel/kprobes.c:1467: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1465. + 1466. if (p != ap) { + 1467. > list_for_each_entry_rcu(list_p, &ap->list, list) + 1468. if (list_p == p) + 1469. /* kprobe p is a valid probe */ + +kernel/trace/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1459. static inline void *event_file_data(struct file *filp) + 1460. { + 1461. > return READ_ONCE(file_inode(filp)->i_private); + 1462. } + 1463. + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.name was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.newlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1480: error: UNINITIALIZED_VALUE + The value read from tmp.newval was never initialized. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. > compat_ptr(tmp.newval), tmp.newlen); + 1481. + 1482. if (result >= 0) { + +kernel/sysctl_binary.c:1478: error: UNINITIALIZED_VALUE + The value read from tmp.nlen was never initialized. + 1476. return -EFAULT; + 1477. + 1478. > result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + +kernel/sysctl_binary.c:1474: error: UNINITIALIZED_VALUE + The value read from tmp.oldlenp was never initialized. + 1472. return -EFAULT; + 1473. + 1474. > compat_oldlenp = compat_ptr(tmp.oldlenp); + 1475. if (compat_oldlenp && get_user(oldlen, compat_oldlenp)) + 1476. return -EFAULT; + +kernel/sysctl_binary.c:1479: error: UNINITIALIZED_VALUE + The value read from tmp.oldval was never initialized. + 1477. + 1478. result = do_sysctl(compat_ptr(tmp.name), tmp.nlen, + 1479. > compat_ptr(tmp.oldval), oldlen, + 1480. compat_ptr(tmp.newval), tmp.newlen); + 1481. + +net/wireless/trace.h:1461: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +net/wireless/trace.h:1461: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1459. ); + 1460. + 1461. > TRACE_EVENT(rdev_return_int_int, + 1462. TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), + 1463. TP_ARGS(wiphy, func_ret, func_fill), + +drivers/net/ethernet/intel/e100.c:1472: error: DEAD_STORE + The value written to &stat (type unsigned short) is never used. + 1470. nic->mii.phy_id = (addr == 0) ? 1 : (addr == 1) ? 0 : addr; + 1471. bmcr = mdio_read(netdev, nic->mii.phy_id, MII_BMCR); + 1472. > stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1473. stat = mdio_read(netdev, nic->mii.phy_id, MII_BMSR); + 1474. if (!((bmcr == 0xFFFF) || ((stat == 0) && (bmcr == 0)))) + +kernel/trace/trace_events_trigger.c:1472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1470. int ret = 0; + 1471. + 1472. > list_for_each_entry_rcu(test, &file->triggers, list) { + 1473. test_enable_data = test->private_data; + 1474. if (test_enable_data && + +net/ipv6/route.c:1475: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1473. + 1474. rcu_read_lock(); + 1475. > bucket = rcu_dereference(from->rt6i_exception_bucket); + 1476. + 1477. #ifdef CONFIG_IPV6_SUBTREES + +net/netlabel/netlabel_unlabeled.c:1472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1470. iface = netlbl_unlhsh_search_iface(skb->skb_iif); + 1471. if (iface == NULL) + 1472. > iface = rcu_dereference(netlbl_unlhsh_def); + 1473. if (iface == NULL || !iface->valid) + 1474. goto unlabel_getattr_nolabel; + +security/selinux/ss/policydb.c:1483: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1481. goto bad; + 1482. + 1483. > len = le32_to_cpu(buf[0]); + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + +security/selinux/ss/policydb.c:1484: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1482. + 1483. len = le32_to_cpu(buf[0]); + 1484. > typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + 1486. u32 prop = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1486: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1484. typdatum->value = le32_to_cpu(buf[1]); + 1485. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) { + 1486. > u32 prop = le32_to_cpu(buf[2]); + 1487. + 1488. if (prop & TYPEDATUM_PROPERTY_PRIMARY) + +security/selinux/ss/policydb.c:1493: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1491. typdatum->attribute = 1; + 1492. + 1493. > typdatum->bounds = le32_to_cpu(buf[3]); + 1494. } else { + 1495. typdatum->primary = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1495: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1493. typdatum->bounds = le32_to_cpu(buf[3]); + 1494. } else { + 1495. > typdatum->primary = le32_to_cpu(buf[2]); + 1496. } + 1497. + +net/core/rtnetlink.c:1481: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1479. return -EMSGSIZE; + 1480. + 1481. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 1482. struct nlattr *af; + 1483. int err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1496: error: DEAD_STORE + The value written to &c (type char) is never used. + 1494. end = addr + size; + 1495. for (; addr < end; addr += PAGE_SIZE) { + 1496. > int err = __get_user(c, addr); + 1497. if (err) + 1498. return err; + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:1500: error: DEAD_STORE + The value written to &c (type char) is never used. + 1498. return err; + 1499. } + 1500. > return __get_user(c, end - 1); + 1501. } + 1502. + +net/netfilter/nf_conntrack_sip.c:1555: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1553. const struct nf_nat_sip_hooks *hooks; + 1554. + 1555. > hooks = rcu_dereference(nf_nat_sip_hooks); + 1556. if (hooks) + 1557. hooks->seq_adjust(skb, protoff, tdiff); + +drivers/cpufreq/intel_pstate.c:1485: error: DEAD_STORE + The value written to &max_pstate (type int) is never used. + 1483. static int intel_pstate_prepare_request(struct cpudata *cpu, int pstate) + 1484. { + 1485. > int max_pstate = intel_pstate_get_base_pstate(cpu); + 1486. int min_pstate; + 1487. + +sound/core/control.c:1511: error: UNINITIALIZED_VALUE + The value read from header.length was never initialized. + 1509. if (header.length < sizeof(unsigned int) * 2) + 1510. return -EINVAL; + 1511. > container_size = header.length; + 1512. container = buf->tlv; + 1513. + +sound/core/control.c:1514: error: UNINITIALIZED_VALUE + The value read from header.numid was never initialized. + 1512. container = buf->tlv; + 1513. + 1514. > kctl = snd_ctl_find_numid(file->card, header.numid); + 1515. if (kctl == NULL) + 1516. return -ENOENT; + +kernel/rcu/tree.c:1512: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1510. print_cpu_stall_info_begin(); + 1511. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1512. > print_cpu_stall_info(rsp, smp_processor_id()); + 1513. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1514. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1541: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1539. * switches for an entirely unreasonable amount of time. + 1540. */ + 1541. > resched_cpu(smp_processor_id()); + 1542. } + 1543. + +kernel/rcu/tree.c:1512: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1510. print_cpu_stall_info_begin(); + 1511. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags); + 1512. > print_cpu_stall_info(rsp, smp_processor_id()); + 1513. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags); + 1514. print_cpu_stall_info_end(); + +kernel/rcu/tree.c:1541: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1539. * switches for an entirely unreasonable amount of time. + 1540. */ + 1541. > resched_cpu(smp_processor_id()); + 1542. } + 1543. + +net/core/net-sysfs.c:1501: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1499. * device is dead and about to be freed. + 1500. */ + 1501. > kfree(rcu_access_pointer(dev->ifalias)); + 1502. netdev_freemem(dev); + 1503. } + +security/keys/keyctl.c:1540: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1538. * there's no point */ + 1539. mycred = current_cred(); + 1540. > pcred = __task_cred(parent); + 1541. if (mycred == pcred || + 1542. mycred->session_keyring == pcred->session_keyring) { + +net/ipv4/netfilter/ip_tables.c:1516: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1514. tmp.name[sizeof(tmp.name)-1] = 0; + 1515. + 1516. > newinfo = xt_alloc_table_info(tmp.size); + 1517. if (!newinfo) + 1518. return -ENOMEM; + +net/ipv4/netfilter/ip_tables.c:1521: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1519. + 1520. loc_cpu_entry = newinfo->entries; + 1521. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1522. tmp.size) != 0) { + 1523. ret = -EFAULT; + +kernel/cgroup/cpuset.c:1503: error: DEAD_STORE + The value written to &cs (type cpuset*) is never used. + 1501. + 1502. cgroup_taskset_first(tset, &css); + 1503. > cs = css_cs(css); + 1504. + 1505. mutex_lock(&cpuset_mutex); + +kernel/trace/trace_events_trigger.c:1512: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1510. bool unregistered = false; + 1511. + 1512. > list_for_each_entry_rcu(data, &file->triggers, list) { + 1513. enable_data = data->private_data; + 1514. if (enable_data && + +net/ipv6/netfilter/ip6_tables.c:1526: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1524. tmp.name[sizeof(tmp.name)-1] = 0; + 1525. + 1526. > newinfo = xt_alloc_table_info(tmp.size); + 1527. if (!newinfo) + 1528. return -ENOMEM; + +net/ipv6/netfilter/ip6_tables.c:1531: error: UNINITIALIZED_VALUE + The value read from tmp.size was never initialized. + 1529. + 1530. loc_cpu_entry = newinfo->entries; + 1531. > if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), + 1532. tmp.size) != 0) { + 1533. ret = -EFAULT; + +net/wireless/trace.h:1506: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +net/wireless/trace.h:1506: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1504. #endif /* CONFIG_NL80211_TESTMODE */ + 1505. + 1506. > TRACE_EVENT(rdev_set_bitrate_mask, + 1507. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1508. const u8 *peer, const struct cfg80211_bitrate_mask *mask), + +kernel/trace/ring_buffer.c:1549: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 1547. first_page->prev = prev_page; + 1548. + 1549. > r = cmpxchg(&prev_page->next, head_page_with_bit, first_page); + 1550. + 1551. if (r == head_page_with_bit) { + +drivers/hid/hid-sony.c:1645: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1643. err_stop: + 1644. kfree(buf); + 1645. > return ret; + 1646. } + 1647. + +net/ipv4/ip_output.c:1518: error: DEAD_STORE + The value written to &rt (type rtable*) is never used. + 1516. struct ipcm_cookie ipc; + 1517. struct flowi4 fl4; + 1518. > struct rtable *rt = skb_rtable(skb); + 1519. struct net *net = sock_net(sk); + 1520. struct sk_buff *nskb; + +net/netfilter/nf_conntrack_netlink.c:1532: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1530. if (help) { + 1531. rcu_read_lock(); + 1532. > helper = rcu_dereference(help->helper); + 1533. if (helper && !strcmp(helper->name, helpname)) + 1534. err = 0; + +net/ipv4/tcp_ipv4.c:1541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1539. skb->destructor = sock_edemux; + 1540. if (sk_fullsock(sk)) { + 1541. > struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst); + 1542. + 1543. if (dst) + +security/selinux/ss/policydb.c:1528: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1526. return rc; + 1527. } + 1528. > lp->sens = le32_to_cpu(buf[0]); + 1529. + 1530. rc = ebitmap_read(&lp->cat, fp); + +kernel/time/timer.c:1530: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1528. * Possible pending timers will be migrated later to an active cpu. + 1529. */ + 1530. > if (cpu_is_offline(smp_processor_id())) + 1531. return expires; + 1532. + +kernel/time/timer.c:1530: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1528. * Possible pending timers will be migrated later to an active cpu. + 1529. */ + 1530. > if (cpu_is_offline(smp_processor_id())) + 1531. return expires; + 1532. + +net/ipv4/af_inet.c:1538: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1536. + 1537. rcu_read_lock(); + 1538. > ops = rcu_dereference(inet_offloads[proto]); + 1539. if (WARN_ON(!ops || !ops->callbacks.gro_complete)) + 1540. goto out_unlock; + +net/wireless/trace.h:1524: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +net/wireless/trace.h:1524: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1522. ); + 1523. + 1524. > TRACE_EVENT(rdev_mgmt_frame_register, + 1525. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1526. u16 frame_type, bool reg), + +drivers/pci/setup-bus.c:1532: error: DEAD_STORE + The value written to &idx (type int) is never used. + 1530. unsigned old_flags = 0; + 1531. struct resource *b_res; + 1532. > int idx = 1; + 1533. + 1534. b_res = &dev->resource[PCI_BRIDGE_RESOURCES]; + +kernel/events/uprobes.c:1532: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1530. + 1531. /* Pairs with xol_add_vma() smp_store_release() */ + 1532. > area = READ_ONCE(current->mm->uprobes_state.xol_area); /* ^^^ */ + 1533. if (area) + 1534. trampoline_vaddr = area->vaddr; + +drivers/cpufreq/intel_pstate.c:1534: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1532. + 1533. /* Don't allow remote callbacks */ + 1534. > if (smp_processor_id() != cpu->cpu) + 1535. return; + 1536. + +net/core/ethtool.c:1560: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1558. return -ENOMEM; + 1559. + 1560. > bytes_remaining = eeprom.len; + 1561. while (bytes_remaining > 0) { + 1562. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +security/selinux/ss/policydb.c:1557: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1555. goto bad; + 1556. + 1557. > len = le32_to_cpu(buf[0]); + 1558. usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + +security/selinux/ss/policydb.c:1558: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1556. + 1557. len = le32_to_cpu(buf[0]); + 1558. > usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1560. usrdatum->bounds = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1560: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1558. usrdatum->value = le32_to_cpu(buf[1]); + 1559. if (p->policyvers >= POLICYDB_VERSION_BOUNDARY) + 1560. > usrdatum->bounds = le32_to_cpu(buf[2]); + 1561. + 1562. rc = str_read(&key, GFP_KERNEL, fp, len); + +kernel/sys.c:1548: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1546. return 0; + 1547. + 1548. > tcred = __task_cred(task); + 1549. id_match = (uid_eq(cred->uid, tcred->euid) && + 1550. uid_eq(cred->uid, tcred->suid) && + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +drivers/gpu/drm/i915/intel_dpll_mgr.c:1559: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1557. I915_WRITE(BXT_PORT_PLL_ENABLE(port), temp); + 1558. + 1559. > if (wait_for_us(!(I915_READ(BXT_PORT_PLL_ENABLE(port)) & + 1560. PORT_PLL_POWER_STATE), 200)) + 1561. DRM_ERROR("Power state not reset for PLL:%d\n", port); + +kernel/rcu/tree.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. * and rsp->gp_start suffice to forestall false positives. + 1575. */ + 1576. > gpnum = READ_ONCE(rsp->gpnum); + 1577. smp_rmb(); /* Pick up ->gpnum first... */ + 1578. js = READ_ONCE(rsp->jiffies_stall); + +kernel/rcu/tree.c:1578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1576. gpnum = READ_ONCE(rsp->gpnum); + 1577. smp_rmb(); /* Pick up ->gpnum first... */ + 1578. > js = READ_ONCE(rsp->jiffies_stall); + 1579. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1580. gps = READ_ONCE(rsp->gp_start); + +kernel/rcu/tree.c:1580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1578. js = READ_ONCE(rsp->jiffies_stall); + 1579. smp_rmb(); /* ...then ->jiffies_stall before the rest... */ + 1580. > gps = READ_ONCE(rsp->gp_start); + 1581. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1582. completed = READ_ONCE(rsp->completed); + +kernel/rcu/tree.c:1582: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1580. gps = READ_ONCE(rsp->gp_start); + 1581. smp_rmb(); /* ...and finally ->gp_start before ->completed. */ + 1582. > completed = READ_ONCE(rsp->completed); + 1583. if (ULONG_CMP_GE(completed, gpnum) || + 1584. ULONG_CMP_LT(j, js) || + +drivers/base/power/runtime.c:1552: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1550. idx = device_links_read_lock(); + 1551. + 1552. > list_for_each_entry_rcu(link, &dev->links.consumers, s_node) { + 1553. if (link->flags & DL_FLAG_STATELESS) + 1554. continue; + +net/wireless/trace.h:1545: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/wireless/trace.h:1545: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1543. ); + 1544. + 1545. > TRACE_EVENT(rdev_return_int_tx_rx, + 1546. TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), + 1547. TP_ARGS(wiphy, ret, tx, rx), + +net/xfrm/xfrm_policy.c:1638: error: NULL_DEREFERENCE + pointer `xdst_prev` last assigned on line 1559 could be null and is dereferenced by call to `xfrm_dst_set_child()` at line 1638, column 2. + 1636. } + 1637. + 1638. > xfrm_dst_set_child(xdst_prev, dst); + 1639. xdst0->path = dst; + 1640. + +net/wireless/util.c:1579: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1577. if (params->radar_detect) { + 1578. rcu_read_lock(); + 1579. > regdom = rcu_dereference(cfg80211_regdomain); + 1580. if (regdom) + 1581. region = regdom->dfs_region; + +arch/x86/events/intel/ds.c:1554: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1552. void perf_restore_debug_store(void) + 1553. { + 1554. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 1555. + 1556. if (!x86_pmu.bts && !x86_pmu.pebs) + +arch/x86/events/intel/ds.c:1554: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1552. void perf_restore_debug_store(void) + 1553. { + 1554. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 1555. + 1556. if (!x86_pmu.bts && !x86_pmu.pebs) + +net/core/sock.c:1565: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1563. sk->sk_destruct(sk); + 1564. + 1565. > filter = rcu_dereference_check(sk->sk_filter, + 1566. refcount_read(&sk->sk_wmem_alloc) == 0); + 1567. if (filter) { + +net/core/sock.c:1571: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1569. RCU_INIT_POINTER(sk->sk_filter, NULL); + 1570. } + 1571. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1572. reuseport_detach_sock(sk); + 1573. + +drivers/gpu/drm/i915/intel_uncore.c:1568: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1566. pci_write_config_byte(pdev, I915_GDRST, 0); + 1567. + 1568. > return wait_for(i915_reset_complete(pdev), 500); + 1569. } + 1570. + +net/wireless/trace.h:1564: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +net/wireless/trace.h:1564: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1562. ); + 1563. + 1564. > TRACE_EVENT(rdev_return_void_tx_rx, + 1565. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, + 1566. u32 rx, u32 rx_max), + +include/linux/blkdev.h:1571: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1569. { + 1570. unsigned int granularity = max(lim->physical_block_size, lim->io_min); + 1571. > unsigned int alignment = sector_div(sector, granularity >> 9) << 9; + 1572. + 1573. return (granularity + lim->alignment_offset - alignment) % granularity; + +net/ipv6/route.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. int i; + 1575. + 1576. > if (!rcu_access_pointer(rt->rt6i_exception_bucket)) + 1577. return; + 1578. + +drivers/base/power/runtime.c:1576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1574. idx = device_links_read_lock(); + 1575. + 1576. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1577. if (link->flags & DL_FLAG_PM_RUNTIME) + 1578. pm_runtime_get_sync(link->supplier); + +kernel/sched/deadline.c:1586: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1584. + 1585. rcu_read_lock(); + 1586. > curr = READ_ONCE(rq->curr); /* unlocked access */ + 1587. + 1588. /* + +net/core/net-sysfs.c:1596: error: DEAD_STORE + The value written to &groups (type attribute_group const **) is never used. + 1594. #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211) + 1595. if (ndev->ieee80211_ptr) + 1596. > *groups++ = &wireless_group; + 1597. #if IS_ENABLED(CONFIG_WIRELESS_EXT) + 1598. else if (ndev->wireless_handlers) + +drivers/gpu/drm/i915/intel_uncore.c:1584: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1582. + 1583. pci_write_config_byte(pdev, I915_GDRST, GRDOM_RESET_ENABLE); + 1584. > return wait_for(g4x_reset_complete(pdev), 500); + 1585. } + 1586. + +net/ipv4/fib_semantics.c:1594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1592. u8 last_tos = 0; + 1593. + 1594. > hlist_for_each_entry_rcu(fa, fa_head, fa_list) { + 1595. struct fib_info *next_fi = fa->fa_info; + 1596. + +drivers/base/power/runtime.c:1594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1592. idx = device_links_read_lock(); + 1593. + 1594. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) + 1595. if (link->flags & DL_FLAG_PM_RUNTIME) + 1596. pm_runtime_put(link->supplier); + +drivers/gpu/drm/i915/intel_uncore.c:1599: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1597. pci_write_config_byte(pdev, I915_GDRST, + 1598. GRDOM_MEDIA | GRDOM_RESET_ENABLE); + 1599. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1600. if (ret) { + 1601. DRM_DEBUG_DRIVER("Wait for media reset failed\n"); + +drivers/gpu/drm/i915/intel_uncore.c:1607: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1605. pci_write_config_byte(pdev, I915_GDRST, + 1606. GRDOM_RENDER | GRDOM_RESET_ENABLE); + 1607. > ret = wait_for(g4x_reset_complete(pdev), 500); + 1608. if (ret) { + 1609. DRM_DEBUG_DRIVER("Wait for render reset failed\n"); + +net/wireless/trace.h:1587: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1585. ); + 1586. + 1587. > DECLARE_EVENT_CLASS(tx_rx_evt, + 1588. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1589. TP_ARGS(wiphy, rx, tx), + +security/selinux/ss/policydb.c:1604: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1602. goto bad; + 1603. + 1604. > len = le32_to_cpu(buf[0]); + 1605. levdatum->isalias = le32_to_cpu(buf[1]); + 1606. + +security/selinux/ss/policydb.c:1605: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1603. + 1604. len = le32_to_cpu(buf[0]); + 1605. > levdatum->isalias = le32_to_cpu(buf[1]); + 1606. + 1607. rc = str_read(&key, GFP_ATOMIC, fp, len); + +net/ipv4/fib_trie.c:1607: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1605. + 1606. /* descend into the next child */ + 1607. > n = get_child_rcu(pn, cindex++); + 1608. if (!n) + 1609. break; + +net/ipv4/fib_trie.c:1622: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1620. t_key pkey = pn->key; + 1621. + 1622. > pn = node_parent_rcu(pn); + 1623. cindex = get_index(pkey, pn) + 1; + 1624. continue; + +net/ipv4/fib_trie.c:1628: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1626. + 1627. /* grab the next available node */ + 1628. > n = get_child_rcu(pn, cindex++); + 1629. if (!n) + 1630. continue; + +drivers/gpu/drm/drm_dp_mst_topology.c:1605: error: DEAD_STORE + The value written to &len (type int) is never used. + 1603. + 1604. txmsg->dst = mstb; + 1605. > len = build_link_address(txmsg); + 1606. + 1607. mstb->link_address_sent = true; + +net/ipv6/addrconf.c:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. struct ipv6_saddr_score *score = &scores[1 - hiscore_idx], *hiscore = &scores[hiscore_idx]; + 1603. + 1604. > list_for_each_entry_rcu(score->ifa, &idev->addr_list, if_list) { + 1605. int i; + 1606. + +net/sunrpc/auth_gss/svcauth_gss.c:1616: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1614. BUG_ON(integ_len % 4); + 1615. *p++ = htonl(integ_len); + 1616. > *p++ = htonl(gc->gc_seq); + 1617. if (xdr_buf_subsegment(resbuf, &integ_buf, integ_offset, integ_len)) { + 1618. WARN_ON_ONCE(1); + +include/linux/blkdev.h:1611: error: DEAD_STORE + The value written to §or (type unsigned long) is never used. + 1609. + 1610. /* Offset of the partition start in 'granularity' sectors */ + 1611. > offset = sector_div(sector, granularity); + 1612. + 1613. /* And why do we do this modulus *again* in blkdev_issue_discard()? */ + +net/core/ethtool.c:1625: error: UNINITIALIZED_VALUE + The value read from eeprom.len was never initialized. + 1623. return -ENOMEM; + 1624. + 1625. > bytes_remaining = eeprom.len; + 1626. while (bytes_remaining > 0) { + 1627. eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE); + +kernel/printk/printk.c:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. + 1603. raw_spin_lock(&console_owner_lock); + 1604. > waiter = READ_ONCE(console_waiter); + 1605. console_owner = NULL; + 1606. raw_spin_unlock(&console_owner_lock); + +net/ipv6/tcp_ipv6.c:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. skb->destructor = sock_edemux; + 1630. if (sk_fullsock(sk)) { + 1631. > struct dst_entry *dst = READ_ONCE(sk->sk_rx_dst); + 1632. + 1633. if (dst) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +net/wireless/trace.h:1604: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1602. ); + 1603. + 1604. > DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, + 1605. TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), + 1606. TP_ARGS(wiphy, rx, tx) + +drivers/scsi/scsi_transport_spi.c:1625: error: DEAD_STORE + The value written to &error (type int) is never used. + 1623. if (error) + 1624. return error; + 1625. > error = anon_transport_class_register(&spi_device_class); + 1626. return transport_class_register(&spi_host_class); + 1627. } + +drivers/scsi/sd.c:1636: error: UNINITIALIZED_VALUE + The value read from res was never initialized. + 1634. + 1635. if (res) { + 1636. > sd_print_result(sdkp, "Synchronize Cache(10) failed", res); + 1637. + 1638. if (driver_byte(res) & DRIVER_SENSE) + +kernel/cgroup/cpuset.c:1614: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1609 could be null and is dereferenced by call to `is_cpuset_online()` at line 1614, column 7. + 1612. + 1613. mutex_lock(&cpuset_mutex); + 1614. > if (!is_cpuset_online(cs)) { + 1615. retval = -ENODEV; + 1616. goto out_unlock; + +net/wireless/trace.h:1609: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1607. ); + 1608. + 1609. > DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, + 1610. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1611. TP_ARGS(wiphy, netdev, id), + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from fault_reason was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from guest_addr was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from source_id was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/iommu/dmar.c:1673: error: UNINITIALIZED_VALUE + The value read from type was never initialized. + 1671. + 1672. if (!ratelimited) + 1673. > dmar_fault_do_one(iommu, type, fault_reason, + 1674. source_id, guest_addr); + 1675. + +drivers/clk/clk.c:1635: error: DEAD_STORE + The value written to &best_parent_rate (type unsigned long) is never used. + 1633. parent = old_parent = core->parent; + 1634. if (parent) + 1635. > best_parent_rate = parent->rate; + 1636. + 1637. clk_core_get_boundaries(core, &min_rate, &max_rate); + +kernel/sched/core.c:1640: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1638. __schedstat_inc(p->se.statistics.nr_wakeups_remote); + 1639. rcu_read_lock(); + 1640. > for_each_domain(rq->cpu, sd) { + 1641. if (cpumask_test_cpu(cpu, sched_domain_span(sd))) { + 1642. __schedstat_inc(sd->ttwu_wake_remote); + +kernel/sched/rt.c:1660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1658. + 1659. rcu_read_lock(); + 1660. > for_each_domain(cpu, sd) { + 1661. if (sd->flags & SD_WAKE_AFFINE) { + 1662. int best_cpu; + +kernel/sched/rt.c:1628: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1626. struct sched_domain *sd; + 1627. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1628. > int this_cpu = smp_processor_id(); + 1629. int cpu = task_cpu(task); + 1630. + +kernel/sched/rt.c:1628: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1626. struct sched_domain *sd; + 1627. struct cpumask *lowest_mask = this_cpu_cpumask_var_ptr(local_cpu_mask); + 1628. > int this_cpu = smp_processor_id(); + 1629. int cpu = task_cpu(task); + 1630. + +net/unix/af_unix.c:1707: error: UNINITIALIZED_VALUE + The value read from hash was never initialized. + 1705. goto out_free; + 1706. + 1707. > other = unix_find_other(net, sunaddr, namelen, sk->sk_type, + 1708. hash, &err); + 1709. if (other == NULL) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1626: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1624. ); + 1625. + 1626. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, + 1627. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1628. TP_ARGS(wiphy, netdev, id) + +kernel/kprobes.c:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. struct kprobe *kp; + 1630. + 1631. > list_for_each_entry_rcu(kp, &ap->list, list) + 1632. if (!kprobe_disabled(kp)) + 1633. /* + +security/selinux/ss/policydb.c:1645: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1643. goto bad; + 1644. + 1645. > len = le32_to_cpu(buf[0]); + 1646. catdatum->value = le32_to_cpu(buf[1]); + 1647. catdatum->isalias = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1646: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1644. + 1645. len = le32_to_cpu(buf[0]); + 1646. > catdatum->value = le32_to_cpu(buf[1]); + 1647. catdatum->isalias = le32_to_cpu(buf[2]); + 1648. + +security/selinux/ss/policydb.c:1647: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1645. len = le32_to_cpu(buf[0]); + 1646. catdatum->value = le32_to_cpu(buf[1]); + 1647. > catdatum->isalias = le32_to_cpu(buf[2]); + 1648. + 1649. rc = str_read(&key, GFP_ATOMIC, fp, len); + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/wireless/trace.h:1631: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1629. ); + 1630. + 1631. > DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, + 1632. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), + 1633. TP_ARGS(wiphy, netdev, id) + +net/ipv4/devinet.c:1654: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1652. cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ + 1653. net->dev_base_seq; + 1654. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 1655. if (idx < s_idx) + 1656. goto cont; + +kernel/printk/printk.c:1649: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1647. + 1648. raw_spin_lock(&console_owner_lock); + 1649. > owner = READ_ONCE(console_owner); + 1650. waiter = READ_ONCE(console_waiter); + 1651. if (!waiter && owner && owner != current) { + +kernel/printk/printk.c:1650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1648. raw_spin_lock(&console_owner_lock); + 1649. owner = READ_ONCE(console_owner); + 1650. > waiter = READ_ONCE(console_waiter); + 1651. if (!waiter && owner && owner != current) { + 1652. WRITE_ONCE(console_waiter, true); + +net/wireless/trace.h:1636: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +net/wireless/trace.h:1636: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1634. ); + 1635. + 1636. > TRACE_EVENT(rdev_tdls_mgmt, + 1637. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1638. u8 *peer, u8 action_code, u8 dialog_token, + +drivers/cdrom/cdrom.c:1764: error: UNINITIALIZED_VALUE + The value read from rpc_state.region_mask was never initialized. + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. > ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + 1766. break; + +drivers/cdrom/cdrom.c:1765: error: UNINITIALIZED_VALUE + The value read from rpc_state.rpc_scheme was never initialized. + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. > ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + 1766. break; + 1767. + +drivers/cdrom/cdrom.c:1761: error: UNINITIALIZED_VALUE + The value read from rpc_state.type_code was never initialized. + 1759. return ret; + 1760. + 1761. > ai->lrpcs.type = rpc_state.type_code; + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + +drivers/cdrom/cdrom.c:1763: error: UNINITIALIZED_VALUE + The value read from rpc_state.ucca was never initialized. + 1761. ai->lrpcs.type = rpc_state.type_code; + 1762. ai->lrpcs.vra = rpc_state.vra; + 1763. > ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + 1765. ai->lrpcs.rpc_scheme = rpc_state.rpc_scheme; + +drivers/cdrom/cdrom.c:1762: error: UNINITIALIZED_VALUE + The value read from rpc_state.vra was never initialized. + 1760. + 1761. ai->lrpcs.type = rpc_state.type_code; + 1762. > ai->lrpcs.vra = rpc_state.vra; + 1763. ai->lrpcs.ucca = rpc_state.ucca; + 1764. ai->lrpcs.region_mask = rpc_state.region_mask; + +drivers/hid/usbhid/hid-core.c:1641: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1639. static int __init hid_init(void) + 1640. { + 1641. > int retval = -ENOMEM; + 1642. + 1643. retval = hid_quirks_init(quirks_param, BUS_USB, MAX_USBHID_BOOT_QUIRKS); + +drivers/hid/hid-core.c:1698: error: DEAD_STORE + The value written to &len (type int) is never used. + 1696. ((struct hiddev *)hdev->hiddev)->minor); + 1697. if (hdev->claimed & HID_CLAIMED_HIDRAW) + 1698. > len += sprintf(buf + len, "%shidraw%d", len ? "," : "", + 1699. ((struct hidraw *)hdev->hidraw)->minor); + 1700. + +net/sunrpc/auth_gss/svcauth_gss.c:1661: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 1659. len = p++; + 1660. offset = (u8 *)p - (u8 *)resbuf->head[0].iov_base; + 1661. > *p++ = htonl(gc->gc_seq); + 1662. inpages = resbuf->pages; + 1663. /* XXX: Would be better to write some xdr helper functions for + +drivers/gpu/drm/drm_dp_mst_topology.c:1659: error: DEAD_STORE + The value written to &len (type int) is never used. + 1657. + 1658. txmsg->dst = mstb; + 1659. > len = build_enum_path_resources(txmsg, port->port_num); + 1660. + 1661. drm_dp_queue_down_tx(mgr, txmsg); + +net/ipv6/route.c:1656: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1654. int i; + 1655. + 1656. > if (!rcu_access_pointer(rt->rt6i_exception_bucket)) + 1657. return; + 1658. + +net/core/sock.c:1696: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1694. + 1695. rcu_read_lock(); + 1696. > filter = rcu_dereference(sk->sk_filter); + 1697. if (filter != NULL) + 1698. /* though it's an empty new sock, the charging may fail + +net/core/sock.c:1722: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1720. newsk->sk_err_soft = 0; + 1721. newsk->sk_priority = 0; + 1722. > newsk->sk_incoming_cpu = raw_smp_processor_id(); + 1723. atomic64_set(&newsk->sk_cookie, 0); + 1724. if (likely(newsk->sk_net_refcnt)) + +kernel/cgroup/cpuset.c:1661: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1656 could be null and is dereferenced by call to `is_cpuset_online()` at line 1661, column 7. + 1659. + 1660. mutex_lock(&cpuset_mutex); + 1661. > if (!is_cpuset_online(cs)) + 1662. goto out_unlock; + 1663. + +net/ipv6/ip6_fib.c:1679: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1677. + 1678. /* Reset round-robin state, if necessary */ + 1679. > if (rcu_access_pointer(fn->rr_ptr) == rt) + 1680. fn->rr_ptr = NULL; + 1681. + +net/ipv6/ip6_fib.c:1711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1709. * 2. For other nodes, expunge its radix tree node. + 1710. */ + 1711. > if (!rcu_access_pointer(fn->leaf)) { + 1712. if (!(fn->fn_flags & RTN_TL_ROOT)) { + 1713. fn->fn_flags &= ~RTN_RTINFO; + +net/sunrpc/xprtsock.c:1670: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1668. return; + 1669. rcu_read_lock(); + 1670. > wq = rcu_dereference(sk->sk_wq); + 1671. if (!wq || test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags) == 0) + 1672. goto out; + +drivers/tty/n_tty.c:1688: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1686. * read_tail (so this producer will not overwrite unread data) + 1687. */ + 1688. > size_t tail = smp_load_acquire(&ldata->read_tail); + 1689. + 1690. room = N_TTY_BUF_SIZE - (ldata->read_head - tail); + +drivers/tty/n_tty.c:1718: error: UNINITIALIZED_VALUE + The value read from room was never initialized. + 1716. } + 1717. + 1718. > tty->receive_room = room; + 1719. + 1720. /* Unthrottle if handling overflow on pty */ + +drivers/net/ethernet/broadcom/tg3.c:1699: error: DEAD_STORE + The value written to &data (type unsigned int*) is never used. + 1697. else + 1698. val = 0; + 1699. > *data++ = val; + 1700. } + 1701. + +drivers/usb/host/uhci-q.c:1693: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1691. urbp = list_entry(qh->queue.next, struct urb_priv, node); + 1692. td = list_entry(urbp->td_list.next, struct uhci_td, list); + 1693. > status = td_status(uhci, td); + 1694. if (!(status & TD_CTRL_ACTIVE)) { + 1695. + +block/bio.c:1674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1672. unsigned long sectors, struct hd_struct *part) + 1673. { + 1674. > int cpu = part_stat_lock(); + 1675. + 1676. part_round_stats(q, cpu, part); + +block/bio.c:1674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1672. unsigned long sectors, struct hd_struct *part) + 1673. { + 1674. > int cpu = part_stat_lock(); + 1675. + 1676. part_round_stats(q, cpu, part); + +net/wireless/trace.h:1675: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +net/wireless/trace.h:1675: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1673. ); + 1674. + 1675. > TRACE_EVENT(rdev_dump_survey, + 1676. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), + 1677. TP_ARGS(wiphy, netdev, idx), + +drivers/base/power/main.c:1692: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1690. idx = device_links_read_lock(); + 1691. + 1692. > list_for_each_entry_rcu(link, &dev->links.suppliers, c_node) { + 1693. spin_lock_irq(&link->supplier->power.lock); + 1694. link->supplier->power.direct_complete = false; + +drivers/gpu/drm/i915/intel_hdmi.c:1688: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 1683 could be null and is dereferenced at line 1688, column 2. + 1686. intel_hdmi_prepare(encoder, pipe_config); + 1687. + 1688. > intel_dig_port->set_infoframes(&encoder->base, + 1689. pipe_config->has_infoframe, + 1690. pipe_config, conn_state); + +drivers/md/dm-ioctl.c:1689: error: UNINITIALIZED_VALUE + The value read from version[_] was never initialized. + 1687. if ((DM_VERSION_MAJOR != version[0]) || + 1688. (DM_VERSION_MINOR < version[1])) { + 1689. > DMWARN("ioctl interface mismatch: " + 1690. "kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)", + 1691. DM_VERSION_MAJOR, DM_VERSION_MINOR, + +kernel/kprobes.c:1712: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1710. ap->break_handler = NULL; + 1711. if (p->post_handler && !kprobe_gone(p)) { + 1712. > list_for_each_entry_rcu(list_p, &ap->list, list) { + 1713. if ((list_p != p) && (list_p->post_handler)) + 1714. goto noclean; + +block/bio.c:1689: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1687. { + 1688. unsigned long duration = jiffies - start_time; + 1689. > int cpu = part_stat_lock(); + 1690. + 1691. part_stat_add(cpu, part, ticks[rw], duration); + +block/bio.c:1689: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1687. { + 1688. unsigned long duration = jiffies - start_time; + 1689. > int cpu = part_stat_lock(); + 1690. + 1691. part_stat_add(cpu, part, ticks[rw], duration); + +net/ipv4/route.c:1738: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1736. if (do_cache) { + 1737. if (fnhe) { + 1738. > rth = rcu_dereference(fnhe->fnhe_rth_input); + 1739. if (rth && rth->dst.expires && + 1740. time_after(jiffies, rth->dst.expires)) { + +net/ipv4/route.c:1748: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1746. } + 1747. + 1748. > rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input); + 1749. + 1750. rt_cache: + +net/ipv6/addrconf.c:1763: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1761. } + 1762. + 1763. > for_each_netdev_rcu(net, dev) { + 1764. /* only consider addresses on devices in the + 1765. * same L3 domain + +net/wireless/trace.h:1692: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +net/wireless/trace.h:1692: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1690. ); + 1691. + 1692. > TRACE_EVENT(rdev_return_int_survey_info, + 1693. TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), + 1694. TP_ARGS(wiphy, ret, info), + +drivers/gpu/drm/i915/intel_hdmi.c:1706: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1697 could be null and is dereferenced at line 1706, column 2. + 1704. 0x2b247878); + 1705. + 1706. > dport->set_infoframes(&encoder->base, + 1707. pipe_config->has_infoframe, + 1708. pipe_config, conn_state); + +net/ipv4/netfilter/ip_tables.c:1731: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1729. target = 0; + 1730. + 1731. > try_then_request_module(xt_find_revision(AF_INET, rev.name, + 1732. rev.revision, + 1733. target, &ret), + +include/net/sock.h:1698: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1696. { + 1697. BUILD_BUG_ON(offsetof(struct socket_wq, wait) != 0); + 1698. > return &rcu_dereference_raw(sk->sk_wq)->wait; + 1699. } + 1700. /* Detach socket from process context. + +kernel/printk/printk.c:1712: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1710. if (!con->write) + 1711. continue; + 1712. > if (!cpu_online(smp_processor_id()) && + 1713. !(con->flags & CON_ANYTIME)) + 1714. continue; + +kernel/printk/printk.c:1712: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1710. if (!con->write) + 1711. continue; + 1712. > if (!cpu_online(smp_processor_id()) && + 1713. !(con->flags & CON_ANYTIME)) + 1714. continue; + +net/ipv4/udp.c:1711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1709. + 1710. spin_lock_bh(&hslot->lock); + 1711. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1712. reuseport_detach_sock(sk); + 1713. if (sk_del_node_init_rcu(sk)) { + +drivers/gpu/drm/drm_atomic_helper.c:1705: error: DEAD_STORE + The value written to &completed (type _Bool) is never used. + 1703. { + 1704. struct drm_crtc_commit *commit, *stall_commit = NULL; + 1705. > bool completed = true; + 1706. int i; + 1707. long ret = 0; + +net/core/filter.c:1707: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1705. int ret; + 1706. + 1707. > if (unlikely(__this_cpu_read(xmit_recursion) > XMIT_RECURSION_LIMIT)) { + 1708. net_crit_ratelimited("bpf: recursion limit reached on datapath, buggy bpf program?\n"); + 1709. kfree_skb(skb); + +net/ipv6/netfilter/ip6_tables.c:1741: error: UNINITIALIZED_VALUE + The value read from rev.revision was never initialized. + 1739. target = 0; + 1740. + 1741. > try_then_request_module(xt_find_revision(AF_INET6, rev.name, + 1742. rev.revision, + 1743. target, &ret), + +net/ipv6/mcast.c:1720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1718. return skb; + 1719. + 1720. > mtu = READ_ONCE(dev->mtu); + 1721. if (mtu < IPV6_MIN_MTU) + 1722. return skb; + +net/ipv4/fib_trie.c:1728: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1726. struct key_vector *local_l = NULL, *local_tp; + 1727. + 1728. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1729. struct fib_alias *new_fa; + 1730. + +net/sunrpc/auth_gss/svcauth_gss.c:1716: error: DEAD_STORE + The value written to &stat (type int) is never used. + 1714. struct rpc_gss_wire_cred *gc = &gsd->clcred; + 1715. struct xdr_buf *resbuf = &rqstp->rq_res; + 1716. > int stat = -EINVAL; + 1717. struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net, sunrpc_net_id); + 1718. + +drivers/gpu/drm/drm_dp_mst_topology.c:1747: error: DEAD_STORE + The value written to &len (type int) is never used. + 1745. + 1746. txmsg->dst = mstb; + 1747. > len = build_allocate_payload(txmsg, port_num, + 1748. id, + 1749. pbn, port->num_sdp_streams, sinks); + +kernel/rcu/tree_plugin.h:1715: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1713. { + 1714. rdp->ticks_this_gp = 0; + 1715. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1716. } + 1717. + +kernel/rcu/tree_plugin.h:1715: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1713. { + 1714. rdp->ticks_this_gp = 0; + 1715. > rdp->softirq_snap = kstat_softirqs_cpu(RCU_SOFTIRQ, smp_processor_id()); + 1716. } + 1717. + +lib/radix-tree.c:1768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1766. else + 1767. while (++offset < RADIX_TREE_MAP_SIZE) { + 1768. > void *slot = rcu_dereference_raw( + 1769. node->slots[offset]); + 1770. if (is_sibling_entry(node, slot)) + +lib/radix-tree.c:1782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1780. if (offset == RADIX_TREE_MAP_SIZE) + 1781. goto restart; + 1782. > child = rcu_dereference_raw(node->slots[offset]); + 1783. } + 1784. + +drivers/iommu/dmar.c:1722: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1720. * Enable fault control interrupt. + 1721. */ + 1722. > for_each_iommu(iommu, drhd) { + 1723. u32 fault_status; + 1724. int ret = dmar_set_interrupt(iommu); + +net/ipv4/devinet.c:1720: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1718. u32 ext_filter_mask) + 1719. { + 1720. > struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 1721. + 1722. if (!in_dev) + +net/xfrm/xfrm_policy.c:1729: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1727. struct xfrm_dst *old; + 1728. + 1729. > old = this_cpu_read(xfrm_last_dst); + 1730. if (old && !xfrm_bundle_ok(old)) + 1731. xfrm_last_dst_update(NULL, old); + +net/xfrm/xfrm_policy.c:1729: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1727. struct xfrm_dst *old; + 1728. + 1729. > old = this_cpu_read(xfrm_last_dst); + 1730. if (old && !xfrm_bundle_ok(old)) + 1731. xfrm_last_dst_update(NULL, old); + +net/ipv4/devinet.c:1731: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1729. u32 ext_filter_mask) + 1730. { + 1731. > struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr); + 1732. struct nlattr *nla; + 1733. int i; + +net/ipv4/udp.c:1742: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1740. + 1741. if (hslot2 != nhslot2 || + 1742. > rcu_access_pointer(sk->sk_reuseport_cb)) { + 1743. hslot = udp_hashslot(udptable, sock_net(sk), + 1744. udp_sk(sk)->udp_port_hash); + +net/ipv4/udp.c:1747: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1745. /* we must lock primary chain too */ + 1746. spin_lock_bh(&hslot->lock); + 1747. > if (rcu_access_pointer(sk->sk_reuseport_cb)) + 1748. reuseport_detach_sock(sk); + 1749. + +kernel/signal.c:1773: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1771. rcu_read_lock(); + 1772. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); + 1773. > info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), + 1774. task_uid(tsk)); + 1775. rcu_read_unlock(); + +kernel/signal.c:1774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1772. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); + 1773. info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), + 1774. > task_uid(tsk)); + 1775. rcu_read_unlock(); + 1776. + +net/wireless/trace.h:1732: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +net/wireless/trace.h:1732: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1730. ); + 1731. + 1732. > TRACE_EVENT(rdev_tdls_oper, + 1733. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1734. u8 *peer, enum nl80211_tdls_operation oper), + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1758: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1756. ret = -ETIMEDOUT; + 1757. if (fast_timeout_us && fast_timeout_us <= 20000) + 1758. > ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. ret = wait_for(done, slow_timeout_ms); + +drivers/gpu/drm/i915/intel_uncore.c:1760: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1758. ret = _wait_for_atomic(done, fast_timeout_us, 0); + 1759. if (ret && slow_timeout_ms) + 1760. > ret = wait_for(done, slow_timeout_ms); + 1761. + 1762. if (out_value) + +net/xfrm/xfrm_policy.c:1756: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1754. old = per_cpu(xfrm_last_dst, cpu); + 1755. if (old && !xfrm_bundle_ok(old)) { + 1756. > if (smp_processor_id() == cpu) { + 1757. __xfrm_pcpu_work_fn(); + 1758. continue; + +sound/core/timer.c:1835: error: UNINITIALIZED_VALUE + The value read from params.filter was never initialized. + 1833. } + 1834. } + 1835. > tu->filter = params.filter; + 1836. tu->ticks = params.ticks; + 1837. spin_unlock_irq(&tu->qlock); + +sound/core/timer.c:1812: error: UNINITIALIZED_VALUE + The value read from params.queue_size was never initialized. + 1810. if (params.queue_size > 0 && + 1811. (unsigned int)tu->queue_size != params.queue_size) { + 1812. > err = realloc_user_queue(tu, params.queue_size); + 1813. if (err < 0) + 1814. goto _end; + +sound/core/timer.c:1836: error: UNINITIALIZED_VALUE + The value read from params.ticks was never initialized. + 1834. } + 1835. tu->filter = params.filter; + 1836. > tu->ticks = params.ticks; + 1837. spin_unlock_irq(&tu->qlock); + 1838. err = 0; + +net/wireless/trace.h:1752: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1750. ); + 1751. + 1752. > DECLARE_EVENT_CLASS(rdev_pmksa, + 1753. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1754. struct cfg80211_pmksa *pmksa), + +drivers/gpu/drm/i915/intel_ddi.c:1760: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 1756 could be null and is dereferenced at line 1760, column 10. + 1758. + 1759. if (intel_ddi_get_hw_state(encoder, &pipe)) + 1760. > return BIT_ULL(dig_port->ddi_io_power_domain); + 1761. + 1762. return 0; + +include/net/sock.h:1757: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1755. __sk_dst_get(struct sock *sk) + 1756. { + 1757. > return rcu_dereference_check(sk->sk_dst_cache, + 1758. lockdep_sock_is_held(sk)); + 1759. } + +kernel/workqueue.c:1758: error: DEAD_STORE + The value written to &id (type int) is never used. + 1756. { + 1757. struct worker *worker = NULL; + 1758. > int id = -1; + 1759. char id_buf[16]; + 1760. + +ipc/sem.c:1761: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1759. struct sem_undo *un; + 1760. + 1761. > list_for_each_entry_rcu(un, &ulp->list_proc, list_proc) { + 1762. if (un->semid == semid) + 1763. return un; + +drivers/block/loop.c:1783: error: DEAD_STORE + The value written to &err (type int) is never used. + 1781. i = err; + 1782. + 1783. > err = -ENOMEM; + 1784. lo->tag_set.ops = &loop_mq_ops; + 1785. lo->tag_set.nr_hw_queues = 1; + +include/net/sock.h:1767: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1765. + 1766. rcu_read_lock(); + 1767. > dst = rcu_dereference(sk->sk_dst_cache); + 1768. if (dst && !atomic_inc_not_zero(&dst->__refcnt)) + 1769. dst = NULL; + +drivers/gpu/drm/i915/intel_hdmi.c:1777: error: NULL_DEREFERENCE + pointer `dport` last assigned on line 1767 could be null and is dereferenced at line 1777, column 2. + 1775. chv_set_phy_signal_level(encoder, 128, 102, false); + 1776. + 1777. > dport->set_infoframes(&encoder->base, + 1778. pipe_config->has_infoframe, + 1779. pipe_config, conn_state); + +drivers/gpu/drm/drm_dp_mst_topology.c:1784: error: DEAD_STORE + The value written to &len (type int) is never used. + 1782. + 1783. txmsg->dst = port->parent; + 1784. > len = build_power_updown_phy(txmsg, port->port_num, power_up); + 1785. drm_dp_queue_down_tx(mgr, txmsg); + 1786. + +net/wireless/trace.h:1770: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +net/wireless/trace.h:1770: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1768. ); + 1769. + 1770. > TRACE_EVENT(rdev_probe_client, + 1771. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1772. const u8 *peer), + +include/net/xfrm.h:1780: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1778. + 1779. rcu_read_lock(); + 1780. > nlsk = rcu_dereference(net->xfrm.nlsk); + 1781. if (nlsk) + 1782. ret = netlink_has_listeners(nlsk, XFRMNLGRP_AEVENTS); + +kernel/cgroup/cgroup.c:1800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1798. */ + 1799. read_lock(&tasklist_lock); + 1800. > do_each_thread(g, p) { + 1801. WARN_ON_ONCE(!list_empty(&p->cg_list) || + 1802. task_css_set(p) != &init_css_set); + +drivers/gpu/drm/drm_fb_helper.c:1862: error: UNINITIALIZED_VALUE + The value read from sizes.surface_height was never initialized. + 1860. + 1861. sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1862. > sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1863. + 1864. for (j = 0; j < mode_set->num_connectors; j++) { + +drivers/gpu/drm/drm_fb_helper.c:1861: error: UNINITIALIZED_VALUE + The value read from sizes.surface_width was never initialized. + 1859. gamma_size = fb_helper->crtc_info[i].mode_set.crtc->gamma_size; + 1860. + 1861. > sizes.surface_width = max_t(u32, desired_mode->hdisplay + x, sizes.surface_width); + 1862. sizes.surface_height = max_t(u32, desired_mode->vdisplay + y, sizes.surface_height); + 1863. + +drivers/gpu/drm/i915/intel_uncore.c:1809: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 1807. + 1808. if (ret) + 1809. > ret = wait_for((I915_READ_NOTRACE(reg) & mask) == value, + 1810. timeout_ms); + 1811. + +include/net/xfrm.h:1793: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1791. + 1792. rcu_read_lock(); + 1793. > nlsk = rcu_dereference(net->xfrm.nlsk); + 1794. if (nlsk) + 1795. ret = netlink_has_listeners(nlsk, XFRMNLGRP_ACQUIRE); + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1788: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1786. ); + 1787. + 1788. > DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, + 1789. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1790. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +net/wireless/trace.h:1794: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1792. ); + 1793. + 1794. > DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, + 1795. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1796. struct cfg80211_pmksa *pmksa), + +kernel/events/core.c:1802: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1800. event_filter_match(struct perf_event *event) + 1801. { + 1802. > return (event->cpu == -1 || event->cpu == smp_processor_id()) && + 1803. perf_cgroup_match(event) && pmu_filter_match(event); + 1804. } + +net/wireless/trace.h:1800: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +net/wireless/trace.h:1800: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1798. ); + 1799. + 1800. > TRACE_EVENT(rdev_remain_on_channel, + 1801. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1802. struct ieee80211_channel *chan, + +kernel/cgroup/cpuset.c:1817: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1813 could be null and is dereferenced at line 1817, column 10. + 1815. switch (type) { + 1816. case FILE_SCHED_RELAX_DOMAIN_LEVEL: + 1817. > return cs->relax_domain_level; + 1818. default: + 1819. BUG(); + +drivers/usb/core/hub.c:1831: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1817 could be null and is dereferenced at line 1831, column 9. + 1829. info->nports = hdev->maxchild; + 1830. for (i = 0; i < info->nports; i++) { + 1831. > if (hub->ports[i]->child == NULL) + 1832. info->port[i] = 0; + 1833. else + +net/xfrm/xfrm_policy.c:1840: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1838. } + 1839. + 1840. > xdst = this_cpu_read(xfrm_last_dst); + 1841. if (xdst && + 1842. xdst->u.dst.dev == dst_orig->dev && + +net/xfrm/xfrm_policy.c:1840: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1838. } + 1839. + 1840. > xdst = this_cpu_read(xfrm_last_dst); + 1841. if (xdst && + 1842. xdst->u.dst.dev == dst_orig->dev && + +kernel/sched/core.c:1828: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1826. rcu_read_lock(); + 1827. + 1828. > if (!is_idle_task(rcu_dereference(rq->curr))) + 1829. goto out; + 1830. + +net/core/ethtool.c:1830: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1828. return -EFAULT; + 1829. + 1830. > ret = __ethtool_get_sset_count(dev, gstrings.string_set); + 1831. if (ret < 0) + 1832. return ret; + +net/core/ethtool.c:1842: error: UNINITIALIZED_VALUE + The value read from gstrings.string_set was never initialized. + 1840. return -ENOMEM; + 1841. + 1842. > __ethtool_get_strings(dev, gstrings.string_set, data); + 1843. + 1844. ret = -EFAULT; + +net/ipv4/udp.c:1848: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1846. + 1847. /* if we're overly short, let UDP handle it */ + 1848. > encap_rcv = READ_ONCE(up->encap_rcv); + 1849. if (encap_rcv) { + 1850. int ret; + +net/ipv4/udp.c:1903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1901. + 1902. prefetch(&sk->sk_rmem_alloc); + 1903. > if (rcu_access_pointer(sk->sk_filter) && + 1904. udp_lib_checksum_complete(skb)) + 1905. goto csum_error; + +net/wireless/trace.h:1821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +net/wireless/trace.h:1821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1819. ); + 1820. + 1821. > TRACE_EVENT(rdev_return_int_cookie, + 1822. TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), + 1823. TP_ARGS(wiphy, ret, cookie), + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.keycode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +drivers/tty/vt/keyboard.c:1834: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1832. switch (cmd) { + 1833. case KDGETKEYCODE: + 1834. > kc = getkeycode(tmp.scancode); + 1835. if (kc >= 0) + 1836. kc = put_user(kc, &user_kbkc->keycode); + +drivers/tty/vt/keyboard.c:1841: error: UNINITIALIZED_VALUE + The value read from tmp.scancode was never initialized. + 1839. if (!perm) + 1840. return -EPERM; + 1841. > kc = setkeycode(tmp.scancode, tmp.keycode); + 1842. break; + 1843. } + +lib/radix-tree.c:1836: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1834. + 1835. radix_tree_for_each_slot(slot, root, &iter, first_index) { + 1836. > results[ret] = rcu_dereference_raw(*slot); + 1837. if (!results[ret]) + 1838. continue; + +net/ipv6/addrconf.c:1830: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1828. + 1829. rcu_read_lock(); + 1830. > list_for_each_entry_rcu(ifp, &idev->addr_list, if_list) + 1831. cnt++; + 1832. rcu_read_unlock(); + +net/ipv4/cipso_ipv4.c:1830: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1828. const struct netlbl_lsm_secattr *secattr) + 1829. { + 1830. > int ret_val = -EPERM; + 1831. unsigned char *buf = NULL; + 1832. u32 buf_len; + +drivers/usb/host/ehci-sched.c:1888: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 1886. + 1887. /* give urb back to the driver; completion often (re)submits */ + 1888. > dev = urb->dev; + 1889. ehci_urb_done(ehci, urb, 0); + 1890. retval = true; + +kernel/sys.c:1835: error: DEAD_STORE + The value written to &mm (type mm_struct*) is never used. + 1833. { + 1834. unsigned long mmap_max_addr = TASK_SIZE; + 1835. > struct mm_struct *mm = current->mm; + 1836. int error = -EINVAL, i; + 1837. + +drivers/iommu/dmar.c:1836: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1834. dmar_res_handler_t handler, void *arg) + 1835. { + 1836. > int ret = -ENODEV; + 1837. union acpi_object *obj; + 1838. struct acpi_dmar_header *start; + +kernel/signal.c:1860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1858. rcu_read_lock(); + 1859. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); + 1860. > info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); + 1861. rcu_read_unlock(); + 1862. + +kernel/signal.c:1860: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1858. rcu_read_lock(); + 1859. info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); + 1860. > info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); + 1861. rcu_read_unlock(); + 1862. + +net/core/neighbour.c:1874: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1872. + 1873. rcu_read_lock_bh(); + 1874. > nht = rcu_dereference_bh(tbl->nht); + 1875. ndc.ndtc_hash_rnd = nht->hash_rnd[0]; + 1876. ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1); + +drivers/cdrom/cdrom.c:1856: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1854. return ret; + 1855. + 1856. > s->copyright.cpst = buf[4]; + 1857. s->copyright.rmi = buf[5]; + 1858. + +drivers/cdrom/cdrom.c:1857: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1855. + 1856. s->copyright.cpst = buf[4]; + 1857. > s->copyright.rmi = buf[5]; + 1858. + 1859. return 0; + +net/wireless/trace.h:1838: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +net/wireless/trace.h:1838: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1836. ); + 1837. + 1838. > TRACE_EVENT(rdev_cancel_remain_on_channel, + 1839. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), + 1840. TP_ARGS(wiphy, wdev, cookie), + +security/selinux/ss/policydb.c:1853: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1851. return rc; + 1852. + 1853. > nel = le32_to_cpu(buf[0]); + 1854. for (i = 0; i < nel; i++) { + 1855. rc = -ENOMEM; + +security/selinux/ss/policydb.c:1864: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1862. goto out; + 1863. + 1864. > rt->source_type = le32_to_cpu(buf[0]); + 1865. rt->target_type = le32_to_cpu(buf[1]); + 1866. if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) { + +security/selinux/ss/policydb.c:1865: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1863. + 1864. rt->source_type = le32_to_cpu(buf[0]); + 1865. > rt->target_type = le32_to_cpu(buf[1]); + 1866. if (p->policyvers >= POLICYDB_VERSION_RANGETRANS) { + 1867. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:1870: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1868. if (rc) + 1869. goto out; + 1870. > rt->target_class = le32_to_cpu(buf[0]); + 1871. } else + 1872. rt->target_class = p->process_class; + +net/sunrpc/xprtsock.c:1850: error: DEAD_STORE + The value written to &port (type unsigned short) is never used. + 1848. if (port <= xprt_min_resvport || port > xprt_max_resvport) + 1849. return xprt_max_resvport; + 1850. > return --port; + 1851. } + 1852. static int xs_bind(struct sock_xprt *transport, struct socket *sock) + +net/ipv6/addrconf.c:1852: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1850. + 1851. rcu_read_lock(); + 1852. > hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { + 1853. if (!net_eq(dev_net(ifp->idev->dev), net)) + 1854. continue; + +drivers/iommu/intel-iommu.c:1850: error: DEAD_STORE + The value written to &count (type int) is never used. + 1848. struct intel_iommu *iommu) + 1849. { + 1850. > int num, count = INT_MAX; + 1851. + 1852. assert_spin_locked(&device_domain_lock); + +net/ipv4/af_inet.c:1854: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1852. struct inet_protosw *q; + 1853. struct list_head *r; + 1854. > int rc = -EINVAL; + 1855. + 1856. sock_skb_cb_check_size(sizeof(struct inet_skb_parm)); + +kernel/sched/core.c:1857: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1855. + 1856. #if defined(CONFIG_SMP) + 1857. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1858. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1859. ttwu_queue_remote(p, cpu, wake_flags); + +kernel/sched/core.c:1857: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1855. + 1856. #if defined(CONFIG_SMP) + 1857. > if (sched_feat(TTWU_QUEUE) && !cpus_share_cache(smp_processor_id(), cpu)) { + 1858. sched_clock_cpu(cpu); /* Sync clocks across CPUs */ + 1859. ttwu_queue_remote(p, cpu, wake_flags); + +kernel/time/hrtimer.c:1853: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1851. void __init hrtimers_init(void) + 1852. { + 1853. > hrtimers_prepare_cpu(smp_processor_id()); + 1854. open_softirq(HRTIMER_SOFTIRQ, hrtimer_run_softirq); + 1855. } + +kernel/time/hrtimer.c:1853: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1851. void __init hrtimers_init(void) + 1852. { + 1853. > hrtimers_prepare_cpu(smp_processor_id()); + 1854. open_softirq(HRTIMER_SOFTIRQ, hrtimer_run_softirq); + 1855. } + +drivers/usb/core/hub.c:1865: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1855 could be null and is dereferenced at line 1865, column 15. + 1863. * will always have maxchild equal to 0. + 1864. */ + 1865. > *ppowner = &(hub->ports[port1 - 1]->port_owner); + 1866. return 0; + 1867. } + +kernel/sched/deadline.c:1895: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1893. + 1894. rcu_read_lock(); + 1895. > for_each_domain(cpu, sd) { + 1896. if (sd->flags & SD_WAKE_AFFINE) { + 1897. int best_cpu; + +kernel/sched/deadline.c:1856: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1854. struct sched_domain *sd; + 1855. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1856. > int this_cpu = smp_processor_id(); + 1857. int cpu = task_cpu(task); + 1858. + +kernel/sched/deadline.c:1856: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1854. struct sched_domain *sd; + 1855. struct cpumask *later_mask = this_cpu_cpumask_var_ptr(local_cpu_mask_dl); + 1856. > int this_cpu = smp_processor_id(); + 1857. int cpu = task_cpu(task); + 1858. + +net/wireless/trace.h:1855: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +net/wireless/trace.h:1855: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1853. ); + 1854. + 1855. > TRACE_EVENT(rdev_mgmt_tx, + 1856. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1857. struct cfg80211_mgmt_tx_params *params), + +security/selinux/ss/services.c:1914: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1912. + 1913. /* Convert the user. */ + 1914. > rc = -EINVAL; + 1915. usrdatum = hashtab_search(args->newp->p_users.table, + 1916. sym_name(args->oldp, SYM_USERS, c->user - 1)); + +security/selinux/ss/services.c:1922: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1920. + 1921. /* Convert the role. */ + 1922. > rc = -EINVAL; + 1923. role = hashtab_search(args->newp->p_roles.table, + 1924. sym_name(args->oldp, SYM_ROLES, c->role - 1)); + +security/selinux/ss/services.c:1930: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1928. + 1929. /* Convert the type. */ + 1930. > rc = -EINVAL; + 1931. typdatum = hashtab_search(args->newp->p_types.table, + 1932. sym_name(args->oldp, SYM_TYPES, c->type - 1)); + +security/selinux/ss/services.c:1960: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1958. while (oc && oc->sid[0] != SECINITSID_UNLABELED) + 1959. oc = oc->next; + 1960. > rc = -EINVAL; + 1961. if (!oc) { + 1962. printk(KERN_ERR "SELinux: unable to look up" + +kernel/auditsc.c:1881: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1879. rcu_read_lock(); + 1880. if (!list_empty(list)) { + 1881. > list_for_each_entry_rcu(e, list, list) { + 1882. for (i = 0; i < e->rule.field_count; i++) { + 1883. struct audit_field *f = &e->rule.fields[i]; + +drivers/gpu/drm/drm_dp_mst_topology.c:1909: error: UNINITIALIZED_VALUE + The value read from req_payload.payload_state was never initialized. + 1907. mgr->payloads[i].start_slot = 0; + 1908. } + 1909. > mgr->payloads[i].payload_state = req_payload.payload_state; + 1910. } + 1911. cur_slots += req_payload.num_slots; + +net/ipv4/igmp.c:1876: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1874. return -ENODEV; + 1875. rcu_read_lock(); + 1876. > for_each_pmc_rcu(in_dev, pmc) { + 1877. if (*pmca == pmc->multiaddr) + 1878. break; + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1870: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1868. void enable_percpu_irq(unsigned int irq, unsigned int type) + 1869. { + 1870. > unsigned int cpu = smp_processor_id(); + 1871. unsigned long flags; + 1872. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/rcu/tree.c:1903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1901. need_gp = !!(rnp->qsmask & rdp->grpmask); + 1902. rdp->cpu_no_qs.b.norm = need_gp; + 1903. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 1904. rdp->core_needs_qs = need_gp; + 1905. zero_cpu_stall_ticks(rdp); + +kernel/rcu/tree.c:1903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1901. need_gp = !!(rnp->qsmask & rdp->grpmask); + 1902. rdp->cpu_no_qs.b.norm = need_gp; + 1903. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 1904. rdp->core_needs_qs = need_gp; + 1905. zero_cpu_stall_ticks(rdp); + +ipc/sem.c:1874: error: DEAD_STORE + The value written to &error (type int) is never used. + 1872. unsigned nsops, const struct timespec64 *timeout) + 1873. { + 1874. > int error = -EINVAL; + 1875. struct sem_array *sma; + 1876. struct sembuf fast_sops[SEMOPM_FAST]; + +ipc/sem.c:2078: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2076. * window between wake_q_add() and wake_up_q(). + 2077. */ + 2078. > error = READ_ONCE(queue.status); + 2079. if (error != -EINTR) { + 2080. /* + +ipc/sem.c:2096: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2094. goto out_unlock_free; + 2095. + 2096. > error = READ_ONCE(queue.status); + 2097. + 2098. /* + +kernel/trace/ring_buffer.c:2000: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1998. struct buffer_page *buffer_tail_page; + 1999. + 2000. > buffer_tail_page = READ_ONCE(cpu_buffer->tail_page); + 2001. /* + 2002. * If the tail had moved passed next, then we need + +net/ipv6/addrconf.c:1889: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1887. idev = __in6_dev_get(dev); + 1888. if (idev) { + 1889. > list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) { + 1890. ret = ipv6_prefix_equal(addr, &ifa->addr, prefix_len); + 1891. if (ret) + +drivers/iommu/dmar.c:1895: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1893. */ + 1894. if (!dmaru->include_all && dmaru->devices && dmaru->devices_cnt) { + 1895. > for_each_active_dev_scope(dmaru->devices, + 1896. dmaru->devices_cnt, i, dev) + 1897. return -EBUSY; + +drivers/gpu/drm/i915/intel_uncore.c:1921: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 1919. intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL); + 1920. + 1921. > return ret; + 1922. } + 1923. + +net/wireless/trace.h:1885: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +net/wireless/trace.h:1885: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1883. ); + 1884. + 1885. > TRACE_EVENT(rdev_set_noack_map, + 1886. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 1887. u16 noack_map), + +crypto/drbg.c:1904: error: DEAD_STORE + The value written to &rc (type int) is never used. + 1902. struct drbg_state *drbg = NULL; + 1903. int ret = -EFAULT; + 1904. > int rc = -EFAULT; + 1905. bool pr = false; + 1906. int coreref = 0; + +crypto/drbg.c:1903: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1901. unsigned char buf[OUTBUFLEN]; + 1902. struct drbg_state *drbg = NULL; + 1903. > int ret = -EFAULT; + 1904. int rc = -EFAULT; + 1905. bool pr = false; + +block/blk-core.c:1992: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1990. + 1991. if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) + 1992. > req->cpu = raw_smp_processor_id(); + 1993. + 1994. plug = current->plug; + +block/blk-core.c:1992: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1990. + 1991. if (test_bit(QUEUE_FLAG_SAME_COMP, &q->queue_flags)) + 1992. > req->cpu = raw_smp_processor_id(); + 1993. + 1994. plug = current->plug; + +net/ipv6/ip6_fib.c:1924: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1922. if (res) { + 1923. #if RT6_DEBUG >= 2 + 1924. > pr_debug("%s: del failed: rt=%p@%p err=%d\n", + 1925. __func__, rt, + 1926. rcu_access_pointer(rt->rt6i_node), + +net/core/dev.c:1908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1906. struct packet_type *ptype, *pt_prev = *pt; + 1907. + 1908. > list_for_each_entry_rcu(ptype, ptype_list, list) { + 1909. if (ptype->type != type) + 1910. continue; + +drivers/cpufreq/cpufreq.c:1906: error: DEAD_STORE + The value written to &retval (type int) is never used. + 1904. unsigned int intermediate_freq = 0; + 1905. unsigned int newfreq = policy->freq_table[index].frequency; + 1906. > int retval = -EINVAL; + 1907. bool notify; + 1908. + +net/ipv6/addrconf.c:1911: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1909. idev = __in6_dev_get(dev); + 1910. if (idev) { + 1911. > list_for_each_entry_rcu(ifa, &idev->addr_list, if_list) { + 1912. onlink = ipv6_prefix_equal(addr, &ifa->addr, + 1913. ifa->prefix_len); + +drivers/usb/core/hub.c:1908: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1904 could be null and is dereferenced at line 1908, column 7. + 1906. + 1907. for (n = 0; n < hdev->maxchild; n++) { + 1908. > if (hub->ports[n]->port_owner == owner) + 1909. hub->ports[n]->port_owner = NULL; + 1910. } + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1901. ); + 1902. + 1903. > DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, + 1904. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1905. TP_ARGS(wiphy, wdev) + +lib/radix-tree.c:1919: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1917. + 1918. radix_tree_for_each_tagged(slot, root, &iter, first_index, tag) { + 1919. > results[ret] = rcu_dereference_raw(*slot); + 1920. if (!results[ret]) + 1921. continue; + +net/ipv4/route.c:2022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2020. if (res->fi) { + 2021. if (!itag) { + 2022. > rth = rcu_dereference(FIB_RES_NH(*res).nh_rth_input); + 2023. if (rt_cache_valid(rth)) { + 2024. skb_dst_set_noref(skb, &rth->dst); + +net/xfrm/xfrm_state.c:1912: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1910. + 1911. rcu_read_lock(); + 1912. > list_for_each_entry_rcu(km, &xfrm_km_list, list) + 1913. if (km->notify_policy) + 1914. km->notify_policy(xp, dir, c); + +net/wireless/trace.h:1908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:1908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1906. ); + 1907. + 1908. > TRACE_EVENT(rdev_return_chandef, + 1909. TP_PROTO(struct wiphy *wiphy, int ret, + 1910. struct cfg80211_chan_def *chandef), + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +kernel/irq/manage.c:1911: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1909. bool irq_percpu_is_enabled(unsigned int irq) + 1910. { + 1911. > unsigned int cpu = smp_processor_id(); + 1912. struct irq_desc *desc; + 1913. unsigned long flags; + +security/selinux/ss/policydb.c:1925: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1923. if (rc) + 1924. return rc; + 1925. > nel = le32_to_cpu(buf[0]); + 1926. + 1927. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:1945: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1943. if (rc) + 1944. goto out; + 1945. > len = le32_to_cpu(buf[0]); + 1946. + 1947. /* path component string */ + +security/selinux/ss/policydb.c:1958: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1956. goto out; + 1957. + 1958. > ft->stype = le32_to_cpu(buf[0]); + 1959. ft->ttype = le32_to_cpu(buf[1]); + 1960. ft->tclass = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:1959: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1957. + 1958. ft->stype = le32_to_cpu(buf[0]); + 1959. > ft->ttype = le32_to_cpu(buf[1]); + 1960. ft->tclass = le32_to_cpu(buf[2]); + 1961. + +security/selinux/ss/policydb.c:1960: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1958. ft->stype = le32_to_cpu(buf[0]); + 1959. ft->ttype = le32_to_cpu(buf[1]); + 1960. > ft->tclass = le32_to_cpu(buf[2]); + 1961. + 1962. otype->otype = le32_to_cpu(buf[3]); + +security/selinux/ss/policydb.c:1962: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 1960. ft->tclass = le32_to_cpu(buf[2]); + 1961. + 1962. > otype->otype = le32_to_cpu(buf[3]); + 1963. + 1964. rc = ebitmap_set_bit(&p->filename_trans_ttypes, ft->ttype, 1); + +net/ipv4/cipso_ipv4.c:1915: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 1913. const struct netlbl_lsm_secattr *secattr) + 1914. { + 1915. > int ret_val = -EPERM; + 1916. unsigned char *buf = NULL; + 1917. u32 buf_len; + +kernel/sched/rt.c:1948: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1946. * Matches WMB in rt_set_overload(). + 1947. */ + 1948. > next = atomic_read_acquire(&rd->rto_loop_next); + 1949. + 1950. if (rd->rto_loop == next) + +net/ipv4/fib_trie.c:1917: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1915. struct fib_alias *fa; + 1916. + 1917. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1918. struct fib_info *fi = fa->fa_info; + 1919. + +drivers/usb/core/hub.c:1922: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1921 could be null and is dereferenced at line 1922, column 11. + 1920. return false; + 1921. hub = usb_hub_to_struct_hub(udev->parent); + 1922. > return !!hub->ports[udev->portnum - 1]->port_owner; + 1923. } + 1924. + +arch/x86/events/core.c:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. * transaction. See x86_pmu_add() and x86_pmu_*_txn(). + 1933. */ + 1934. > __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + +arch/x86/events/core.c:1935: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1933. */ + 1934. __this_cpu_sub(cpu_hw_events.n_added, __this_cpu_read(cpu_hw_events.n_txn)); + 1935. > __this_cpu_sub(cpu_hw_events.n_events, __this_cpu_read(cpu_hw_events.n_txn)); + 1936. perf_pmu_enable(pmu); + 1937. } + +net/xfrm/xfrm_state.c:1922: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1920. struct xfrm_mgr *km; + 1921. rcu_read_lock(); + 1922. > list_for_each_entry_rcu(km, &xfrm_km_list, list) + 1923. if (km->notify) + 1924. km->notify(x, c); + +net/socket.c:1930: error: UNINITIALIZED_VALUE + The value read from msg.msg_control was never initialized. + 1928. return -EFAULT; + 1929. + 1930. > kmsg->msg_control = (void __force *)msg.msg_control; + 1931. kmsg->msg_controllen = msg.msg_controllen; + 1932. kmsg->msg_flags = msg.msg_flags; + +net/socket.c:1931: error: UNINITIALIZED_VALUE + The value read from msg.msg_controllen was never initialized. + 1929. + 1930. kmsg->msg_control = (void __force *)msg.msg_control; + 1931. > kmsg->msg_controllen = msg.msg_controllen; + 1932. kmsg->msg_flags = msg.msg_flags; + 1933. + +net/socket.c:1932: error: UNINITIALIZED_VALUE + The value read from msg.msg_flags was never initialized. + 1930. kmsg->msg_control = (void __force *)msg.msg_control; + 1931. kmsg->msg_controllen = msg.msg_controllen; + 1932. > kmsg->msg_flags = msg.msg_flags; + 1933. + 1934. kmsg->msg_namelen = msg.msg_namelen; + +net/socket.c:1965: error: UNINITIALIZED_VALUE + The value read from msg.msg_iovlen was never initialized. + 1963. kmsg->msg_iocb = NULL; + 1964. + 1965. > return import_iovec(save_addr ? READ : WRITE, + 1966. msg.msg_iov, msg.msg_iovlen, + 1967. UIO_FASTIOV, iov, &kmsg->msg_iter); + +net/socket.c:1945: error: UNINITIALIZED_VALUE + The value read from msg.msg_name was never initialized. + 1943. + 1944. if (save_addr) + 1945. > *save_addr = msg.msg_name; + 1946. + 1947. if (msg.msg_name && kmsg->msg_namelen) { + +net/socket.c:1934: error: UNINITIALIZED_VALUE + The value read from msg.msg_namelen was never initialized. + 1932. kmsg->msg_flags = msg.msg_flags; + 1933. + 1934. > kmsg->msg_namelen = msg.msg_namelen; + 1935. if (!msg.msg_name) + 1936. kmsg->msg_namelen = 0; + +net/ipv6/addrconf.c:1930: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1928. + 1929. rcu_read_lock(); + 1930. > hlist_for_each_entry_rcu(ifp, &inet6_addr_lst[hash], addr_lst) { + 1931. if (!net_eq(dev_net(ifp->idev->dev), net)) + 1932. continue; + +drivers/usb/core/hub.c:1931: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 1927 could be null and is dereferenced at line 1931, column 7. + 1929. + 1930. for (i = 0; i < udev->maxchild; ++i) { + 1931. > if (hub->ports[i]->child) + 1932. recursively_mark_NOTATTACHED(hub->ports[i]->child); + 1933. } + +net/ipv4/tcp_output.c:1966: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1964. goto send_now; + 1965. + 1966. > win_divisor = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_tso_win_divisor); + 1967. if (win_divisor) { + 1968. u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache); + +drivers/video/fbdev/core/fbmem.c:1934: error: DEAD_STORE + The value written to &err (type int) is never used. + 1932. struct fb_modelist *modelist; + 1933. struct fb_videomode *m, mode; + 1934. > int err = 1; + 1935. + 1936. list_for_each_safe(pos, n, &info->modelist) { + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +kernel/irq/manage.c:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. void disable_percpu_irq(unsigned int irq) + 1928. { + 1929. > unsigned int cpu = smp_processor_id(); + 1930. unsigned long flags; + 1931. struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU); + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1929: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1927. ); + 1928. + 1929. > DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, + 1930. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1931. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1934: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1932. ); + 1933. + 1934. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, + 1935. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1936. TP_ARGS(wiphy, wdev) + +net/core/dev.c:1945: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1943. rcu_read_lock(); + 1944. again: + 1945. > list_for_each_entry_rcu(ptype, ptype_list, list) { + 1946. /* Never send packets back to the socket + 1947. * they originated from - MvS (miquels@drinkel.ow.org) + +drivers/tty/n_tty.c:1947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1945. size_t n; + 1946. bool is_eof; + 1947. > size_t head = smp_load_acquire(&ldata->commit_head); + 1948. size_t tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + 1949. + +net/wireless/trace.h:1939: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +net/wireless/trace.h:1939: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1937. ); + 1938. + 1939. > TRACE_EVENT(rdev_start_nan, + 1940. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1941. struct cfg80211_nan_conf *conf), + +drivers/input/mouse/alps.c:1948: error: DEAD_STORE + The value written to &ret (type int) is never used. + 1946. { + 1947. u16 reg_val = 0x181; + 1948. > int ret = -1; + 1949. + 1950. /* enter monitor mode, to write the register */ + +net/ipv4/udp.c:1956: error: DEAD_STORE + The value written to &dif (type int) is never used. + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. > int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + +net/ipv4/udp.c:1955: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1953. struct udp_hslot *hslot = udp_hashslot(udptable, net, hnum); + 1954. unsigned int hash2 = 0, hash2_any = 0, use_hash2 = (hslot->count > 10); + 1955. > unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. int sdif = inet_sdif(skb); + +net/ipv4/udp.c:1967: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 1965. start_lookup: + 1966. hslot = &udptable->hash2[hash2]; + 1967. > offset = offsetof(typeof(*sk), __sk_common.skc_portaddr_node); + 1968. } + 1969. + +net/ipv4/udp.c:1957: error: DEAD_STORE + The value written to &sdif (type int) is never used. + 1955. unsigned int offset = offsetof(typeof(*sk), sk_node); + 1956. int dif = skb->dev->ifindex; + 1957. > int sdif = inet_sdif(skb); + 1958. struct hlist_node *node; + 1959. struct sk_buff *nskb; + +net/ipv4/udp.c:1970: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1968. } + 1969. + 1970. > sk_for_each_entry_offset_rcu(sk, node, &hslot->head, offset) { + 1971. if (!__udp_is_mcast_sock(net, sk, uh->dest, daddr, + 1972. uh->source, saddr, dif, sdif, hnum)) + +net/xfrm/xfrm_state.c:1952: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1950. + 1951. rcu_read_lock(); + 1952. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 1953. acqret = km->acquire(x, t, pol); + 1954. if (!acqret) + +net/ipv4/fib_trie.c:1959: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1957. struct fib_table *tb; + 1958. + 1959. > hlist_for_each_entry_rcu(tb, head, tb_hlist) + 1960. fib_table_notify(net, tb, nb); + 1961. } + +net/sunrpc/auth_gss/auth_gss.c:1965: error: DEAD_STORE + The value written to &status (type int) is never used. + 1963. struct kvec *head = ((struct rpc_rqst *)rqstp)->rq_rcv_buf.head; + 1964. int savedlen = head->iov_len; + 1965. > int status = -EIO; + 1966. + 1967. if (ctx->gc_proc != RPC_GSS_PROC_DATA) + +drivers/input/input.c:1967: error: UNINITIALIZED_VALUE + The value read from mt_slots was never initialized. + 1965. mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum - + 1966. dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1, + 1967. > mt_slots = clamp(mt_slots, 2, 32); + 1968. } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) { + 1969. mt_slots = 2; + +net/wireless/trace.h:1961: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +net/wireless/trace.h:1961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1959. ); + 1960. + 1961. > TRACE_EVENT(rdev_nan_change_conf, + 1962. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1963. struct cfg80211_nan_conf *conf, u32 changes), + +drivers/usb/core/devio.c:1969: error: UNINITIALIZED_VALUE + The value read from ds.context was never initialized. + 1967. return -EFAULT; + 1968. ps->discsignr = ds.signr; + 1969. > ps->disccontext = compat_ptr(ds.context); + 1970. return 0; + 1971. } + +drivers/usb/core/devio.c:1968: error: UNINITIALIZED_VALUE + The value read from ds.signr was never initialized. + 1966. if (copy_from_user(&ds, arg, sizeof(ds))) + 1967. return -EFAULT; + 1968. > ps->discsignr = ds.signr; + 1969. ps->disccontext = compat_ptr(ds.context); + 1970. return 0; + +net/xfrm/xfrm_state.c:1968: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1966. + 1967. rcu_read_lock(); + 1968. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 1969. if (km->new_mapping) + 1970. err = km->new_mapping(x, ipaddr, sport); + +kernel/cgroup/cpuset.c:1974: error: NULL_DEREFERENCE + pointer `cs` last assigned on line 1973 could be null and is dereferenced by call to `parent_cs()` at line 1974, column 26. + 1972. { + 1973. struct cpuset *cs = css_cs(css); + 1974. > struct cpuset *parent = parent_cs(cs); + 1975. struct cpuset *tmp_cs; + 1976. struct cgroup_subsys_state *pos_css; + +net/ipv6/ip6_fib.c:1983: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1981. for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { + 1982. head = &net->ipv6.fib_table_hash[h]; + 1983. > hlist_for_each_entry_rcu(table, head, tb6_hlist) { + 1984. spin_lock_bh(&table->tb6_lock); + 1985. fib6_clean_tree(net, &table->tb6_root, + +drivers/usb/core/devio.c:1985: error: UNINITIALIZED_VALUE + The value read from urb32.actual_length was never initialized. + 1983. kurb->buffer = compat_ptr(urb32.buffer); + 1984. kurb->buffer_length = urb32.buffer_length; + 1985. > kurb->actual_length = urb32.actual_length; + 1986. kurb->start_frame = urb32.start_frame; + 1987. kurb->number_of_packets = urb32.number_of_packets; + +drivers/usb/core/devio.c:1983: error: UNINITIALIZED_VALUE + The value read from urb32.buffer was never initialized. + 1981. kurb->status = urb32.status; + 1982. kurb->flags = urb32.flags; + 1983. > kurb->buffer = compat_ptr(urb32.buffer); + 1984. kurb->buffer_length = urb32.buffer_length; + 1985. kurb->actual_length = urb32.actual_length; + +drivers/usb/core/devio.c:1984: error: UNINITIALIZED_VALUE + The value read from urb32.buffer_length was never initialized. + 1982. kurb->flags = urb32.flags; + 1983. kurb->buffer = compat_ptr(urb32.buffer); + 1984. > kurb->buffer_length = urb32.buffer_length; + 1985. kurb->actual_length = urb32.actual_length; + 1986. kurb->start_frame = urb32.start_frame; + +drivers/usb/core/devio.c:1980: error: UNINITIALIZED_VALUE + The value read from urb32.endpoint was never initialized. + 1978. return -EFAULT; + 1979. kurb->type = urb32.type; + 1980. > kurb->endpoint = urb32.endpoint; + 1981. kurb->status = urb32.status; + 1982. kurb->flags = urb32.flags; + +drivers/usb/core/devio.c:1988: error: UNINITIALIZED_VALUE + The value read from urb32.error_count was never initialized. + 1986. kurb->start_frame = urb32.start_frame; + 1987. kurb->number_of_packets = urb32.number_of_packets; + 1988. > kurb->error_count = urb32.error_count; + 1989. kurb->signr = urb32.signr; + 1990. kurb->usercontext = compat_ptr(urb32.usercontext); + +drivers/usb/core/devio.c:1982: error: UNINITIALIZED_VALUE + The value read from urb32.flags was never initialized. + 1980. kurb->endpoint = urb32.endpoint; + 1981. kurb->status = urb32.status; + 1982. > kurb->flags = urb32.flags; + 1983. kurb->buffer = compat_ptr(urb32.buffer); + 1984. kurb->buffer_length = urb32.buffer_length; + +drivers/usb/core/devio.c:1987: error: UNINITIALIZED_VALUE + The value read from urb32.number_of_packets was never initialized. + 1985. kurb->actual_length = urb32.actual_length; + 1986. kurb->start_frame = urb32.start_frame; + 1987. > kurb->number_of_packets = urb32.number_of_packets; + 1988. kurb->error_count = urb32.error_count; + 1989. kurb->signr = urb32.signr; + +drivers/usb/core/devio.c:1989: error: UNINITIALIZED_VALUE + The value read from urb32.signr was never initialized. + 1987. kurb->number_of_packets = urb32.number_of_packets; + 1988. kurb->error_count = urb32.error_count; + 1989. > kurb->signr = urb32.signr; + 1990. kurb->usercontext = compat_ptr(urb32.usercontext); + 1991. return 0; + +drivers/usb/core/devio.c:1986: error: UNINITIALIZED_VALUE + The value read from urb32.start_frame was never initialized. + 1984. kurb->buffer_length = urb32.buffer_length; + 1985. kurb->actual_length = urb32.actual_length; + 1986. > kurb->start_frame = urb32.start_frame; + 1987. kurb->number_of_packets = urb32.number_of_packets; + 1988. kurb->error_count = urb32.error_count; + +drivers/usb/core/devio.c:1981: error: UNINITIALIZED_VALUE + The value read from urb32.status was never initialized. + 1979. kurb->type = urb32.type; + 1980. kurb->endpoint = urb32.endpoint; + 1981. > kurb->status = urb32.status; + 1982. kurb->flags = urb32.flags; + 1983. kurb->buffer = compat_ptr(urb32.buffer); + +drivers/usb/core/devio.c:1979: error: UNINITIALIZED_VALUE + The value read from urb32.type was never initialized. + 1977. if (copy_from_user(&urb32, uurb, sizeof(*uurb))) + 1978. return -EFAULT; + 1979. > kurb->type = urb32.type; + 1980. kurb->endpoint = urb32.endpoint; + 1981. kurb->status = urb32.status; + +drivers/usb/core/devio.c:1990: error: UNINITIALIZED_VALUE + The value read from urb32.usercontext was never initialized. + 1988. kurb->error_count = urb32.error_count; + 1989. kurb->signr = urb32.signr; + 1990. > kurb->usercontext = compat_ptr(urb32.usercontext); + 1991. return 0; + 1992. } + +net/ipv4/devinet.c:1993: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1991. cb->seq = atomic_read(&net->ipv4.dev_addr_genid) ^ + 1992. net->dev_base_seq; + 1993. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 1994. if (idx < s_idx) + 1995. goto cont; + +kernel/sched/core.c:2054: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2052. * their previous state and preserve Program Order. + 2053. */ + 2054. > smp_cond_load_acquire(&p->on_cpu, !VAL); + 2055. + 2056. p->sched_contributes_to_load = !!task_contributes_to_load(p); + +kernel/module.c:1989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1987. + 1988. mutex_lock(&module_mutex); + 1989. > list_for_each_entry_rcu(mod, &modules, list) { + 1990. if (mod->state == MODULE_STATE_UNFORMED) + 1991. continue; + +net/ipv4/fib_trie.c:1992: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1990. + 1991. /* rcu_read_lock is hold by caller */ + 1992. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 1993. int err; + 1994. + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:1985: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1983. ); + 1984. + 1985. > DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, + 1986. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 1987. TP_ARGS(wiphy, wdev) + +lib/radix-tree.c:1989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1987. struct radix_tree_node *node, void __rcu **slot) + 1988. { + 1989. > void *old = rcu_dereference_raw(*slot); + 1990. int exceptional = radix_tree_exceptional_entry(old) ? -1 : 0; + 1991. unsigned offset = get_slot_offset(node, slot); + +lib/vsprintf.c:2056: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2054. /* it's the next argument */ + 2055. spec->type = FORMAT_TYPE_WIDTH; + 2056. > return ++fmt - start; + 2057. } + 2058. + +lib/vsprintf.c:2071: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2069. /* it's the next argument */ + 2070. spec->type = FORMAT_TYPE_PRECISION; + 2071. > return ++fmt - start; + 2072. } + 2073. } + +lib/vsprintf.c:2097: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2095. case 'c': + 2096. spec->type = FORMAT_TYPE_CHAR; + 2097. > return ++fmt - start; + 2098. + 2099. case 's': + +lib/vsprintf.c:2101: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2099. case 's': + 2100. spec->type = FORMAT_TYPE_STR; + 2101. > return ++fmt - start; + 2102. + 2103. case 'p': + +lib/vsprintf.c:2105: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2103. case 'p': + 2104. spec->type = FORMAT_TYPE_PTR; + 2105. > return ++fmt - start; + 2106. + 2107. case '%': + +lib/vsprintf.c:2109: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2107. case '%': + 2108. spec->type = FORMAT_TYPE_PERCENT_CHAR; + 2109. > return ++fmt - start; + 2110. + 2111. /* integer number formats - set up the flags and "break" */ + +lib/vsprintf.c:2163: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2161. } + 2162. + 2163. > return ++fmt - start; + 2164. } + 2165. + +net/wireless/trace.h:1990: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +net/wireless/trace.h:1990: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1988. ); + 1989. + 1990. > TRACE_EVENT(rdev_add_nan_func, + 1991. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 1992. const struct cfg80211_nan_func *func), + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +arch/x86/events/core.c:1995: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 1993. { + 1994. struct cpu_hw_events *cpuc; + 1995. > int cpu = raw_smp_processor_id(); + 1996. + 1997. cpuc = kzalloc(sizeof(*cpuc), GFP_KERNEL); + +security/selinux/ss/policydb.c:2005: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2003. if (rc) + 2004. return rc; + 2005. > nel = le32_to_cpu(buf[0]); + 2006. + 2007. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2011: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2009. if (rc) + 2010. goto out; + 2011. > len = le32_to_cpu(buf[0]); + 2012. + 2013. rc = -ENOMEM; + +security/selinux/ss/policydb.c:2045: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2043. goto out; + 2044. + 2045. > nel2 = le32_to_cpu(buf[0]); + 2046. for (j = 0; j < nel2; j++) { + 2047. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:2050: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2048. if (rc) + 2049. goto out; + 2050. > len = le32_to_cpu(buf[0]); + 2051. + 2052. rc = -ENOMEM; + +security/selinux/ss/policydb.c:2065: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2063. goto out; + 2064. + 2065. > newc->v.sclass = le32_to_cpu(buf[0]); + 2066. rc = context_read_and_validate(&newc->context[0], p, fp); + 2067. if (rc) + +drivers/tty/n_tty.c:2007: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2005. return 0; + 2006. + 2007. > n = min(*nr + 1, smp_load_acquire(&ldata->canon_head) - ldata->read_tail); + 2008. + 2009. tail = ldata->read_tail & (N_TTY_BUF_SIZE - 1); + +drivers/cpufreq/cpufreq.c:2002: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2000. unsigned int relation) + 2001. { + 2002. > int ret = -EINVAL; + 2003. + 2004. down_write(&policy->rwsem); + +drivers/gpu/drm/drm_dp_mst_topology.c:2019: error: DEAD_STORE + The value written to &len (type int) is never used. + 2017. } + 2018. + 2019. > len = build_dpcd_write(txmsg, port->port_num, offset, size, bytes); + 2020. txmsg->dst = mstb; + 2021. + +kernel/module.c:2008: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2006. + 2007. mutex_lock(&module_mutex); + 2008. > list_for_each_entry_rcu(mod, &modules, list) { + 2009. /* + 2010. * Ignore going modules since it's possible that ro + +net/ipv4/tcp_ipv4.c:2005: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2003. { + 2004. struct tcp_iter_state *st = seq->private; + 2005. > struct net *net = seq_file_net(seq); + 2006. void *rc = NULL; + 2007. + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +kernel/cpu.c:2009: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2007. void __init boot_cpu_init(void) + 2008. { + 2009. > int cpu = smp_processor_id(); + 2010. + 2011. /* Mark the boot cpu "present", "online" etc for SMP and UP case */ + +drivers/net/ethernet/broadcom/tg3.c:2023: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2014 could be null and is dereferenced at line 2023, column 6. + 2021. oldflowctrl = tp->link_config.active_flowctrl; + 2022. + 2023. > if (phydev->link) { + 2024. lcl_adv = 0; + 2025. rmt_adv = 0; + +net/packet/af_packet.c:2016: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2014. + 2015. rcu_read_lock(); + 2016. > filter = rcu_dereference(sk->sk_filter); + 2017. if (filter != NULL) + 2018. res = bpf_prog_run_clear_cb(filter->prog, skb); + +kernel/cgroup/cgroup.c:2022: error: NULL_DEREFERENCE + pointer `ns` last assigned on line 2015 could be null and is dereferenced at line 2022, column 18. + 2020. + 2021. /* Check if the caller has permission to mount. */ + 2022. > if (!ns_capable(ns->user_ns, CAP_SYS_ADMIN)) { + 2023. put_cgroup_ns(ns); + 2024. return ERR_PTR(-EPERM); + +net/wireless/trace.h:2011: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +net/wireless/trace.h:2011: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2009. ); + 2010. + 2011. > TRACE_EVENT(rdev_del_nan_func, + 2012. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2013. u64 cookie), + +kernel/workqueue.c:2034: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2032. #endif + 2033. /* ensure we're on the correct CPU */ + 2034. > WARN_ON_ONCE(!(pool->flags & POOL_DISASSOCIATED) && + 2035. raw_smp_processor_id() != pool->cpu); + 2036. + +kernel/auditsc.c:2028: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2026. return; + 2027. + 2028. > uid = from_kuid(&init_user_ns, task_uid(current)); + 2029. oldloginuid = from_kuid(&init_user_ns, koldloginuid); + 2030. loginuid = from_kuid(&init_user_ns, kloginuid), + +net/xfrm/xfrm_state.c:2022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2020. + 2021. rcu_read_lock(); + 2022. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2023. if (km->report) { + 2024. ret = km->report(net, proto, sel, addr); + +kernel/trace/trace.c:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. if (atomic_read(&trace_record_taskinfo_disabled) || !tracing_is_on()) + 2028. return true; + 2029. > if (!__this_cpu_read(trace_taskinfo_save)) + 2030. return true; + 2031. return false; + +kernel/cpu.c:2027: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2025. void __init boot_cpu_state_init(void) + 2026. { + 2027. > per_cpu_ptr(&cpuhp_state, smp_processor_id())->state = CPUHP_ONLINE; + 2028. } + +net/wireless/trace.h:2029: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/wireless/trace.h:2029: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2027. ); + 2028. + 2029. > TRACE_EVENT(rdev_set_mac_acl, + 2030. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2031. struct cfg80211_acl_data *params), + +net/ipv6/route.c:2045: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2043. + 2044. rcu_read_lock(); + 2045. > fn = rcu_dereference(rt->rt6i_node); + 2046. if (fn && (rt->rt6i_flags & RTF_DEFAULT)) + 2047. fn->fn_sernum = -1; + +net/ipv4/tcp_output.c:2036: error: NULL_DEREFERENCE + pointer `skb` last assigned on line 2035 could be null and is dereferenced at line 2036, column 2. + 2034. + 2035. skb = tcp_send_head(sk); + 2036. > tcp_for_write_queue_from_safe(skb, next, sk) { + 2037. if (len <= skb->len) + 2038. break; + +net/ipv4/tcp_ipv4.c:2038: error: DEAD_STORE + The value written to &net (type net*) is never used. + 2036. struct hlist_nulls_node *node; + 2037. struct tcp_iter_state *st = seq->private; + 2038. > struct net *net = seq_file_net(seq); + 2039. + 2040. ++st->num; + +net/xfrm/xfrm_state.c:2040: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2038. + 2039. rcu_read_lock(); + 2040. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2041. if (km->is_alive && km->is_alive(c)) { + 2042. is_alive = true; + +net/ipv4/igmp.c:2048: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2046. return -ENODEV; + 2047. rcu_read_lock(); + 2048. > for_each_pmc_rcu(in_dev, pmc) { + 2049. if (*pmca == pmc->multiaddr) + 2050. break; + +net/sunrpc/xprtsock.c:2042: error: DEAD_STORE + The value written to &status (type int) is never used. + 2040. struct rpc_xprt *xprt = &transport->xprt; + 2041. struct socket *sock; + 2042. > int status = -EIO; + 2043. + 2044. status = __sock_create(xprt->xprt_net, AF_LOCAL, + +net/ipv4/devinet.c:2052: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2050. + 2051. rcu_read_lock(); + 2052. > for_each_netdev_rcu(net, dev) { + 2053. struct in_device *in_dev; + 2054. + +net/wireless/trace.h:2047: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/wireless/trace.h:2047: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2045. ); + 2046. + 2047. > TRACE_EVENT(rdev_update_ft_ies, + 2048. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2049. struct cfg80211_update_ft_ies_params *ftie), + +net/xfrm/xfrm_state.c:2080: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2078. err = -EINVAL; + 2079. rcu_read_lock(); + 2080. > list_for_each_entry_rcu(km, &xfrm_km_list, list) { + 2081. pol = km->compile_policy(sk, optname, data, + 2082. optlen, &err); + +drivers/md/md.c:2062: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2060. + 2061. rcu_read_lock(); + 2062. > rdev_for_each_rcu(rdev, mddev1) { + 2063. if (test_bit(Faulty, &rdev->flags) || + 2064. test_bit(Journal, &rdev->flags) || + +drivers/md/md.c:2067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2065. rdev->raid_disk == -1) + 2066. continue; + 2067. > rdev_for_each_rcu(rdev2, mddev2) { + 2068. if (test_bit(Faulty, &rdev2->flags) || + 2069. test_bit(Journal, &rdev2->flags) || + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2115: error: UNINITIALIZED_VALUE + The value read from fence.flags was never initialized. + 2113. ~__I915_EXEC_FENCE_UNKNOWN_FLAGS); + 2114. + 2115. > fences[n] = ptr_pack_bits(syncobj, fence.flags, 2); + 2116. } + 2117. + +drivers/gpu/drm/i915/i915_gem_execbuffer.c:2105: error: UNINITIALIZED_VALUE + The value read from fence.handle was never initialized. + 2103. } + 2104. + 2105. > syncobj = drm_syncobj_find(file, fence.handle); + 2106. if (!syncobj) { + 2107. DRM_DEBUG("Invalid syncobj handle provided\n"); + +kernel/rcu/tree.c:2067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2065. + 2066. /* Someone like call_rcu() requested a force-quiescent-state scan. */ + 2067. > *gfp = READ_ONCE(rsp->gp_flags); + 2068. if (*gfp & RCU_GP_FLAG_FQS) + 2069. return true; + +net/ipv6/route.c:2066: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2064. return !(rt->rt6i_flags & RTF_CACHE) && + 2065. (rt->rt6i_flags & RTF_PCPU || + 2066. > rcu_access_pointer(rt->rt6i_node)); + 2067. } + 2068. + +net/wireless/trace.h:2067: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/wireless/trace.h:2067: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2065. ); + 2066. + 2067. > TRACE_EVENT(rdev_crit_proto_start, + 2068. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 2069. enum nl80211_crit_proto_id protocol, u16 duration), + +net/xfrm/xfrm_user.c:2084: error: DEAD_STORE + The value written to &err (type int) is never used. + 2082. struct xfrm_userpolicy_info *p = &up->pol; + 2083. u8 type = XFRM_POLICY_TYPE_MAIN; + 2084. > int err = -ENOENT; + 2085. struct xfrm_mark m; + 2086. u32 mark = xfrm_mark_get(attrs, &m); + +drivers/usb/core/devio.c:2084: error: UNINITIALIZED_VALUE + The value read from ds.context was never initialized. + 2082. return -EFAULT; + 2083. ps->discsignr = ds.signr; + 2084. > ps->disccontext = ds.context; + 2085. return 0; + 2086. } + +drivers/usb/core/devio.c:2083: error: UNINITIALIZED_VALUE + The value read from ds.signr was never initialized. + 2081. if (copy_from_user(&ds, arg, sizeof(ds))) + 2082. return -EFAULT; + 2083. > ps->discsignr = ds.signr; + 2084. ps->disccontext = ds.context; + 2085. return 0; + +drivers/hid/hid-sony.c:2126: error: DEAD_STORE + The value written to &offset (type int) is never used. + 2124. /* If both delay values are zero the DualShock 4 disables blinking. */ + 2125. buf[offset++] = sc->led_delay_on[3]; + 2126. > buf[offset++] = sc->led_delay_off[3]; + 2127. + 2128. if (sc->quirks & (DUALSHOCK4_CONTROLLER_USB | DUALSHOCK4_DONGLE)) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2088: error: NULL_DEREFERENCE + pointer `power_well` last assigned on line 2087 could be null and is dereferenced at line 2088, column 8. + 2086. + 2087. power_well = lookup_power_well(dev_priv, power_well_id); + 2088. > ret = power_well->ops->is_enabled(dev_priv, power_well); + 2089. + 2090. return ret; + +drivers/usb/core/hub.c:2088: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2083 could be null and is dereferenced at line 2088, column 7. + 2086. /* Free up all the children before we remove this device */ + 2087. for (i = 0; i < udev->maxchild; i++) { + 2088. > if (hub->ports[i]->child) + 2089. usb_disconnect(&hub->ports[i]->child); + 2090. } + +net/wireless/trace.h:2087: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:2087: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2085. ); + 2086. + 2087. > TRACE_EVENT(rdev_crit_proto_stop, + 2088. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 2089. TP_ARGS(wiphy, wdev), + +drivers/net/ethernet/broadcom/tg3.c:2106: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2103 could be null and is dereferenced by call to `phydev_name()` at line 2106, column 32. + 2104. + 2105. /* Attach the MAC to the PHY. */ + 2106. > phydev = phy_connect(tp->dev, phydev_name(phydev), + 2107. tg3_adjust_link, phydev->interface); + 2108. if (IS_ERR(phydev)) { + +arch/x86/events/intel/core.c:2100: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2098. + 2099. if (unlikely(hwc->idx == INTEL_PMC_IDX_FIXED_BTS)) { + 2100. > if (!__this_cpu_read(cpu_hw_events.enabled)) + 2101. return; + 2102. + +kernel/kprobes.c:2105: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2103. * chained probes and mark them GONE. + 2104. */ + 2105. > list_for_each_entry_rcu(kp, &p->list, list) + 2106. kp->flags |= KPROBE_FLAG_GONE; + 2107. p->post_handler = NULL; + +kernel/sched/core.c:2133: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2131. + 2132. ttwu_do_wakeup(rq, p, 0, rf); + 2133. > ttwu_stat(p, smp_processor_id(), 0); + 2134. out: + 2135. raw_spin_unlock(&p->pi_lock); + +kernel/sched/core.c:2133: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2131. + 2132. ttwu_do_wakeup(rq, p, 0, rf); + 2133. > ttwu_stat(p, smp_processor_id(), 0); + 2134. out: + 2135. raw_spin_unlock(&p->pi_lock); + +kernel/sched/sched.h:2106: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2104. struct update_util_data *data; + 2105. + 2106. > data = rcu_dereference_sched(*per_cpu_ptr(&cpufreq_update_util_data, + 2107. cpu_of(rq))); + 2108. if (data) + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +net/wireless/trace.h:2102: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2100. ); + 2101. + 2102. > TRACE_EVENT(rdev_channel_switch, + 2103. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2104. struct cfg80211_csa_settings *params), + +security/selinux/ss/policydb.c:2118: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2116. if (rc) + 2117. goto out; + 2118. > nel = le32_to_cpu(buf[0]); + 2119. + 2120. l = NULL; + +security/selinux/ss/policydb.c:2138: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2136. goto out; + 2137. + 2138. > c->sid[0] = le32_to_cpu(buf[0]); + 2139. rc = context_read_and_validate(&c->context[0], p, fp); + 2140. if (rc) + +security/selinux/ss/policydb.c:2148: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2146. if (rc) + 2147. goto out; + 2148. > len = le32_to_cpu(buf[0]); + 2149. + 2150. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:2165: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2163. if (rc) + 2164. goto out; + 2165. > c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. c->u.port.high_port = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:2166: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2164. goto out; + 2165. c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. > c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. c->u.port.high_port = le32_to_cpu(buf[2]); + 2168. rc = context_read_and_validate(&c->context[0], p, fp); + +security/selinux/ss/policydb.c:2167: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2165. c->u.port.protocol = le32_to_cpu(buf[0]); + 2166. c->u.port.low_port = le32_to_cpu(buf[1]); + 2167. > c->u.port.high_port = le32_to_cpu(buf[2]); + 2168. rc = context_read_and_validate(&c->context[0], p, fp); + 2169. if (rc) + +security/selinux/ss/policydb.c:2188: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2186. + 2187. rc = -EINVAL; + 2188. > c->v.behavior = le32_to_cpu(buf[0]); + 2189. /* Determined at runtime, not in policy DB. */ + 2190. if (c->v.behavior == SECURITY_FS_USE_MNTPOINT) + +security/selinux/ss/policydb.c:2195: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2193. goto out; + 2194. + 2195. > len = le32_to_cpu(buf[1]); + 2196. rc = str_read(&c->u.name, GFP_KERNEL, fp, len); + 2197. if (rc) + +security/selinux/ss/policydb.c:2245: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2243. if (rc) + 2244. goto out; + 2245. > len = le32_to_cpu(buf[0]); + 2246. + 2247. rc = str_read(&c->u.ibendport.dev_name, GFP_KERNEL, fp, len); + +security/selinux/ss/policydb.c:2256: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2254. } + 2255. + 2256. > c->u.ibendport.port = le32_to_cpu(buf[1]); + 2257. + 2258. rc = context_read_and_validate(&c->context[0], + +security/selinux/ss/policydb.c:2176: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2174. if (rc) + 2175. goto out; + 2176. > c->u.node.addr = nodebuf[0]; /* network order */ + 2177. c->u.node.mask = nodebuf[1]; /* network order */ + 2178. rc = context_read_and_validate(&c->context[0], p, fp); + +security/selinux/ss/policydb.c:2177: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2175. goto out; + 2176. c->u.node.addr = nodebuf[0]; /* network order */ + 2177. > c->u.node.mask = nodebuf[1]; /* network order */ + 2178. rc = context_read_and_validate(&c->context[0], p, fp); + 2179. if (rc) + +security/selinux/ss/policydb.c:2211: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2209. goto out; + 2210. for (k = 0; k < 4; k++) + 2211. > c->u.node6.addr[k] = nodebuf[k]; + 2212. for (k = 0; k < 4; k++) + 2213. c->u.node6.mask[k] = nodebuf[k+4]; + +security/selinux/ss/policydb.c:2213: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2211. c->u.node6.addr[k] = nodebuf[k]; + 2212. for (k = 0; k < 4; k++) + 2213. > c->u.node6.mask[k] = nodebuf[k+4]; + 2214. rc = context_read_and_validate(&c->context[0], p, fp); + 2215. if (rc) + +security/selinux/ss/policydb.c:2232: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2230. } + 2231. + 2232. > c->u.ibpkey.low_pkey = le32_to_cpu(nodebuf[2]); + 2233. c->u.ibpkey.high_pkey = le32_to_cpu(nodebuf[3]); + 2234. + +security/selinux/ss/policydb.c:2233: error: UNINITIALIZED_VALUE + The value read from nodebuf[_] was never initialized. + 2231. + 2232. c->u.ibpkey.low_pkey = le32_to_cpu(nodebuf[2]); + 2233. > c->u.ibpkey.high_pkey = le32_to_cpu(nodebuf[3]); + 2234. + 2235. rc = context_read_and_validate(&c->context[0], + +include/net/sock.h:2110: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2108. if (sock_flag(sk, SOCK_FASYNC)) { + 2109. rcu_read_lock(); + 2110. > sock_wake_async(rcu_dereference(sk->sk_wq), how, band); + 2111. rcu_read_unlock(); + 2112. } + +kernel/rcu/tree.c:2170: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2168. if (needgp || cpu_needs_another_gp(rsp, rdp)) { + 2169. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2170. > trace_rcu_grace_period(rsp->name, + 2171. READ_ONCE(rsp->gpnum), + 2172. TPS("newreq")); + +drivers/tty/n_tty.c:2168: error: DEAD_STORE + The value written to &nr (type unsigned long) is never used. + 2166. } + 2167. b++; + 2168. > nr--; + 2169. break; + 2170. } + +sound/core/pcm_lib.c:2208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2206. } + 2207. frames = size > avail ? avail : size; + 2208. > appl_ptr = READ_ONCE(runtime->control->appl_ptr); + 2209. appl_ofs = appl_ptr % runtime->buffer_size; + 2210. cont = runtime->buffer_size - appl_ofs; + +net/core/ethtool.c:2135: error: UNINITIALIZED_VALUE + The value read from dump.len was never initialized. + 2133. return ret; + 2134. + 2135. > len = min(tmp.len, dump.len); + 2136. if (!len) + 2137. return -EFAULT; + +net/ipv4/fib_trie.c:2126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2124. while (!IS_TRIE(pn)) { + 2125. while (cindex < child_length(pn)) { + 2126. > struct key_vector *n = get_child_rcu(pn, cindex++); + 2127. + 2128. if (!n) + +net/ipv4/fib_trie.c:2146: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2144. /* Current node exhausted, pop back up */ + 2145. pkey = pn->key; + 2146. > pn = node_parent_rcu(pn); + 2147. cindex = get_index(pkey, pn) + 1; + 2148. --iter->depth; + +lib/radix-tree.c:2131: error: UNINITIALIZED_VALUE + The value read from pco_ret__ was never initialized. + 2129. if (!bitmap) + 2130. return 0; + 2131. > if (this_cpu_cmpxchg(ida_bitmap, NULL, bitmap)) + 2132. kfree(bitmap); + 2133. } + +lib/radix-tree.c:2127: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2125. preempt_enable(); + 2126. + 2127. > if (!this_cpu_read(ida_bitmap)) { + 2128. struct ida_bitmap *bitmap = kzalloc(sizeof(*bitmap), gfp); + 2129. if (!bitmap) + +net/ipv4/route.c:2154: error: NULL_DEREFERENCE + pointer `in_dev` last assigned on line 2132 could be null and is dereferenced at line 2154, column 8. + 2152. || + 2153. (!ipv4_is_local_multicast(daddr) && + 2154. > IN_DEV_MFORWARD(in_dev)) + 2155. #endif + 2156. ) { + +kernel/irq/manage.c:2154: error: MEMORY_LEAK + `chip` is not reachable after line 2154, column 3. + 2152. + 2153. if (data) + 2154. > err = chip->irq_get_irqchip_state(data, which, state); + 2155. + 2156. irq_put_desc_busunlock(desc, flags); + +arch/x86/events/core.c:2130: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2128. static void refresh_pce(void *ignored) + 2129. { + 2130. > load_mm_cr4(this_cpu_read(cpu_tlbstate.loaded_mm)); + 2131. } + 2132. + +net/ipv4/cipso_ipv4.c:2138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2136. + 2137. rcu_read_lock(); + 2138. > opt = rcu_dereference(inet_sk(sk)->inet_opt); + 2139. if (opt && opt->opt.cipso) + 2140. res = cipso_v4_getattr(opt->opt.__data + + +net/xfrm/xfrm_state.c:2147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2145. spin_lock_bh(&xfrm_state_afinfo_lock); + 2146. if (likely(xfrm_state_afinfo[afinfo->family] != NULL)) { + 2147. > if (rcu_access_pointer(xfrm_state_afinfo[family]) != afinfo) + 2148. err = -EINVAL; + 2149. else + +drivers/md/md.c:2148: error: DEAD_STORE + The value written to &bi_rdev (type blk_integrity*) is never used. + 2146. return 0; + 2147. + 2148. > bi_rdev = bdev_get_integrity(rdev->bdev); + 2149. bi_mddev = blk_get_integrity(mddev->gendisk); + 2150. + +lib/radix-tree.c:2160: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2158. return ERR_PTR(error); + 2159. shift = error; + 2160. > child = rcu_dereference_raw(root->rnode); + 2161. } + 2162. + +lib/radix-tree.c:2193: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2191. shift = node->shift; + 2192. } + 2193. > child = rcu_dereference_raw(node->slots[offset]); + 2194. } + 2195. slot = &node->slots[offset]; + +net/wireless/trace.h:2139: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/wireless/trace.h:2139: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2137. ); + 2138. + 2139. > TRACE_EVENT(rdev_set_qos_map, + 2140. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2141. struct cfg80211_qos_map *qos_map), + +net/ipv4/ipmr.c:2186: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2184. struct sock *mroute_sk; + 2185. + 2186. > mroute_sk = rcu_dereference(mrt->mroute_sk); + 2187. if (mroute_sk) { + 2188. nf_reset(skb); + +drivers/net/ethernet/broadcom/tg3.c:2154: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced at line 2154, column 3. + 2152. if (tp->phy_flags & TG3_PHYFLG_IS_LOW_POWER) { + 2153. tp->phy_flags &= ~TG3_PHYFLG_IS_LOW_POWER; + 2154. > phydev->speed = tp->link_config.speed; + 2155. phydev->duplex = tp->link_config.duplex; + 2156. phydev->autoneg = tp->link_config.autoneg; + +drivers/net/ethernet/broadcom/tg3.c:2160: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 2150 could be null and is dereferenced by call to `phy_start()` at line 2160, column 2. + 2158. } + 2159. + 2160. > phy_start(phydev); + 2161. + 2162. phy_start_aneg(phydev); + +drivers/tty/serial/serial_core.c:2155: error: NULL_DEREFERENCE + pointer `tty_dev` last assigned on line 2154 could be null and is dereferenced by call to `device_may_wakeup()` at line 2155, column 27. + 2153. + 2154. tty_dev = device_find_child(uport->dev, &match, serial_match_port); + 2155. > if (!uport->suspended && device_may_wakeup(tty_dev)) { + 2156. if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq)))) + 2157. disable_irq_wake(uport->irq); + +arch/x86/events/intel/core.c:2157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2155. static void intel_pmu_reset(void) + 2156. { + 2157. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 2158. unsigned long flags; + 2159. int idx; + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +arch/x86/events/intel/core.c:2157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2155. static void intel_pmu_reset(void) + 2156. { + 2157. > struct debug_store *ds = __this_cpu_read(cpu_hw_events.ds); + 2158. unsigned long flags; + 2159. int idx; + +arch/x86/events/intel/core.c:2166: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2164. local_irq_save(flags); + 2165. + 2166. > pr_info("clearing PMU state on CPU#%d\n", smp_processor_id()); + 2167. + 2168. for (idx = 0; idx < x86_pmu.num_counters; idx++) { + +net/wireless/trace.h:2157: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2157: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2155. ); + 2156. + 2157. > TRACE_EVENT(rdev_set_ap_chanwidth, + 2158. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2159. struct cfg80211_chan_def *chandef), + +net/ipv4/fib_trie.c:2167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2165. + 2166. pn = t->kv; + 2167. > n = rcu_dereference(pn->tnode[0]); + 2168. if (!n) + 2169. return NULL; + +net/xfrm/xfrm_state.c:2163: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2161. return NULL; + 2162. + 2163. > return rcu_dereference(xfrm_state_afinfo[family]); + 2164. } + 2165. + +net/ipv4/udp.c:2179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2177. + 2178. result = NULL; + 2179. > sk_for_each_rcu(sk, &hslot->head) { + 2180. if (__udp_is_mcast_sock(net, sk, loc_port, loc_addr, + 2181. rmt_port, rmt_addr, dif, sdif, hnum)) { + +block/blk-mq.c:2172: error: NULL_DEREFERENCE + pointer `hctx` last assigned on line 2171 could be null and is dereferenced at line 2172, column 25. + 2170. + 2171. hctx = hlist_entry_safe(node, struct blk_mq_hw_ctx, cpuhp_dead); + 2172. > ctx = __blk_mq_get_ctx(hctx->queue, cpu); + 2173. + 2174. spin_lock(&ctx->lock); + +kernel/trace/trace.c:2189: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2187. + 2188. preempt_disable(); + 2189. > if (cpu == smp_processor_id() && + 2190. this_cpu_read(trace_buffered_event) != + 2191. per_cpu(trace_buffered_event, cpu)) + +kernel/trace/trace.c:2190: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2188. preempt_disable(); + 2189. if (cpu == smp_processor_id() && + 2190. > this_cpu_read(trace_buffered_event) != + 2191. per_cpu(trace_buffered_event, cpu)) + 2192. WARN_ON_ONCE(1); + +net/ipv6/route.c:2188: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2186. fn = fib6_lookup(&table->tb6_root, &fl6->daddr, &fl6->saddr); + 2187. restart: + 2188. > for_each_fib6_node_rt_rcu(fn) { + 2189. if (rt->rt6i_nh_flags & RTNH_F_DEAD) + 2190. continue; + +net/xfrm/xfrm_state.c:2172: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2170. return NULL; + 2171. rcu_read_lock(); + 2172. > afinfo = rcu_dereference(xfrm_state_afinfo[family]); + 2173. if (unlikely(!afinfo)) + 2174. rcu_read_unlock(); + +net/ipv4/route.c:2239: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2237. if (fnhe) { + 2238. prth = &fnhe->fnhe_rth_output; + 2239. > rth = rcu_dereference(*prth); + 2240. if (rth && rth->dst.expires && + 2241. time_after(jiffies, rth->dst.expires)) { + +net/ipv4/route.c:2257: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2255. } + 2256. prth = raw_cpu_ptr(nh->nh_pcpu_rth_output); + 2257. > rth = rcu_dereference(*prth); + 2258. + 2259. rt_cache: + +net/xfrm/xfrm_user.c:2214: error: DEAD_STORE + The value written to &err (type int) is never used. + 2212. t->ealgos = ua->ealgos; + 2213. t->calgos = ua->calgos; + 2214. > err = km_query(x, t, xp); + 2215. + 2216. } + +kernel/irq/manage.c:2200: error: MEMORY_LEAK + `chip` is not reachable after line 2200, column 3. + 2198. + 2199. if (data) + 2200. > err = chip->irq_set_irqchip_state(data, which, val); + 2201. + 2202. irq_put_desc_busunlock(desc, flags); + +net/wireless/trace.h:2175: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +net/wireless/trace.h:2175: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2173. ); + 2174. + 2175. > TRACE_EVENT(rdev_add_tx_ts, + 2176. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2177. u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), + +kernel/rcu/tree.c:2230: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2228. TPS("fqswait")); + 2229. rsp->gp_state = RCU_GP_WAIT_FQS; + 2230. > ret = swait_event_idle_timeout(rsp->gp_wq, + 2231. rcu_gp_fqs_check_wake(rsp, &gf), j); + 2232. rsp->gp_state = RCU_GP_DOING_FQS; + +kernel/rcu/tree.c:2194: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2192. /* Handle grace-period start. */ + 2193. for (;;) { + 2194. > trace_rcu_grace_period(rsp->name, + 2195. READ_ONCE(rsp->gpnum), + 2196. TPS("reqwait")); + +kernel/rcu/tree.c:2207: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2205. WRITE_ONCE(rsp->gp_activity, jiffies); + 2206. WARN_ON(signal_pending(current)); + 2207. > trace_rcu_grace_period(rsp->name, + 2208. READ_ONCE(rsp->gpnum), + 2209. TPS("reqwaitsig")); + +kernel/rcu/tree.c:2226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2224. jiffies + 3 * j); + 2225. } + 2226. > trace_rcu_grace_period(rsp->name, + 2227. READ_ONCE(rsp->gpnum), + 2228. TPS("fqswait")); + +kernel/rcu/tree.c:2241: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2239. if (ULONG_CMP_GE(jiffies, rsp->jiffies_force_qs) || + 2240. (gf & RCU_GP_FLAG_FQS)) { + 2241. > trace_rcu_grace_period(rsp->name, + 2242. READ_ONCE(rsp->gpnum), + 2243. TPS("fqsstart")); + +kernel/rcu/tree.c:2246: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2244. rcu_gp_fqs(rsp, first_gp_fqs); + 2245. first_gp_fqs = false; + 2246. > trace_rcu_grace_period(rsp->name, + 2247. READ_ONCE(rsp->gpnum), + 2248. TPS("fqsend")); + +kernel/rcu/tree.c:2265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2263. WRITE_ONCE(rsp->gp_activity, jiffies); + 2264. WARN_ON(signal_pending(current)); + 2265. > trace_rcu_grace_period(rsp->name, + 2266. READ_ONCE(rsp->gpnum), + 2267. TPS("fqswaitsig")); + +net/core/dev.c:2231: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2229. for (i = tc, tci = cpu * num_tc; dev_maps && i--; tci++) { + 2230. /* fill in the new device map from the old device map */ + 2231. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2232. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2233. } + +net/core/dev.c:2258: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2256. } else if (dev_maps) { + 2257. /* fill in the new device map from the old device map */ + 2258. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2259. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2260. } + +net/core/dev.c:2265: error: DEAD_STORE + The value written to &map (type xps_map*) is never used. + 2263. for (i = num_tc - tc, tci++; dev_maps && --i; tci++) { + 2264. /* fill in the new device map from the old device map */ + 2265. > map = xmap_dereference(dev_maps->cpu_map[tci]); + 2266. RCU_INIT_POINTER(new_dev_maps->cpu_map[tci], map); + 2267. } + +net/ipv4/fib_trie.c:2201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2199. s->maxdepth = iter.depth; + 2200. + 2201. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) + 2202. ++s->prefixes; + 2203. } else { + +drivers/net/ethernet/intel/e1000/e1000_main.c:2206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2204. struct e1000_rx_ring *ring = &adapter->rx_ring[0]; + 2205. e1000_configure_rx(adapter); + 2206. > adapter->alloc_rx_buf(adapter, ring, E1000_DESC_UNUSED(ring)); + 2207. } + 2208. } + +ipc/sem.c:2210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2208. + 2209. rcu_read_lock(); + 2210. > un = list_entry_rcu(ulp->list_proc.next, + 2211. struct sem_undo, list_proc); + 2212. if (&un->list_proc == &ulp->list_proc) { + +net/xfrm/xfrm_state.c:2195: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2193. int xfrm_state_mtu(struct xfrm_state *x, int mtu) + 2194. { + 2195. > const struct xfrm_type *type = READ_ONCE(x->type); + 2196. + 2197. if (x->km.state == XFRM_STATE_VALID && + +net/ipv4/udp.c:2208: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2206. struct sock *sk; + 2207. + 2208. > udp_portaddr_for_each_entry_rcu(sk, &hslot2->head) { + 2209. if (INET_MATCH(sk, net, acookie, rmt_addr, + 2210. loc_addr, ports, dif, sdif)) + +kernel/fork.c:2206: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2204. leader = top = top->group_leader; + 2205. down: + 2206. > for_each_thread(leader, parent) { + 2207. list_for_each_entry(child, &parent->children, sibling) { + 2208. res = visitor(child, data); + +block/cfq-iosched.c:2213: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced at line 2213, column 12. + 2211. if (cfq_class_idle(cfqq)) { + 2212. rb_key = CFQ_IDLE_DELAY; + 2213. > parent = st->rb_rightmost; + 2214. if (parent && parent != &cfqq->rb_node) { + 2215. __cfqq = rb_entry(parent, struct cfq_queue, rb_node); + +block/cfq-iosched.c:2231: error: NULL_DEREFERENCE + pointer `st` last assigned on line 2210 could be null and is dereferenced by call to `cfq_rb_first()` at line 2231, column 12. + 2229. } else { + 2230. rb_key = -NSEC_PER_SEC; + 2231. > __cfqq = cfq_rb_first(st); + 2232. rb_key += __cfqq ? __cfqq->rb_key : now; + 2233. } + +net/wireless/trace.h:2200: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +net/wireless/trace.h:2200: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2198. ); + 2199. + 2200. > TRACE_EVENT(rdev_del_tx_ts, + 2201. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2202. u8 tsid, const u8 *peer), + +drivers/usb/core/devio.c:2210: error: UNINITIALIZED_VALUE + The value read from ioc32.data was never initialized. + 2208. ctrl.ifno = ioc32.ifno; + 2209. ctrl.ioctl_code = ioc32.ioctl_code; + 2210. > ctrl.data = compat_ptr(ioc32.data); + 2211. return proc_ioctl(ps, &ctrl); + 2212. } + +drivers/usb/core/devio.c:2208: error: UNINITIALIZED_VALUE + The value read from ioc32.ifno was never initialized. + 2206. if (copy_from_user(&ioc32, compat_ptr(arg), sizeof(ioc32))) + 2207. return -EFAULT; + 2208. > ctrl.ifno = ioc32.ifno; + 2209. ctrl.ioctl_code = ioc32.ioctl_code; + 2210. ctrl.data = compat_ptr(ioc32.data); + +drivers/usb/core/devio.c:2209: error: UNINITIALIZED_VALUE + The value read from ioc32.ioctl_code was never initialized. + 2207. return -EFAULT; + 2208. ctrl.ifno = ioc32.ifno; + 2209. > ctrl.ioctl_code = ioc32.ioctl_code; + 2210. ctrl.data = compat_ptr(ioc32.data); + 2211. return proc_ioctl(ps, &ctrl); + +kernel/trace/trace_events.c:2237: error: UNINITIALIZED_VALUE + The value read from last_i was never initialized. + 2235. * system. + 2236. */ + 2237. > for (i = last_i; i < len; i++) { + 2238. if (call->class->system == map[i]->system) { + 2239. /* Save the first system if need be */ + +kernel/kprobes.c:2238: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2236. for (i = 0; i < KPROBE_TABLE_SIZE; i++) { + 2237. head = &kprobe_table[i]; + 2238. > hlist_for_each_entry_rcu(p, head, hlist) + 2239. if (within_module_init((unsigned long)p->addr, mod) || + 2240. (checkcore && + +net/ipv4/udp.c:2261: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2259. skb->sk = sk; + 2260. skb->destructor = sock_efree; + 2261. > dst = READ_ONCE(sk->sk_rx_dst); + 2262. + 2263. if (dst) + +net/wireless/trace.h:2220: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +net/wireless/trace.h:2220: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2218. ); + 2219. + 2220. > TRACE_EVENT(rdev_tdls_channel_switch, + 2221. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2222. const u8 *addr, u8 oper_class, + +kernel/futex.c:2233: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2231. * optimizing lock_ptr out of the logic below. + 2232. */ + 2233. > lock_ptr = READ_ONCE(q->lock_ptr); + 2234. if (lock_ptr != NULL) { + 2235. spin_lock(lock_ptr); + +lib/radix-tree.c:2223: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2221. void idr_destroy(struct idr *idr) + 2222. { + 2223. > struct radix_tree_node *node = rcu_dereference_raw(idr->idr_rt.rnode); + 2224. if (radix_tree_is_internal_node(node)) + 2225. radix_tree_free_nodes(node); + +drivers/usb/host/ehci-sched.c:2270: error: DEAD_STORE + The value written to &dev (type usb_device*) is never used. + 2268. + 2269. /* give urb back to the driver; completion often (re)submits */ + 2270. > dev = urb->dev; + 2271. ehci_urb_done(ehci, urb, 0); + 2272. retval = true; + +drivers/iommu/intel-iommu.c:2293: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2291. * touches the iova range + 2292. */ + 2293. > tmp = cmpxchg64_local(&pte->val, 0ULL, pteval); + 2294. if (tmp) { + 2295. static int dumps = 5; + +kernel/signal.c:2279: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2277. info->si_pid = task_pid_vnr(current->parent); + 2278. info->si_uid = from_kuid_munged(current_user_ns(), + 2279. > task_uid(current->parent)); + 2280. rcu_read_unlock(); + 2281. } + +net/wireless/trace.h:2244: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/wireless/trace.h:2244: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2242. ); + 2243. + 2244. > TRACE_EVENT(rdev_tdls_cancel_channel_switch, + 2245. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2246. const u8 *addr), + +net/unix/af_unix.c:2365: error: DEAD_STORE + The value written to &sunaddr (type sockaddr_un*) is never used. + 2363. /* Copy address just once */ + 2364. if (state->msg && state->msg->msg_name) { + 2365. > DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, + 2366. state->msg->msg_name); + 2367. unix_copy_addr(state->msg, skb->sk); + +drivers/gpu/drm/drm_dp_mst_topology.c:2276: error: DEAD_STORE + The value written to &origlen (type int) is never used. + 2274. replylen = msg->curchunk_len + msg->curchunk_hdrlen; + 2275. + 2276. > origlen = replylen; + 2277. replylen -= len; + 2278. curreply = len; + +drivers/usb/core/devio.c:2264: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2262. return -EFAULT; + 2263. + 2264. > intf = usb_ifnum_to_if(ps->dev, dc.interface); + 2265. if (!intf) + 2266. return -EINVAL; + +drivers/usb/core/devio.c:2288: error: UNINITIALIZED_VALUE + The value read from dc.interface was never initialized. + 2286. } + 2287. + 2288. > return claimintf(ps, dc.interface); + 2289. } + 2290. + +kernel/auditsc.c:2265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2263. context->target_pid = task_tgid_nr(t); + 2264. context->target_auid = audit_get_loginuid(t); + 2265. > context->target_uid = task_uid(t); + 2266. context->target_sessionid = audit_get_sessionid(t); + 2267. security_task_getsecid(t, &context->target_sid); + +kernel/trace/trace.c:2274: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2272. if ((trace_file->flags & + 2273. (EVENT_FILE_FL_SOFT_DISABLED | EVENT_FILE_FL_FILTERED)) && + 2274. > (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. val = this_cpu_inc_return(trace_buffered_event_cnt); + +kernel/trace/trace.c:2276: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2274. (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. > val = this_cpu_inc_return(trace_buffered_event_cnt); + 2277. if (val == 1) { + 2278. trace_event_setup(entry, type, flags, pc); + +kernel/trace/trace.c:2274: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2272. if ((trace_file->flags & + 2273. (EVENT_FILE_FL_SOFT_DISABLED | EVENT_FILE_FL_FILTERED)) && + 2274. > (entry = this_cpu_read(trace_buffered_event))) { + 2275. /* Try to use the per cpu buffer first */ + 2276. val = this_cpu_inc_return(trace_buffered_event_cnt); + +net/wireless/trace.h:2262: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +net/wireless/trace.h:2262: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2260. ); + 2261. + 2262. > TRACE_EVENT(rdev_set_pmk, + 2263. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 2264. struct cfg80211_pmk_conf *pmk_conf), + +kernel/printk/printk.c:2271: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2269. static inline int can_use_console(void) + 2270. { + 2271. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2272. } + 2273. + +kernel/printk/printk.c:2271: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2269. static inline int can_use_console(void) + 2270. { + 2271. > return cpu_online(raw_smp_processor_id()) || have_callable_console(); + 2272. } + 2273. + +drivers/input/input.c:2278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2276. rcu_read_lock(); + 2277. + 2278. > list_for_each_entry_rcu(handle, &handler->h_list, h_node) { + 2279. retval = fn(handle, data); + 2280. if (retval) + +net/ipv6/ip6_fib.c:2278: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2276. if (tbl) { + 2277. h = (tbl->tb6_id & (FIB6_TABLE_HASHSZ - 1)) + 1; + 2278. > node = rcu_dereference_bh(hlist_next_rcu(&tbl->tb6_hlist)); + 2279. } else { + 2280. h = 0; + +net/ipv6/ip6_fib.c:2285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2283. + 2284. while (!node && h < FIB6_TABLE_HASHSZ) { + 2285. > node = rcu_dereference_bh( + 2286. hlist_first_rcu(&net->ipv6.fib_table_hash[h++])); + 2287. } + +security/selinux/ss/policydb.c:2447: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2445. goto bad; + 2446. + 2447. > rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + +security/selinux/ss/policydb.c:2298: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2296. rc = -EINVAL; + 2297. if (le32_to_cpu(buf[0]) != POLICYDB_MAGIC) { + 2298. > printk(KERN_ERR "SELinux: policydb magic number 0x%x does " + 2299. "not match expected magic number 0x%x\n", + 2300. le32_to_cpu(buf[0]), POLICYDB_MAGIC); + +security/selinux/ss/policydb.c:2305: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2303. + 2304. rc = -EINVAL; + 2305. > len = le32_to_cpu(buf[1]); + 2306. if (len != strlen(POLICYDB_STRING)) { + 2307. printk(KERN_ERR "SELinux: policydb string length %d does not " + +security/selinux/ss/policydb.c:2346: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2344. + 2345. rc = -EINVAL; + 2346. > p->policyvers = le32_to_cpu(buf[0]); + 2347. if (p->policyvers < POLICYDB_VERSION_MIN || + 2348. p->policyvers > POLICYDB_VERSION_MAX) { + +security/selinux/ss/policydb.c:2349: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2347. if (p->policyvers < POLICYDB_VERSION_MIN || + 2348. p->policyvers > POLICYDB_VERSION_MAX) { + 2349. > printk(KERN_ERR "SELinux: policydb version %d does not match " + 2350. "my version range %d-%d\n", + 2351. le32_to_cpu(buf[0]), POLICYDB_VERSION_MIN, POLICYDB_VERSION_MAX); + +security/selinux/ss/policydb.c:2392: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2390. if (le32_to_cpu(buf[2]) != info->sym_num || + 2391. le32_to_cpu(buf[3]) != info->ocon_num) { + 2392. > printk(KERN_ERR "SELinux: policydb table sizes (%d,%d) do " + 2393. "not match mine (%d,%d)\n", le32_to_cpu(buf[2]), + 2394. le32_to_cpu(buf[3]), + +security/selinux/ss/policydb.c:2403: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2401. if (rc) + 2402. goto bad; + 2403. > nprim = le32_to_cpu(buf[0]); + 2404. nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + +security/selinux/ss/policydb.c:2404: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2402. goto bad; + 2403. nprim = le32_to_cpu(buf[0]); + 2404. > nel = le32_to_cpu(buf[1]); + 2405. for (j = 0; j < nel; j++) { + 2406. rc = read_f[i](p, p->symtab[i].table, fp); + +security/selinux/ss/policydb.c:2432: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2430. if (rc) + 2431. goto bad; + 2432. > nel = le32_to_cpu(buf[0]); + 2433. ltr = NULL; + 2434. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2448: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2446. + 2447. rc = -EINVAL; + 2448. > tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + 2450. tr->new_role = le32_to_cpu(buf[2]); + +security/selinux/ss/policydb.c:2449: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2447. rc = -EINVAL; + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. > tr->type = le32_to_cpu(buf[1]); + 2450. tr->new_role = le32_to_cpu(buf[2]); + 2451. if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) { + +security/selinux/ss/policydb.c:2450: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2448. tr->role = le32_to_cpu(buf[0]); + 2449. tr->type = le32_to_cpu(buf[1]); + 2450. > tr->new_role = le32_to_cpu(buf[2]); + 2451. if (p->policyvers >= POLICYDB_VERSION_ROLETRANS) { + 2452. rc = next_entry(buf, fp, sizeof(u32)); + +security/selinux/ss/policydb.c:2455: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2453. if (rc) + 2454. goto bad; + 2455. > tr->tclass = le32_to_cpu(buf[0]); + 2456. } else + 2457. tr->tclass = p->process_class; + +security/selinux/ss/policydb.c:2471: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2469. if (rc) + 2470. goto bad; + 2471. > nel = le32_to_cpu(buf[0]); + 2472. lra = NULL; + 2473. for (i = 0; i < nel; i++) { + +security/selinux/ss/policydb.c:2487: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2485. + 2486. rc = -EINVAL; + 2487. > ra->role = le32_to_cpu(buf[0]); + 2488. ra->new_role = le32_to_cpu(buf[1]); + 2489. if (!policydb_role_isvalid(p, ra->role) || + +security/selinux/ss/policydb.c:2488: error: UNINITIALIZED_VALUE + The value read from buf[_] was never initialized. + 2486. rc = -EINVAL; + 2487. ra->role = le32_to_cpu(buf[0]); + 2488. > ra->new_role = le32_to_cpu(buf[1]); + 2489. if (!policydb_role_isvalid(p, ra->role) || + 2490. !policydb_role_isvalid(p, ra->new_role)) + +kernel/sysctl.c:2325: error: DEAD_STORE + The value written to &left (type unsigned long) is never used. + 2323. + 2324. if (!err && left) + 2325. > left -= proc_skip_spaces(&p); + 2326. + 2327. out_free: + +kernel/auditsc.c:2284: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2282. struct task_struct *tsk = current; + 2283. struct audit_context *ctx = tsk->audit_context; + 2284. > kuid_t uid = current_uid(), t_uid = task_uid(t); + 2285. + 2286. if (auditd_test_task(t) && + +drivers/cdrom/cdrom.c:2302: error: UNINITIALIZED_VALUE + The value read from ms_info.addr_format was never initialized. + 2300. return -EFAULT; + 2301. + 2302. > requested_format = ms_info.addr_format; + 2303. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2304. return -EINVAL; + +kernel/printk/printk.c:2428: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 2426. retry = console_seq != log_next_seq; + 2427. raw_spin_unlock(&logbuf_lock); + 2428. > printk_safe_exit_irqrestore(flags); + 2429. + 2430. if (retry && console_trylock()) + +include/linux/pci.h:2314: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2312. + 2313. if (idx > 0) { + 2314. > envp[idx++] = NULL; + 2315. kobject_uevent_env(&pdev->dev.kobj, KOBJ_CHANGE, envp); + 2316. } + +net/ipv4/udp.c:2298: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2296. if (static_key_false(&udp_encap_needed) && up->encap_type) { + 2297. void (*encap_destroy)(struct sock *sk); + 2298. > encap_destroy = READ_ONCE(up->encap_destroy); + 2299. if (encap_destroy) + 2300. encap_destroy(sk); + +kernel/signal.c:2474: error: UNINITIALIZED_VALUE + The value read from signr was never initialized. + 2472. spin_unlock_irq(&sighand->siglock); + 2473. + 2474. > ksig->sig = signr; + 2475. return ksig->sig > 0; + 2476. } + +drivers/gpu/drm/i915/intel_ddi.c:2303: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2298 could be null and is dereferenced at line 2303, column 2. + 2301. intel_disable_ddi_buf(encoder); + 2302. + 2303. > dig_port->set_infoframes(&encoder->base, false, + 2304. old_crtc_state, old_conn_state); + 2305. + +kernel/rcu/tree.c:2310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2308. } + 2309. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT); + 2310. > trace_rcu_grace_period(rsp->name, READ_ONCE(rsp->gpnum), + 2311. TPS("newreq")); + 2312. + +net/ipv4/fib_trie.c:2311: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2309. struct fib_table *tb; + 2310. + 2311. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2312. struct trie *t = (struct trie *) tb->tb_data; + 2313. struct trie_stat stat; + +drivers/gpu/drm/drm_dp_mst_topology.c:2314: error: DEAD_STORE + The value written to &slot (type int) is never used. + 2312. struct drm_dp_sideband_msg_tx *txmsg; + 2313. struct drm_dp_mst_branch *mstb; + 2314. > int slot = -1; + 2315. mstb = drm_dp_get_mst_branch_device(mgr, + 2316. mgr->down_rep_recv.initial_hdr.lct, + +net/wireless/trace.h:2301: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/wireless/trace.h:2301: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2299. ); + 2300. + 2301. > TRACE_EVENT(rdev_del_pmk, + 2302. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), + 2303. + +net/ipv4/ipmr.c:2343: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2341. nla_nest_end(skb, mp_attr); + 2342. + 2343. > lastuse = READ_ONCE(c->mfc_un.res.lastuse); + 2344. lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0; + 2345. + +net/ipv6/ip6_fib.c:2312: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2310. goto iter_table; + 2311. + 2312. > n = rcu_dereference_bh(((struct rt6_info *)v)->rt6_next); + 2313. if (n) { + 2314. ++*pos; + +kernel/trace/ring_buffer.c:2338: error: UNINITIALIZED_VALUE + The value read from __ret was never initialized. + 2336. old_index += write_mask; + 2337. new_index += write_mask; + 2338. > index = local_cmpxchg(&bpage->write, old_index, new_index); + 2339. if (index == old_index) { + 2340. /* update counters */ + +kernel/trace/ring_buffer.c:2324: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2322. addr &= PAGE_MASK; + 2323. + 2324. > bpage = READ_ONCE(cpu_buffer->tail_page); + 2325. + 2326. if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) { + +net/core/neighbour.c:2337: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2335. + 2336. rcu_read_lock_bh(); + 2337. > nht = rcu_dereference_bh(tbl->nht); + 2338. + 2339. for (h = s_h; h < (1 << nht->hash_shift); h++) { + +net/core/neighbour.c:2342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2340. if (h > s_h) + 2341. s_idx = 0; + 2342. > for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; + 2343. n != NULL; + 2344. n = rcu_dereference_bh(n->next)) { + +net/core/neighbour.c:2344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2342. for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; + 2343. n != NULL; + 2344. > n = rcu_dereference_bh(n->next)) { + 2345. if (idx < s_idx || !net_eq(dev_net(n->dev), net)) + 2346. goto next; + +net/sunrpc/clnt.c:2375: error: DEAD_STORE + The value written to &len (type int) is never used. + 2373. goto out_err; + 2374. } + 2375. > if (--len < 0) + 2376. goto out_overflow; + 2377. switch ((n = ntohl(*p++))) { + +net/sunrpc/clnt.c:2377: error: DEAD_STORE + The value written to &p (type unsigned int*) is never used. + 2375. if (--len < 0) + 2376. goto out_overflow; + 2377. > switch ((n = ntohl(*p++))) { + 2378. case RPC_AUTH_REJECTEDCRED: + 2379. case RPC_AUTH_REJECTEDVERF: + +net/ipv6/addrconf.c:2345: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2343. goto out; + 2344. + 2345. > for_each_fib6_node_rt_rcu(fn) { + 2346. if (rt->dst.dev->ifindex != dev->ifindex) + 2347. continue; + +net/wireless/trace.h:2326: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/wireless/trace.h:2326: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2324. *************************************************************/ + 2325. + 2326. > TRACE_EVENT(cfg80211_return_bool, + 2327. TP_PROTO(bool ret), + 2328. TP_ARGS(ret), + +net/ipv4/route.c:2337: error: DEAD_STORE + The value written to &err (type int) is never used. + 2335. unsigned int flags = 0; + 2336. struct rtable *rth; + 2337. > int err = -ENETUNREACH; + 2338. + 2339. if (fl4->saddr) { + +net/xfrm/xfrm_policy.c:2349: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2347. for (; idx < sp->len; idx++) { + 2348. if (xfrm_state_ok(tmpl, sp->xvec[idx], family)) + 2349. > return ++idx; + 2350. if (sp->xvec[idx]->props.mode != XFRM_MODE_TRANSPORT) { + 2351. if (start == -1) + +net/wireless/trace.h:2338: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2336. ); + 2337. + 2338. > DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, + 2339. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2340. TP_ARGS(netdev, macaddr), + +kernel/sched/core.c:2344: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2342. { + 2343. unsigned long flags; + 2344. > int cpu = get_cpu(); + 2345. + 2346. __sched_fork(clone_flags, p); + +kernel/sched/core.c:2344: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2342. { + 2343. unsigned long flags; + 2344. > int cpu = get_cpu(); + 2345. + 2346. __sched_fork(clone_flags, p); + +drivers/usb/core/hub.c:2360: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 2354 could be null and is dereferenced at line 2360, column 10. + 2358. * use that to determine whether it's removable. + 2359. */ + 2360. > switch (hub->ports[udev->portnum - 1]->connect_type) { + 2361. case USB_PORT_CONNECT_TYPE_HOT_PLUG: + 2362. udev->removable = USB_DEVICE_REMOVABLE; + +net/ipv4/fib_trie.c:2354: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2352. struct fib_table *tb; + 2353. + 2354. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2355. struct key_vector *n; + 2356. + +kernel/events/core.c:2355: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2353. int cpu) + 2354. { + 2355. > struct task_struct *task = READ_ONCE(ctx->task); + 2356. + 2357. lockdep_assert_held(&ctx->mutex); + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2353: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2351. ); + 2352. + 2353. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, + 2354. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2355. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2358: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2356. ); + 2357. + 2358. > DECLARE_EVENT_CLASS(netdev_evt_only, + 2359. TP_PROTO(struct net_device *netdev), + 2360. TP_ARGS(netdev), + +arch/x86/events/core.c:2375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2373. + 2374. /* IRQs are off, so this synchronizes with smp_store_release */ + 2375. > ldt = READ_ONCE(current->active_mm->context.ldt); + 2376. if (!ldt || idx >= ldt->nr_entries) + 2377. return 0; + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +net/wireless/trace.h:2370: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2368. ); + 2369. + 2370. > DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, + 2371. TP_PROTO(struct net_device *netdev), + 2372. TP_ARGS(netdev) + +kernel/kprobes.c:2383: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2381. head = &kprobe_table[i]; + 2382. preempt_disable(); + 2383. > hlist_for_each_entry_rcu(p, head, hlist) { + 2384. sym = kallsyms_lookup((unsigned long)p->addr, NULL, + 2385. &offset, &modname, namebuf); + +kernel/kprobes.c:2387: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2385. &offset, &modname, namebuf); + 2386. if (kprobe_aggrprobe(p)) { + 2387. > list_for_each_entry_rcu(kp, &p->list, list) + 2388. report_probe(pi, kp, sym, offset, modname, p); + 2389. } else + +net/wireless/trace.h:2375: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/wireless/trace.h:2375: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2373. ); + 2374. + 2375. > TRACE_EVENT(cfg80211_send_rx_assoc, + 2376. TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), + 2377. TP_ARGS(netdev, bss), + +net/ipv4/fib_trie.c:2394: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2392. /* walk rest of this hash chain */ + 2393. h = tb->tb_id & (FIB_TABLE_HASHSZ - 1); + 2394. > while ((tb_node = rcu_dereference(hlist_next_rcu(&tb->tb_hlist)))) { + 2395. tb = hlist_entry(tb_node, struct fib_table, tb_hlist); + 2396. n = fib_trie_get_first(iter, (struct trie *) tb->tb_data); + +net/ipv4/fib_trie.c:2404: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2402. while (++h < FIB_TABLE_HASHSZ) { + 2403. struct hlist_head *head = &net->ipv4.fib_table_hash[h]; + 2404. > hlist_for_each_entry_rcu(tb, head, tb_hlist) { + 2405. n = fib_trie_get_first(iter, (struct trie *) tb->tb_data); + 2406. if (n) + +drivers/gpu/drm/i915/i915_drv.c:2388: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 2386. * valleyview_enable_rps) so use a 3ms timeout. + 2387. */ + 2388. > return wait_for((I915_READ_NOTRACE(VLV_GTLC_PW_STATUS) & mask) == val, + 2389. 3); + 2390. } + +drivers/gpu/drm/i915/intel_ddi.c:2408: error: NULL_DEREFERENCE + pointer `dig_port` last assigned on line 2396 could be null and is dereferenced at line 2408, column 2. + 2406. * enabling the port. + 2407. */ + 2408. > I915_WRITE(DDI_BUF_CTL(port), + 2409. dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE); + 2410. + +net/wireless/trace.h:2392: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2390. ); + 2391. + 2392. > DECLARE_EVENT_CLASS(netdev_frame_event, + 2393. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2394. TP_ARGS(netdev, buf, len), + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2407: error: DEAD_STORE + The value written to &ctrl (type unsigned int) is never used. + 2405. u16 phy_data; + 2406. + 2407. > ctrl = er32(CTRL); + 2408. status = er32(STATUS); + 2409. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2468: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 2466. hw->forced_speed_duplex == e1000_10_half)) { + 2467. ew32(IMC, 0xffffffff); + 2468. > ret_val = + 2469. e1000_polarity_reversal_workaround(hw); + 2470. icr = er32(ICR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2416: error: DEAD_STORE + The value written to &rxcw (type unsigned int) is never used. + 2414. if ((hw->media_type == e1000_media_type_fiber) || + 2415. (hw->media_type == e1000_media_type_internal_serdes)) { + 2416. > rxcw = er32(RXCW); + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + +drivers/net/ethernet/intel/e1000/e1000_hw.c:2419: error: DEAD_STORE + The value written to &signal (type unsigned int) is never used. + 2417. + 2418. if (hw->media_type == e1000_media_type_fiber) { + 2419. > signal = + 2420. (hw->mac_type > + 2421. e1000_82544) ? E1000_CTRL_SWDPIN1 : 0; + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +kernel/sys.c:2412: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2410. { + 2411. int err = 0; + 2412. > int cpu = raw_smp_processor_id(); + 2413. + 2414. if (cpup) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2408: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2406. ); + 2407. + 2408. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, + 2409. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2410. TP_ARGS(netdev, buf, len) + +net/sunrpc/xprtsock.c:2419: error: DEAD_STORE + The value written to &status (type int) is never used. + 2417. struct socket *sock = transport->sock; + 2418. struct rpc_xprt *xprt = &transport->xprt; + 2419. > int status = -EIO; + 2420. + 2421. if (!sock) { + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +net/wireless/trace.h:2413: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2411. ); + 2412. + 2413. > DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, + 2414. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2415. TP_ARGS(netdev, buf, len) + +include/linux/netdevice.h:2424: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2422. + 2423. net = dev_net(dev); + 2424. > lh = rcu_dereference(list_next_rcu(&dev->dev_list)); + 2425. return lh == &net->dev_base_head ? NULL : net_device_entry(lh); + 2426. } + +net/wireless/trace.h:2418: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +net/wireless/trace.h:2418: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2416. ); + 2417. + 2418. > TRACE_EVENT(cfg80211_tx_mlme_mgmt, + 2419. TP_PROTO(struct net_device *netdev, const u8 *buf, int len), + 2420. TP_ARGS(netdev, buf, len), + +drivers/md/md.c:2453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2451. if (ret == 0) + 2452. md_cluster_ops->metadata_update_cancel(mddev); + 2453. > bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2454. BIT(MD_SB_CHANGE_DEVS) | + 2455. BIT(MD_SB_CHANGE_CLEAN)); + +drivers/md/md.c:2602: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2600. + 2601. if (mddev->in_sync != sync_req || + 2602. > !bit_clear_unless(&mddev->sb_flags, BIT(MD_SB_CHANGE_PENDING), + 2603. BIT(MD_SB_CHANGE_DEVS) | BIT(MD_SB_CHANGE_CLEAN))) + 2604. /* have to write it out again */ + +net/wireless/trace.h:2434: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2432. ); + 2433. + 2434. > DECLARE_EVENT_CLASS(netdev_mac_evt, + 2435. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2436. TP_ARGS(netdev, mac), + +kernel/trace/trace.c:2448: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2446. preempt_disable_notrace(); + 2447. + 2448. > export = rcu_dereference_raw_notrace(ftrace_exports_list); + 2449. while (export) { + 2450. trace_process_export(export, event); + +kernel/trace/trace.c:2451: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2449. while (export) { + 2450. trace_process_export(export, event); + 2451. > export = rcu_dereference_raw_notrace(export->next); + 2452. } + 2453. + +drivers/net/ethernet/intel/e1000/e1000_main.c:2461: error: DEAD_STORE + The value written to &txb2b (type _Bool) is never used. + 2459. if (!netif_carrier_ok(netdev)) { + 2460. u32 ctrl; + 2461. > bool txb2b = true; + 2462. /* update snapshot of PHY registers on LSC */ + 2463. e1000_get_speed_and_duplex(hw, + +drivers/net/ethernet/intel/e1000/e1000_main.c:2535: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2533. + 2534. if (!netif_carrier_ok(netdev)) { + 2535. > if (E1000_DESC_UNUSED(txdr) + 1 < txdr->count) { + 2536. /* We've lost link, so the controller stops DMA, + 2537. * but we've got queued Tx work that's never going + +net/core/neighbour.c:2453: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2451. + 2452. rcu_read_lock_bh(); + 2453. > nht = rcu_dereference_bh(tbl->nht); + 2454. + 2455. read_lock(&tbl->lock); /* avoid resizes */ + +net/core/neighbour.c:2459: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2457. struct neighbour *n; + 2458. + 2459. > for (n = rcu_dereference_bh(nht->hash_buckets[chain]); + 2460. n != NULL; + 2461. n = rcu_dereference_bh(n->next)) + +net/core/neighbour.c:2461: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2459. for (n = rcu_dereference_bh(nht->hash_buckets[chain]); + 2460. n != NULL; + 2461. > n = rcu_dereference_bh(n->next)) + 2462. cb(n, cookie); + 2463. } + +net/wireless/reg.c:2457: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2455. rcu_read_lock(); + 2456. + 2457. > cfg80211_regd = rcu_dereference(cfg80211_regdomain); + 2458. wiphy1_regd = rcu_dereference(wiphy1->regd); + 2459. if (!wiphy1_regd) + +net/wireless/reg.c:2458: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2456. + 2457. cfg80211_regd = rcu_dereference(cfg80211_regdomain); + 2458. > wiphy1_regd = rcu_dereference(wiphy1->regd); + 2459. if (!wiphy1_regd) + 2460. wiphy1_regd = cfg80211_regd; + +net/wireless/reg.c:2462: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2460. wiphy1_regd = cfg80211_regd; + 2461. + 2462. > wiphy2_regd = rcu_dereference(wiphy2->regd); + 2463. if (!wiphy2_regd) + 2464. wiphy2_regd = cfg80211_regd; + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2449: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2447. ); + 2448. + 2449. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, + 2450. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2451. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +net/wireless/trace.h:2454: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2452. ); + 2453. + 2454. > DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, + 2455. TP_PROTO(struct net_device *netdev, const u8 *mac), + 2456. TP_ARGS(netdev, mac) + +kernel/kprobes.c:2478: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2476. head = &kprobe_table[i]; + 2477. /* Arm all kprobes on a best-effort basis */ + 2478. > hlist_for_each_entry_rcu(p, head, hlist) { + 2479. if (!kprobe_disabled(p)) { + 2480. err = arm_kprobe(p); + +net/wireless/trace.h:2459: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +net/wireless/trace.h:2459: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2457. ); + 2458. + 2459. > TRACE_EVENT(cfg80211_michael_mic_failure, + 2460. TP_PROTO(struct net_device *netdev, const u8 *addr, + 2461. enum nl80211_key_type key_type, int key_id, const u8 *tsc), + +drivers/net/ethernet/intel/e100.c:2464: error: DEAD_STORE + The value written to &nic (type nic*) is never used. + 2462. static int e100_get_regs_len(struct net_device *netdev) + 2463. { + 2464. > struct nic *nic = netdev_priv(netdev); + 2465. return 1 + E100_PHY_REGS + sizeof(nic->mem->dump_buf); + 2466. } + +net/ipv4/fib_trie.c:2472: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2470. struct key_vector *n = v; + 2471. + 2472. > if (IS_TRIE(node_parent_rcu(n))) + 2473. fib_table_print(seq, iter->tb); + 2474. + +net/ipv4/fib_trie.c:2490: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2488. seq_printf(seq, " |-- %pI4\n", &val); + 2489. + 2490. > hlist_for_each_entry_rcu(fa, &n->leaf, fa_list) { + 2491. char buf1[32], buf2[32]; + 2492. + +net/ipv4/tcp.c:2502: error: UNINITIALIZED_VALUE + The value read from opt.max_window was never initialized. + 2500. tp->snd_wl1 = opt.snd_wl1; + 2501. tp->snd_wnd = opt.snd_wnd; + 2502. > tp->max_window = opt.max_window; + 2503. + 2504. tp->rcv_wnd = opt.rcv_wnd; + +net/ipv4/tcp.c:2504: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wnd was never initialized. + 2502. tp->max_window = opt.max_window; + 2503. + 2504. > tp->rcv_wnd = opt.rcv_wnd; + 2505. tp->rcv_wup = opt.rcv_wup; + 2506. + +net/ipv4/tcp.c:2497: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wup was never initialized. + 2495. return -EINVAL; + 2496. + 2497. > if (after(opt.rcv_wup, tp->rcv_nxt)) + 2498. return -EINVAL; + 2499. + +net/ipv4/tcp.c:2505: error: UNINITIALIZED_VALUE + The value read from opt.rcv_wup was never initialized. + 2503. + 2504. tp->rcv_wnd = opt.rcv_wnd; + 2505. > tp->rcv_wup = opt.rcv_wup; + 2506. + 2507. return 0; + +net/ipv4/tcp.c:2494: error: UNINITIALIZED_VALUE + The value read from opt.snd_wl1 was never initialized. + 2492. return -EINVAL; + 2493. + 2494. > if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd)) + 2495. return -EINVAL; + 2496. + +net/ipv4/tcp.c:2500: error: UNINITIALIZED_VALUE + The value read from opt.snd_wl1 was never initialized. + 2498. return -EINVAL; + 2499. + 2500. > tp->snd_wl1 = opt.snd_wl1; + 2501. tp->snd_wnd = opt.snd_wnd; + 2502. tp->max_window = opt.max_window; + +net/ipv4/tcp.c:2501: error: UNINITIALIZED_VALUE + The value read from opt.snd_wnd was never initialized. + 2499. + 2500. tp->snd_wl1 = opt.snd_wl1; + 2501. > tp->snd_wnd = opt.snd_wnd; + 2502. tp->max_window = opt.max_window; + 2503. + +kernel/rcu/tree.c:2499: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2497. */ + 2498. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */ + 2499. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 2500. raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + 2501. return; + +kernel/rcu/tree.c:2499: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2497. */ + 2498. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */ + 2499. > rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr); + 2500. raw_spin_unlock_irqrestore_rcu_node(rnp, flags); + 2501. return; + +net/wireless/trace.h:2483: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +net/wireless/trace.h:2483: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2481. ); + 2482. + 2483. > TRACE_EVENT(cfg80211_ready_on_channel, + 2484. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2485. struct ieee80211_channel *chan, + +include/linux/netdevice.h:2487: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2485. static inline int dev_recursion_level(void) + 2486. { + 2487. > return this_cpu_read(xmit_recursion); + 2488. } + 2489. + +include/linux/netdevice.h:2487: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2485. static inline int dev_recursion_level(void) + 2486. { + 2487. > return this_cpu_read(xmit_recursion); + 2488. } + 2489. + +net/core/dev.c:2502: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2500. rcu_read_lock(); + 2501. if (!(txq->state & QUEUE_STATE_ANY_XOFF)) { + 2502. > struct Qdisc *q = rcu_dereference(txq->qdisc); + 2503. + 2504. __netif_schedule(q); + +kernel/kprobes.c:2521: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2519. head = &kprobe_table[i]; + 2520. /* Disarm all kprobes on a best-effort basis */ + 2521. > hlist_for_each_entry_rcu(p, head, hlist) { + 2522. if (!arch_trampoline_kprobe(p) && !kprobe_disabled(p)) { + 2523. err = disarm_kprobe(p, false); + +net/wireless/trace.h:2505: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/wireless/trace.h:2505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2503. ); + 2504. + 2505. > TRACE_EVENT(cfg80211_ready_on_channel_expired, + 2506. TP_PROTO(struct wireless_dev *wdev, u64 cookie, + 2507. struct ieee80211_channel *chan), + +net/core/dev.c:2516: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2514. + 2515. rcu_read_lock(); + 2516. > q = rcu_dereference(dev_queue->qdisc); + 2517. __netif_schedule(q); + 2518. rcu_read_unlock(); + +net/ipv4/tcp.c:2525: error: UNINITIALIZED_VALUE + The value read from opt.opt_val was never initialized. + 2523. switch (opt.opt_code) { + 2524. case TCPOPT_MSS: + 2525. > tp->rx_opt.mss_clamp = opt.opt_val; + 2526. tcp_mtup_init(sk); + 2527. break; + +net/core/dev.c:2538: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2536. get_kfree_skb_cb(skb)->reason = reason; + 2537. local_irq_save(flags); + 2538. > skb->next = __this_cpu_read(softnet_data.completion_queue); + 2539. __this_cpu_write(softnet_data.completion_queue, skb); + 2540. raise_softirq_irqoff(NET_TX_SOFTIRQ); + +net/core/dev.c:2538: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2536. get_kfree_skb_cb(skb)->reason = reason; + 2537. local_irq_save(flags); + 2538. > skb->next = __this_cpu_read(softnet_data.completion_queue); + 2539. __this_cpu_write(softnet_data.completion_queue, skb); + 2540. raise_softirq_irqoff(NET_TX_SOFTIRQ); + +net/wireless/trace.h:2523: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +net/wireless/trace.h:2523: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2521. ); + 2522. + 2523. > TRACE_EVENT(cfg80211_new_sta, + 2524. TP_PROTO(struct net_device *netdev, const u8 *mac_addr, + 2525. struct station_info *sinfo), + +drivers/base/regmap/regmap.c:2574: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2572. map->unlock(map->lock_arg); + 2573. + 2574. > return ret; + 2575. } + 2576. EXPORT_SYMBOL_GPL(regmap_raw_read); + +drivers/iommu/intel-iommu.c:2542: error: DEAD_STORE + The value written to &req_id (type unsigned short) is never used. + 2540. return NULL; + 2541. + 2542. > req_id = ((u16)bus << 8) | devfn; + 2543. + 2544. if (dev_is_pci(dev)) { + +kernel/events/core.c:2549: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2547. * so we need to check again lest we try to stop another CPU's event. + 2548. */ + 2549. > if (READ_ONCE(event->oncpu) != smp_processor_id()) + 2550. return -EAGAIN; + 2551. + +net/netlink/af_netlink.c:2565: error: UNINITIALIZED_VALUE + The value read from nlk was never initialized. + 2563. } while (sock_net(&nlk->sk) != seq_file_net(seq)); + 2564. + 2565. > return nlk; + 2566. } + 2567. + +drivers/gpu/drm/i915/intel_ddi.c:2585: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 2583 could be null and is dereferenced at line 2585, column 7. + 2583. intel_dig_port = enc_to_dig_port(&encoder->base); + 2584. + 2585. > if (intel_dig_port->infoframe_enabled(&encoder->base, pipe_config)) + 2586. pipe_config->has_infoframe = true; + 2587. + +net/netfilter/nf_conntrack_netlink.c:2593: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2591. struct nf_conntrack_helper *helper; + 2592. + 2593. > helper = rcu_dereference(help->helper); + 2594. if (helper && + 2595. nla_put_string(skb, CTA_EXPECT_HELP_NAME, helper->name)) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2541: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2539. ); + 2540. + 2541. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, + 2542. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2543. TP_ARGS(netdev, macaddr) + +net/core/neighbour.c:2550: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2548. struct neigh_hash_table *nht = state->nht; + 2549. struct neighbour *n = NULL; + 2550. > int bucket = state->bucket; + 2551. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + +net/core/neighbour.c:2554: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2552. state->flags &= ~NEIGH_SEQ_IS_PNEIGH; + 2553. for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) { + 2554. > n = rcu_dereference_bh(nht->hash_buckets[bucket]); + 2555. + 2556. while (n) { + +net/core/neighbour.c:2572: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2570. break; + 2571. next: + 2572. > n = rcu_dereference_bh(n->next); + 2573. } + 2574. + +net/wireless/trace.h:2546: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +net/wireless/trace.h:2546: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2544. ); + 2545. + 2546. > TRACE_EVENT(cfg80211_rx_mgmt, + 2547. TP_PROTO(struct wireless_dev *wdev, int freq, int sig_dbm), + 2548. TP_ARGS(wdev, freq, sig_dbm), + +kernel/workqueue.c:2560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2558. } + 2559. + 2560. > for_each_pwq(pwq, wq) { + 2561. struct worker_pool *pool = pwq->pool; + 2562. + +drivers/net/ethernet/broadcom/tg3.c:2613: error: UNINITIALIZED_VALUE + The value read from phy9_orig was never initialized. + 2611. tg3_phy_toggle_auxctl_smdsp(tp, false); + 2612. + 2613. > tg3_writephy(tp, MII_CTRL1000, phy9_orig); + 2614. + 2615. err = tg3_readphy(tp, MII_TG3_EXT_CTRL, ®32); + +net/wireless/trace.h:2563: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +net/wireless/trace.h:2563: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2561. ); + 2562. + 2563. > TRACE_EVENT(cfg80211_mgmt_tx_status, + 2564. TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), + 2565. TP_ARGS(wdev, cookie, ack), + +kernel/events/core.c:2589: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2587. * fall through with ret==-ENXIO. + 2588. */ + 2589. > ret = cpu_function_call(READ_ONCE(event->oncpu), + 2590. __perf_event_stop, &sd); + 2591. } while (ret == -EAGAIN); + +kernel/trace/trace.c:2603: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2601. preempt_disable_notrace(); + 2602. + 2603. > use_stack = __this_cpu_inc_return(ftrace_stack_reserve); + 2604. /* + 2605. * We don't need any atomic variables, just a barrier. + +drivers/iommu/amd_iommu.c:2581: error: DEAD_STORE + The value written to &npages (type int) is never used. + 2579. struct dma_ops_domain *dma_dom; + 2580. unsigned long startaddr; + 2581. > int npages = 2; + 2582. + 2583. domain = get_domain(dev); + +net/ipv4/ipmr.c:2592: error: DEAD_STORE + The value written to &rtm (type rtmsg*) is never used. + 2590. goto errout; + 2591. + 2592. > rtm = nlmsg_data(nlh); + 2593. + 2594. src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0; + +net/wireless/trace.h:2580: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/wireless/trace.h:2580: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2578. ); + 2579. + 2580. > TRACE_EVENT(cfg80211_cqm_rssi_notify, + 2581. TP_PROTO(struct net_device *netdev, + 2582. enum nl80211_cqm_rssi_threshold_event rssi_event, + +net/core/neighbour.c:2596: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2594. return n; + 2595. } + 2596. > n = rcu_dereference_bh(n->next); + 2597. + 2598. while (1) { + +net/core/neighbour.c:2614: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2612. break; + 2613. next: + 2614. > n = rcu_dereference_bh(n->next); + 2615. } + 2616. + +net/core/neighbour.c:2623: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2621. break; + 2622. + 2623. > n = rcu_dereference_bh(nht->hash_buckets[state->bucket]); + 2624. } + 2625. + +net/ipv4/igmp.c:2600: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2598. + 2599. rcu_read_lock(); + 2600. > for_each_pmc_rcu(inet, pmc) { + 2601. if (pmc->multi.imr_multiaddr.s_addr == loc_addr && + 2602. (pmc->multi.imr_ifindex == dif || + +net/ipv4/igmp.c:2609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2607. if (!pmc) + 2608. goto unlock; + 2609. > psl = rcu_dereference(pmc->sflist); + 2610. ret = (pmc->sfmode == MCAST_EXCLUDE); + 2611. if (!psl) + +net/socket.c:2592: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2590. bool sock_is_registered(int family) + 2591. { + 2592. > return family < NPROTO && rcu_access_pointer(net_families[family]); + 2593. } + 2594. + +drivers/iommu/amd_iommu.c:2601: error: DEAD_STORE + The value written to &dma_mask (type unsigned long long) is never used. + 2599. unsigned long attrs) + 2600. { + 2601. > u64 dma_mask = dev->coherent_dma_mask; + 2602. struct protection_domain *domain; + 2603. struct dma_ops_domain *dma_dom; + +net/wireless/trace.h:2599: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +net/wireless/trace.h:2599: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2597. ); + 2598. + 2599. > TRACE_EVENT(cfg80211_reg_can_beacon, + 2600. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, + 2601. enum nl80211_iftype iftype, bool check_no_ir), + +drivers/gpu/drm/i915/intel_runtime_pm.c:2620: error: NULL_DEREFERENCE + pointer `well` last assigned on line 2619 could be null and is dereferenced by call to `intel_power_well_enable()` at line 2620, column 2. + 2618. + 2619. well = lookup_power_well(dev_priv, SKL_DISP_PW_1); + 2620. > intel_power_well_enable(dev_priv, well); + 2621. + 2622. well = lookup_power_well(dev_priv, SKL_DISP_PW_MISC_IO); + +net/core/sock.c:2609: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2607. + 2608. rcu_read_lock(); + 2609. > wq = rcu_dereference(sk->sk_wq); + 2610. if (skwq_has_sleeper(wq)) + 2611. wake_up_interruptible_all(&wq->wait); + +block/blk-core.c:2613: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2611. int cpu; + 2612. + 2613. > cpu = part_stat_lock(); + 2614. part = req->part; + 2615. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +block/blk-core.c:2613: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2611. int cpu; + 2612. + 2613. > cpu = part_stat_lock(); + 2614. part = req->part; + 2615. part_stat_add(cpu, part, sectors[rw], bytes >> 9); + +drivers/cdrom/cdrom.c:2618: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 2616. return -EFAULT; + 2617. + 2618. > requested = q.cdsc_format; + 2619. if (requested != CDROM_MSF && requested != CDROM_LBA) + 2620. return -EINVAL; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +kernel/trace/ring_buffer.c:2612: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2610. { + 2611. struct ring_buffer_per_cpu *cpu_buffer; + 2612. > int cpu = raw_smp_processor_id(); + 2613. + 2614. cpu_buffer = buffer->buffers[cpu]; + +net/core/sock.c:2620: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2618. + 2619. rcu_read_lock(); + 2620. > wq = rcu_dereference(sk->sk_wq); + 2621. if (skwq_has_sleeper(wq)) + 2622. wake_up_interruptible_poll(&wq->wait, EPOLLERR); + +net/sunrpc/clnt.c:2657: error: NULL_DEREFERENCE + pointer `xprt` last assigned on line 2627 could be null and is dereferenced at line 2657, column 2. + 2655. xprt_put(xprt); + 2656. xprt_switch_put(xps); + 2657. > pr_info("RPC: rpc_clnt_test_xprt failed: %d addr %s not added\n", + 2658. status, xprt->address_strings[RPC_DISPLAY_ADDR]); + 2659. return status; + +drivers/net/ethernet/intel/e100.c:2631: error: DEAD_STORE + The value written to &err (type int) is never used. + 2629. + 2630. /* save speed, duplex & autoneg settings */ + 2631. > err = mii_ethtool_gset(&nic->mii, &cmd); + 2632. + 2633. if (netif_running(netdev)) + +drivers/net/ethernet/intel/e100.c:2640: error: DEAD_STORE + The value written to &err (type int) is never used. + 2638. + 2639. /* restore speed, duplex & autoneg settings */ + 2640. > err = mii_ethtool_sset(&nic->mii, &cmd); + 2641. + 2642. if (netif_running(netdev)) + +block/blk-core.c:2633: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2631. int cpu; + 2632. + 2633. > cpu = part_stat_lock(); + 2634. part = req->part; + 2635. + +block/blk-core.c:2633: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2631. int cpu; + 2632. + 2633. > cpu = part_stat_lock(); + 2634. part = req->part; + 2635. + +net/wireless/trace.h:2620: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2620: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2618. ); + 2619. + 2620. > TRACE_EVENT(cfg80211_chandef_dfs_required, + 2621. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2622. TP_ARGS(wiphy, chandef), + +net/core/sock.c:2632: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2630. + 2631. rcu_read_lock(); + 2632. > wq = rcu_dereference(sk->sk_wq); + 2633. if (skwq_has_sleeper(wq)) + 2634. wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI | + +net/ipv4/ipmr.c:2650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2648. if (t < s_t) + 2649. goto next_table; + 2650. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) { + 2651. if (e < s_e) + 2652. goto next_entry; + +net/wireless/trace.h:2635: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2635: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2633. ); + 2634. + 2635. > TRACE_EVENT(cfg80211_ch_switch_notify, + 2636. TP_PROTO(struct net_device *netdev, + 2637. struct cfg80211_chan_def *chandef), + +kernel/rcu/tree.c:2663: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2661. */ + 2662. local_irq_save(flags); + 2663. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2664. bl = rdp->blimit; + 2665. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +kernel/rcu/tree.c:2663: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2661. */ + 2662. local_irq_save(flags); + 2663. > WARN_ON_ONCE(cpu_is_offline(smp_processor_id())); + 2664. bl = rdp->blimit; + 2665. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist), + +net/core/sock.c:2650: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2648. */ + 2649. if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) { + 2650. > wq = rcu_dereference(sk->sk_wq); + 2651. if (skwq_has_sleeper(wq)) + 2652. wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT | + +kernel/trace/ring_buffer.c:2661: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2659. + 2660. /* Don't let the compiler play games with cpu_buffer->tail_page */ + 2661. > tail_page = info->tail_page = READ_ONCE(cpu_buffer->tail_page); + 2662. write = local_add_return(info->length, &tail_page->write); + 2663. + +drivers/gpu/drm/i915/intel_sdvo.c:2695: error: UNINITIALIZED_VALUE + The value read from bytes[_] was never initialized. + 2693. intel_sdvo->controlled_output = 0; + 2694. memcpy(bytes, &intel_sdvo->caps.output_flags, 2); + 2695. > DRM_DEBUG_KMS("%s: Unknown SDVO output type (0x%02x%02x)\n", + 2696. SDVO_NAME(intel_sdvo), + 2697. bytes[0], bytes[1]); + +net/ipv4/fib_trie.c:2662: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2660. prefix = htonl(l->key); + 2661. + 2662. > hlist_for_each_entry_rcu(fa, &l->leaf, fa_list) { + 2663. const struct fib_info *fi = fa->fa_info; + 2664. __be32 mask = inet_make_mask(KEYLENGTH - fa->fa_slen); + +net/core/neighbour.c:2652: error: DEAD_STORE + The value written to &bucket (type int) is never used. + 2650. struct neigh_table *tbl = state->tbl; + 2651. struct pneigh_entry *pn = NULL; + 2652. > int bucket = state->bucket; + 2653. + 2654. state->flags |= NEIGH_SEQ_IS_PNEIGH; + +net/ipv6/mcast.c:2654: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2652. + 2653. state->idev = NULL; + 2654. > for_each_netdev_rcu(net, state->dev) { + 2655. struct inet6_dev *idev; + 2656. idev = __in6_dev_get(state->dev); + +net/wireless/trace.h:2651: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +net/wireless/trace.h:2651: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2649. ); + 2650. + 2651. > TRACE_EVENT(cfg80211_ch_switch_started_notify, + 2652. TP_PROTO(struct net_device *netdev, + 2653. struct cfg80211_chan_def *chandef), + +drivers/cdrom/cdrom.c:2670: error: UNINITIALIZED_VALUE + The value read from entry.cdte_format was never initialized. + 2668. return -EFAULT; + 2669. + 2670. > requested_format = entry.cdte_format; + 2671. if (requested_format != CDROM_MSF && requested_format != CDROM_LBA) + 2672. return -EINVAL; + +net/ipv4/igmp.c:2667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2665. int rv = 0; + 2666. + 2667. > mc_hash = rcu_dereference(in_dev->mc_hash); + 2668. if (mc_hash) { + 2669. u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); + +net/ipv4/igmp.c:2671: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2669. u32 hash = hash_32((__force u32)mc_addr, MC_HASH_SZ_LOG); + 2670. + 2671. > for (im = rcu_dereference(mc_hash[hash]); + 2672. im != NULL; + 2673. im = rcu_dereference(im->next_hash)) { + +net/ipv4/igmp.c:2673: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2671. for (im = rcu_dereference(mc_hash[hash]); + 2672. im != NULL; + 2673. > im = rcu_dereference(im->next_hash)) { + 2674. if (im->multiaddr == mc_addr) + 2675. break; + +net/ipv4/igmp.c:2678: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2676. } + 2677. } else { + 2678. > for_each_pmc_rcu(in_dev, im) { + 2679. if (im->multiaddr == mc_addr) + 2680. break; + +drivers/tty/tty_io.c:2669: error: DEAD_STORE + The value written to &retval (type int) is never used. + 2667. struct tty_struct *tty = file_tty(file); + 2668. struct tty_ldisc *ld; + 2669. > int retval = -ENOIOCTLCMD; + 2670. + 2671. if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl")) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2688: error: NULL_DEREFERENCE + pointer `well` last assigned on line 2687 could be null and is dereferenced by call to `intel_power_well_enable()` at line 2688, column 2. + 2686. + 2687. well = lookup_power_well(dev_priv, SKL_DISP_PW_1); + 2688. > intel_power_well_enable(dev_priv, well); + 2689. + 2690. mutex_unlock(&power_domains->lock); + +net/wireless/trace.h:2667: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +net/wireless/trace.h:2667: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2665. ); + 2666. + 2667. > TRACE_EVENT(cfg80211_radar_event, + 2668. TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), + 2669. TP_ARGS(wiphy, chandef), + +block/blk-core.c:2679: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2677. return; + 2678. + 2679. > cpu = part_stat_lock(); + 2680. + 2681. if (!new_io) { + +block/blk-core.c:2679: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2677. return; + 2678. + 2679. > cpu = part_stat_lock(); + 2680. + 2681. if (!new_io) { + +drivers/usb/core/hub.c:2721: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 2719. return -EBUSY; + 2720. + 2721. > if (hub_port_warm_reset_required(hub, port1, portstatus)) + 2722. return -ENOTCONN; + 2723. + +kernel/cgroup/cgroup.c:2685: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2684 could be null and is dereferenced at line 2685, column 7. + 2683. percpu_up_write(&cgroup_threadgroup_rwsem); + 2684. for_each_subsys(ss, ssid) + 2685. > if (ss->post_attach) + 2686. ss->post_attach(); + 2687. } + +net/sunrpc/clnt.c:2692: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2690. + 2691. rcu_read_lock(); + 2692. > xps = xprt_switch_get(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 2693. xprt = xprt_iter_xprt(&clnt->cl_xpi); + 2694. if (xps == NULL || xprt == NULL) { + +drivers/md/md.c:2687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2685. char *sep = ","; + 2686. size_t len = 0; + 2687. > unsigned long flags = READ_ONCE(rdev->flags); + 2688. + 2689. if (test_bit(Faulty, &flags) || + +net/wireless/trace.h:2682: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/wireless/trace.h:2682: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2680. ); + 2681. + 2682. > TRACE_EVENT(cfg80211_cac_event, + 2683. TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), + 2684. TP_ARGS(netdev, evt), + +net/socket.c:2697: error: UNINITIALIZED_VALUE + The value read from ifc32.ifc_len was never initialized. + 2695. return -EFAULT; + 2696. + 2697. > ifc.ifc_len = ifc32.ifc_len; + 2698. ifc.ifc_req = compat_ptr(ifc32.ifcbuf); + 2699. + +net/socket.c:2698: error: UNINITIALIZED_VALUE + The value read from ifc32.ifcbuf was never initialized. + 2696. + 2697. ifc.ifc_len = ifc32.ifc_len; + 2698. > ifc.ifc_req = compat_ptr(ifc32.ifcbuf); + 2699. + 2700. rtnl_lock(); + +net/wireless/trace.h:2697: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2695. ); + 2696. + 2697. > DECLARE_EVENT_CLASS(cfg80211_rx_evt, + 2698. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2699. TP_ARGS(netdev, addr), + +net/netfilter/nf_conntrack_netlink.c:2713: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2711. for (; cb->args[0] < nf_ct_expect_hsize; cb->args[0]++) { + 2712. restart: + 2713. > hlist_for_each_entry_rcu(exp, &nf_ct_expect_hash[cb->args[0]], + 2714. hnode) { + 2715. if (l3proto && exp->tuple.src.l3num != l3proto) + +block/blk-core.c:2709: error: NULL_DEREFERENCE + pointer `null` could be null and is dereferenced by call to `blk_get_flush_queue()` at line 2709, column 31. + 2707. { + 2708. struct request *rq; + 2709. > struct blk_flush_queue *fq = blk_get_flush_queue(q, NULL); + 2710. + 2711. WARN_ON_ONCE(q->mq_ops); + +sound/pci/hda/hda_codec.c:2728: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2726. msleep(1); + 2727. } + 2728. > return state; + 2729. } + 2730. + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2711: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2709. ); + 2710. + 2711. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, + 2712. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2713. TP_ARGS(netdev, addr) + +net/ipv4/igmp.c:2719: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2717. + 2718. state->in_dev = NULL; + 2719. > for_each_netdev_rcu(net, state->dev) { + 2720. struct in_device *in_dev; + 2721. + +net/ipv4/igmp.c:2725: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2723. if (!in_dev) + 2724. continue; + 2725. > im = rcu_dereference(in_dev->mc_list); + 2726. if (im) { + 2727. state->in_dev = in_dev; + +drivers/net/ethernet/intel/e100.c:2732: error: DEAD_STORE + The value written to &i (type int) is never used. + 2730. data[i++] = nic->rx_tco_frames; + 2731. data[i++] = nic->rx_short_frame_errors; + 2732. > data[i++] = nic->rx_over_length_errors; + 2733. } + 2734. + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +net/wireless/trace.h:2716: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2714. ); + 2715. + 2716. > DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, + 2717. TP_PROTO(struct net_device *netdev, const u8 *addr), + 2718. TP_ARGS(netdev, addr) + +drivers/tty/tty_io.c:2738: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2736. read_lock(&tasklist_lock); + 2737. /* Kill the entire session */ + 2738. > do_each_pid_task(session, PIDTYPE_SID, p) { + 2739. tty_notice(tty, "SAK: killed process %d (%s): by session\n", + 2740. task_pid_nr(p), p->comm); + +drivers/tty/tty_io.c:2745: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2743. + 2744. /* Now kill any processes that happen to have the tty open */ + 2745. > do_each_thread(g, p) { + 2746. if (p->signal->tty == tty) { + 2747. tty_notice(tty, "SAK: killed process %d (%s): by controlling tty\n", + +kernel/trace/trace.c:2743: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2741. */ + 2742. preempt_disable(); + 2743. > if (__this_cpu_read(user_stack_count)) + 2744. goto out; + 2745. + +net/wireless/trace.h:2721: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/wireless/trace.h:2721: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2719. ); + 2720. + 2721. > TRACE_EVENT(cfg80211_ibss_joined, + 2722. TP_PROTO(struct net_device *netdev, const u8 *bssid, + 2723. struct ieee80211_channel *channel), + +net/core/neighbour.c:2733: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2731. + 2732. rcu_read_lock_bh(); + 2733. > state->nht = rcu_dereference_bh(tbl->nht); + 2734. + 2735. return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN; + +net/ipv6/addrconf.c:2731: error: DEAD_STORE + The value written to &err (type int) is never used. + 2729. struct in6_ifreq ireq; + 2730. struct net_device *dev; + 2731. > int err = -EINVAL; + 2732. + 2733. rtnl_lock(); + +net/ipv6/addrconf.c:2739: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2737. goto err_exit; + 2738. + 2739. > dev = __dev_get_by_index(net, ireq.ifr6_ifindex); + 2740. + 2741. err = -ENODEV; + +net/ipv4/tcp_output.c:2737: error: NULL_DEREFERENCE + pointer `next_skb` last assigned on line 2733 could be null and is dereferenced at line 2737, column 18. + 2735. + 2736. skb_size = skb->len; + 2737. > next_skb_size = next_skb->len; + 2738. + 2739. BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1); + +net/ipv4/igmp.c:2738: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2736. struct igmp_mc_iter_state *state = igmp_mc_seq_private(seq); + 2737. + 2738. > im = rcu_dereference(im->next_rcu); + 2739. while (!im) { + 2740. state->dev = next_net_device_rcu(state->dev); + +net/ipv4/igmp.c:2748: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2746. if (!state->in_dev) + 2747. continue; + 2748. > im = rcu_dereference(state->in_dev->mc_list); + 2749. } + 2750. return im; + +net/wireless/trace.h:2739: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +net/wireless/trace.h:2739: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2737. ); + 2738. + 2739. > TRACE_EVENT(cfg80211_probe_status, + 2740. TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, + 2741. bool acked), + +kernel/sched/fair.c:2753: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2751. cfs_rq->runnable_weight -= se->runnable_weight; + 2752. + 2753. > sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + +kernel/sched/fair.c:2754: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2752. + 2753. sub_positive(&cfs_rq->avg.runnable_load_avg, se->avg.runnable_load_avg); + 2754. > sub_positive(&cfs_rq->avg.runnable_load_sum, + 2755. se_runnable(se) * se->avg.runnable_load_sum); + 2756. } + +net/core/dev.c:2764: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2762. + 2763. rcu_read_lock(); + 2764. > list_for_each_entry_rcu(ptype, &offload_base, list) { + 2765. if (ptype->type == type && ptype->callbacks.gso_segment) { + 2766. segs = ptype->callbacks.gso_segment(skb, features); + +net/netfilter/nf_conntrack_netlink.c:2765: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2763. last = (struct nf_conntrack_expect *)cb->args[1]; + 2764. restart: + 2765. > hlist_for_each_entry_rcu(exp, &help->expectations, lnode) { + 2766. if (l3proto && exp->tuple.src.l3num != l3proto) + 2767. continue; + +kernel/workqueue.c:2774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2772. mutex_lock(&wq->mutex); + 2773. + 2774. > for_each_pwq(pwq, wq) { + 2775. bool drained; + 2776. + +drivers/scsi/scsi_lib.c:2793: error: DEAD_STORE + The value written to &idx (type int) is never used. + 2791. } + 2792. + 2793. > envp[idx++] = NULL; + 2794. + 2795. kobject_uevent_env(&sdev->sdev_gendev.kobj, KOBJ_CHANGE, envp); + +net/wireless/trace.h:2760: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +net/wireless/trace.h:2760: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2758. ); + 2759. + 2760. > TRACE_EVENT(cfg80211_cqm_pktloss_notify, + 2761. TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), + 2762. TP_ARGS(netdev, peer, num_packets), + +sound/pci/hda/hda_codec.c:2798: error: UNINITIALIZED_VALUE + The value read from state was never initialized. + 2796. } + 2797. + 2798. > return state; + 2799. } + 2800. + +drivers/usb/core/hub.c:2882: error: UNINITIALIZED_VALUE + The value read from status was never initialized. + 2880. up_read(&ehci_cf_port_reset_rwsem); + 2881. + 2882. > return status; + 2883. } + 2884. + +net/sunrpc/clnt.c:2766: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2764. { + 2765. rcu_read_lock(); + 2766. > xprt_switch_put(rcu_dereference(clnt->cl_xpi.xpi_xpswitch)); + 2767. rcu_read_unlock(); + 2768. } + +kernel/sched/fair.c:2768: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2766. dequeue_load_avg(struct cfs_rq *cfs_rq, struct sched_entity *se) + 2767. { + 2768. > sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + +kernel/sched/fair.c:2769: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2767. { + 2768. sub_positive(&cfs_rq->avg.load_avg, se->avg.load_avg); + 2769. > sub_positive(&cfs_rq->avg.load_sum, se_weight(se) * se->avg.load_sum); + 2770. } + 2771. #else + +sound/core/pcm_native.c:2782: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2780. return -EFAULT; + 2781. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2782. > result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + +sound/core/pcm_native.c:2784: error: UNINITIALIZED_VALUE + The value read from xferi.frames was never initialized. + 2782. result = snd_pcm_lib_write(substream, xferi.buf, xferi.frames); + 2783. else + 2784. > result = snd_pcm_lib_read(substream, xferi.buf, xferi.frames); + 2785. __put_user(result, &_xferi->result); + 2786. return result < 0 ? result : 0; + +net/sunrpc/clnt.c:2774: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2772. { + 2773. rcu_read_lock(); + 2774. > rpc_xprt_switch_add_xprt(rcu_dereference(clnt->cl_xpi.xpi_xpswitch), + 2775. xprt); + 2776. rcu_read_unlock(); + +net/ipv6/mcast.c:2783: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2781. state->idev = NULL; + 2782. state->im = NULL; + 2783. > for_each_netdev_rcu(net, state->dev) { + 2784. struct inet6_dev *idev; + 2785. idev = __in6_dev_get(state->dev); + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/wireless/trace.h:2777: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2775. ); + 2776. + 2777. > DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, + 2778. TP_PROTO(struct net_device *netdev, const u8 *macaddr), + 2779. TP_ARGS(netdev, macaddr) + +net/sunrpc/clnt.c:2787: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2785. + 2786. rcu_read_lock(); + 2787. > xps = rcu_dereference(clnt->cl_xpi.xpi_xpswitch); + 2788. ret = rpc_xprt_switch_has_addr(xps, sap); + 2789. rcu_read_unlock(); + +net/wireless/trace.h:2782: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +net/wireless/trace.h:2782: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2780. ); + 2781. + 2782. > TRACE_EVENT(cfg80211_pmksa_candidate_notify, + 2783. TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, + 2784. bool preauth), + +drivers/gpu/drm/i915/intel_sdvo.c:2809: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2807. sdvo_state->tv.overscan_h = response; + 2808. + 2809. > intel_sdvo_connector->max_hscan = data_value[0]; + 2810. intel_sdvo_connector->left = + 2811. drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]); + +drivers/gpu/drm/i915/intel_sdvo.c:2811: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2809. intel_sdvo_connector->max_hscan = data_value[0]; + 2810. intel_sdvo_connector->left = + 2811. > drm_property_create_range(dev, 0, "left_margin", 0, data_value[0]); + 2812. if (!intel_sdvo_connector->left) + 2813. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2819: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2817. + 2818. intel_sdvo_connector->right = + 2819. > drm_property_create_range(dev, 0, "right_margin", 0, data_value[0]); + 2820. if (!intel_sdvo_connector->right) + 2821. return false; + +drivers/gpu/drm/i915/intel_sdvo.c:2825: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2823. drm_object_attach_property(&connector->base, + 2824. intel_sdvo_connector->right, 0); + 2825. > DRM_DEBUG_KMS("h_overscan: max %d, " + 2826. "default %d, current %d\n", + 2827. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2843: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2841. sdvo_state->tv.overscan_v = response; + 2842. + 2843. > intel_sdvo_connector->max_vscan = data_value[0]; + 2844. intel_sdvo_connector->top = + 2845. drm_property_create_range(dev, 0, + +drivers/gpu/drm/i915/intel_sdvo.c:2845: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2843. intel_sdvo_connector->max_vscan = data_value[0]; + 2844. intel_sdvo_connector->top = + 2845. > drm_property_create_range(dev, 0, + 2846. "top_margin", 0, data_value[0]); + 2847. if (!intel_sdvo_connector->top) + +drivers/gpu/drm/i915/intel_sdvo.c:2854: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2852. + 2853. intel_sdvo_connector->bottom = + 2854. > drm_property_create_range(dev, 0, + 2855. "bottom_margin", 0, data_value[0]); + 2856. if (!intel_sdvo_connector->bottom) + +drivers/gpu/drm/i915/intel_sdvo.c:2861: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2859. drm_object_attach_property(&connector->base, + 2860. intel_sdvo_connector->bottom, 0); + 2861. > DRM_DEBUG_KMS("v_overscan: max %d, " + 2862. "default %d, current %d\n", + 2863. data_value[0], data_value[1], response); + +drivers/gpu/drm/i915/intel_sdvo.c:2866: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2864. } + 2865. + 2866. > ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + +drivers/gpu/drm/i915/intel_sdvo.c:2867: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2865. + 2866. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. > ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + +drivers/gpu/drm/i915/intel_sdvo.c:2868: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2866. ENHANCEMENT(&sdvo_state->tv, hpos, HPOS); + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. > ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + +drivers/gpu/drm/i915/intel_sdvo.c:2869: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2867. ENHANCEMENT(&sdvo_state->tv, vpos, VPOS); + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. > ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2870: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2868. ENHANCEMENT(&conn_state->tv, saturation, SATURATION); + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. > ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + +drivers/gpu/drm/i915/intel_sdvo.c:2871: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2869. ENHANCEMENT(&conn_state->tv, contrast, CONTRAST); + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. > ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2872: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2870. ENHANCEMENT(&conn_state->tv, hue, HUE); + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. > ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + +drivers/gpu/drm/i915/intel_sdvo.c:2873: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2871. ENHANCEMENT(&conn_state->tv, brightness, BRIGHTNESS); + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. > ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + +drivers/gpu/drm/i915/intel_sdvo.c:2874: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2872. ENHANCEMENT(&sdvo_state->tv, sharpness, SHARPNESS); + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2875: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2873. ENHANCEMENT(&sdvo_state->tv, flicker_filter, FLICKER_FILTER); + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. > ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + +drivers/gpu/drm/i915/intel_sdvo.c:2876: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2874. ENHANCEMENT(&sdvo_state->tv, flicker_filter_adaptive, FLICKER_FILTER_ADAPTIVE); + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. > _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2878. + +drivers/gpu/drm/i915/intel_sdvo.c:2877: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2875. ENHANCEMENT(&sdvo_state->tv, flicker_filter_2d, FLICKER_FILTER_2D); + 2876. _ENHANCEMENT(sdvo_state->tv.chroma_filter, tv_chroma_filter, TV_CHROMA_FILTER); + 2877. > _ENHANCEMENT(sdvo_state->tv.luma_filter, tv_luma_filter, TV_LUMA_FILTER); + 2878. + 2879. if (enhancements.dot_crawl) { + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +kernel/trace/ring_buffer.c:2802: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2800. goto out; + 2801. + 2802. > cpu = raw_smp_processor_id(); + 2803. + 2804. if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask))) + +sound/core/pcm_native.c:2810: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2808. return PTR_ERR(bufs); + 2809. if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + 2810. > result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + +sound/core/pcm_native.c:2812: error: UNINITIALIZED_VALUE + The value read from xfern.frames was never initialized. + 2810. result = snd_pcm_lib_writev(substream, bufs, xfern.frames); + 2811. else + 2812. > result = snd_pcm_lib_readv(substream, bufs, xfern.frames); + 2813. kfree(bufs); + 2814. __put_user(result, &_xfern->result); + +net/ipv4/igmp.c:2809: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2807. #endif + 2808. + 2809. > if (rcu_access_pointer(state->in_dev->mc_list) == im) { + 2810. seq_printf(seq, "%d\t%-10s: %5d %7s\n", + 2811. state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier); + +net/wireless/trace.h:2803: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +net/wireless/trace.h:2803: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2801. ); + 2802. + 2803. > TRACE_EVENT(cfg80211_report_obss_beacon, + 2804. TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, + 2805. int freq, int sig_dbm), + +drivers/iommu/intel-iommu.c:2832: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2830. * is passed in. + 2831. */ + 2832. > for_each_active_dev_scope(rmrr->devices, + 2833. rmrr->devices_cnt, i, tmp) + 2834. if (tmp == dev) { + +net/wireless/trace.h:2821: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +net/wireless/trace.h:2821: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2819. ); + 2820. + 2821. > TRACE_EVENT(cfg80211_tdls_oper_request, + 2822. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, + 2823. enum nl80211_tdls_operation oper, u16 reason_code), + +kernel/events/core.c:2850: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2848. goto unlock; + 2849. + 2850. > parent = rcu_dereference(ctx->parent_ctx); + 2851. next_parent = rcu_dereference(next_ctx->parent_ctx); + 2852. + +kernel/events/core.c:2851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2849. + 2850. parent = rcu_dereference(ctx->parent_ctx); + 2851. > next_parent = rcu_dereference(next_ctx->parent_ctx); + 2852. + 2853. /* If neither context have a parent context; they cannot be clones. */ + +drivers/cdrom/cdrom.c:2838: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2836. track_information ti; + 2837. __u32 last_track; + 2838. > int ret = -1, ti_size; + 2839. + 2840. if (!CDROM_CAN(CDC_GENERIC_PACKET)) + +kernel/rcu/tree.c:2842: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2840. + 2841. /* Funnel through hierarchy to reduce memory contention. */ + 2842. > rnp = __this_cpu_read(rsp->rda->mynode); + 2843. for (; rnp != NULL; rnp = rnp->parent) { + 2844. ret = (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) || + +kernel/rcu/tree.c:2842: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2840. + 2841. /* Funnel through hierarchy to reduce memory contention. */ + 2842. > rnp = __this_cpu_read(rsp->rda->mynode); + 2843. for (; rnp != NULL; rnp = rnp->parent) { + 2844. ret = (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) || + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +net/wireless/trace.h:2844: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2842. ); + 2843. + 2844. > TRACE_EVENT(cfg80211_scan_done, + 2845. TP_PROTO(struct cfg80211_scan_request *request, + 2846. struct cfg80211_scan_info *info), + +drivers/input/mouse/alps.c:2895: error: DEAD_STORE + The value written to &protocol (type alps_protocol_info const *) is never used. + 2893. protocol = &alps_v8_protocol_data; + 2894. } else if (e7[0] == 0x73 && e7[1] == 0x03 && e7[2] == 0xc8) { + 2895. > protocol = &alps_v9_protocol_data; + 2896. psmouse_warn(psmouse, + 2897. "Unsupported ALPS V9 touchpad: E7=%3ph, EC=%3ph\n", + +net/ipv4/igmp.c:2863: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2861. state->idev = NULL; + 2862. state->im = NULL; + 2863. > for_each_netdev_rcu(net, state->dev) { + 2864. struct in_device *idev; + 2865. idev = __in_dev_get_rcu(state->dev); + +net/ipv4/igmp.c:2868: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2866. if (unlikely(!idev)) + 2867. continue; + 2868. > im = rcu_dereference(idev->mc_list); + 2869. if (likely(im)) { + 2870. spin_lock_bh(&im->lock); + +drivers/gpu/drm/i915/i915_gem_gtt.c:2885: error: UNINITIALIZED_VALUE + The value read from hole_end was never initialized. + 2883. /* Clear any non-preallocated blocks */ + 2884. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2885. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2886. hole_start, hole_end); + 2887. ggtt->base.clear_range(&ggtt->base, hole_start, + +drivers/gpu/drm/i915/i915_gem_gtt.c:2885: error: UNINITIALIZED_VALUE + The value read from hole_start was never initialized. + 2883. /* Clear any non-preallocated blocks */ + 2884. drm_mm_for_each_hole(entry, &ggtt->base.mm, hole_start, hole_end) { + 2885. > DRM_DEBUG_KMS("clearing unused GTT space: [%lx, %lx]\n", + 2886. hole_start, hole_end); + 2887. ggtt->base.clear_range(&ggtt->base, hole_start, + +kernel/printk/printk.c:2860: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 2858. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2859. { + 2860. > int pending = __this_cpu_xchg(printk_pending, 0); + 2861. + 2862. if (pending & PRINTK_PENDING_OUTPUT) { + +kernel/printk/printk.c:2860: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 2858. static void wake_up_klogd_work_func(struct irq_work *irq_work) + 2859. { + 2860. > int pending = __this_cpu_xchg(printk_pending, 0); + 2861. + 2862. if (pending & PRINTK_PENDING_OUTPUT) { + +drivers/ata/libata-core.c:2922: error: UNINITIALIZED_VALUE + The value read from classes[_] was never initialized. + 2920. ata_for_each_dev(dev, &ap->link, ALL_REVERSE) { + 2921. if (tries[dev->devno]) + 2922. > dev->class = classes[dev->devno]; + 2923. + 2924. if (!ata_dev_enabled(dev)) + +drivers/gpu/drm/i915/i915_debugfs.c:2879: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 2877 could be null and is dereferenced at line 2879, column 36. + 2877. struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base); + 2878. + 2879. > seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]); + 2880. seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio)); + 2881. if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP) + +drivers/md/dm.c:2913: error: UNINITIALIZED_VALUE + The value read from front_pad was never initialized. + 2911. } + 2912. + 2913. > pools->bs = bioset_create(pool_size, front_pad, 0); + 2914. if (!pools->bs) + 2915. goto out; + +net/ipv4/igmp.c:2900: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2898. if (!state->idev) + 2899. continue; + 2900. > state->im = rcu_dereference(state->idev->mc_list); + 2901. } + 2902. if (!state->im) + +net/wireless/trace.h:2884: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2882. ); + 2883. + 2884. > DECLARE_EVENT_CLASS(wiphy_id_evt, + 2885. TP_PROTO(struct wiphy *wiphy, u64 id), + 2886. TP_ARGS(wiphy, id), + +drivers/tty/serial/8250/8250_port.c:2899: error: DEAD_STORE + The value written to &i (type int) is never used. + 2897. if (bytes < conf_type->rxtrig_bytes[i]) + 2898. /* Use the nearest lower value */ + 2899. > return (--i) << UART_FCR_R_TRIG_SHIFT; + 2900. } + 2901. + +lib/vsprintf.c:2911: error: DEAD_STORE + The value written to &fmt (type char const *) is never used. + 2909. */ + 2910. if (isspace(*fmt)) { + 2911. > fmt = skip_spaces(++fmt); + 2912. str = skip_spaces(str); + 2913. } + +lib/vsprintf.c:3116: error: UNINITIALIZED_VALUE + The value read from val.s was never initialized. + 3114. while (next - str > field_width) { + 3115. if (is_sign) + 3116. > val.s = div_s64(val.s, base); + 3117. else + 3118. val.u = div_u64(val.u, base); + +lib/vsprintf.c:3118: error: UNINITIALIZED_VALUE + The value read from val.u was never initialized. + 3116. val.s = div_s64(val.s, base); + 3117. else + 3118. > val.u = div_u64(val.u, base); + 3119. --next; + 3120. } + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +kernel/trace/ring_buffer.c:2900: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2898. rb_event_discard(event); + 2899. + 2900. > cpu = smp_processor_id(); + 2901. cpu_buffer = buffer->buffers[cpu]; + 2902. + +drivers/gpu/drm/i915/intel_sdvo.c:2906: error: UNINITIALIZED_VALUE + The value read from data_value[_] was never initialized. + 2904. uint16_t response, data_value[2]; + 2905. + 2906. > ENHANCEMENT(&connector->state->tv, brightness, BRIGHTNESS); + 2907. + 2908. return true; + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2898: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2896. ); + 2897. + 2898. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, + 2899. TP_PROTO(struct wiphy *wiphy, u64 id), + 2900. TP_ARGS(wiphy, id) + +kernel/cgroup/cgroup.c:2912: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2907 could be null and is dereferenced at line 2912, column 39. + 2910. WARN_ON_ONCE(css && percpu_ref_is_dying(&css->refcnt)); + 2911. + 2912. > if (!(cgroup_ss_mask(dsct) & (1 << ss->id))) + 2913. continue; + 2914. + +kernel/sched/fair.c:2905: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2903. struct task_group *tg = cfs_rq->tg; + 2904. + 2905. > tg_shares = READ_ONCE(tg->shares); + 2906. + 2907. load = max(scale_load_down(cfs_rq->load.weight), cfs_rq->avg.load_avg); + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2903: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2901. ); + 2902. + 2903. > DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, + 2904. TP_PROTO(struct wiphy *wiphy, u64 id), + 2905. TP_ARGS(wiphy, id) + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +net/wireless/trace.h:2908: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2906. ); + 2907. + 2908. > TRACE_EVENT(cfg80211_get_bss, + 2909. TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, + 2910. const u8 *bssid, const u8 *ssid, size_t ssid_len, + +kernel/rcu/tree.c:2913: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2911. struct rcu_state *rsp; + 2912. + 2913. > if (cpu_is_offline(smp_processor_id())) + 2914. return; + 2915. trace_rcu_utilization(TPS("Start RCU core")); + +kernel/rcu/tree.c:2913: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2911. struct rcu_state *rsp; + 2912. + 2913. > if (cpu_is_offline(smp_processor_id())) + 2914. return; + 2915. trace_rcu_utilization(TPS("Start RCU core")); + +net/unix/af_unix.c:2920: error: DEAD_STORE + The value written to &rc (type int) is never used. + 2918. static int __init af_unix_init(void) + 2919. { + 2920. > int rc = -1; + 2921. + 2922. BUILD_BUG_ON(sizeof(struct unix_skb_parms) > FIELD_SIZEOF(struct sk_buff, cb)); + +net/ipv4/tcp.c:2938: error: UNINITIALIZED_VALUE + The value read from stats[_] was never initialized. + 2936. + 2937. info->tcpi_busy_time = total; + 2938. > info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED]; + 2939. info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED]; + 2940. } + +net/ipv4/tcp.c:2939: error: UNINITIALIZED_VALUE + The value read from stats[_] was never initialized. + 2937. info->tcpi_busy_time = total; + 2938. info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED]; + 2939. > info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED]; + 2940. } + 2941. + +net/netfilter/nf_conntrack_netlink.c:2931: error: NULL_DEREFERENCE + pointer `m_help` last assigned on line 2929 could be null and is dereferenced at line 2931, column 16. + 2929. m_help = nfct_help(exp->master); + 2930. + 2931. > return strcmp(m_help->helper->name, name) == 0; + 2932. } + 2933. + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: DEAD_STORE + The value written to &ret (type int) is never used. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +net/wireless/trace.h:2937: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2935. ); + 2936. + 2937. > TRACE_EVENT(cfg80211_inform_bss_frame, + 2938. TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, + 2939. struct ieee80211_mgmt *mgmt, size_t len), + +kernel/rcu/tree.c:2941: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2939. static void invoke_rcu_core(void) + 2940. { + 2941. > if (cpu_online(smp_processor_id())) + 2942. raise_softirq(RCU_SOFTIRQ); + 2943. } + +kernel/rcu/tree.c:2941: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2939. static void invoke_rcu_core(void) + 2940. { + 2941. > if (cpu_online(smp_processor_id())) + 2942. raise_softirq(RCU_SOFTIRQ); + 2943. } + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +kernel/trace/ring_buffer.c:2957: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2955. goto out; + 2956. + 2957. > cpu = raw_smp_processor_id(); + 2958. + 2959. if (!cpumask_test_cpu(cpu, buffer->cpumask)) + +net/ipv4/tcp.c:2959: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2957. + 2958. /* Report meaningful fields for all TCP states, including listeners */ + 2959. > rate = READ_ONCE(sk->sk_pacing_rate); + 2960. rate64 = rate != ~0U ? rate : ~0ULL; + 2961. info->tcpi_pacing_rate = rate64; + +net/ipv4/tcp.c:2963: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2961. info->tcpi_pacing_rate = rate64; + 2962. + 2963. > rate = READ_ONCE(sk->sk_max_pacing_rate); + 2964. rate64 = rate != ~0U ? rate : ~0ULL; + 2965. info->tcpi_max_pacing_rate = rate64; + +net/ipv6/addrconf.c:2955: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2953. + 2954. rtnl_lock(); + 2955. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2956. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2957. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +net/ipv6/addrconf.c:2955: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2953. + 2954. rtnl_lock(); + 2955. > err = inet6_addr_add(net, ireq.ifr6_ifindex, &ireq.ifr6_addr, NULL, + 2956. ireq.ifr6_prefixlen, IFA_F_PERMANENT, + 2957. INFINITY_LIFE_TIME, INFINITY_LIFE_TIME, NULL); + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +drivers/cdrom/cdrom.c:2968: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec0 was never initialized. + 2966. if (copy_from_user(&msf, (struct cdrom_msf __user *)arg, sizeof(msf))) + 2967. return -EFAULT; + 2968. > lba = msf_to_lba(msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0); + 2969. /* FIXME: we need upper bound checking, too!! */ + 2970. if (lba < 0) + +kernel/cgroup/cgroup.c:2966: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 2953 could be null and is dereferenced at line 2966, column 9. + 2964. } else if (!css_visible(css)) { + 2965. css_clear_dir(css); + 2966. > if (ss->css_reset) + 2967. ss->css_reset(css); + 2968. } + +kernel/rcu/tree.c:2961: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2959. + 2960. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 2961. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 2962. return; + 2963. + +kernel/rcu/tree.c:2961: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2959. + 2960. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */ + 2961. > if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id())) + 2962. return; + 2963. + +net/core/neighbour.c:2955: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2953. + 2954. rcu_read_lock(); + 2955. > for_each_netdev_rcu(net, dev) { + 2956. struct neigh_parms *dst_p = + 2957. neigh_get_dev_parms_rcu(dev, family); + +drivers/gpu/drm/i915/intel_runtime_pm.c:2963: error: NULL_DEREFERENCE + pointer `cmn` last assigned on line 2957 could be null and is dereferenced at line 2963, column 6. + 2961. + 2962. /* If the display might be already active skip this */ + 2963. > if (cmn->ops->is_enabled(dev_priv, cmn) && + 2964. disp2d->ops->is_enabled(dev_priv, disp2d) && + 2965. I915_READ(DPIO_CTL) & DPIO_CMNRST) + +drivers/gpu/drm/i915/intel_runtime_pm.c:2964: error: NULL_DEREFERENCE + pointer `disp2d` last assigned on line 2959 could be null and is dereferenced at line 2964, column 6. + 2962. /* If the display might be already active skip this */ + 2963. if (cmn->ops->is_enabled(dev_priv, cmn) && + 2964. > disp2d->ops->is_enabled(dev_priv, disp2d) && + 2965. I915_READ(DPIO_CTL) & DPIO_CMNRST) + 2966. return; + +net/ipv6/addrconf.c:2974: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_ifindex was never initialized. + 2972. + 2973. rtnl_lock(); + 2974. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2975. ireq.ifr6_prefixlen); + 2976. rtnl_unlock(); + +net/ipv6/addrconf.c:2974: error: UNINITIALIZED_VALUE + The value read from ireq.ifr6_prefixlen was never initialized. + 2972. + 2973. rtnl_lock(); + 2974. > err = inet6_addr_del(net, ireq.ifr6_ifindex, 0, &ireq.ifr6_addr, + 2975. ireq.ifr6_prefixlen); + 2976. rtnl_unlock(); + +drivers/iommu/intel-iommu.c:2983: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2981. } + 2982. + 2983. > for_each_active_iommu(iommu, drhd) + 2984. for_each_active_dev_scope(drhd->devices, drhd->devices_cnt, i, dev) { + 2985. struct acpi_device_physical_node *pn; + +drivers/iommu/intel-iommu.c:2984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2982. + 2983. for_each_active_iommu(iommu, drhd) + 2984. > for_each_active_dev_scope(drhd->devices, drhd->devices_cnt, i, dev) { + 2985. struct acpi_device_physical_node *pn; + 2986. struct acpi_device *adev; + +drivers/gpu/drm/drm_dp_mst_topology.c:3016: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3014. int ret; + 3015. + 3016. > ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + +drivers/gpu/drm/drm_dp_mst_topology.c:3018: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3016. ret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, buf, DP_RECEIVER_CAP_SIZE); + 3017. seq_printf(m, "dpcd: %*ph\n", DP_RECEIVER_CAP_SIZE, buf); + 3018. > ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + +drivers/gpu/drm/drm_dp_mst_topology.c:3020: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3018. ret = drm_dp_dpcd_read(mgr->aux, DP_FAUX_CAP, buf, 2); + 3019. seq_printf(m, "faux/mst: %*ph\n", 2, buf); + 3020. > ret = drm_dp_dpcd_read(mgr->aux, DP_MSTM_CTRL, buf, 1); + 3021. seq_printf(m, "mst ctrl: %*ph\n", 1, buf); + 3022. + +drivers/gpu/drm/drm_dp_mst_topology.c:3024: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3022. + 3023. /* dump the standard OUI branch header */ + 3024. > ret = drm_dp_dpcd_read(mgr->aux, DP_BRANCH_OUI, buf, DP_BRANCH_OUI_HEADER_SIZE); + 3025. seq_printf(m, "branch oui: %*phN devid: ", 3, buf); + 3026. for (i = 0x3; i < 0x8 && buf[i]; i++) + +net/wireless/trace.h:2970: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2968. ); + 2969. + 2970. > DECLARE_EVENT_CLASS(cfg80211_bss_evt, + 2971. TP_PROTO(struct cfg80211_bss *pub), + 2972. TP_ARGS(pub), + +kernel/events/core.c:2981: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2979. int ctxn; + 2980. + 2981. > if (__this_cpu_read(perf_sched_cb_usages)) + 2982. perf_pmu_sched_task(task, next, false); + 2983. + +kernel/sched/core.c:2988: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2986. raw_spin_lock_irqsave(&p->pi_lock, flags); + 2987. dest_cpu = p->sched_class->select_task_rq(p, task_cpu(p), SD_BALANCE_EXEC, 0); + 2988. > if (dest_cpu == smp_processor_id()) + 2989. goto unlock; + 2990. + +drivers/gpu/drm/drm_atomic_helper.c:3001: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 2999. + 3000. if (ret) + 3001. > DRM_ERROR("Disabling all crtc's during unload failed with %i\n", ret); + 3002. + 3003. drm_modeset_drop_locks(&ctx); + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/wireless/trace.h:2984: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2982. ); + 2983. + 2984. > DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, + 2985. TP_PROTO(struct cfg80211_bss *pub), + 2986. TP_ARGS(pub) + +net/ipv6/route.c:3009: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3007. + 3008. if (fn) { + 3009. > for_each_fib6_node_rt_rcu(fn) { + 3010. if (cfg->fc_flags & RTF_CACHE) { + 3011. rt_cache = rt6_find_cached_rt(rt, &cfg->fc_dst, + +net/wireless/trace.h:2989: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:2989: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2987. ); + 2988. + 2989. > TRACE_EVENT(cfg80211_return_uint, + 2990. TP_PROTO(unsigned int ret), + 2991. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +net/wireless/trace.h:3001: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 2999. ); + 3000. + 3001. > TRACE_EVENT(cfg80211_return_u32, + 3002. TP_PROTO(u32 ret), + 3003. TP_ARGS(ret), + +drivers/cdrom/cdrom.c:3026: error: UNINITIALIZED_VALUE + The value read from ra.nframes was never initialized. + 3024. return -EINVAL; + 3025. + 3026. > return cdrom_read_cdda(cdi, ra.buf, lba, ra.nframes); + 3027. } + 3028. + +net/wireless/trace.h:3013: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/wireless/trace.h:3013: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3011. ); + 3012. + 3013. > TRACE_EVENT(cfg80211_report_wowlan_wakeup, + 3014. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, + 3015. struct cfg80211_wowlan_wakeup *wakeup), + +net/ipv4/tcp_input.c:3126: error: UNINITIALIZED_VALUE + The value read from last_ackt was never initialized. + 3124. if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) { + 3125. seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt); + 3126. > ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt); + 3127. + 3128. if (pkts_acked == 1 && last_in_flight < tp->mss_cache && + +kernel/printk/printk.c:3027: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3025. + 3026. rcu_read_lock(); + 3027. > list_for_each_entry_rcu(dumper, &dump_list, list) { + 3028. if (dumper->max_reason && reason > dumper->max_reason) + 3029. continue; + +drivers/cdrom/cdrom.c:3037: error: UNINITIALIZED_VALUE + The value read from q.cdsc_format was never initialized. + 3035. if (copy_from_user(&q, (struct cdrom_subchnl __user *)arg, sizeof(q))) + 3036. return -EFAULT; + 3037. > requested = q.cdsc_format; + 3038. if (!((requested == CDROM_MSF) || + 3039. (requested == CDROM_LBA))) + +kernel/signal.c:3044: error: UNINITIALIZED_VALUE + The value read from from.si_code was never initialized. + 3042. to->si_signo = from.si_signo; + 3043. to->si_errno = from.si_errno; + 3044. > to->si_code = from.si_code; + 3045. switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + +kernel/signal.c:3045: error: UNINITIALIZED_VALUE + The value read from from.si_code was never initialized. + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. > switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + 3047. to->si_pid = from.si_pid; + +kernel/signal.c:3043: error: UNINITIALIZED_VALUE + The value read from from.si_errno was never initialized. + 3041. clear_siginfo(to); + 3042. to->si_signo = from.si_signo; + 3043. > to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. switch(siginfo_layout(from.si_signo, from.si_code)) { + +kernel/signal.c:3042: error: UNINITIALIZED_VALUE + The value read from from.si_signo was never initialized. + 3040. + 3041. clear_siginfo(to); + 3042. > to->si_signo = from.si_signo; + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + +kernel/signal.c:3045: error: UNINITIALIZED_VALUE + The value read from from.si_signo was never initialized. + 3043. to->si_errno = from.si_errno; + 3044. to->si_code = from.si_code; + 3045. > switch(siginfo_layout(from.si_signo, from.si_code)) { + 3046. case SIL_KILL: + 3047. to->si_pid = from.si_pid; + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/wireless/trace.h:3051: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3049. ); + 3050. + 3051. > TRACE_EVENT(cfg80211_ft_event, + 3052. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3053. struct cfg80211_ft_event_params *ft_event), + +net/ipv4/tcp.c:3078: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3076. tp->total_retrans, TCP_NLA_PAD); + 3077. + 3078. > rate = READ_ONCE(sk->sk_pacing_rate); + 3079. rate64 = rate != ~0U ? rate : ~0ULL; + 3080. nla_put_u64_64bit(stats, TCP_NLA_PACING_RATE, rate64, TCP_NLA_PAD); + +drivers/cdrom/cdrom.c:3066: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame0 was never initialized. + 3064. cgc->cmd[3] = msf.cdmsf_min0; + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. > cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + +drivers/cdrom/cdrom.c:3069: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_frame1 was never initialized. + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + 3069. > cgc->cmd[8] = msf.cdmsf_frame1; + 3070. cgc->data_direction = CGC_DATA_NONE; + 3071. return cdo->generic_packet(cdi, cgc); + +drivers/cdrom/cdrom.c:3064: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min0 was never initialized. + 3062. return -EFAULT; + 3063. cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF; + 3064. > cgc->cmd[3] = msf.cdmsf_min0; + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + +drivers/cdrom/cdrom.c:3067: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_min1 was never initialized. + 3065. cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. > cgc->cmd[6] = msf.cdmsf_min1; + 3068. cgc->cmd[7] = msf.cdmsf_sec1; + 3069. cgc->cmd[8] = msf.cdmsf_frame1; + +drivers/cdrom/cdrom.c:3065: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec0 was never initialized. + 3063. cgc->cmd[0] = GPCMD_PLAY_AUDIO_MSF; + 3064. cgc->cmd[3] = msf.cdmsf_min0; + 3065. > cgc->cmd[4] = msf.cdmsf_sec0; + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + +drivers/cdrom/cdrom.c:3068: error: UNINITIALIZED_VALUE + The value read from msf.cdmsf_sec1 was never initialized. + 3066. cgc->cmd[5] = msf.cdmsf_frame0; + 3067. cgc->cmd[6] = msf.cdmsf_min1; + 3068. > cgc->cmd[7] = msf.cdmsf_sec1; + 3069. cgc->cmd[8] = msf.cdmsf_frame1; + 3070. cgc->data_direction = CGC_DATA_NONE; + +drivers/gpu/drm/drm_dp_mst_topology.c:3069: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3067. for (;;) { + 3068. mutex_lock(&mgr->destroy_connector_lock); + 3069. > port = list_first_entry_or_null(&mgr->destroy_connector_list, struct drm_dp_mst_port, next); + 3070. if (!port) { + 3071. mutex_unlock(&mgr->destroy_connector_lock); + +net/ipv4/ipmr.c:3068: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3066. rcu_read_lock(); + 3067. it->cache = &mrt->mfc_cache_list; + 3068. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) + 3069. if (pos-- == 0) + 3070. return mfc; + +kernel/sched/core.c:3077: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3075. void scheduler_tick(void) + 3076. { + 3077. > int cpu = smp_processor_id(); + 3078. struct rq *rq = cpu_rq(cpu); + 3079. struct task_struct *curr = rq->curr; + +kernel/sched/core.c:3077: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3075. void scheduler_tick(void) + 3076. { + 3077. > int cpu = smp_processor_id(); + 3078. struct rq *rq = cpu_rq(cpu); + 3079. struct task_struct *curr = rq->curr; + +net/wireless/trace.h:3077: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +net/wireless/trace.h:3077: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3075. ); + 3076. + 3077. > TRACE_EVENT(cfg80211_stop_iface, + 3078. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3079. TP_ARGS(wiphy, wdev), + +drivers/gpu/drm/drm_edid.c:3150: error: UNINITIALIZED_VALUE + The value read from clock2 was never initialized. + 3148. newmode->clock = clock1; + 3149. else + 3150. > newmode->clock = clock2; + 3151. + 3152. list_add_tail(&newmode->head, &list); + +drivers/net/ethernet/intel/e1000/e1000_main.c:3107: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3105. * made room available. + 3106. */ + 3107. > if (likely(E1000_DESC_UNUSED(tx_ring) < size)) + 3108. return -EBUSY; + 3109. + +net/wireless/trace.h:3092: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +net/wireless/trace.h:3092: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3090. ); + 3091. + 3092. > TRACE_EVENT(rdev_start_radar_detection, + 3093. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3094. struct cfg80211_chan_def *chandef, + +drivers/cdrom/cdrom.c:3142: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3140. a CDROMVOLREAD, return these values */ + 3141. if (cmd == CDROMVOLREAD) { + 3142. > volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + +drivers/cdrom/cdrom.c:3143: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3141. if (cmd == CDROMVOLREAD) { + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. > volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + +drivers/cdrom/cdrom.c:3144: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3142. volctrl.channel0 = buffer[offset+9]; + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. > volctrl.channel2 = buffer[offset+13]; + 3145. volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + +drivers/cdrom/cdrom.c:3145: error: UNINITIALIZED_VALUE + The value read from buffer[_] was never initialized. + 3143. volctrl.channel1 = buffer[offset+11]; + 3144. volctrl.channel2 = buffer[offset+13]; + 3145. > volctrl.channel3 = buffer[offset+15]; + 3146. if (copy_to_user((struct cdrom_volctrl __user *)arg, &volctrl, + 3147. sizeof(volctrl))) + +net/ipv4/tcp.c:3220: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3218. + 3219. rcu_read_lock(); + 3220. > ctx = rcu_dereference(icsk->icsk_accept_queue.fastopenq.ctx); + 3221. if (ctx) + 3222. memcpy(key, ctx->key, sizeof(key)); + +net/wireless/trace.h:3115: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +net/wireless/trace.h:3115: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3113. ); + 3114. + 3115. > TRACE_EVENT(rdev_set_mcast_rate, + 3116. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3117. int mcast_rate[NUM_NL80211_BANDS]), + +drivers/net/ethernet/intel/e1000/e1000_main.c:3119: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3117. struct e1000_tx_ring *tx_ring, int size) + 3118. { + 3119. > if (likely(E1000_DESC_UNUSED(tx_ring) >= size)) + 3120. return 0; + 3121. return __e1000_maybe_stop_tx(netdev, size); + +net/core/filter.c:3143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3141. return -E2BIG; + 3142. + 3143. > cgrp = READ_ONCE(array->ptrs[idx]); + 3144. if (unlikely(!cgrp)) + 3145. return -EAGAIN; + +drivers/gpu/drm/drm_atomic_helper.c:3163: error: UNINITIALIZED_VALUE + The value read from err was never initialized. + 3161. drm_modeset_acquire_fini(&ctx); + 3162. + 3163. > return err; + 3164. } + 3165. EXPORT_SYMBOL(drm_atomic_helper_resume); + +net/wireless/trace.h:3138: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +net/wireless/trace.h:3138: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3136. ); + 3137. + 3138. > TRACE_EVENT(rdev_set_coalesce, + 3139. TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), + 3140. TP_ARGS(wiphy, coalesce), + +drivers/net/ethernet/nvidia/forcedeth.c:3193: error: UNINITIALIZED_VALUE + The value read from mask[_] was never initialized. + 3191. writel(addr[0], base + NvRegMulticastAddrA); + 3192. writel(addr[1], base + NvRegMulticastAddrB); + 3193. > writel(mask[0], base + NvRegMulticastMaskA); + 3194. writel(mask[1], base + NvRegMulticastMaskB); + 3195. writel(pff, base + NvRegPacketFilterFlags); + +drivers/net/ethernet/nvidia/forcedeth.c:3194: error: UNINITIALIZED_VALUE + The value read from mask[_] was never initialized. + 3192. writel(addr[1], base + NvRegMulticastAddrB); + 3193. writel(mask[0], base + NvRegMulticastMaskA); + 3194. > writel(mask[1], base + NvRegMulticastMaskB); + 3195. writel(pff, base + NvRegPacketFilterFlags); + 3196. nv_start_rx(dev); + +net/socket.c:3159: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced at line 3159, column 2. + 3157. } + 3158. + 3159. > (*newsock)->ops = sock->ops; + 3160. __module_get((*newsock)->ops->owner); + 3161. + +net/socket.c:3154: error: NULL_DEREFERENCE + pointer `*newsock` last assigned on line 3147 could be null and is dereferenced by call to `sock_release()` at line 3154, column 3. + 3152. err = sock->ops->accept(sock, *newsock, flags, true); + 3153. if (err < 0) { + 3154. > sock_release(*newsock); + 3155. *newsock = NULL; + 3156. goto done; + +drivers/usb/core/hub.c:3146: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3145 could be null and is dereferenced at line 3146, column 30. + 3144. { + 3145. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3146. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3147. int port1 = udev->portnum; + 3148. int status; + +security/selinux/hooks.c:3149: error: MEMORY_LEAK + `return` is not reachable after line 3149, column 3. + 3147. + 3148. if (cap_capable(cred, &init_user_ns, CAP_MAC_ADMIN, cap_audit)) + 3149. > return false; + 3150. if (cred_has_capability(cred, CAP_MAC_ADMIN, cap_audit, true)) + 3151. return false; + +net/core/rtnetlink.c:3169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3167. */ + 3168. rcu_read_lock(); + 3169. > for_each_netdev_rcu(net, dev) { + 3170. min_ifinfo_dump_size = max_t(u16, min_ifinfo_dump_size, + 3171. if_nlmsg_size(dev, + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +net/wireless/trace.h:3153: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3151. ); + 3152. + 3153. > DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, + 3154. TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), + 3155. TP_ARGS(wiphy, wdev) + +kernel/events/core.c:3182: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3180. perf_event_switch(task, prev, true); + 3181. + 3182. > if (__this_cpu_read(perf_sched_cb_usages)) + 3183. perf_pmu_sched_task(prev, task, true); + 3184. } + +net/wireless/trace.h:3158: error: DEAD_STORE + The value written to &p (type trace_seq*) is never used. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +net/wireless/trace.h:3158: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3156. ); + 3157. + 3158. > TRACE_EVENT(rdev_set_multicast_to_unicast, + 3159. TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, + 3160. const bool enabled), + +block/blk-mq.c:3196: error: NULL_DEREFERENCE + pointer `rq` last assigned on line 3183 could be null and is dereferenced by call to `__blk_mq_poll()` at line 3196, column 9. + 3194. } + 3195. + 3196. > return __blk_mq_poll(hctx, rq); + 3197. } + 3198. + +kernel/cgroup/cgroup.c:3177: error: NULL_DEREFERENCE + pointer `parent` last assigned on line 3176 could be null and is dereferenced at line 3177, column 28. + 3175. { + 3176. struct cgroup *parent = cgroup_parent(cgrp); + 3177. > struct cgroup *dom_cgrp = parent->dom_cgrp; + 3178. int ret; + 3179. + +drivers/tty/serial/8250/8250_port.c:3230: error: UNINITIALIZED_VALUE + The value read from flags was never initialized. + 3228. + 3229. if (locked) + 3230. > spin_unlock_irqrestore(&port->lock, flags); + 3231. serial8250_rpm_put(up); + 3232. } + +net/core/rtnetlink.c:3199: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3197. continue; + 3198. + 3199. > tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]); + 3200. if (!tab) + 3201. continue; + +net/ipv4/ipmr.c:3247: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3245. + 3246. /* Notify on table MFC entries */ + 3247. > list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) + 3248. call_ipmr_mfc_entry_notifier(nb, net, + 3249. FIB_EVENT_ENTRY_ADD, mfc, + +drivers/iommu/intel-iommu.c:3240: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3238. * endfor + 3239. */ + 3240. > for_each_drhd_unit(drhd) { + 3241. /* + 3242. * lock not needed as this is only incremented in the single + +drivers/iommu/intel-iommu.c:3265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3263. } + 3264. + 3265. > for_each_active_iommu(iommu, drhd) { + 3266. g_iommus[iommu->seq_id] = iommu; + 3267. + +drivers/iommu/intel-iommu.c:3330: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3328. * flush_context function will loop forever and the boot hangs. + 3329. */ + 3330. > for_each_active_iommu(iommu, drhd) { + 3331. iommu_flush_write_buffer(iommu); + 3332. iommu_set_root_entry(iommu); + +drivers/iommu/intel-iommu.c:3391: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3389. for_each_rmrr_units(rmrr) { + 3390. /* some BIOS lists non-exist devices in DMAR table. */ + 3391. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 3392. i, dev) { + 3393. ret = iommu_prepare_rmrr_dev(rmrr, dev); + +drivers/iommu/intel-iommu.c:3410: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3408. * enable translation + 3409. */ + 3410. > for_each_iommu(iommu, drhd) { + 3411. if (drhd->ignored) { + 3412. /* + +drivers/iommu/intel-iommu.c:3443: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3441. + 3442. free_iommu: + 3443. > for_each_active_iommu(iommu, drhd) { + 3444. disable_dmar_iommu(iommu); + 3445. free_dmar_iommu(iommu); + +kernel/rcu/tree.c:3263: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3261. * and cond_synchronize_rcu(). + 3262. */ + 3263. > return smp_load_acquire(&rcu_state_p->gpnum); + 3264. } + 3265. EXPORT_SYMBOL_GPL(get_state_synchronize_rcu); + +kernel/cgroup/cgroup.c:3258: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3256. { + 3257. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3258. > int descendants = READ_ONCE(cgrp->max_descendants); + 3259. + 3260. if (descendants == INT_MAX) + +net/core/sock.c:3276: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3274. #ifdef CONFIG_INET + 3275. if (family == AF_INET && + 3276. > !rcu_access_pointer(inet_protos[protocol])) + 3277. return -ENOENT; + 3278. #endif + +net/ipv6/route.c:3277: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3275. + 3276. rcu_read_lock(); + 3277. > for_each_fib6_node_rt_rcu(&table->tb6_root) { + 3278. if (dev == rt->dst.dev && + 3279. ((rt->rt6i_flags & (RTF_ADDRCONF | RTF_DEFAULT)) == (RTF_ADDRCONF | RTF_DEFAULT)) && + +kernel/rcu/tree.c:3289: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3287. * actions the caller might carry out after we return. + 3288. */ + 3289. > newstate = smp_load_acquire(&rcu_state_p->completed); + 3290. if (ULONG_CMP_GE(oldstate, newstate)) + 3291. synchronize_rcu(); + +kernel/printk/printk.c:3292: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3290. { + 3291. printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3292. > log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3293. print_tainted(), init_utsname()->release, + 3294. (int)strcspn(init_utsname()->version, " "), + +kernel/printk/printk.c:3291: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3289. void dump_stack_print_info(const char *log_lvl) + 3290. { + 3291. > printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n", + 3292. log_lvl, raw_smp_processor_id(), current->pid, current->comm, + 3293. print_tainted(), init_utsname()->release, + +kernel/events/core.c:3315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3313. perf_pmu_disable(ctx->pmu); + 3314. + 3315. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 3316. if (event->state != PERF_EVENT_STATE_ACTIVE) + 3317. continue; + +kernel/cgroup/cgroup.c:3301: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3299. { + 3300. struct cgroup *cgrp = seq_css(seq)->cgroup; + 3301. > int depth = READ_ONCE(cgrp->max_depth); + 3302. + 3303. if (depth == INT_MAX) + +kernel/rcu/tree.c:3315: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3313. * and cond_synchronize_sched(). + 3314. */ + 3315. > return smp_load_acquire(&rcu_sched_state.gpnum); + 3316. } + 3317. EXPORT_SYMBOL_GPL(get_state_synchronize_sched); + +drivers/net/ethernet/nvidia/forcedeth.c:3321: error: DEAD_STORE + The value written to &newdup (type int) is never used. + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. int newls = np->linkspeed; + 3321. > int newdup = np->duplex; + 3322. int mii_status; + 3323. u32 bmcr; + +drivers/net/ethernet/nvidia/forcedeth.c:3320: error: DEAD_STORE + The value written to &newls (type int) is never used. + 3318. int lpa = 0; + 3319. int adv_lpa, adv_pause, lpa_pause; + 3320. > int newls = np->linkspeed; + 3321. int newdup = np->duplex; + 3322. int mii_status; + +net/ipv6/route.c:3324: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3322. restart: + 3323. rcu_read_lock(); + 3324. > for_each_fib6_node_rt_rcu(&table->tb6_root) { + 3325. if (rt->rt6i_flags & (RTF_DEFAULT | RTF_ADDRCONF) && + 3326. (!rt->rt6i_idev || rt->rt6i_idev->cnf.accept_ra != 2)) { + +kernel/rcu/tree.c:3341: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3339. * actions the caller might carry out after we return. + 3340. */ + 3341. > newstate = smp_load_acquire(&rcu_sched_state.completed); + 3342. if (ULONG_CMP_GE(oldstate, newstate)) + 3343. synchronize_sched(); + +drivers/gpu/drm/i915/i915_drv.h:3338: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3336. static inline u32 i915_reset_count(struct i915_gpu_error *error) + 3337. { + 3338. > return READ_ONCE(error->reset_count); + 3339. } + 3340. + +drivers/gpu/drm/i915/i915_drv.h:3344: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3342. struct intel_engine_cs *engine) + 3343. { + 3344. > return READ_ONCE(error->reset_engine_count[engine->id]); + 3345. } + 3346. + +net/ipv6/route.c:3351: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3349. for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { + 3350. head = &net->ipv6.fib_table_hash[h]; + 3351. > hlist_for_each_entry_rcu(table, head, tb6_hlist) { + 3352. if (table->flags & RT6_TABLE_HAS_DFLT_ROUTER) + 3353. __rt6_purge_dflt_routers(table); + +kernel/sched/core.c:3358: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3356. int cpu; + 3357. + 3358. > cpu = smp_processor_id(); + 3359. rq = cpu_rq(cpu); + 3360. prev = rq->curr; + +kernel/sched/core.c:3358: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3356. int cpu; + 3357. + 3358. > cpu = smp_processor_id(); + 3359. rq = cpu_rq(cpu); + 3360. prev = rq->curr; + +kernel/rcu/tree.c:3370: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3368. if (rcu_scheduler_fully_active && + 3369. rdp->core_needs_qs && rdp->cpu_no_qs.b.norm && + 3370. > rdp->rcu_qs_ctr_snap == __this_cpu_read(rcu_dynticks.rcu_qs_ctr)) { + 3371. rdp->n_rp_core_needs_qs++; + 3372. } else if (rdp->core_needs_qs && !rdp->cpu_no_qs.b.norm) { + +net/core/dev.c:3375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3373. + 3374. rcu_read_lock(); + 3375. > dev_maps = rcu_dereference(dev->xps_maps); + 3376. if (dev_maps) { + 3377. unsigned int tci = skb->sender_cpu - 1; + +net/core/dev.c:3384: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3382. } + 3383. + 3384. > map = rcu_dereference(dev_maps->cpu_map[tci]); + 3385. if (map) { + 3386. if (map->len == 1) + +drivers/scsi/scsi_lib.c:3377: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3375. + 3376. rcu_read_lock(); + 3377. > vpd_pg83 = rcu_dereference(sdev->vpd_pg83); + 3378. if (!vpd_pg83) { + 3379. rcu_read_unlock(); + +kernel/trace/trace.c:3393: error: DEAD_STORE + The value written to &name (type char const *) is never used. + 3391. unsigned long entries; + 3392. unsigned long total; + 3393. > const char *name = "preemption"; + 3394. + 3395. name = type->name; + +net/ipv4/tcp_input.c:3407: error: DEAD_STORE + The value written to &half (type unsigned int) is never used. + 3405. if (now != challenge_timestamp) { + 3406. u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit; + 3407. > u32 half = (ack_limit + 1) >> 1; + 3408. + 3409. challenge_timestamp = now; + +net/ipv4/tcp_input.c:3412: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3410. WRITE_ONCE(challenge_count, half + prandom_u32_max(ack_limit)); + 3411. } + 3412. > count = READ_ONCE(challenge_count); + 3413. if (count > 0) { + 3414. WRITE_ONCE(challenge_count, count - 1); + +drivers/iommu/amd_iommu.c:3421: error: UNINITIALIZED_VALUE + The value read from pte was never initialized. + 3419. } + 3420. + 3421. > return pte; + 3422. } + 3423. + +net/core/dev.c:3417: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3415. if (queue_index != new_index && sk && + 3416. sk_fullsock(sk) && + 3417. > rcu_access_pointer(sk->sk_dst_cache)) + 3418. sk_tx_queue_set(sk, new_index); + 3419. + +drivers/usb/core/hub.c:3415: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 3414 could be null and is dereferenced at line 3415, column 30. + 3413. { + 3414. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 3415. > struct usb_port *port_dev = hub->ports[udev->portnum - 1]; + 3416. int port1 = udev->portnum; + 3417. int status; + +kernel/events/core.c:3425: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + 3427. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3424: error: UNINITIALIZED_VALUE + The value read from pscr2_ret__ was never initialized. + 3422. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + +kernel/events/core.c:3425: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. > tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + 3427. list_for_each_entry_safe(ctx, tmp, head, active_ctx_list) + +kernel/events/core.c:3424: error: UNINITIALIZED_VALUE + The value read from pxo_ret__ was never initialized. + 3422. + 3423. __this_cpu_inc(perf_throttled_seq); + 3424. > throttled = __this_cpu_xchg(perf_throttled_count, 0); + 3425. tick_dep_clear_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 3426. + +net/core/rtnetlink.c:3461: error: NULL_DEREFERENCE + pointer `br_dev` last assigned on line 3460 could be null and is dereferenced at line 3461, column 38. + 3459. (dev->priv_flags & IFF_BRIDGE_PORT)) { + 3460. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + 3461. > const struct net_device_ops *ops = br_dev->netdev_ops; + 3462. + 3463. err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid, + +drivers/gpu/drm/i915/i915_debugfs.c:3442: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 3441 could be null and is dereferenced at line 3442, column 8. + 3440. + 3441. intel_dig_port = enc_to_dig_port(&intel_encoder->base); + 3442. > if (!intel_dig_port->dp.can_mst) + 3443. continue; + 3444. + +net/core/dev.c:3436: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3434. + 3435. if (sender_cpu >= (u32)NR_CPUS) + 3436. > skb->sender_cpu = raw_smp_processor_id() + 1; + 3437. #endif + 3438. + +kernel/signal.c:3488: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3486. sigaddset(&mask, sig); + 3487. flush_sigqueue_mask(&mask, &p->signal->shared_pending); + 3488. > for_each_thread(p, t) + 3489. flush_sigqueue_mask(&mask, &t->pending); + 3490. } + +drivers/gpu/drm/i915/i915_debugfs.c:3499: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3499, column 5. + 3497. */ + 3498. if (val == 1) + 3499. > intel_dp->compliance.test_active = 1; + 3500. else + 3501. intel_dp->compliance.test_active = 0; + +drivers/gpu/drm/i915/i915_debugfs.c:3501: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3490 could be null and is dereferenced at line 3501, column 5. + 3499. intel_dp->compliance.test_active = 1; + 3500. else + 3501. > intel_dp->compliance.test_active = 0; + 3502. } + 3503. } + +drivers/net/ethernet/intel/e1000e/netdev.c:3474: error: UNINITIALIZED_VALUE + The value read from rss_key[_] was never initialized. + 3472. netdev_rss_key_fill(rss_key, sizeof(rss_key)); + 3473. for (i = 0; i < 10; i++) + 3474. > ew32(RSSRK(i), rss_key[i]); + 3475. + 3476. /* Direct all traffic to queue 0 */ + +kernel/sched/fair.c:3492: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3490. + 3491. /* Update parent cfs_rq utilization */ + 3492. > add_positive(&cfs_rq->avg.util_avg, delta); + 3493. cfs_rq->avg.util_sum = cfs_rq->avg.util_avg * LOAD_AVG_MAX; + 3494. } + +net/core/dev.c:3521: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3519. + 3520. txq = netdev_pick_tx(dev, skb, accel_priv); + 3521. > q = rcu_dereference_bh(txq->qdisc); + 3522. + 3523. trace_net_dev_queue(skb); + +net/core/dev.c:3542: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3540. */ + 3541. if (dev->flags & IFF_UP) { + 3542. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + +net/core/dev.c:3545: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + 3545. > if (unlikely(__this_cpu_read(xmit_recursion) > + 3546. XMIT_RECURSION_LIMIT)) + 3547. goto recursion_alert; + +net/core/dev.c:3542: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3540. */ + 3541. if (dev->flags & IFF_UP) { + 3542. > int cpu = smp_processor_id(); /* ok because BHs are off */ + 3543. + 3544. if (txq->xmit_lock_owner != cpu) { + +drivers/iommu/intel-iommu.c:3506: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3504. rcu_read_lock(); + 3505. for_each_rmrr_units(rmrr) { + 3506. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 3507. i, i_dev) { + 3508. if (i_dev != dev) + +kernel/events/core.c:3501: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3499. + 3500. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3501. > int local_cpu = smp_processor_id(); + 3502. + 3503. event_pkg = topology_physical_package_id(event_cpu); + +kernel/events/core.c:3501: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3499. + 3500. if (event->group_caps & PERF_EV_CAP_READ_ACTIVE_PKG) { + 3501. > int local_cpu = smp_processor_id(); + 3502. + 3503. event_pkg = topology_physical_package_id(event_cpu); + +kernel/sched/fair.c:3547: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3545. se->avg.load_sum = runnable_sum; + 3546. se->avg.load_avg = load_avg; + 3547. > add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + +kernel/sched/fair.c:3548: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3546. se->avg.load_avg = load_avg; + 3547. add_positive(&cfs_rq->avg.load_avg, delta_avg); + 3548. > add_positive(&cfs_rq->avg.load_sum, delta_sum); + 3549. + 3550. runnable_load_sum = (s64)se_runnable(se) * runnable_sum; + +kernel/sched/fair.c:3559: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3557. + 3558. if (se->on_rq) { + 3559. > add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + +kernel/sched/fair.c:3560: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3558. if (se->on_rq) { + 3559. add_positive(&cfs_rq->avg.runnable_load_avg, delta_avg); + 3560. > add_positive(&cfs_rq->avg.runnable_load_sum, delta_sum); + 3561. } + 3562. } + +drivers/gpu/drm/i915/i915_debugfs.c:3534: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3533 could be null and is dereferenced at line 3534, column 8. + 3532. if (encoder && connector->status == connector_status_connected) { + 3533. intel_dp = enc_to_intel_dp(&encoder->base); + 3534. > if (intel_dp->compliance.test_active) + 3535. seq_puts(m, "1"); + 3536. else + +net/core/rtnetlink.c:3525: error: DEAD_STORE + The value written to &err (type int) is never used. + 3523. struct nlattr *tb[NDA_MAX+1]; + 3524. struct net_device *dev; + 3525. > int err = -EINVAL; + 3526. __u8 *addr; + 3527. u16 vid; + +drivers/scsi/scsi_lib.c:3526: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3524. + 3525. rcu_read_lock(); + 3526. > vpd_pg83 = rcu_dereference(sdev->vpd_pg83); + 3527. if (!vpd_pg83) { + 3528. rcu_read_unlock(); + +drivers/clk/clk.c:3549: error: DEAD_STORE + The value written to &ret (type int) is never used. + 3547. { + 3548. struct clk_notifier *cn = NULL; + 3549. > int ret = -EINVAL; + 3550. + 3551. if (!clk || !nb) + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3569: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3567. u32 flash_linear_addr; + 3568. u32 flash_data = 0; + 3569. > s32 ret_val = -E1000_ERR_NVM; + 3570. u8 count = 0; + 3571. + +drivers/gpu/drm/i915/i915_debugfs.c:3585: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3584 could be null and is dereferenced at line 3585, column 8. + 3583. if (encoder && connector->status == connector_status_connected) { + 3584. intel_dp = enc_to_intel_dp(&encoder->base); + 3585. > if (intel_dp->compliance.test_type == + 3586. DP_TEST_LINK_EDID_READ) + 3587. seq_printf(m, "%lx", + +drivers/usb/core/hub.c:3611: error: DEAD_STORE + The value written to &status (type int) is never used. + 3609. /* Enable hub to send remote wakeup for all ports. */ + 3610. for (port1 = 1; port1 <= hdev->maxchild; port1++) { + 3611. > status = set_port_feature(hdev, + 3612. port1 | + 3613. USB_PORT_FEAT_REMOTE_WAKE_CONNECT | + +drivers/video/fbdev/core/fbcon.c:3597: error: DEAD_STORE + The value written to &pending (type int) is never used. + 3595. + 3596. if (info->queue.func) + 3597. > pending = cancel_work_sync(&info->queue); + 3598. DPRINTK("fbcon: %s pending work\n", (pending ? "canceled" : + 3599. "no")); + +kernel/signal.c:3588: error: UNINITIALIZED_VALUE + The value read from uss32.ss_flags was never initialized. + 3586. return -EFAULT; + 3587. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. > uss.ss_flags = uss32.ss_flags; + 3589. uss.ss_size = uss32.ss_size; + 3590. } + +kernel/signal.c:3589: error: UNINITIALIZED_VALUE + The value read from uss32.ss_size was never initialized. + 3587. uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. uss.ss_flags = uss32.ss_flags; + 3589. > uss.ss_size = uss32.ss_size; + 3590. } + 3591. ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss, + +kernel/signal.c:3587: error: UNINITIALIZED_VALUE + The value read from uss32.ss_sp was never initialized. + 3585. if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t))) + 3586. return -EFAULT; + 3587. > uss.ss_sp = compat_ptr(uss32.ss_sp); + 3588. uss.ss_flags = uss32.ss_flags; + 3589. uss.ss_size = uss32.ss_size; + +include/linux/netdevice.h:3586: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3584. bool ok = spin_trylock(&txq->_xmit_lock); + 3585. if (likely(ok)) + 3586. > txq->xmit_lock_owner = smp_processor_id(); + 3587. return ok; + 3588. } + +include/linux/netdevice.h:3586: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3584. bool ok = spin_trylock(&txq->_xmit_lock); + 3585. if (likely(ok)) + 3586. > txq->xmit_lock_owner = smp_processor_id(); + 3587. return ok; + 3588. } + +net/ipv6/addrconf.c:3633: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3631. spin_lock_bh(&addrconf_hash_lock); + 3632. restart: + 3633. > hlist_for_each_entry_rcu(ifa, h, addr_lst) { + 3634. if (ifa->idev == idev) { + 3635. addrconf_del_dad_work(ifa); + +net/wireless/reg.c:3593: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3591. rcu_read_lock(); + 3592. + 3593. > regd = rcu_dereference(cfg80211_regdomain); + 3594. wiphy_regd = rcu_dereference(wiphy->regd); + 3595. if (!wiphy_regd) { + +net/wireless/reg.c:3594: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3592. + 3593. regd = rcu_dereference(cfg80211_regdomain); + 3594. > wiphy_regd = rcu_dereference(wiphy->regd); + 3595. if (!wiphy_regd) { + 3596. if (regd->dfs_region == NL80211_DFS_ETSI) + +kernel/events/core.c:3616: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3614. /* If this is a per-CPU event, it must be for this CPU */ + 3615. if (!(event->attach_state & PERF_ATTACH_TASK) && + 3616. > event->cpu != smp_processor_id()) { + 3617. ret = -EINVAL; + 3618. goto out; + +kernel/events/core.c:3626: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3624. * oncpu == -1). + 3625. */ + 3626. > if (event->oncpu == smp_processor_id()) + 3627. event->pmu->read(event); + 3628. + +kernel/workqueue.c:3610: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3608. link_pwq(pwq); + 3609. + 3610. > old_pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]); + 3611. rcu_assign_pointer(wq->numa_pwq_tbl[node], pwq); + 3612. return old_pwq; + +drivers/gpu/drm/i915/i915_debugfs.c:3643: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 3642 could be null and is dereferenced at line 3643, column 27. + 3641. if (encoder && connector->status == connector_status_connected) { + 3642. intel_dp = enc_to_intel_dp(&encoder->base); + 3643. > seq_printf(m, "%02lx", intel_dp->compliance.test_type); + 3644. } else + 3645. seq_puts(m, "0"); + +include/linux/netdevice.h:3629: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3627. + 3628. spin_lock(&dev->tx_global_lock); + 3629. > cpu = smp_processor_id(); + 3630. for (i = 0; i < dev->num_tx_queues; i++) { + 3631. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3629: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3627. + 3628. spin_lock(&dev->tx_global_lock); + 3629. > cpu = smp_processor_id(); + 3630. for (i = 0; i < dev->num_tx_queues; i++) { + 3631. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3644: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 3642. union ich8_hws_flash_ctrl hsflctl; + 3643. u32 flash_linear_addr; + 3644. > s32 ret_val = -E1000_ERR_NVM; + 3645. u8 count = 0; + 3646. + +net/core/dev.c:3660: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3658. + 3659. rxqueue = dev->_rx + rxq_index; + 3660. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3661. if (!flow_table) + 3662. goto out; + +kernel/events/core.c:3648: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3646. static int perf_event_read(struct perf_event *event, bool group) + 3647. { + 3648. > enum perf_event_state state = READ_ONCE(event->state); + 3649. int event_cpu, ret = 0; + 3650. + +kernel/events/core.c:3667: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3665. smp_rmb(); + 3666. + 3667. > event_cpu = READ_ONCE(event->oncpu); + 3668. if ((unsigned)event_cpu >= nr_cpu_ids) + 3669. return 0; + +kernel/sched/fair.c:3672: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3670. + 3671. r = removed_load; + 3672. > sub_positive(&sa->load_avg, r); + 3673. sub_positive(&sa->load_sum, r * divider); + 3674. + +kernel/sched/fair.c:3673: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3671. r = removed_load; + 3672. sub_positive(&sa->load_avg, r); + 3673. > sub_positive(&sa->load_sum, r * divider); + 3674. + 3675. r = removed_util; + +kernel/sched/fair.c:3676: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3674. + 3675. r = removed_util; + 3676. > sub_positive(&sa->util_avg, r); + 3677. sub_positive(&sa->util_sum, r * divider); + 3678. + +kernel/sched/fair.c:3677: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3675. r = removed_util; + 3676. sub_positive(&sa->util_avg, r); + 3677. > sub_positive(&sa->util_sum, r * divider); + 3678. + 3679. add_tg_cfs_propagate(cfs_rq, -(long)removed_runnable_sum); + +drivers/gpu/drm/i915/intel_dp.c:3745: error: UNINITIALIZED_VALUE + The value read from sink_rates[_] was never initialized. + 3743. + 3744. for (i = 0; i < ARRAY_SIZE(sink_rates); i++) { + 3745. > int val = le16_to_cpu(sink_rates[i]); + 3746. + 3747. if (val == 0) + +net/core/dev.c:3714: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3712. /* Avoid computing hash if RFS/RPS is not active for this rxqueue */ + 3713. + 3714. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3715. map = rcu_dereference(rxqueue->rps_map); + 3716. if (!flow_table && !map) + +net/core/dev.c:3715: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3713. + 3714. flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3715. > map = rcu_dereference(rxqueue->rps_map); + 3716. if (!flow_table && !map) + 3717. goto done; + +net/core/dev.c:3724: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3722. goto done; + 3723. + 3724. > sock_flow_table = rcu_dereference(rps_sock_flow_table); + 3725. if (flow_table && sock_flow_table) { + 3726. struct rps_dev_flow *rflow; + +drivers/ata/libata-scsi.c:3697: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3695. struct scsi_cmnd *scmd = qc->scsicmd; + 3696. const u8 *cdb = scmd->cmnd; + 3697. > u16 sect, fp = (u16)-1; + 3698. u8 sa, options, bp = 0xff; + 3699. u64 block; + +drivers/gpu/drm/drm_edid.c:3734: error: UNINITIALIZED_VALUE + The value read from hdmi_len was never initialized. + 3732. */ + 3733. if (hdmi) + 3734. > modes += do_hdmi_vsdb_modes(connector, hdmi, hdmi_len, video, + 3735. video_len); + 3736. + +include/linux/netdevice.h:3701: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 3699. + 3700. local_bh_disable(); + 3701. > cpu = smp_processor_id(); + 3702. for (i = 0; i < dev->num_tx_queues; i++) { + 3703. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +include/linux/netdevice.h:3701: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 3699. + 3700. local_bh_disable(); + 3701. > cpu = smp_processor_id(); + 3702. for (i = 0; i < dev->num_tx_queues; i++) { + 3703. struct netdev_queue *txq = netdev_get_tx_queue(dev, i); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3821: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3819. + 3820. /* Convert offset to bytes. */ + 3821. > act_offset = (i + new_bank_offset) << 1; + 3822. + 3823. usleep_range(100, 200); + +drivers/net/ethernet/intel/e1000e/ich8lan.c:3867: error: DEAD_STORE + The value written to &act_offset (type unsigned int) is never used. + 3865. * to 1's. We can write 1's to 0's without an erase + 3866. */ + 3867. > act_offset = (old_bank_offset + E1000_ICH_NVM_SIG_WORD) * 2 + 1; + 3868. + 3869. /* offset in words but we read dword */ + +kernel/sched/fair.c:3755: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3753. { + 3754. dequeue_load_avg(cfs_rq, se); + 3755. > sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + +kernel/sched/fair.c:3756: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3754. dequeue_load_avg(cfs_rq, se); + 3755. sub_positive(&cfs_rq->avg.util_avg, se->avg.util_avg); + 3756. > sub_positive(&cfs_rq->avg.util_sum, se->avg.util_sum); + 3757. + 3758. add_tg_cfs_propagate(cfs_rq, -se->avg.load_sum); + +drivers/ata/libata-scsi.c:3784: error: DEAD_STORE + The value written to &fp (type unsigned short) is never used. + 3782. u64 block; + 3783. u32 n_block; + 3784. > u16 fp = (u16)-1; + 3785. + 3786. if (unlikely(scmd->cmd_len < 16)) { + +net/core/dev.c:3806: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3804. + 3805. rcu_read_lock(); + 3806. > flow_table = rcu_dereference(rxqueue->rps_flow_table); + 3807. if (flow_table && flow_id <= flow_table->mask) { + 3808. rflow = &flow_table->flows[flow_id]; + +net/core/dev.c:3809: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3807. if (flow_table && flow_id <= flow_table->mask) { + 3808. rflow = &flow_table->flows[flow_id]; + 3809. > cpu = READ_ONCE(rflow->cpu); + 3810. if (rflow->filter == filter_id && cpu < nr_cpu_ids && + 3811. ((int)(per_cpu(softnet_data, cpu).input_queue_head - + +kernel/rcu/tree.c:3834: error: DEAD_STORE + The value written to &nbits (type int) is never used. + 3832. rnp->expmaskinitnext |= mask; + 3833. oldmask ^= rnp->expmaskinitnext; + 3834. > nbits = bitmap_weight(&oldmask, BITS_PER_LONG); + 3835. /* Allow lockless access for expedited grace periods. */ + 3836. smp_store_release(&rsp->ncpus, rsp->ncpus + nbits); /* ^^^ */ + +kernel/cgroup/cgroup.c:3849: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3847. */ + 3848. if (!pos) { + 3849. > next = list_entry_rcu(parent->children.next, struct cgroup_subsys_state, sibling); + 3850. } else if (likely(!(pos->flags & CSS_RELEASED))) { + 3851. next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + +kernel/cgroup/cgroup.c:3851: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3849. next = list_entry_rcu(parent->children.next, struct cgroup_subsys_state, sibling); + 3850. } else if (likely(!(pos->flags & CSS_RELEASED))) { + 3851. > next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + 3852. } else { + 3853. list_for_each_entry_rcu(next, &parent->children, sibling) + +kernel/cgroup/cgroup.c:3853: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3851. next = list_entry_rcu(pos->sibling.next, struct cgroup_subsys_state, sibling); + 3852. } else { + 3853. > list_for_each_entry_rcu(next, &parent->children, sibling) + 3854. if (next->serial_nr > pos->serial_nr) + 3855. break; + +net/packet/af_packet.c:3875: error: DEAD_STORE + The value written to &val (type int) is never used. + 3873. break; + 3874. case PACKET_AUXDATA: + 3875. > val = po->auxdata; + 3876. break; + 3877. case PACKET_ORIGDEV: + +net/packet/af_packet.c:3878: error: DEAD_STORE + The value written to &val (type int) is never used. + 3876. break; + 3877. case PACKET_ORIGDEV: + 3878. > val = po->origdev; + 3879. break; + 3880. case PACKET_VNET_HDR: + +net/packet/af_packet.c:3881: error: DEAD_STORE + The value written to &val (type int) is never used. + 3879. break; + 3880. case PACKET_VNET_HDR: + 3881. > val = po->has_vnet_hdr; + 3882. break; + 3883. case PACKET_VERSION: + +net/packet/af_packet.c:3884: error: DEAD_STORE + The value written to &val (type int) is never used. + 3882. break; + 3883. case PACKET_VERSION: + 3884. > val = po->tp_version; + 3885. break; + 3886. case PACKET_HDRLEN: + +net/packet/af_packet.c:3895: error: DEAD_STORE + The value written to &val (type int) is never used. + 3893. switch (val) { + 3894. case TPACKET_V1: + 3895. > val = sizeof(struct tpacket_hdr); + 3896. break; + 3897. case TPACKET_V2: + +net/packet/af_packet.c:3898: error: DEAD_STORE + The value written to &val (type int) is never used. + 3896. break; + 3897. case TPACKET_V2: + 3898. > val = sizeof(struct tpacket2_hdr); + 3899. break; + 3900. case TPACKET_V3: + +net/packet/af_packet.c:3901: error: DEAD_STORE + The value written to &val (type int) is never used. + 3899. break; + 3900. case TPACKET_V3: + 3901. > val = sizeof(struct tpacket3_hdr); + 3902. break; + 3903. default: + +net/packet/af_packet.c:3908: error: DEAD_STORE + The value written to &val (type int) is never used. + 3906. break; + 3907. case PACKET_RESERVE: + 3908. > val = po->tp_reserve; + 3909. break; + 3910. case PACKET_LOSS: + +net/packet/af_packet.c:3911: error: DEAD_STORE + The value written to &val (type int) is never used. + 3909. break; + 3910. case PACKET_LOSS: + 3911. > val = po->tp_loss; + 3912. break; + 3913. case PACKET_TIMESTAMP: + +net/packet/af_packet.c:3914: error: DEAD_STORE + The value written to &val (type int) is never used. + 3912. break; + 3913. case PACKET_TIMESTAMP: + 3914. > val = po->tp_tstamp; + 3915. break; + 3916. case PACKET_FANOUT: + +net/packet/af_packet.c:3917: error: DEAD_STORE + The value written to &val (type int) is never used. + 3915. break; + 3916. case PACKET_FANOUT: + 3917. > val = (po->fanout ? + 3918. ((u32)po->fanout->id | + 3919. ((u32)po->fanout->type << 16) | + +net/packet/af_packet.c:3933: error: DEAD_STORE + The value written to &val (type int) is never used. + 3931. break; + 3932. case PACKET_TX_HAS_OFF: + 3933. > val = po->tp_tx_has_off; + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + +net/packet/af_packet.c:3936: error: DEAD_STORE + The value written to &val (type int) is never used. + 3934. break; + 3935. case PACKET_QDISC_BYPASS: + 3936. > val = packet_use_direct_xmit(po); + 3937. break; + 3938. default: + +drivers/net/ethernet/intel/e1000/e1000_main.c:3906: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3904. + 3905. #define TX_WAKE_THRESHOLD 32 + 3906. > if (unlikely(count && netif_carrier_ok(netdev) && + 3907. E1000_DESC_UNUSED(tx_ring) >= TX_WAKE_THRESHOLD)) { + 3908. /* Make sure that anybody stopping the queue after this + +net/core/dev.c:3872: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3870. + 3871. rcu_read_lock(); + 3872. > fl = rcu_dereference(sd->flow_limit); + 3873. if (fl) { + 3874. new_flow = skb_get_hash(skb) & (fl->num_buckets - 1); + +net/core/rtnetlink.c:3885: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3883. + 3884. rcu_read_lock(); + 3885. > for_each_netdev_rcu(net, dev) { + 3886. const struct net_device_ops *ops = dev->netdev_ops; + 3887. struct net_device *br_dev = netdev_master_upper_dev_get(dev); + +kernel/module.c:3913: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3911. unsigned int i, best = 0; + 3912. unsigned long nextval; + 3913. > struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms); + 3914. + 3915. /* At worse, next value is at end of module */ + +net/core/rtnetlink.c:3947: error: DEAD_STORE + The value written to &err (type int) is never used. + 3945. struct net *net = dev_net(dev); + 3946. struct sk_buff *skb; + 3947. > int err = -EOPNOTSUPP; + 3948. + 3949. if (!dev->netdev_ops->ndo_bridge_getlink) + +kernel/workqueue.c:4043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4041. + 4042. mutex_lock(&wq->mutex); + 4043. > for_each_pwq(pwq, wq) + 4044. pwq_adjust_max_active(pwq); + 4045. mutex_unlock(&wq->mutex); + +drivers/iommu/intel-iommu.c:3976: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3974. int i; + 3975. + 3976. > for_each_drhd_unit(drhd) { + 3977. if (!drhd->include_all) { + 3978. for_each_active_dev_scope(drhd->devices, + +drivers/iommu/intel-iommu.c:3978: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3976. for_each_drhd_unit(drhd) { + 3977. if (!drhd->include_all) { + 3978. > for_each_active_dev_scope(drhd->devices, + 3979. drhd->devices_cnt, i, dev) + 3980. break; + +drivers/iommu/intel-iommu.c:3987: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3985. } + 3986. + 3987. > for_each_active_drhd_unit(drhd) { + 3988. if (drhd->include_all) + 3989. continue; + +drivers/iommu/intel-iommu.c:3991: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3989. continue; + 3990. + 3991. > for_each_active_dev_scope(drhd->devices, + 3992. drhd->devices_cnt, i, dev) + 3993. if (!dev_is_pci(dev) || !IS_GFX_DEVICE(to_pci_dev(dev))) + +drivers/iommu/intel-iommu.c:4004: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4002. } else { + 4003. drhd->ignored = 1; + 4004. > for_each_active_dev_scope(drhd->devices, + 4005. drhd->devices_cnt, i, dev) + 4006. dev->archdata.iommu = DUMMY_DEVICE_DOMAIN_INFO; + +net/packet/af_packet.c:3981: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3979. + 3980. rcu_read_lock(); + 3981. > sk_for_each_rcu(sk, &net->packet.sklist) { + 3982. struct packet_sock *po = pkt_sk(sk); + 3983. + +drivers/tty/vt/vt.c:3993: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3991. console_lock(); + 3992. for (i = k = 0; i < 16; i++) { + 3993. > default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + +drivers/tty/vt/vt.c:3994: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3992. for (i = k = 0; i < 16; i++) { + 3993. default_red[i] = colormap[k++]; + 3994. > default_grn[i] = colormap[k++]; + 3995. default_blu[i] = colormap[k++]; + 3996. } + +drivers/tty/vt/vt.c:3995: error: UNINITIALIZED_VALUE + The value read from colormap[_] was never initialized. + 3993. default_red[i] = colormap[k++]; + 3994. default_grn[i] = colormap[k++]; + 3995. > default_blu[i] = colormap[k++]; + 3996. } + 3997. for (i = 0; i < MAX_NR_CONSOLES; i++) { + +kernel/module.c:3990: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 3988. + 3989. preempt_disable(); + 3990. > list_for_each_entry_rcu(mod, &modules, list) { + 3991. if (mod->state == MODULE_STATE_UNFORMED) + 3992. continue; + +kernel/module.c:4015: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4013. + 4014. preempt_disable(); + 4015. > list_for_each_entry_rcu(mod, &modules, list) { + 4016. if (mod->state == MODULE_STATE_UNFORMED) + 4017. continue; + +drivers/iommu/intel-iommu.c:4017: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4015. struct intel_iommu *iommu = NULL; + 4016. + 4017. > for_each_active_iommu(iommu, drhd) + 4018. if (iommu->qi) + 4019. dmar_reenable_qi(iommu); + +drivers/iommu/intel-iommu.c:4021: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4019. dmar_reenable_qi(iommu); + 4020. + 4021. > for_each_iommu(iommu, drhd) { + 4022. if (drhd->ignored) { + 4023. /* + +kernel/module.c:4043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4041. + 4042. preempt_disable(); + 4043. > list_for_each_entry_rcu(mod, &modules, list) { + 4044. struct mod_kallsyms *kallsyms; + 4045. + +kernel/module.c:4048: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4046. if (mod->state == MODULE_STATE_UNFORMED) + 4047. continue; + 4048. > kallsyms = rcu_dereference_sched(mod->kallsyms); + 4049. if (symnum < kallsyms->num_symtab) { + 4050. *value = kallsyms->symtab[symnum].st_value; + +drivers/iommu/intel-iommu.c:4051: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4049. struct intel_iommu *iommu; + 4050. + 4051. > for_each_active_iommu(iommu, drhd) { + 4052. iommu->flush.flush_context(iommu, 0, 0, 0, + 4053. DMA_CCMD_GLOBAL_INVL); + +net/core/dev.c:4063: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4061. + 4062. txq = netdev_pick_tx(dev, skb, NULL); + 4063. > cpu = smp_processor_id(); + 4064. HARD_TX_LOCK(dev, txq, cpu); + 4065. if (!netif_xmit_stopped(txq)) { + +net/core/dev.c:4063: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4061. + 4062. txq = netdev_pick_tx(dev, skb, NULL); + 4063. > cpu = smp_processor_id(); + 4064. HARD_TX_LOCK(dev, txq, cpu); + 4065. if (!netif_xmit_stopped(txq)) { + +drivers/tty/vt/vt.c:4060: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4058. { + 4059. struct console_font font; + 4060. > int rc = -EINVAL; + 4061. int c; + 4062. + +drivers/tty/vt/vt.c:4101: error: UNINITIALIZED_VALUE + The value read from font.charcount was never initialized. + 4099. op->height = font.height; + 4100. op->width = font.width; + 4101. > op->charcount = font.charcount; + 4102. + 4103. if (op->data && copy_to_user(op->data, font.data, c)) + +drivers/tty/vt/vt.c:4099: error: UNINITIALIZED_VALUE + The value read from font.height was never initialized. + 4097. goto out; + 4098. + 4099. > op->height = font.height; + 4100. op->width = font.width; + 4101. op->charcount = font.charcount; + +drivers/tty/vt/vt.c:4100: error: UNINITIALIZED_VALUE + The value read from font.width was never initialized. + 4098. + 4099. op->height = font.height; + 4100. > op->width = font.width; + 4101. op->charcount = font.charcount; + 4102. + +drivers/iommu/intel-iommu.c:4065: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4063. unsigned long flag; + 4064. + 4065. > for_each_active_iommu(iommu, drhd) { + 4066. iommu->iommu_state = kzalloc(sizeof(u32) * MAX_SR_DMAR_REGS, + 4067. GFP_ATOMIC); + +drivers/iommu/intel-iommu.c:4074: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4072. iommu_flush_all(); + 4073. + 4074. > for_each_active_iommu(iommu, drhd) { + 4075. iommu_disable_translation(iommu); + 4076. + +drivers/iommu/intel-iommu.c:4093: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4091. + 4092. nomem: + 4093. > for_each_active_iommu(iommu, drhd) + 4094. kfree(iommu->iommu_state); + 4095. + +kernel/module.c:4067: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4065. { + 4066. unsigned int i; + 4067. > struct mod_kallsyms *kallsyms = rcu_dereference_sched(mod->kallsyms); + 4068. + 4069. for (i = 0; i < kallsyms->num_symtab; i++) + +kernel/sched/core.c:4073: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4071. + 4072. rcu_read_lock(); + 4073. > pcred = __task_cred(p); + 4074. match = (uid_eq(cred->euid, pcred->euid) || + 4075. uid_eq(cred->euid, pcred->uid)); + +kernel/workqueue.c:4079: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4077. /* sanity checks */ + 4078. mutex_lock(&wq->mutex); + 4079. > for_each_pwq(pwq, wq) { + 4080. int i; + 4081. + +kernel/workqueue.c:4126: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4124. */ + 4125. for_each_node(node) { + 4126. > pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]); + 4127. RCU_INIT_POINTER(wq->numa_pwq_tbl[node], NULL); + 4128. put_pwq_unlocked(pwq); + +kernel/module.c:4089: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4087. ret = mod_find_symname(mod, colon+1); + 4088. } else { + 4089. > list_for_each_entry_rcu(mod, &modules, list) { + 4090. if (mod->state == MODULE_STATE_UNFORMED) + 4091. continue; + +drivers/gpu/drm/i915/intel_pm.c:4131: error: DEAD_STORE + The value written to &src_h (type unsigned int) is never used. + 4129. if (fb->format->format == DRM_FORMAT_NV12 && !y) { + 4130. src_w /= 2; + 4131. > src_h /= 2; + 4132. } + 4133. + +drivers/iommu/intel-iommu.c:4113: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4111. } + 4112. + 4113. > for_each_active_iommu(iommu, drhd) { + 4114. + 4115. raw_spin_lock_irqsave(&iommu->register_lock, flag); + +drivers/iommu/intel-iommu.c:4129: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4127. } + 4128. + 4129. > for_each_active_iommu(iommu, drhd) + 4130. kfree(iommu->iommu_state); + 4131. } + +net/core/dev.c:4121: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4119. preempt_disable(); + 4120. rcu_read_lock(); + 4121. > ret = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb); + 4122. rcu_read_unlock(); + 4123. preempt_enable(); + +net/core/dev.c:4143: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4141. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4142. if (cpu < 0) + 4143. > cpu = smp_processor_id(); + 4144. + 4145. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4154: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4152. unsigned int qtail; + 4153. + 4154. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4155. put_cpu(); + 4156. } + +net/core/dev.c:4143: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4141. cpu = get_rps_cpu(skb->dev, skb, &rflow); + 4142. if (cpu < 0) + 4143. > cpu = smp_processor_id(); + 4144. + 4145. ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); + +net/core/dev.c:4154: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4152. unsigned int qtail; + 4153. + 4154. > ret = enqueue_to_backlog(skb, get_cpu(), &qtail); + 4155. put_cpu(); + 4156. } + +drivers/tty/vt/vt.c:4114: error: DEAD_STORE + The value written to &rc (type int) is never used. + 4112. { + 4113. struct console_font font; + 4114. > int rc = -EINVAL; + 4115. int size; + 4116. + +net/ipv6/addrconf.c:4143: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4141. + 4142. for (; state->bucket < IN6_ADDR_HSIZE; ++state->bucket) { + 4143. > hlist_for_each_entry_rcu(ifa, &inet6_addr_lst[state->bucket], + 4144. addr_lst) { + 4145. if (!net_eq(dev_net(ifa->idev->dev), net)) + +drivers/net/ethernet/intel/e1000/e1000_main.c:4331: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4329. rx_ring->next_to_clean = i; + 4330. + 4331. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4332. if (cleaned_count) + 4333. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +kernel/events/core.c:4162: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4160. * owner->perf_event_mutex. + 4161. */ + 4162. > owner = READ_ONCE(event->owner); + 4163. if (owner) { + 4164. /* + +kernel/workqueue.c:4167: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4165. wq->saved_max_active = max_active; + 4166. + 4167. > for_each_pwq(pwq, wq) + 4168. pwq_adjust_max_active(pwq); + 4169. + +kernel/sched/fair.c:4184: error: NULL_DEREFERENCE + pointer `se` last assigned on line 4183 could be null and is dereferenced at line 4184, column 27. + 4182. + 4183. se = __pick_first_entity(cfs_rq); + 4184. > delta = curr->vruntime - se->vruntime; + 4185. + 4186. if (delta < 0) + +net/ipv6/addrconf.c:4169: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4167. struct net *net = seq_file_net(seq); + 4168. + 4169. > hlist_for_each_entry_continue_rcu(ifa, addr_lst) { + 4170. if (!net_eq(dev_net(ifa->idev->dev), net)) + 4171. continue; + +net/ipv6/addrconf.c:4178: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4176. while (++state->bucket < IN6_ADDR_HSIZE) { + 4177. state->offset = 0; + 4178. > hlist_for_each_entry_rcu(ifa, + 4179. &inet6_addr_lst[state->bucket], addr_lst) { + 4180. if (!net_eq(dev_net(ifa->idev->dev), net)) + +net/core/dev.c:4191: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4189. preempt_disable(); + 4190. err = netif_rx_internal(skb); + 4191. > if (local_softirq_pending()) + 4192. do_softirq(); + 4193. preempt_enable(); + +drivers/iommu/intel-iommu.c:4192: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4190. struct acpi_dmar_atsr *tmp; + 4191. + 4192. > list_for_each_entry_rcu(atsru, &dmar_atsr_units, list) { + 4193. tmp = (struct acpi_dmar_atsr *)atsru->hdr; + 4194. if (atsr->segment != tmp->segment) + +net/packet/af_packet.c:4209: error: DEAD_STORE + The value written to &err (type int) is never used. + 4207. struct sk_buff_head *rb_queue; + 4208. __be16 num; + 4209. > int err = -EINVAL; + 4210. /* Added to avoid minimal code churn */ + 4211. struct tpacket_req *req = &req_u->req; + +net/ipv6/route.c:4211: error: DEAD_STORE + The value written to &err (type int) is never used. + 4209. int remaining; + 4210. int attrlen; + 4211. > int err = 1, last_err = 0; + 4212. + 4213. remaining = cfg->fc_mp_len; + +drivers/usb/core/hub.c:4212: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 4210 could be null and is dereferenced by call to `hub_port_disable()` at line 4212, column 9. + 4210. struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent); + 4211. + 4212. > return hub_port_disable(hub, udev->portnum, 0); + 4213. } + 4214. + +kernel/events/core.c:4260: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4258. * comment with perf_event_ctx_lock_nested(). + 4259. */ + 4260. > ctx = READ_ONCE(child->ctx); + 4261. /* + 4262. * Since child_mutex nests inside ctx::mutex, we must jump + +kernel/events/core.c:4285: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4283. * and we can continue doing so. + 4284. */ + 4285. > tmp = list_first_entry_or_null(&event->child_list, + 4286. struct perf_event, child_list); + 4287. if (tmp == child) { + +net/core/rtnetlink.c:4322: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4320. + 4321. rcu_read_lock(); + 4322. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 4323. if (af_ops->fill_stats_af) { + 4324. struct nlattr *af; + +kernel/workqueue.c:4231: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4229. + 4230. if (cpu == WORK_CPU_UNBOUND) + 4231. > cpu = smp_processor_id(); + 4232. + 4233. if (!(wq->flags & WQ_UNBOUND)) + +kernel/workqueue.c:4231: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 4229. + 4230. if (cpu == WORK_CPU_UNBOUND) + 4231. > cpu = smp_processor_id(); + 4232. + 4233. if (!(wq->flags & WQ_UNBOUND)) + +drivers/usb/core/hub.c:4265: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4263. } + 4264. + 4265. > dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n", + 4266. total_time, stable_time, portstatus); + 4267. + +drivers/usb/core/hub.c:4270: error: UNINITIALIZED_VALUE + The value read from portstatus was never initialized. + 4268. if (stable_time < HUB_DEBOUNCE_STABLE) + 4269. return -ETIMEDOUT; + 4270. > return portstatus; + 4271. } + 4272. + +drivers/gpu/drm/i915/intel_display.c:4266: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4264. struct drm_crtc_commit *commit; + 4265. spin_lock(&crtc->commit_lock); + 4266. > commit = list_first_entry_or_null(&crtc->commit_list, + 4267. struct drm_crtc_commit, commit_entry); + 4268. cleanup_done = commit ? + +drivers/iommu/intel-iommu.c:4280: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4278. + 4279. if (!atsru->include_all && atsru->devices && atsru->devices_cnt) { + 4280. > for_each_active_dev_scope(atsru->devices, atsru->devices_cnt, + 4281. i, dev) + 4282. return -EBUSY; + +net/core/dev.c:4276: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4274. { + 4275. #ifdef CONFIG_NET_CLS_ACT + 4276. > struct mini_Qdisc *miniq = rcu_dereference_bh(skb->dev->miniq_ingress); + 4277. struct tcf_result cl_res; + 4278. + +drivers/gpu/drm/i915/intel_display.c:4338: error: UNINITIALIZED_VALUE + The value read from divsel was never initialized. + 4336. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4337. + 4338. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4339. clock, + 4340. auxdiv, + +drivers/gpu/drm/i915/intel_display.c:4338: error: UNINITIALIZED_VALUE + The value read from phaseinc was never initialized. + 4336. ~SBI_SSCDIVINTPHASE_INCVAL_MASK); + 4337. + 4338. > DRM_DEBUG_KMS("iCLKIP clock: found settings for %dKHz refresh rate: auxdiv=%x, divsel=%x, phasedir=%x, phaseinc=%x\n", + 4339. clock, + 4340. auxdiv, + +net/ipv6/addrconf.c:4316: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4314. for (i = 0; i < IN6_ADDR_HSIZE; i++) { + 4315. restart: + 4316. > hlist_for_each_entry_rcu_bh(ifp, &inet6_addr_lst[i], addr_lst) { + 4317. unsigned long age; + 4318. + +net/ipv4/tcp_input.c:4346: error: UNINITIALIZED_VALUE + The value read from fragstolen was never initialized. + 4344. __skb_queue_tail(&sk->sk_receive_queue, skb); + 4345. else + 4346. > kfree_skb_partial(skb, fragstolen); + 4347. + 4348. if (unlikely(fin)) { + +kernel/cgroup/cgroup.c:4330: error: NULL_DEREFERENCE + pointer `com_cgrp` last assigned on line 4331 could be null and is dereferenced by call to `cgroup_is_descendant()` at line 4330, column 10. + 4328. + 4329. /* find the common ancestor */ + 4330. > while (!cgroup_is_descendant(dst_cgrp, com_cgrp)) + 4331. com_cgrp = cgroup_parent(com_cgrp); + 4332. + +drivers/gpu/drm/i915/i915_gem.c:4372: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4370. + 4371. /* Translate the exclusive fence to the READ *and* WRITE engine */ + 4372. > args->busy = busy_check_writer(rcu_dereference(obj->resv->fence_excl)); + 4373. + 4374. /* Translate shared fences to READ set of engines */ + +drivers/gpu/drm/i915/i915_gem.c:4375: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4373. + 4374. /* Translate shared fences to READ set of engines */ + 4375. > list = rcu_dereference(obj->resv->fence); + 4376. if (list) { + 4377. unsigned int shared_count = list->shared_count, i; + +drivers/gpu/drm/i915/i915_gem.c:4381: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4379. for (i = 0; i < shared_count; ++i) { + 4380. struct dma_fence *fence = + 4381. > rcu_dereference(list->shared[i]); + 4382. + 4383. args->busy |= busy_check_reader(fence); + +drivers/net/ethernet/intel/e1000e/netdev.c:4365: error: DEAD_STORE + The value written to &temp (type unsigned long long) is never used. + 4363. temp = time_delta; + 4364. /* VMWare users have seen incvalue of zero, don't div / 0 */ + 4365. > rem = incvalue ? do_div(temp, incvalue) : (time_delta != 0); + 4366. + 4367. systim = systim_next; + +kernel/module.c:4368: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4366. /* Most callers should already have preempt disabled, but make sure */ + 4367. preempt_disable(); + 4368. > list_for_each_entry_rcu(mod, &modules, list) { + 4369. if (mod->state == MODULE_STATE_UNFORMED) + 4370. continue; + +net/core/rtnetlink.c:4414: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4412. + 4413. rcu_read_lock(); + 4414. > list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) { + 4415. if (af_ops->get_stats_af_size) { + 4416. size += nla_total_size( + +net/core/filter.c:4375: error: DEAD_STORE + The value written to &insn (type bpf_insn*) is never used. + 4373. struct bpf_prog *prog, u32 *target_size) + 4374. { + 4375. > struct bpf_insn *insn = insn_buf; + 4376. + 4377. switch (si->off) { + +net/core/filter.c:4379: error: NULL_DEREFERENCE + pointer `insn` last assigned on line 4379 could be null and is dereferenced at line 4379, column 13. + 4377. switch (si->off) { + 4378. case offsetof(struct __sk_buff, ifindex): + 4379. > *insn++ = BPF_LDX_MEM(BPF_FIELD_SIZEOF(struct sk_buff, dev), + 4380. si->dst_reg, si->src_reg, + 4381. offsetof(struct sk_buff, dev)); + +drivers/net/ethernet/intel/e1000/e1000_main.c:4504: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4502. rx_ring->next_to_clean = i; + 4503. + 4504. > cleaned_count = E1000_DESC_UNUSED(rx_ring); + 4505. if (cleaned_count) + 4506. adapter->alloc_rx_buf(adapter, rx_ring, cleaned_count); + +drivers/iommu/intel-iommu.c:4433: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4431. + 4432. rcu_read_lock(); + 4433. > list_for_each_entry_rcu(atsru, &dmar_atsr_units, list) { + 4434. atsr = container_of(atsru->hdr, struct acpi_dmar_atsr, header); + 4435. if (atsr->segment != pci_domain_nr(dev->bus)) + +drivers/iommu/intel-iommu.c:4438: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4436. continue; + 4437. + 4438. > for_each_dev_scope(atsru->devices, atsru->devices_cnt, i, tmp) + 4439. if (tmp == &bridge->dev) + 4440. goto out; + +net/core/dev.c:4471: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4469. goto skip_taps; + 4470. + 4471. > list_for_each_entry_rcu(ptype, &ptype_all, list) { + 4472. if (pt_prev) + 4473. ret = deliver_skb(skb, pt_prev, orig_dev); + +net/core/dev.c:4477: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4475. } + 4476. + 4477. > list_for_each_entry_rcu(ptype, &skb->dev->ptype_all, list) { + 4478. if (pt_prev) + 4479. ret = deliver_skb(skb, pt_prev, orig_dev); + +net/core/dev.c:4510: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4508. } + 4509. + 4510. > rx_handler = rcu_dereference(skb->dev->rx_handler); + 4511. if (rx_handler) { + 4512. if (pt_prev) { + +drivers/md/md.c:4482: error: DEAD_STORE + The value written to &namelen (type unsigned long) is never used. + 4480. mddev->metadata_type[namelen] = 0; + 4481. if (namelen && mddev->metadata_type[namelen-1] == '\n') + 4482. > mddev->metadata_type[--namelen] = 0; + 4483. mddev->persistent = 0; + 4484. mddev->external = 1; + +kernel/workqueue.c:4466: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4464. pr_info("Showing busy workqueues and worker pools:\n"); + 4465. + 4466. > list_for_each_entry_rcu(wq, &workqueues, list) { + 4467. struct pool_workqueue *pwq; + 4468. bool idle = true; + +kernel/workqueue.c:4470: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4468. bool idle = true; + 4469. + 4470. > for_each_pwq(pwq, wq) { + 4471. if (pwq->nr_active || !list_empty(&pwq->delayed_works)) { + 4472. idle = false; + +kernel/workqueue.c:4481: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4479. pr_info("workqueue %s: flags=0x%x\n", wq->name, wq->flags); + 4480. + 4481. > for_each_pwq(pwq, wq) { + 4482. spin_lock_irqsave(&pwq->pool->lock, flags); + 4483. if (pwq->nr_active || !list_empty(&pwq->delayed_works)) + +drivers/gpu/drm/i915/i915_gem.c:4562: error: NULL_DEREFERENCE + pointer `obj->base.filp` last assigned on line 4551 could be null and is dereferenced at line 4562, column 12. + 4560. } + 4561. + 4562. > mapping = obj->base.filp->f_mapping; + 4563. mapping_set_gfp_mask(mapping, mask); + 4564. GEM_BUG_ON(!(mapping_gfp_mask(mapping) & __GFP_RECLAIM)); + +drivers/iommu/intel-iommu.c:4583: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4581. + 4582. rcu_read_lock(); + 4583. > for_each_active_iommu(iommu, drhd) + 4584. iommu_flush_iotlb_psi(iommu, si_domain, + 4585. iova->pfn_lo, iova_size(iova), + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &preferred_lft (type unsigned int) is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +net/ipv6/addrconf.c:4576: error: DEAD_STORE + The value written to &valid_lft (type unsigned int) is never used. + 4574. struct inet6_ifaddr *ifa; + 4575. struct net_device *dev; + 4576. > u32 valid_lft = INFINITY_LIFE_TIME, preferred_lft = INFINITY_LIFE_TIME; + 4577. u32 ifa_flags; + 4578. int err; + +drivers/ata/libata-scsi.c:4621: error: UNINITIALIZED_VALUE + The value read from dev was never initialized. + 4619. if (dev != last_failed_dev) { + 4620. msleep(100); + 4621. > last_failed_dev = dev; + 4622. goto repeat; + 4623. } + +kernel/workqueue.c:4656: error: DEAD_STORE + The value written to &worker_flags (type unsigned int) is never used. + 4654. WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND)); + 4655. worker_flags |= WORKER_REBOUND; + 4656. > worker_flags &= ~WORKER_UNBOUND; + 4657. WRITE_ONCE(worker->flags, worker_flags); + 4658. } + +drivers/iommu/intel-iommu.c:4637: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4635. struct dmar_drhd_unit *drhd; + 4636. + 4637. > for_each_iommu(iommu, drhd) + 4638. iommu_disable_translation(iommu); + 4639. } + +net/core/dev.c:4680: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4678. preempt_disable(); + 4679. rcu_read_lock(); + 4680. > ret = do_xdp_generic(rcu_dereference(skb->dev->xdp_prog), skb); + 4681. rcu_read_unlock(); + 4682. preempt_enable(); + +kernel/events/core.c:4739: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4737. + 4738. rcu_read_lock(); + 4739. > rb = rcu_dereference(event->rb); + 4740. if (!rb || !rb->nr_pages) { + 4741. rcu_read_unlock(); + +kernel/sched/core.c:4732: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4730. if (!check_same_owner(p)) { + 4731. rcu_read_lock(); + 4732. > if (!ns_capable(__task_cred(p)->user_ns, CAP_SYS_NICE)) { + 4733. rcu_read_unlock(); + 4734. goto out_free_new_mask; + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4705: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4703. volatile u32 temp; + 4704. + 4705. > temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4706: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4704. + 4705. temp = er32(CRCERRS); + 4706. > temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4707: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4705. temp = er32(CRCERRS); + 4706. temp = er32(SYMERRS); + 4707. > temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4708: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4706. temp = er32(SYMERRS); + 4707. temp = er32(MPC); + 4708. > temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4709: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4707. temp = er32(MPC); + 4708. temp = er32(SCC); + 4709. > temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4710: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4708. temp = er32(SCC); + 4709. temp = er32(ECOL); + 4710. > temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4711: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4709. temp = er32(ECOL); + 4710. temp = er32(MCC); + 4711. > temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4712: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4710. temp = er32(MCC); + 4711. temp = er32(LATECOL); + 4712. > temp = er32(COLC); + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4713: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4711. temp = er32(LATECOL); + 4712. temp = er32(COLC); + 4713. > temp = er32(DC); + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4714: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4712. temp = er32(COLC); + 4713. temp = er32(DC); + 4714. > temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4715: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4713. temp = er32(DC); + 4714. temp = er32(SEC); + 4715. > temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4716: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4714. temp = er32(SEC); + 4715. temp = er32(RLEC); + 4716. > temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4717: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4715. temp = er32(RLEC); + 4716. temp = er32(XONRXC); + 4717. > temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4718: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4716. temp = er32(XONRXC); + 4717. temp = er32(XONTXC); + 4718. > temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4719: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4717. temp = er32(XONTXC); + 4718. temp = er32(XOFFRXC); + 4719. > temp = er32(XOFFTXC); + 4720. temp = er32(FCRUC); + 4721. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4720: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4718. temp = er32(XOFFRXC); + 4719. temp = er32(XOFFTXC); + 4720. > temp = er32(FCRUC); + 4721. + 4722. temp = er32(PRC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4722: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4720. temp = er32(FCRUC); + 4721. + 4722. > temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4723: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4721. + 4722. temp = er32(PRC64); + 4723. > temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4724: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4722. temp = er32(PRC64); + 4723. temp = er32(PRC127); + 4724. > temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4725: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4723. temp = er32(PRC127); + 4724. temp = er32(PRC255); + 4725. > temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4726: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4724. temp = er32(PRC255); + 4725. temp = er32(PRC511); + 4726. > temp = er32(PRC1023); + 4727. temp = er32(PRC1522); + 4728. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4727: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4725. temp = er32(PRC511); + 4726. temp = er32(PRC1023); + 4727. > temp = er32(PRC1522); + 4728. + 4729. temp = er32(GPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4729: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4727. temp = er32(PRC1522); + 4728. + 4729. > temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4730: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4728. + 4729. temp = er32(GPRC); + 4730. > temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4731: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4729. temp = er32(GPRC); + 4730. temp = er32(BPRC); + 4731. > temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4732: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4730. temp = er32(BPRC); + 4731. temp = er32(MPRC); + 4732. > temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4733: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4731. temp = er32(MPRC); + 4732. temp = er32(GPTC); + 4733. > temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4734: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4732. temp = er32(GPTC); + 4733. temp = er32(GORCL); + 4734. > temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4735: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4733. temp = er32(GORCL); + 4734. temp = er32(GORCH); + 4735. > temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4736: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4734. temp = er32(GORCH); + 4735. temp = er32(GOTCL); + 4736. > temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4737: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4735. temp = er32(GOTCL); + 4736. temp = er32(GOTCH); + 4737. > temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4738: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4736. temp = er32(GOTCH); + 4737. temp = er32(RNBC); + 4738. > temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4739: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4737. temp = er32(RNBC); + 4738. temp = er32(RUC); + 4739. > temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4740: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4738. temp = er32(RUC); + 4739. temp = er32(RFC); + 4740. > temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4741: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4739. temp = er32(RFC); + 4740. temp = er32(ROC); + 4741. > temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4742: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4740. temp = er32(ROC); + 4741. temp = er32(RJC); + 4742. > temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4743: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4741. temp = er32(RJC); + 4742. temp = er32(TORL); + 4743. > temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4744: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4742. temp = er32(TORL); + 4743. temp = er32(TORH); + 4744. > temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4745: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4743. temp = er32(TORH); + 4744. temp = er32(TOTL); + 4745. > temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. temp = er32(TPT); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4746: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4744. temp = er32(TOTL); + 4745. temp = er32(TOTH); + 4746. > temp = er32(TPR); + 4747. temp = er32(TPT); + 4748. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4747: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4745. temp = er32(TOTH); + 4746. temp = er32(TPR); + 4747. > temp = er32(TPT); + 4748. + 4749. temp = er32(PTC64); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4749: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4747. temp = er32(TPT); + 4748. + 4749. > temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4750: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4748. + 4749. temp = er32(PTC64); + 4750. > temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4751: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4749. temp = er32(PTC64); + 4750. temp = er32(PTC127); + 4751. > temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4752: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4750. temp = er32(PTC127); + 4751. temp = er32(PTC255); + 4752. > temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4753: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4751. temp = er32(PTC255); + 4752. temp = er32(PTC511); + 4753. > temp = er32(PTC1023); + 4754. temp = er32(PTC1522); + 4755. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4754: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4752. temp = er32(PTC511); + 4753. temp = er32(PTC1023); + 4754. > temp = er32(PTC1522); + 4755. + 4756. temp = er32(MPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4756: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4754. temp = er32(PTC1522); + 4755. + 4756. > temp = er32(MPTC); + 4757. temp = er32(BPTC); + 4758. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4757: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4755. + 4756. temp = er32(MPTC); + 4757. > temp = er32(BPTC); + 4758. + 4759. if (hw->mac_type < e1000_82543) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4762: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4760. return; + 4761. + 4762. > temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4763: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4761. + 4762. temp = er32(ALGNERRC); + 4763. > temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4764: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4762. temp = er32(ALGNERRC); + 4763. temp = er32(RXERRC); + 4764. > temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4765: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4763. temp = er32(RXERRC); + 4764. temp = er32(TNCRS); + 4765. > temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4766: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4764. temp = er32(TNCRS); + 4765. temp = er32(CEXTERR); + 4766. > temp = er32(TSCTC); + 4767. temp = er32(TSCTFC); + 4768. + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4767: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4765. temp = er32(CEXTERR); + 4766. temp = er32(TSCTC); + 4767. > temp = er32(TSCTFC); + 4768. + 4769. if (hw->mac_type <= e1000_82544) + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4772: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4770. return; + 4771. + 4772. > temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4773: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4771. + 4772. temp = er32(MGTPRC); + 4773. > temp = er32(MGTPDC); + 4774. temp = er32(MGTPTC); + 4775. } + +drivers/net/ethernet/intel/e1000/e1000_hw.c:4774: error: DEAD_STORE + The value written to &temp (type unsigned int) is never used. + 4772. temp = er32(MGTPRC); + 4773. temp = er32(MGTPDC); + 4774. > temp = er32(MGTPTC); + 4775. } + 4776. + +drivers/pci/quirks.c:4792: error: DEAD_STORE + The value written to &i (type int) is never used. + 4790. pcie_capability_read_word(pdev, PCI_EXP_DEVCTL2, &cap[i++]); + 4791. pcie_capability_read_word(pdev, PCI_EXP_LNKCTL2, &cap[i++]); + 4792. > pcie_capability_read_word(pdev, PCI_EXP_SLTCTL2, &cap[i++]); + 4793. hlist_add_head(&state->next, &pdev->saved_cap_space); + 4794. } + +drivers/iommu/intel-iommu.c:4773: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4771. */ + 4772. if (intel_iommu_tboot_noforce) { + 4773. > for_each_iommu(iommu, drhd) + 4774. iommu_disable_protect_mem_regions(iommu); + 4775. } + +drivers/iommu/intel-iommu.c:4817: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4815. init_iommu_pm_ops(); + 4816. + 4817. > for_each_active_iommu(iommu, drhd) { + 4818. iommu_device_sysfs_add(&iommu->iommu, NULL, + 4819. intel_iommu_groups, + +kernel/workqueue.c:4736: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 4734. + 4735. /* unbinding per-cpu workers should happen on the local CPU */ + 4736. > if (WARN_ON(cpu != smp_processor_id())) + 4737. return -1; + 4738. + +drivers/gpu/drm/i915/i915_gem.c:4780: error: DEAD_STORE + The value written to &kernel_context (type i915_gem_context*) is never used. + 4778. static void assert_kernel_context_is_current(struct drm_i915_private *i915) + 4779. { + 4780. > struct i915_gem_context *kernel_context = i915->kernel_context; + 4781. struct intel_engine_cs *engine; + 4782. enum intel_engine_id id; + +net/core/dev.c:4793: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4791. + 4792. rcu_read_lock(); + 4793. > list_for_each_entry_rcu(ptype, head, list) { + 4794. if (ptype->type != type || !ptype->callbacks.gro_complete) + 4795. continue; + +kernel/workqueue.c:4837: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4835. list_for_each_entry(wq, &workqueues, list) { + 4836. mutex_lock(&wq->mutex); + 4837. > for_each_pwq(pwq, wq) + 4838. pwq_adjust_max_active(pwq); + 4839. mutex_unlock(&wq->mutex); + +kernel/events/core.c:4857: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4855. + 4856. rcu_read_lock(); + 4857. > rb = rcu_dereference(event->rb); + 4858. if (!rb) + 4859. goto unlock; + +kernel/workqueue.c:4876: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4874. */ + 4875. rcu_read_lock_sched(); + 4876. > for_each_pwq(pwq, wq) { + 4877. WARN_ON_ONCE(pwq->nr_active < 0); + 4878. if (pwq->nr_active) { + +net/ipv6/addrconf.c:4883: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4881. idx = 0; + 4882. head = &net->dev_index_head[h]; + 4883. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 4884. if (idx < s_idx) + 4885. goto cont; + +kernel/events/core.c:4890: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4888. + 4889. rcu_read_lock(); + 4890. > rb = rcu_dereference(event->rb); + 4891. if (!rb) + 4892. goto unlock; + +kernel/workqueue.c:4915: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4913. list_for_each_entry(wq, &workqueues, list) { + 4914. mutex_lock(&wq->mutex); + 4915. > for_each_pwq(pwq, wq) + 4916. pwq_adjust_max_active(pwq); + 4917. mutex_unlock(&wq->mutex); + +net/core/dev.c:4928: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4926. + 4927. rcu_read_lock(); + 4928. > list_for_each_entry_rcu(ptype, head, list) { + 4929. if (ptype->type != type || !ptype->callbacks.gro_receive) + 4930. continue; + +kernel/events/core.c:4947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 4945. + 4946. rcu_read_lock(); + 4947. > rb = rcu_dereference(event->rb); + 4948. if (!rb) + 4949. goto unlock; + +drivers/gpu/drm/i915/intel_dp.c:4944: error: NULL_DEREFERENCE + pointer `intel_dig_port` last assigned on line 4941 could be null and is dereferenced by call to `intel_dp_mst_encoder_cleanup()` at line 4944, column 2. + 4942. struct intel_dp *intel_dp = &intel_dig_port->dp; + 4943. + 4944. > intel_dp_mst_encoder_cleanup(intel_dig_port); + 4945. if (intel_dp_is_edp(intel_dp)) { + 4946. cancel_delayed_work_sync(&intel_dp->panel_vdd_work); + +drivers/gpu/drm/i915/intel_dp.c:5025: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5025, column 18. + 5023. + 5024. if (!HAS_DDI(dev_priv)) + 5025. > intel_dp->DP = I915_READ(intel_dp->output_reg); + 5026. + 5027. if (lspcon->active) + +drivers/gpu/drm/i915/intel_dp.c:5030: error: NULL_DEREFERENCE + pointer `intel_dp` last assigned on line 5021 could be null and is dereferenced at line 5030, column 2. + 5028. lspcon_resume(lspcon); + 5029. + 5030. > intel_dp->reset_link_params = true; + 5031. + 5032. pps_lock(intel_dp); + +net/core/dev.c:5029: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5027. struct packet_offload *ptype; + 5028. + 5029. > list_for_each_entry_rcu(ptype, offload_head, list) { + 5030. if (ptype->type != type || !ptype->callbacks.gro_receive) + 5031. continue; + +kernel/events/core.c:5033: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5031. + 5032. rcu_read_lock(); + 5033. > rb = rcu_dereference(event->rb); + 5034. if (rb) { + 5035. list_for_each_entry_rcu(event, &rb->event_list, rb_entry) + +kernel/events/core.c:5035: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5033. rb = rcu_dereference(event->rb); + 5034. if (rb) { + 5035. > list_for_each_entry_rcu(event, &rb->event_list, rb_entry) + 5036. wake_up_all(&event->waitq); + 5037. } + +net/core/dev.c:5043: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5041. struct packet_offload *ptype; + 5042. + 5043. > list_for_each_entry_rcu(ptype, offload_head, list) { + 5044. if (ptype->type != type || !ptype->callbacks.gro_complete) + 5045. continue; + +kernel/events/core.c:5046: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5044. + 5045. rcu_read_lock(); + 5046. > rb = rcu_dereference(event->rb); + 5047. if (rb) { + 5048. if (!atomic_inc_not_zero(&rb->refcount)) + +kernel/cgroup/cgroup.c:5097: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5095. + 5096. /* initiate massacre of all css's */ + 5097. > for_each_css(css, ssid, cgrp) + 5098. kill_css(css); + 5099. + +drivers/iommu/intel-iommu.c:5095: error: DEAD_STORE + The value written to &iommu (type intel_iommu*) is never used. + 5093. + 5094. for_each_domain_iommu(iommu_id, dmar_domain) { + 5095. > iommu = g_iommus[iommu_id]; + 5096. + 5097. iommu_flush_iotlb_psi(g_iommus[iommu_id], dmar_domain, + +kernel/events/core.c:5147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5145. again: + 5146. rcu_read_lock(); + 5147. > list_for_each_entry_rcu(event, &rb->event_list, rb_entry) { + 5148. if (!atomic_long_inc_not_zero(&event->refcount)) { + 5149. /* + +drivers/ata/libata-core.c:5126: error: NULL_DEREFERENCE + pointer `qc` last assigned on line 5125 could be null and is dereferenced at line 5126, column 2. + 5124. + 5125. qc = __ata_qc_from_tag(ap, tag); + 5126. > qc->tag = tag; + 5127. qc->scsicmd = NULL; + 5128. qc->ap = ap; + +drivers/net/ethernet/intel/e1000e/ich8lan.c:5141: error: DEAD_STORE + The value written to &ret_val (type int) is never used. + 5139. * stability + 5140. */ + 5141. > ret_val = e1000e_phy_has_link_generic(hw, 1, 0, &link); + 5142. if (!link) + 5143. return 0; + +drivers/iommu/intel-iommu.c:5179: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5177. rcu_read_lock(); + 5178. for_each_rmrr_units(rmrr) { + 5179. > for_each_active_dev_scope(rmrr->devices, rmrr->devices_cnt, + 5180. i, i_dev) { + 5181. if (i_dev != device) + +kernel/events/core.c:5253: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5251. goto aux_unlock; + 5252. + 5253. > aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5254. aux_size = READ_ONCE(rb->user_page->aux_size); + 5255. + +kernel/events/core.c:5254: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5252. + 5253. aux_offset = READ_ONCE(rb->user_page->aux_offset); + 5254. > aux_size = READ_ONCE(rb->user_page->aux_size); + 5255. + 5256. if (aux_offset < perf_data_size(rb) + PAGE_SIZE) + +kernel/cgroup/cgroup.c:5219: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5218 could be null and is dereferenced at line 5219, column 3. + 5217. + 5218. for_each_subsys(ss, i) { + 5219. > WARN(!ss->css_alloc || !ss->css_free || ss->name || ss->id, + 5220. "invalid cgroup_subsys %d:%s css_alloc=%p css_free=%p id:name=%d:%s\n", + 5221. i, cgroup_subsys_name[i], ss->css_alloc, ss->css_free, + +kernel/trace/trace.c:5245: error: DEAD_STORE + The value written to &ret (type int) is never used. + 5243. unsigned long size, int cpu_id) + 5244. { + 5245. > int ret = size; + 5246. + 5247. mutex_lock(&trace_types_lock); + +kernel/sched/core.c:5264: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5262. rcu_read_lock(); + 5263. if (pid_alive(p)) + 5264. > ppid = task_pid_nr(rcu_dereference(p->real_parent)); + 5265. rcu_read_unlock(); + 5266. printk(KERN_CONT "%5lu %5d %6d 0x%08lx\n", free, + +kernel/sched/core.c:5310: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5308. #endif + 5309. rcu_read_lock(); + 5310. > for_each_process_thread(g, p) { + 5311. /* + 5312. * reset the NMI-timeout, listing all files on a slow + +net/core/dev.c:5370: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5368. + 5369. do { + 5370. > val = READ_ONCE(n->state); + 5371. if (unlikely(val & NAPIF_STATE_DISABLE)) + 5372. return false; + +net/core/dev.c:5435: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5433. + 5434. do { + 5435. > val = READ_ONCE(n->state); + 5436. + 5437. WARN_ON_ONCE(!(val & NAPIF_STATE_SCHED)); + +drivers/net/ethernet/broadcom/tg3.c:5440: error: UNINITIALIZED_VALUE + The value read from aninfo.txconfig was never initialized. + 5438. udelay(40); + 5439. + 5440. > *txflags = aninfo.txconfig; + 5441. *rxflags = aninfo.flags; + 5442. + +net/ipv6/addrconf.c:5433: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5431. idx = 0; + 5432. head = &net->dev_index_head[h]; + 5433. > hlist_for_each_entry_rcu(dev, head, index_hlist) { + 5434. if (idx < s_idx) + 5435. goto cont; + +net/core/dev.c:5464: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5462. struct napi_struct *napi; + 5463. + 5464. > hlist_for_each_entry_rcu(napi, &napi_hash[hash], napi_hash_node) + 5465. if (napi->napi_id == napi_id) + 5466. return napi; + +kernel/cgroup/cgroup.c:5495: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5492 could be null and is dereferenced at line 5495, column 7. + 5493. if (j >= i) + 5494. break; + 5495. > if (ss->cancel_fork) + 5496. ss->cancel_fork(child); + 5497. } + +drivers/gpu/drm/i915/intel_dp.c:5500: error: DEAD_STORE + The value written to &encoder (type intel_encoder*) is never used. + 5498. + 5499. dig_port = dp_to_dig_port(intel_dp); + 5500. > encoder = &dig_port->base; + 5501. + 5502. if (!intel_crtc) { + +kernel/sched/core.c:5505: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5503. struct mm_struct *mm = current->active_mm; + 5504. + 5505. > BUG_ON(cpu_online(smp_processor_id())); + 5506. + 5507. if (mm != &init_mm) { + +kernel/sched/core.c:5505: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5503. struct mm_struct *mm = current->active_mm; + 5504. + 5505. > BUG_ON(cpu_online(smp_processor_id())); + 5506. + 5507. if (mm != &init_mm) { + +net/core/dev.c:5528: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5526. local_bh_disable(); + 5527. if (!napi_poll) { + 5528. > unsigned long val = READ_ONCE(napi->state); + 5529. + 5530. /* If multiple threads are competing for this napi, + +kernel/sched/fair.c:5513: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5511. return; + 5512. + 5513. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), 0); + 5514. } + 5515. + +kernel/cgroup/cgroup.c:5515: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5514 could be null and is dereferenced at line 5515, column 7. + 5513. + 5514. for_each_subsys(ss, i) + 5515. > if (ss->cancel_fork) + 5516. ss->cancel_fork(child); + 5517. } + +kernel/sched/fair.c:5539: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5537. void cpu_load_update_nohz_stop(void) + 5538. { + 5539. > unsigned long curr_jiffies = READ_ONCE(jiffies); + 5540. struct rq *this_rq = this_rq(); + 5541. unsigned long load; + +net/ipv6/addrconf.c:5569: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5567. * to do it again + 5568. */ + 5569. > if (!rcu_access_pointer(ifp->rt->rt6i_node)) + 5570. ip6_ins_rt(ifp->rt); + 5571. if (ifp->idev->cnf.forwarding) + +kernel/sched/fair.c:5563: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5561. #ifdef CONFIG_NO_HZ_COMMON + 5562. /* See the mess around cpu_load_update_nohz(). */ + 5563. > this_rq->last_load_update_tick = READ_ONCE(jiffies); + 5564. #endif + 5565. cpu_load_update(this_rq, load, 1); + +kernel/sched/fair.c:5576: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5574. + 5575. if (tick_nohz_tick_stopped()) + 5576. > cpu_load_update_nohz(this_rq, READ_ONCE(jiffies), load); + 5577. else + 5578. cpu_load_update_periodic(this_rq, load); + +kernel/sched/fair.c:5627: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5625. { + 5626. struct rq *rq = cpu_rq(cpu); + 5627. > unsigned long nr_running = READ_ONCE(rq->cfs.h_nr_running); + 5628. unsigned long load_avg = weighted_cpuload(rq); + 5629. + +kernel/events/core.c:5661: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5659. + 5660. if (sample_type & PERF_SAMPLE_CPU) { + 5661. > data->cpu_entry.cpu = raw_smp_processor_id(); + 5662. data->cpu_entry.reserved = 0; + 5663. } + +kernel/events/core.c:5661: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5659. + 5660. if (sample_type & PERF_SAMPLE_CPU) { + 5661. > data->cpu_entry.cpu = raw_smp_processor_id(); + 5662. data->cpu_entry.reserved = 0; + 5663. } + +kernel/cgroup/cgroup.c:5648: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5647 could be null and is dereferenced at line 5648, column 22. + 5646. + 5647. for_each_subsys(ss, i) { + 5648. > if (strcmp(token, ss->name) && + 5649. strcmp(token, ss->legacy_name)) + 5650. continue; + +drivers/usb/core/hub.c:5674: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5659 could be null and is dereferenced at line 5674, column 13. + 5672. } + 5673. + 5674. > port_dev = hub->ports[udev->portnum - 1]; + 5675. + 5676. /* + +kernel/workqueue.c:5678: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5676. + 5677. list_for_each_entry(wq, &workqueues, list) { + 5678. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5679. WARN(init_rescuer(wq), + 5680. "workqueue: failed to create early rescuer for %s", + +kernel/workqueue.c:5678: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5676. + 5677. list_for_each_entry(wq, &workqueues, list) { + 5678. > wq_update_unbound_numa(wq, smp_processor_id(), true); + 5679. WARN(init_rescuer(wq), + 5680. "workqueue: failed to create early rescuer for %s", + +kernel/cgroup/cgroup.c:5687: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5685. * protected for this access. See css_release_work_fn() for details. + 5686. */ + 5687. > cgrp = rcu_dereference(*(void __rcu __force **)&kn->priv); + 5688. if (cgrp) + 5689. css = cgroup_css(cgrp, ss); + +kernel/sched/fair.c:5674: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5672. unsigned int master = current->wakee_flips; + 5673. unsigned int slave = p->wakee_flips; + 5674. > int factor = this_cpu_read(sd_llc_size); + 5675. + 5676. if (master < slave) + +kernel/sched/fair.c:5674: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5672. unsigned int master = current->wakee_flips; + 5673. unsigned int slave = p->wakee_flips; + 5674. > int factor = this_cpu_read(sd_llc_size); + 5675. + 5676. if (master < slave) + +net/wireless/nl80211.c:5711: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5709. * even possible. + 5710. */ + 5711. > if (unlikely(!rcu_access_pointer(cfg80211_regdomain))) + 5712. return -EINPROGRESS; + 5713. + +drivers/md/md.c:5745: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5743. + 5744. rcu_read_lock(); + 5745. > rdev_for_each_rcu(rdev, mddev) { + 5746. if (test_bit(Journal, &rdev->flags) && + 5747. !test_bit(Faulty, &rdev->flags)) + +net/wireless/nl80211.c:5803: error: UNINITIALIZED_VALUE + The value read from cur_params.auto_open_plinks was never initialized. + 5801. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5802. cur_params.element_ttl) || + 5803. > nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5804. cur_params.auto_open_plinks) || + 5805. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + +net/wireless/nl80211.c:5841: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshAwakeWindowDuration was never initialized. + 5839. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5840. cur_params.power_mode) || + 5841. > nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5842. cur_params.dot11MeshAwakeWindowDuration) || + 5843. nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + +net/wireless/nl80211.c:5791: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshConfirmTimeout was never initialized. + 5789. nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5790. cur_params.dot11MeshRetryTimeout) || + 5791. > nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5792. cur_params.dot11MeshConfirmTimeout) || + 5793. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + +net/wireless/nl80211.c:5827: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshForwarding was never initialized. + 5825. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5826. cur_params.dot11MeshGateAnnouncementProtocol) || + 5827. > nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5828. cur_params.dot11MeshForwarding) || + 5829. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + +net/wireless/nl80211.c:5825: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshGateAnnouncementProtocol was never initialized. + 5823. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5824. cur_params.dot11MeshHWMPRannInterval) || + 5825. > nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + 5826. cur_params.dot11MeshGateAnnouncementProtocol) || + 5827. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + +net/wireless/nl80211.c:5823: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRannInterval was never initialized. + 5821. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5822. cur_params.dot11MeshHWMPRootMode) || + 5823. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + 5824. cur_params.dot11MeshHWMPRannInterval) || + 5825. nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, + +net/wireless/nl80211.c:5821: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPRootMode was never initialized. + 5819. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5820. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5821. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + 5822. cur_params.dot11MeshHWMPRootMode) || + 5823. nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, + +net/wireless/nl80211.c:5813: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathTimeout was never initialized. + 5811. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5812. cur_params.min_discovery_timeout) || + 5813. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5814. cur_params.dot11MeshHWMPactivePathTimeout) || + 5815. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + +net/wireless/nl80211.c:5833: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPactivePathToRootTimeout was never initialized. + 5831. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5832. cur_params.ht_opmode) || + 5833. > nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5834. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5835. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + +net/wireless/nl80211.c:5837: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPconfirmationInterval was never initialized. + 5835. nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5836. cur_params.dot11MeshHWMProotInterval) || + 5837. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5838. cur_params.dot11MeshHWMPconfirmationInterval) || + 5839. nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + +net/wireless/nl80211.c:5807: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPmaxPREQretries was never initialized. + 5805. nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5806. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5807. > nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5808. cur_params.dot11MeshHWMPmaxPREQretries) || + 5809. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + +net/wireless/nl80211.c:5819: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPnetDiameterTraversalTime was never initialized. + 5817. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5818. cur_params.dot11MeshHWMPperrMinInterval) || + 5819. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + 5820. cur_params.dot11MeshHWMPnetDiameterTraversalTime) || + 5821. nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, + +net/wireless/nl80211.c:5817: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPperrMinInterval was never initialized. + 5815. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5816. cur_params.dot11MeshHWMPpreqMinInterval) || + 5817. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + 5818. cur_params.dot11MeshHWMPperrMinInterval) || + 5819. nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, + +net/wireless/nl80211.c:5815: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMPpreqMinInterval was never initialized. + 5813. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + 5814. cur_params.dot11MeshHWMPactivePathTimeout) || + 5815. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, + 5816. cur_params.dot11MeshHWMPpreqMinInterval) || + 5817. nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, + +net/wireless/nl80211.c:5835: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHWMProotInterval was never initialized. + 5833. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + 5834. cur_params.dot11MeshHWMPactivePathToRootTimeout) || + 5835. > nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, + 5836. cur_params.dot11MeshHWMProotInterval) || + 5837. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + +net/wireless/nl80211.c:5793: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshHoldingTimeout was never initialized. + 5791. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + 5792. cur_params.dot11MeshConfirmTimeout) || + 5793. > nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5794. cur_params.dot11MeshHoldingTimeout) || + 5795. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + +net/wireless/nl80211.c:5795: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxPeerLinks was never initialized. + 5793. nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, + 5794. cur_params.dot11MeshHoldingTimeout) || + 5795. > nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5796. cur_params.dot11MeshMaxPeerLinks) || + 5797. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + +net/wireless/nl80211.c:5797: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshMaxRetries was never initialized. + 5795. nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, + 5796. cur_params.dot11MeshMaxPeerLinks) || + 5797. > nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5798. cur_params.dot11MeshMaxRetries) || + 5799. nla_put_u8(msg, NL80211_MESHCONF_TTL, + +net/wireless/nl80211.c:5805: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshNbrOffsetMaxNeighbor was never initialized. + 5803. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + 5804. cur_params.auto_open_plinks) || + 5805. > nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, + 5806. cur_params.dot11MeshNbrOffsetMaxNeighbor) || + 5807. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + +net/wireless/nl80211.c:5789: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshRetryTimeout was never initialized. + 5787. goto nla_put_failure; + 5788. if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || + 5789. > nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, + 5790. cur_params.dot11MeshRetryTimeout) || + 5791. nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, + +net/wireless/nl80211.c:5799: error: UNINITIALIZED_VALUE + The value read from cur_params.dot11MeshTTL was never initialized. + 5797. nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, + 5798. cur_params.dot11MeshMaxRetries) || + 5799. > nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5800. cur_params.dot11MeshTTL) || + 5801. nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + +net/wireless/nl80211.c:5801: error: UNINITIALIZED_VALUE + The value read from cur_params.element_ttl was never initialized. + 5799. nla_put_u8(msg, NL80211_MESHCONF_TTL, + 5800. cur_params.dot11MeshTTL) || + 5801. > nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, + 5802. cur_params.element_ttl) || + 5803. nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, + +net/wireless/nl80211.c:5831: error: UNINITIALIZED_VALUE + The value read from cur_params.ht_opmode was never initialized. + 5829. nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5830. cur_params.rssi_threshold) || + 5831. > nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + 5832. cur_params.ht_opmode) || + 5833. nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, + +net/wireless/nl80211.c:5811: error: UNINITIALIZED_VALUE + The value read from cur_params.min_discovery_timeout was never initialized. + 5809. nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5810. cur_params.path_refresh_time) || + 5811. > nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + 5812. cur_params.min_discovery_timeout) || + 5813. nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, + +net/wireless/nl80211.c:5809: error: UNINITIALIZED_VALUE + The value read from cur_params.path_refresh_time was never initialized. + 5807. nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, + 5808. cur_params.dot11MeshHWMPmaxPREQretries) || + 5809. > nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, + 5810. cur_params.path_refresh_time) || + 5811. nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, + +net/wireless/nl80211.c:5843: error: UNINITIALIZED_VALUE + The value read from cur_params.plink_timeout was never initialized. + 5841. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + 5842. cur_params.dot11MeshAwakeWindowDuration) || + 5843. > nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, + 5844. cur_params.plink_timeout)) + 5845. goto nla_put_failure; + +net/wireless/nl80211.c:5839: error: UNINITIALIZED_VALUE + The value read from cur_params.power_mode was never initialized. + 5837. nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, + 5838. cur_params.dot11MeshHWMPconfirmationInterval) || + 5839. > nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, + 5840. cur_params.power_mode) || + 5841. nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, + +net/wireless/nl80211.c:5829: error: UNINITIALIZED_VALUE + The value read from cur_params.rssi_threshold was never initialized. + 5827. nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, + 5828. cur_params.dot11MeshForwarding) || + 5829. > nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, + 5830. cur_params.rssi_threshold) || + 5831. nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, + +kernel/sched/fair.c:5756: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5754. int prev_cpu, int sync) + 5755. { + 5756. > int this_cpu = smp_processor_id(); + 5757. int target = nr_cpumask_bits; + 5758. + +kernel/sched/fair.c:5756: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5754. int prev_cpu, int sync) + 5755. { + 5756. > int this_cpu = smp_processor_id(); + 5757. int target = nr_cpumask_bits; + 5758. + +drivers/usb/core/hub.c:5795: error: NULL_DEREFERENCE + pointer `hub` last assigned on line 5791 could be null and is dereferenced at line 5795, column 9. + 5793. if (port1 < 1 || port1 > hdev->maxchild) + 5794. return NULL; + 5795. > return hub->ports[port1 - 1]->child; + 5796. } + 5797. EXPORT_SYMBOL_GPL(usb_hub_find_child); + +drivers/net/ethernet/broadcom/tg3.c:5990: error: UNINITIALIZED_VALUE + The value read from local_adv was never initialized. + 5988. fiber_setup_done: + 5989. if (current_link_up && current_duplex == DUPLEX_FULL) + 5990. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5991. + 5992. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +drivers/net/ethernet/broadcom/tg3.c:5990: error: UNINITIALIZED_VALUE + The value read from remote_adv was never initialized. + 5988. fiber_setup_done: + 5989. if (current_link_up && current_duplex == DUPLEX_FULL) + 5990. > tg3_setup_flow_control(tp, local_adv, remote_adv); + 5991. + 5992. tp->mac_mode &= ~MAC_MODE_HALF_DUPLEX; + +kernel/sched/core.c:5862: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5860. static int __init migration_init(void) + 5861. { + 5862. > sched_rq_cpu_starting(smp_processor_id()); + 5863. return 0; + 5864. } + +kernel/sched/core.c:5862: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5860. static int __init migration_init(void) + 5861. { + 5862. > sched_rq_cpu_starting(smp_processor_id()); + 5863. return 0; + 5864. } + +kernel/sched/core.c:5918: error: DEAD_STORE + The value written to &ptr (type unsigned long) is never used. + 5916. + 5917. root_task_group.cfs_rq = (struct cfs_rq **)ptr; + 5918. > ptr += nr_cpu_ids * sizeof(void **); + 5919. + 5920. #endif /* CONFIG_FAIR_GROUP_SCHED */ + +kernel/sched/core.c:6049: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6047. * when this runqueue becomes "idle". + 6048. */ + 6049. > init_idle(current, smp_processor_id()); + 6050. + 6051. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:6055: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6053. #ifdef CONFIG_SMP + 6054. idle_thread_set_boot_cpu(); + 6055. > set_cpu_rq_start_time(smp_processor_id()); + 6056. #endif + 6057. init_sched_fair_class(); + +kernel/sched/core.c:6049: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6047. * when this runqueue becomes "idle". + 6048. */ + 6049. > init_idle(current, smp_processor_id()); + 6050. + 6051. calc_load_update = jiffies + LOAD_FREQ; + +kernel/sched/core.c:6055: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6053. #ifdef CONFIG_SMP + 6054. idle_thread_set_boot_cpu(); + 6055. > set_cpu_rq_start_time(smp_processor_id()); + 6056. #endif + 6057. init_sched_fair_class(); + +security/selinux/hooks.c:5908: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5906. + 5907. rcu_read_lock(); + 5908. > __tsec = __task_cred(p)->security; + 5909. + 5910. if (current != p) { + +kernel/cgroup/cgroup.c:5913: error: NULL_DEREFERENCE + pointer `ss` last assigned on line 5912 could be null and is dereferenced at line 5913, column 33. + 5911. + 5912. for_each_subsys(ss, ssid) + 5913. > ret += show_delegatable_files(ss->dfl_cftypes, buf + ret, + 5914. PAGE_SIZE - ret, + 5915. cgroup_subsys_name[ssid]); + +drivers/gpu/drm/i915/intel_pm.c:5976: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 5974. I915_WRITE(MEMMODECTL, rgvmodectl); + 5975. + 5976. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5977. DRM_ERROR("stuck trying to change perf mode\n"); + 5978. mdelay(1); + +drivers/gpu/drm/i915/intel_pm.c:5976: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 5974. I915_WRITE(MEMMODECTL, rgvmodectl); + 5975. + 5976. > if (wait_for_atomic((I915_READ(MEMSWCTL) & MEMCTL_CMD_STS) == 0, 10)) + 5977. DRM_ERROR("stuck trying to change perf mode\n"); + 5978. mdelay(1); + +net/core/dev.c:5947: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5945. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 5946. + 5947. > upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 5948. + 5949. if (&upper->list == &dev->adj_list.upper) + +security/selinux/hooks.c:6040: error: DEAD_STORE + The value written to &error (type int) is never used. + 6038. + 6039. /* Only allow single threaded processes to change context */ + 6040. > error = -EPERM; + 6041. if (!current_is_single_threaded()) { + 6042. error = security_bounded_transition(tsec->sid, sid); + +net/core/dev.c:5965: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 5963. WARN_ON_ONCE(!rcu_read_lock_held() && !lockdep_rtnl_is_held()); + 5964. + 5965. > upper = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 5966. + 5967. if (&upper->list == &dev->adj_list.upper) + +kernel/sched/fair.c:6004: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6002. weight = sd->span_weight; + 6003. sd = NULL; + 6004. > for_each_domain(cpu, tmp) { + 6005. if (weight <= tmp->span_weight) + 6006. break; + +kernel/sched/fair.c:6022: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6020. struct sched_domain_shared *sds; + 6021. + 6022. > sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6023. if (sds) + 6024. WRITE_ONCE(sds->has_idle_cores, val); + +kernel/sched/fair.c:6031: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6029. struct sched_domain_shared *sds; + 6030. + 6031. > sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6032. if (sds) + 6033. return READ_ONCE(sds->has_idle_cores); + +kernel/sched/fair.c:6033: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6031. sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 6032. if (sds) + 6033. > return READ_ONCE(sds->has_idle_cores); + 6034. + 6035. return def; + +net/core/dev.c:6047: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6045. WARN_ON_ONCE(!rcu_read_lock_held()); + 6046. + 6047. > lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 6048. + 6049. if (&lower->list == &dev->adj_list.lower) + +net/core/dev.c:6132: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6130. struct netdev_adjacent *lower; + 6131. + 6132. > lower = list_entry_rcu((*iter)->next, struct netdev_adjacent, list); + 6133. if (&lower->list == &dev->adj_list.lower) + 6134. return NULL; + +kernel/sched/core.c:6148: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6146. + 6147. read_lock(&tasklist_lock); + 6148. > for_each_process_thread(g, p) { + 6149. /* + 6150. * Only normalize user tasks: + +kernel/sched/fair.c:6153: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6151. int cpu, nr = INT_MAX; + 6152. + 6153. > this_sd = rcu_dereference(*this_cpu_ptr(&sd_llc)); + 6154. if (!this_sd) + 6155. return -1; + +net/core/dev.c:6182: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6180. struct netdev_adjacent *lower; + 6181. + 6182. > lower = list_first_or_null_rcu(&dev->adj_list.lower, + 6183. struct netdev_adjacent, list); + 6184. if (lower) + +drivers/md/md.c:6191: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6189. nr = working = insync = failed = spare = 0; + 6190. rcu_read_lock(); + 6191. > rdev_for_each_rcu(rdev, mddev) { + 6192. nr++; + 6193. if (test_bit(Faulty, &rdev->flags)) + +kernel/sched/fair.c:6226: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6224. } + 6225. + 6226. > sd = rcu_dereference(per_cpu(sd_llc, target)); + 6227. if (!sd) + 6228. return target; + +net/core/dev.c:6201: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6199. struct netdev_adjacent *upper; + 6200. + 6201. > upper = list_first_or_null_rcu(&dev->adj_list.upper, + 6202. struct netdev_adjacent, list); + 6203. if (upper && likely(upper->master)) + +kernel/events/core.c:6242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6240. struct perf_event *event; + 6241. + 6242. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 6243. if (!all) { + 6244. if (event->state < PERF_EVENT_STATE_INACTIVE) + +kernel/events/core.c:6259: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6257. struct perf_event *event; + 6258. + 6259. > list_for_each_entry_rcu(event, &pel->list, sb_list) { + 6260. /* + 6261. * Skip events that are not fully formed yet; ensure that + +kernel/events/core.c:6265: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6263. * complete enough. See perf_install_in_context(). + 6264. */ + 6265. > if (!smp_load_acquire(&event->ctx)) + 6266. continue; + 6267. + +net/wireless/nl80211.c:6319: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6317. + 6318. if (!regdom) + 6319. > regdom = rcu_dereference(cfg80211_regdomain); + 6320. + 6321. if (nl80211_put_regdom(regdom, msg)) + +drivers/md/md.c:6284: error: UNINITIALIZED_VALUE + The value read from info.number was never initialized. + 6282. + 6283. rcu_read_lock(); + 6284. > rdev = md_find_rdev_nr_rcu(mddev, info.number); + 6285. if (rdev) { + 6286. info.major = MAJOR(rdev->bdev->bd_dev); + +kernel/events/core.c:6305: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6303. + 6304. for_each_task_context_nr(ctxn) { + 6305. > ctx = rcu_dereference(current->perf_event_ctxp[ctxn]); + 6306. if (ctx) + 6307. perf_iterate_ctx(ctx, output, data, false); + +kernel/sched/core.c:6313: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6311. * to prevent lockdep warnings. + 6312. */ + 6313. > tg = container_of(task_css_check(tsk, cpu_cgrp_id, true), + 6314. struct task_group, css); + 6315. tg = autogroup_task_group(tsk, tg); + +drivers/net/ethernet/intel/e1000e/netdev.c:6420: error: DEAD_STORE + The value written to &retval (type int) is never used. + 6418. lpi_ctrl |= I82579_LPI_CTRL_1000_ENABLE; + 6419. + 6420. > retval = e1e_wphy_locked(hw, I82579_LPI_CTRL, + 6421. lpi_ctrl); + 6422. } + +kernel/sched/fair.c:6354: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6352. + 6353. rcu_read_lock(); + 6354. > for_each_domain(cpu, tmp) { + 6355. if (!(tmp->flags & SD_LOAD_BALANCE)) + 6356. break; + +kernel/sched/fair.c:6342: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6340. { + 6341. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6342. > int cpu = smp_processor_id(); + 6343. int new_cpu = prev_cpu; + 6344. int want_affine = 0; + +kernel/sched/fair.c:6342: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6340. { + 6341. struct sched_domain *tmp, *affine_sd = NULL, *sd = NULL; + 6342. > int cpu = smp_processor_id(); + 6343. int new_cpu = prev_cpu; + 6344. int want_affine = 0; + +kernel/events/core.c:6395: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6393. * its rb pointer. + 6394. */ + 6395. > if (rcu_dereference(parent->rb) == rb) + 6396. ro->err = __perf_event_stop(&sd); + 6397. } + +kernel/sched/core.c:6399: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6397 could be null and is dereferenced by call to `sched_offline_group()` at line 6399, column 2. + 6397. struct task_group *tg = css_tg(css); + 6398. + 6399. > sched_offline_group(tg); + 6400. } + 6401. + +kernel/events/core.c:6425: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6423. restart: + 6424. rcu_read_lock(); + 6425. > list_for_each_entry_rcu(iter, &event->rb->event_list, rb_entry) { + 6426. /* + 6427. * For per-CPU events, we need to make sure that neither they + +kernel/events/core.c:6434: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 6432. cpu = iter->cpu; + 6433. if (cpu == -1) + 6434. > cpu = READ_ONCE(iter->oncpu); + 6435. + 6436. if (cpu == -1) + +kernel/sched/core.c:6485: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6483 could be null and is dereferenced at line 6485, column 15. + 6483. struct task_group *tg = css_tg(css); + 6484. + 6485. > return (u64) scale_load_down(tg->shares); + 6486. } + 6487. + +drivers/net/ethernet/broadcom/tg3.c:6619: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 6617. if (unlikely(netif_tx_queue_stopped(txq) && + 6618. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6619. > __netif_tx_lock(txq, smp_processor_id()); + 6620. if (netif_tx_queue_stopped(txq) && + 6621. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +drivers/net/ethernet/broadcom/tg3.c:6619: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 6617. if (unlikely(netif_tx_queue_stopped(txq) && + 6618. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi)))) { + 6619. > __netif_tx_lock(txq, smp_processor_id()); + 6620. if (netif_tx_queue_stopped(txq) && + 6621. (tg3_tx_avail(tnapi) > TG3_TX_WAKEUP_THRESH(tnapi))) + +kernel/sched/core.c:6831: error: NULL_DEREFERENCE + pointer `tg` last assigned on line 6830 could be null and is dereferenced at line 6831, column 15. + 6829. { + 6830. struct task_group *tg = css_tg(css); + 6831. > u64 weight = scale_load_down(tg->shares); + 6832. + 6833. return DIV_ROUND_CLOSEST_ULL(weight * CGROUP_WEIGHT_DFL, 1024); + +kernel/events/core.c:7058: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7056. rcu_read_lock(); + 7057. for_each_task_context_nr(ctxn) { + 7058. > ctx = rcu_dereference(current->perf_event_ctxp[ctxn]); + 7059. if (!ctx) + 7060. continue; + +kernel/events/core.c:7343: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7341. u64 seq; + 7342. + 7343. > seq = __this_cpu_read(perf_throttled_seq); + 7344. if (seq != hwc->interrupts_seq) { + 7345. hwc->interrupts_seq = seq; + +kernel/events/core.c:7352: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7350. && hwc->interrupts >= max_samples_per_tick)) { + 7351. __this_cpu_inc(perf_throttled_count); + 7352. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7353. hwc->interrupts = MAX_INTERRUPTS; + 7354. perf_log_throttle(event, 0); + +kernel/events/core.c:7343: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7341. u64 seq; + 7342. + 7343. > seq = __this_cpu_read(perf_throttled_seq); + 7344. if (seq != hwc->interrupts_seq) { + 7345. hwc->interrupts_seq = seq; + +kernel/events/core.c:7352: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7350. && hwc->interrupts >= max_samples_per_tick)) { + 7351. __this_cpu_inc(perf_throttled_count); + 7352. > tick_dep_set_cpu(smp_processor_id(), TICK_DEP_BIT_PERF_EVENTS); + 7353. hwc->interrupts = MAX_INTERRUPTS; + 7354. perf_log_throttle(event, 0); + +drivers/gpu/drm/i915/intel_display.c:7480: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7478. + 7479. if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) { + 7480. > offset = I915_READ(DSPOFFSET(i9xx_plane)); + 7481. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + +drivers/gpu/drm/i915/intel_display.c:7484: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7482. } else if (INTEL_GEN(dev_priv) >= 4) { + 7483. if (plane_config->tiling) + 7484. > offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. offset = I915_READ(DSPLINOFF(i9xx_plane)); + +drivers/gpu/drm/i915/intel_display.c:7486: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 7484. offset = I915_READ(DSPTILEOFF(i9xx_plane)); + 7485. else + 7486. > offset = I915_READ(DSPLINOFF(i9xx_plane)); + 7487. base = I915_READ(DSPSURF(i9xx_plane)) & 0xfffff000; + 7488. } else { + +net/wireless/nl80211.c:7487: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced at line 7487, column 11. + 7485. */ + 7486. if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) { + 7487. > while (!sched_scan_req->reqid) + 7488. sched_scan_req->reqid = rdev->wiphy.cookie_counter++; + 7489. } + +net/wireless/nl80211.c:7491: error: NULL_DEREFERENCE + pointer `sched_scan_req` last assigned on line 7475 could be null and is dereferenced by call to `rdev_sched_scan_start()` at line 7491, column 8. + 7489. } + 7490. + 7491. > err = rdev_sched_scan_start(rdev, dev, sched_scan_req); + 7492. if (err) + 7493. goto out_free; + +net/wireless/nl80211.c:7527: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7525. } + 7526. + 7527. > req = list_first_or_null_rcu(&rdev->sched_scan_req_list, + 7528. struct cfg80211_sched_scan_request, + 7529. list); + +kernel/sched/fair.c:7577: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7575. * we read them once before doing sanity checks on them. + 7576. */ + 7577. > age_stamp = READ_ONCE(rq->age_stamp); + 7578. avg = READ_ONCE(rq->rt_avg); + 7579. delta = __rq_clock_broken(rq) - age_stamp; + +kernel/sched/fair.c:7578: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7576. */ + 7577. age_stamp = READ_ONCE(rq->age_stamp); + 7578. > avg = READ_ONCE(rq->rt_avg); + 7579. delta = __rq_clock_broken(rq) - age_stamp; + 7580. + +kernel/events/core.c:7583: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7581. struct swevent_hlist *hlist; + 7582. + 7583. > hlist = rcu_dereference(swhash->swevent_hlist); + 7584. if (!hlist) + 7585. return NULL; + +kernel/events/core.c:7625: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7623. goto end; + 7624. + 7625. > hlist_for_each_entry_rcu(event, head, hlist_entry) { + 7626. if (perf_swevent_match(event, type, event_id, data, regs)) + 7627. perf_swevent_event(event, nr, data, regs); + +drivers/md/md.c:7750: error: DEAD_STORE + The value written to &l (type long long) is never used. + 7748. } + 7749. spin_unlock(&all_mddevs_lock); + 7750. > if (!l--) + 7751. return (void*)2;/* tail */ + 7752. return NULL; + +net/wireless/nl80211.c:7799: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7797. rcu_read_lock(); + 7798. /* indicate whether we have probe response data or not */ + 7799. > if (rcu_access_pointer(res->proberesp_ies) && + 7800. nla_put_flag(msg, NL80211_BSS_PRESP_DATA)) + 7801. goto fail_unlock_rcu; + +net/wireless/nl80211.c:7806: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7804. * but is always valid + 7805. */ + 7806. > ies = rcu_dereference(res->ies); + 7807. if (ies) { + 7808. if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf, + +net/wireless/nl80211.c:7817: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7815. + 7816. /* and this pointer is always (unless driver didn't know) beacon data */ + 7817. > ies = rcu_dereference(res->beacon_ies); + 7818. if (ies && ies->from_beacon) { + 7819. if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf, + +drivers/md/md.c:7828: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7826. sectors = 0; + 7827. rcu_read_lock(); + 7828. > rdev_for_each_rcu(rdev, mddev) { + 7829. char b[BDEVNAME_SIZE]; + 7830. seq_printf(seq, " %s[%d]", + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7835: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7833. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7834. + 7835. > if (wait_for_us(I915_READ(SOUTH_CHICKEN2) & + 7836. FDI_MPHY_IOSFSB_RESET_STATUS, 100)) + 7837. DRM_ERROR("FDI mPHY reset assert timeout\n"); + +drivers/gpu/drm/i915/intel_display.c:7843: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 7841. I915_WRITE(SOUTH_CHICKEN2, tmp); + 7842. + 7843. > if (wait_for_us((I915_READ(SOUTH_CHICKEN2) & + 7844. FDI_MPHY_IOSFSB_RESET_STATUS) == 0, 100)) + 7845. DRM_ERROR("FDI mPHY reset de-assert timeout\n"); + +drivers/net/ethernet/broadcom/tg3.c:8153: error: DEAD_STORE + The value written to &i (type int) is never used. + 8151. + 8152. dma_error: + 8153. > tg3_tx_skb_unmap(tnapi, tnapi->tx_prod, --i); + 8154. tnapi->tx_buffers[tnapi->tx_prod].skb = NULL; + 8155. drop: + +kernel/events/core.c:7940: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7938. perf_trace_buf_update(record, event_type); + 7939. + 7940. > hlist_for_each_entry_rcu(event, head, hlist_entry) { + 7941. if (perf_tp_event_match(event, &data, regs)) + 7942. perf_swevent_event(event, count, &data, regs); + +kernel/events/core.c:7954: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7952. + 7953. rcu_read_lock(); + 7954. > ctx = rcu_dereference(task->perf_event_ctxp[perf_sw_context]); + 7955. if (!ctx) + 7956. goto unlock; + +kernel/events/core.c:7958: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 7956. goto unlock; + 7957. + 7958. > list_for_each_entry_rcu(event, &ctx->event_list, event_entry) { + 7959. if (event->attr.type != PERF_TYPE_TRACEPOINT) + 7960. continue; + +drivers/md/md.c:8015: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8013. idle = 1; + 8014. rcu_read_lock(); + 8015. > rdev_for_each_rcu(rdev, mddev) { + 8016. struct gendisk *disk = rdev->bdev->bd_contains->bd_disk; + 8017. curr_events = (int)part_stat_read(&disk->part0, sectors[0]) + + +net/core/dev.c:8154: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8152. BUG_ON(!list_empty(&dev->ptype_all)); + 8153. BUG_ON(!list_empty(&dev->ptype_specific)); + 8154. > WARN_ON(rcu_access_pointer(dev->ip_ptr)); + 8155. WARN_ON(rcu_access_pointer(dev->ip6_ptr)); + 8156. WARN_ON(dev->dn_ptr); + +net/core/dev.c:8155: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8153. BUG_ON(!list_empty(&dev->ptype_specific)); + 8154. WARN_ON(rcu_access_pointer(dev->ip_ptr)); + 8155. > WARN_ON(rcu_access_pointer(dev->ip6_ptr)); + 8156. WARN_ON(dev->dn_ptr); + 8157. + +kernel/trace/trace.c:8197: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8195. break; + 8196. case DUMP_ORIG: + 8197. > iter.cpu_file = raw_smp_processor_id(); + 8198. break; + 8199. case DUMP_NONE: + +kernel/trace/trace.c:8197: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8195. break; + 8196. case DUMP_ORIG: + 8197. > iter.cpu_file = raw_smp_processor_id(); + 8198. break; + 8199. case DUMP_NONE: + +kernel/events/core.c:8275: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8273. { + 8274. struct perf_addr_filters_head *ifh = perf_event_addr_filters(event); + 8275. > struct task_struct *task = READ_ONCE(event->ctx->task); + 8276. struct perf_addr_filter *filter; + 8277. struct mm_struct *mm = NULL; + +drivers/gpu/drm/i915/intel_display.c:8540: error: DEAD_STORE + The value written to &offset (type unsigned int) is never used. + 8538. plane_config->base = base; + 8539. + 8540. > offset = I915_READ(PLANE_OFFSET(pipe, plane_id)); + 8541. + 8542. val = I915_READ(PLANE_SIZE(pipe, plane_id)); + +net/core/dev.c:8562: error: DEAD_STORE + The value written to &err (type int) is never used. + 8560. + 8561. /* And unlink it from device chain */ + 8562. > err = -ENODEV; + 8563. unlist_netdevice(dev); + 8564. + +net/core/dev.c:8640: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8638. + 8639. local_irq_disable(); + 8640. > cpu = smp_processor_id(); + 8641. sd = &per_cpu(softnet_data, cpu); + 8642. oldsd = &per_cpu(softnet_data, oldcpu); + +net/core/dev.c:8640: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8638. + 8639. local_irq_disable(); + 8640. > cpu = smp_processor_id(); + 8641. sd = &per_cpu(softnet_data, cpu); + 8642. oldsd = &per_cpu(softnet_data, oldcpu); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8765: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8763. I915_WRITE(LCPLL_CTL, val); + 8764. + 8765. > if (wait_for_us(I915_READ(LCPLL_CTL) & + 8766. LCPLL_CD_SOURCE_FCLK_DONE, 1)) + 8767. DRM_ERROR("Switching to FCLK failed\n"); + +kernel/sched/fair.c:8810: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8808. !this_rq->rd->overload) { + 8809. rcu_read_lock(); + 8810. > sd = rcu_dereference_check_sched_domain(this_rq->sd); + 8811. if (sd) + 8812. update_next_balance(sd, &next_balance); + +kernel/sched/fair.c:8822: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8820. update_blocked_averages(this_cpu); + 8821. rcu_read_lock(); + 8822. > for_each_domain(this_cpu, sd) { + 8823. int continue_balancing = 1; + 8824. u64 t0, domain_cost; + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +drivers/gpu/drm/i915/intel_display.c:8841: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 8839. I915_WRITE(LCPLL_CTL, val); + 8840. + 8841. > if (wait_for_us((I915_READ(LCPLL_CTL) & + 8842. LCPLL_CD_SOURCE_FCLK_DONE) == 0, 1)) + 8843. DRM_ERROR("Switching back to LCPLL failed\n"); + +kernel/events/core.c:8886: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8884. static int perf_pmu_commit_txn(struct pmu *pmu) + 8885. { + 8886. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8887. + 8888. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8886: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8884. static int perf_pmu_commit_txn(struct pmu *pmu) + 8885. { + 8886. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8887. + 8888. __this_cpu_write(nop_txn_flags, 0); + +kernel/sched/fair.c:8932: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8930. /* Search for an sd spanning us and the target CPU. */ + 8931. rcu_read_lock(); + 8932. > for_each_domain(target_cpu, sd) { + 8933. if ((sd->flags & SD_LOAD_BALANCE) && + 8934. cpumask_test_cpu(busiest_cpu, sched_domain_span(sd))) + +kernel/sched/fair.c:8915: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8913. + 8914. /* make sure the requested cpu hasn't gone down in the meantime */ + 8915. > if (unlikely(busiest_cpu != smp_processor_id() || + 8916. !busiest_rq->active_balance)) + 8917. goto out_unlock; + +kernel/events/core.c:8899: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 8897. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8898. { + 8899. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8900. + 8901. __this_cpu_write(nop_txn_flags, 0); + +kernel/events/core.c:8899: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 8897. static void perf_pmu_cancel_txn(struct pmu *pmu) + 8898. { + 8899. > unsigned int flags = __this_cpu_read(nop_txn_flags); + 8900. + 8901. __this_cpu_write(nop_txn_flags, 0); + +kernel/sched/fair.c:8982: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 8980. static inline int on_null_domain(struct rq *rq) + 8981. { + 8982. > return unlikely(!rcu_dereference_sched(rq->sd)); + 8983. } + 8984. + +drivers/md/md.c:9014: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9012. "unacknowledged_bad_blocks"); + 9013. sysfs_notify_dirent_safe(rdev->sysfs_state); + 9014. > set_mask_bits(&mddev->sb_flags, 0, + 9015. BIT(MD_SB_CHANGE_CLEAN) | BIT(MD_SB_CHANGE_PENDING)); + 9016. md_wakeup_thread(rdev->mddev->thread); + +kernel/sched/fair.c:9056: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9054. + 9055. rcu_read_lock(); + 9056. > sd = rcu_dereference(per_cpu(sd_llc, cpu)); + 9057. + 9058. if (!sd || !sd->nohz_idle) + +kernel/sched/fair.c:9053: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9051. { + 9052. struct sched_domain *sd; + 9053. > int cpu = smp_processor_id(); + 9054. + 9055. rcu_read_lock(); + +kernel/sched/fair.c:9053: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9051. { + 9052. struct sched_domain *sd; + 9053. > int cpu = smp_processor_id(); + 9054. + 9055. rcu_read_lock(); + +kernel/sched/fair.c:9073: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9071. + 9072. rcu_read_lock(); + 9073. > sd = rcu_dereference(per_cpu(sd_llc, cpu)); + 9074. + 9075. if (!sd || sd->nohz_idle) + +kernel/sched/fair.c:9070: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9068. { + 9069. struct sched_domain *sd; + 9070. > int cpu = smp_processor_id(); + 9071. + 9072. rcu_read_lock(); + +kernel/sched/fair.c:9070: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9068. { + 9069. struct sched_domain *sd; + 9070. > int cpu = smp_processor_id(); + 9071. + 9072. rcu_read_lock(); + +drivers/md/md.c:9161: error: DEAD_STORE + The value written to &ret (type int) is never used. + 9159. if (rdev2->raid_disk == -1 && role != 0xffff) { + 9160. rdev2->saved_raid_disk = role; + 9161. > ret = remove_and_add_spares(mddev, rdev2); + 9162. pr_info("Activated spare: %s\n", + 9163. bdevname(rdev2->bdev,b)); + +kernel/sched/fair.c:9147: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9145. + 9146. rcu_read_lock(); + 9147. > for_each_domain(cpu, sd) { + 9148. /* + 9149. * Decay the newidle max times here because this is a regular + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9266: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 9264. WARN_ON_ONCE(timeout_base_ms > 3); + 9265. preempt_disable(); + 9266. > ret = wait_for_atomic(COND, 50); + 9267. preempt_enable(); + 9268. + +drivers/gpu/drm/i915/intel_pm.c:9249: error: UNINITIALIZED_VALUE + The value read from ret__ was never initialized. + 9247. goto out; + 9248. } + 9249. > ret = _wait_for(COND, timeout_base_ms * 1000, 10, 10); + 9250. if (!ret) + 9251. goto out; + +drivers/md/md.c:9242: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9240. + 9241. /* Find the rdev */ + 9242. > rdev_for_each_rcu(rdev, mddev) { + 9243. if (rdev->desc_nr == nr) + 9244. break; + +drivers/md/md.c:9259: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9257. + 9258. /* Read all rdev's to update recovery_offset */ + 9259. > rdev_for_each_rcu(rdev, mddev) + 9260. read_rdev(mddev, rdev); + 9261. } + +drivers/gpu/drm/i915/intel_display.c:9260: error: NULL_DEREFERENCE + pointer `obj` last assigned on line 9256 could be null and is dereferenced at line 9260, column 10. + 9258. + 9259. if (INTEL_INFO(dev_priv)->cursor_needs_physical) + 9260. > base = obj->phys_handle->busaddr; + 9261. else + 9262. base = intel_plane_ggtt_offset(plane_state); + +kernel/events/core.c:9290: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9288. } + 9289. + 9290. > list_for_each_entry_rcu(pmu, &pmus, entry) { + 9291. ret = perf_try_init_event(pmu, event); + 9292. if (!ret) + +kernel/sched/fair.c:9342: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9340. + 9341. rcu_read_lock(); + 9342. > sds = rcu_dereference(per_cpu(sd_llc_shared, cpu)); + 9343. if (sds) { + 9344. /* + +kernel/sched/fair.c:9356: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9354. } + 9355. + 9356. > sd = rcu_dereference(rq->sd); + 9357. if (sd) { + 9358. if ((rq->cfs.h_nr_running >= 1) && + +kernel/sched/fair.c:9365: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9363. } + 9364. + 9365. > sd = rcu_dereference(per_cpu(sd_asym, cpu)); + 9366. if (sd) { + 9367. for_each_cpu(i, sched_domain_span(sd)) { + +drivers/gpu/drm/i915/intel_pm.c:9381: error: DEAD_STORE + The value written to &loop (type int) is never used. + 9379. _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH)); + 9380. upper = I915_READ_FW(reg); + 9381. > } while (upper != tmp && --loop); + 9382. + 9383. /* Everywhere else we always use VLV_COUNTER_CONTROL with the + +kernel/events/core.c:9869: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 9867. again: + 9868. rcu_read_lock(); + 9869. > gctx = READ_ONCE(group_leader->ctx); + 9870. if (!atomic_inc_not_zero(&gctx->refcount)) { + 9871. rcu_read_unlock(); + +drivers/net/ethernet/broadcom/tg3.c:10778: error: DEAD_STORE + The value written to &off (type unsigned int) is never used. + 10776. + 10777. tg3_ape_scratchpad_read(tp, (u32 *) ocir, off, len); + 10778. > off += len; + 10779. + 10780. if (ocir->signature != TG3_OCIR_SIG_MAGIC || + +kernel/events/core.c:11198: error: UNINITIALIZED_VALUE + The value read from pfo_ret__ was never initialized. + 11196. perf_pmu_register(&perf_task_clock, NULL, -1); + 11197. perf_tp_register(); + 11198. > perf_event_init_cpu(smp_processor_id()); + 11199. register_reboot_notifier(&perf_reboot_notifier); + 11200. + +kernel/events/core.c:11198: error: UNINITIALIZED_VALUE + The value read from pscr_ret__ was never initialized. + 11196. perf_pmu_register(&perf_task_clock, NULL, -1); + 11197. perf_tp_register(); + 11198. > perf_event_init_cpu(smp_processor_id()); + 11199. register_reboot_notifier(&perf_reboot_notifier); + 11200. + +drivers/net/ethernet/broadcom/tg3.c:12197: error: NULL_DEREFERENCE + pointer `phydev` last assigned on line 12196 could be null and is dereferenced by call to `phy_ethtool_ksettings_set()` at line 12197, column 10. + 12195. return -EAGAIN; + 12196. phydev = mdiobus_get_phy(tp->mdio_bus, tp->phy_addr); + 12197. > return phy_ethtool_ksettings_set(phydev, cmd); + 12198. } + 12199. + +drivers/gpu/drm/i915/intel_display.c:12320: error: UNINITIALIZED_VALUE + The value read from put_domains[_] was never initialized. + 12318. + 12319. if (put_domains[i]) + 12320. > modeset_put_power_domains(dev_priv, put_domains[i]); + 12321. + 12322. intel_modeset_verify_crtc(crtc, state, old_crtc_state, new_crtc_state); + +drivers/net/ethernet/broadcom/tg3.c:12980: error: UNINITIALIZED_VALUE + The value read from data[_] was never initialized. + 12978. err = -EIO; + 12979. for (i = 0; i < NVRAM_SELFBOOT_DATA_SIZE; i++) { + 12980. > u8 hw8 = hweight8(data[i]); + 12981. + 12982. if ((hw8 & 0x1) && parity[i]) + +net/wireless/nl80211.c:14334: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 14332. struct sk_buff *msg; + 14333. void *hdr; + 14334. > u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid); + 14335. + 14336. if (!nlportid) + +drivers/gpu/drm/i915/intel_display.c:15182: error: UNINITIALIZED_VALUE + The value read from ret was never initialized. + 15180. + 15181. if (ret) + 15182. > DRM_ERROR("Restoring old state failed with %i\n", ret); + 15183. if (state) + 15184. drm_atomic_state_put(state); + +net/wireless/nl80211.c:15210: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15208. rcu_read_lock(); + 15209. + 15210. > list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) { + 15211. struct cfg80211_sched_scan_request *sched_scan_req; + 15212. + +net/wireless/nl80211.c:15213: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15211. struct cfg80211_sched_scan_request *sched_scan_req; + 15212. + 15213. > list_for_each_entry_rcu(sched_scan_req, + 15214. &rdev->sched_scan_req_list, + 15215. list) { + +net/wireless/nl80211.c:15222: error: UNINITIALIZED_VALUE + The value read from __u.__val was never initialized. + 15220. } + 15221. + 15222. > list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) { + 15223. cfg80211_mlme_unregister_socket(wdev, notify->portid); + 15224. + +Summary of the reports + + UNINITIALIZED_VALUE: 4669 + DEAD_STORE: 733 + NULL_DEREFERENCE: 211 + MEMORY_LEAK: 16 + RESOURCE_LEAK: 9 \ No newline at end of file diff --git a/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/Makefile b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/Makefile new file mode 100644 index 0000000..554bbd3 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/Makefile @@ -0,0 +1,5 @@ +all: + clang main.c lib.h macros.h str.h +clean: + rm a.out lib.h.gch macros.h.gch str.h.gch + rm -r infer-out diff --git a/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/lib.h b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/lib.h new file mode 100644 index 0000000..da841fc --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/lib.h @@ -0,0 +1,23 @@ +#include +#include +#include +#include "macros.h" +#include "str.h" + + + +int dummy_func() { + unsigned long var = 5; + srand(time(NULL)); + d_struct rnd; + rnd.val = (unsigned int) rand(); + if(rnd.val < 10) { + return 2; + } + if(time_before(var, rnd.val)) { + return 0; + } else { + return 1; + } + +} diff --git a/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/macros.h b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/macros.h new file mode 100644 index 0000000..936b75f --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/macros.h @@ -0,0 +1,11 @@ +#define typecheck(type,x) \ +({ type __dummy; \ + typeof(x) __dummy2; \ + (void)(&__dummy == &__dummy2); \ + 1; \ +}) +#define time_after(a,b) \ + (typecheck(unsigned long, a) && \ + typecheck(unsigned long, b) && \ + ((long)((b) - (a)) < 0)) +#define time_before(a,b) time_after(b,a) diff --git a/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/main.c b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/main.c new file mode 100644 index 0000000..2f63459 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/main.c @@ -0,0 +1,7 @@ +#include "lib.h" +#include + +int main(void) { + printf("%d \n", dummy_func()); + return 0; +} \ No newline at end of file diff --git a/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/str.h b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/str.h new file mode 100644 index 0000000..a910e66 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-false-positive-dead-store-with-macro/str.h @@ -0,0 +1,3 @@ +typedef struct { + unsigned int val; +} d_struct; diff --git a/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/Makefile b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/Makefile new file mode 100644 index 0000000..554bbd3 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/Makefile @@ -0,0 +1,5 @@ +all: + clang main.c lib.h macros.h str.h +clean: + rm a.out lib.h.gch macros.h.gch str.h.gch + rm -r infer-out diff --git a/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/lib.h b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/lib.h new file mode 100644 index 0000000..98e13a1 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/lib.h @@ -0,0 +1,24 @@ +#include +#include +#include +#include "macros.h" +#include "str.h" + + + +int dummy_func() { + unsigned long var = 5; + srand(time(NULL)); + d_struct rnd; + rnd.val = (unsigned long) rand(); + if(rnd.val < 10) { + return 2; + } + + if(time_before(var, rnd.val)) { + return 0; + } else { + return 1; + } + +} diff --git a/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/macros.h b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/macros.h new file mode 100644 index 0000000..d90dd3f --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/macros.h @@ -0,0 +1,3 @@ +#define time_after(a,b) \ + (((long)((b) - (a)) < 0)) +#define time_before(a,b) time_after(b,a) diff --git a/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/main.c b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/main.c new file mode 100644 index 0000000..2f63459 --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/main.c @@ -0,0 +1,7 @@ +#include "lib.h" +#include + +int main(void) { + printf("%d \n", dummy_func()); + return 0; +} \ No newline at end of file diff --git a/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/str.h b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/str.h new file mode 100644 index 0000000..9b705aa --- /dev/null +++ b/infer/MockCodes/infer-dead-store-macro/infer-no-dead-store-without-macro/str.h @@ -0,0 +1,3 @@ +typedef struct { + unsigned long val; +} d_struct; \ No newline at end of file diff --git a/infer/MockCodes/infer-uninitialized-with-loop/README.md b/infer/MockCodes/infer-uninitialized-with-loop/README.md new file mode 100644 index 0000000..8410949 --- /dev/null +++ b/infer/MockCodes/infer-uninitialized-with-loop/README.md @@ -0,0 +1,73 @@ +## Infer UNINITIALIZED_VALUE false-posive problem ## +**Infer Version:** : Infer version v0.14.0 +**Kernel-Version:** : Linux-4.16 +**Original Warning:** : [drivers/usb/core/hub.c](https://github.com/OzanAlpay/linux-kernel-analysis/blob/clang-warning-reports/reports/v416/infer-014/drivers:usb:core:hub:c:uninitializedvalue:0004.md) +### Testing ### +**Case 1:** +``` +cd infer-uninit-false-positive-with-loop +infer capture -- make +infer analyze +``` +**Output:** +``` +lib.h:21: error: UNINITIALIZED_VALUE + The value read from dummy was never initialized. + 19. ret_func(&dummy); + 20. } + 21. > return dummy; + 22. } + 23. +``` +**Expected Output:** +``` +No issues found. +``` +**Case 2:** +``` +cd infer-no-false-positive-without-loop +infer capture -- make +infer analyze +``` +**Output:** +``` +No issues found +``` +**Expected Output:** +``` +No issues found +``` + +**Summary:** +Only difference between this two examples is: +In [infer-uinit-false-positive-with-loop/lib.h](https://github.com/OzanAlpay/linux-kernel-analysis/blob/infer-documentation/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/lib.h), we call ret_func and assign a value to dummy inside a loop +```C +int first_func(int value) { + int i; + int dummy; + for(i=0; ;i++) { + ret_func(&dummy); + if(i == 5) break; + /* with this break I tried to imitate: + if (total_time >= HUB_DEBOUNCE_TIMEOUT) + break; + */ + } + return dummy; +} +``` +However [infer-no-false-positive-without-loop/lib.h](https://github.com/OzanAlpay/linux-kernel-analysis/blob/infer-documentation/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/lib.h), we call ret_func and then assign a value to dummy without using a loop +```C +int first_func(int value) { + + int i; + int dummy; + ret_func(&dummy); + printf("Dummy is = %d \n", dummy); + return dummy; +} +``` +These two files infer output should be equal to ```No issues found```. Because in both cases, we assign a value to ```int dummy``` + + + diff --git a/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/Makefile b/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/Makefile new file mode 100644 index 0000000..f25ba69 --- /dev/null +++ b/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/Makefile @@ -0,0 +1,4 @@ +all: + clang main.c lib.h +clean: + rm a.out diff --git a/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/lib.h b/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/lib.h new file mode 100644 index 0000000..b49c8ec --- /dev/null +++ b/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/lib.h @@ -0,0 +1,22 @@ +#include + + + +int assign_func(int* dummy) { + *dummy = 10; + return 1; +} + +void ret_func(int* dummy) { + assign_func(dummy); +} + +int first_func(int value) { + + int i; + int dummy; + ret_func(&dummy); + printf("Dummy is = %d \n", dummy); + return dummy; +} + diff --git a/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/main.c b/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/main.c new file mode 100644 index 0000000..c7cf471 --- /dev/null +++ b/infer/MockCodes/infer-uninitialized-with-loop/infer-no-false-positive-without-loop/main.c @@ -0,0 +1,9 @@ +#include "lib.h" + +int main(void) { + + first_func(5); + + return 0; +} + diff --git a/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/Makefile b/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/Makefile new file mode 100644 index 0000000..f25ba69 --- /dev/null +++ b/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/Makefile @@ -0,0 +1,4 @@ +all: + clang main.c lib.h +clean: + rm a.out diff --git a/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/lib.h b/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/lib.h new file mode 100644 index 0000000..e358965 --- /dev/null +++ b/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/lib.h @@ -0,0 +1,28 @@ +#include + + + +int assign_func(int* dummy) { + *dummy = 10; + return 1; +} + +int ret_func(int* dummy) { + return assign_func(dummy); +} + +int first_func(int value) { + + int i; + int dummy; + for(i=0; ;i++) { + ret_func(&dummy); + if(i == 5) break; + /* with this break I tried to imitate: + if (total_time >= HUB_DEBOUNCE_TIMEOUT) + break; + */ + } + return dummy; +} + diff --git a/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/main.c b/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/main.c new file mode 100644 index 0000000..b6b34e4 --- /dev/null +++ b/infer/MockCodes/infer-uninitialized-with-loop/infer-uninit-false-positive-with-loop/main.c @@ -0,0 +1,8 @@ +#include "lib.h" + +int main(void) { + + first_func(5); + return 0; +} +