| # SPDX-License-Identifier: GPL-2.0 | |
| # Copyright (c) 2026: Mauro Carvalho Chehab <mchehab@kernel.org> | |
| # Test cases for the dynamic tests. | |
| # Useful to test if kernel-doc classes are doing what it is expected. | |
| # | |
| tests: | |
| - name: func1 | |
| fname: mock_functions.c | |
| description: "Simplest function test: do nothing, just rst output" | |
| source: | | |
| /** | |
| * func1 - Not exported function | |
| * @arg1: @arg1 does nothing | |
| * | |
| * Does nothing | |
| * | |
| * return: | |
| * always return 0. | |
| */ | |
| int func1(char *arg1) { return 0; }; | |
| expected: | |
| - rst: | | |
| .. c:function:: int func1 (char *arg1) | |
| Not exported function | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``char *arg1`` | |
| **arg1** does nothing | |
| **Description** | |
| Does nothing | |
| **Return** | |
| always return 0. | |
| # TODO: how to handle timestamps at .TH? | |
| man: | | |
| .TH "func1" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| func1 \- Not exported function | |
| .SH SYNOPSIS | |
| .B "int" func1 | |
| .BI "(char *arg1 " ");" | |
| .SH ARGUMENTS | |
| .IP "arg1" 12 | |
| \fIarg1\fP does nothing | |
| .SH "DESCRIPTION" | |
| Does nothing | |
| .SH "RETURN" | |
| always return 0. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_functions.c\fR | |
| - name: func2 | |
| fname: func2.c | |
| description: Simple test with exports | |
| source: | | |
| /** | |
| * func2() - Exported function | |
| * @arg1: @arg1 does nothing | |
| * | |
| * Does nothing | |
| * | |
| * return: | |
| * always return 0. | |
| */ | |
| int func2(char *arg1) { return 0; }; | |
| EXPORT_SYMBOL(func2); | |
| exports: func2 | |
| expected: | |
| - kdoc_item: | |
| name: func2 | |
| type: function | |
| declaration_start_line: 1 | |
| sections: | |
| Description: | | |
| Does nothing | |
| Return: | | |
| always return 0. | |
| sections_start_lines: | |
| Description: 3 | |
| Return: 6 | |
| parameterdescs: | |
| arg1: | | |
| @arg1 does nothing | |
| parameterlist: | |
| - arg1 | |
| parameterdesc_start_lines: | |
| arg1: 2 | |
| parametertypes: | |
| arg1: char *arg1 | |
| other_stuff: | |
| func_macro: false | |
| functiontype: int | |
| purpose: "Exported function" | |
| typedef: false | |
| rst: | | |
| .. c:function:: int func2 (char *arg1) | |
| Exported function | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``char *arg1`` | |
| **arg1** does nothing | |
| **Description** | |
| Does nothing | |
| **Return** | |
| always return 0. | |
| man: | | |
| .TH "func2" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| func2 \- Exported function | |
| .SH SYNOPSIS | |
| .B "int" func2 | |
| .BI "(char *arg1 " ");" | |
| .SH ARGUMENTS | |
| .IP "arg1" 12 | |
| \fIarg1\fP does nothing | |
| .SH "DESCRIPTION" | |
| Does nothing | |
| .SH "RETURN" | |
| always return 0. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBfunc2.c\fR | |
| - name: doc_with_complex_table | |
| description: Test if complex tables are handled | |
| fname: mock.c | |
| source: | | |
| /** | |
| * DOC: Supported input formats and encodings | |
| * | |
| * Depending on the Hardware configuration of the Controller IP, it supports | |
| * a subset of the following input formats and encodings on its internal | |
| * 48bit bus. | |
| * | |
| * +----------------------+----------------------------------+------------------------------+ | |
| * | Format Name | Format Code | Encodings | | |
| * +======================+==================================+==============================+ | |
| * | RGB 4:4:4 8bit | ``MEDIA_BUS_FMT_RGB888_1X24`` | ``V4L2_YCBCR_ENC_DEFAULT`` | | |
| * +----------------------+----------------------------------+------------------------------+ | |
| * | RGB 4:4:4 10bits | ``MEDIA_BUS_FMT_RGB101010_1X30`` | ``V4L2_YCBCR_ENC_DEFAULT`` | | |
| * +----------------------+----------------------------------+------------------------------+ | |
| */ | |
| expected: | |
| - man: | | |
| .TH "Supported input formats and encodings" 9 "March 2026" "" "Kernel API Manual" | |
| .SH "Supported input formats and encodings" | |
| Depending on the Hardware configuration of the Controller IP, it supports | |
| a subset of the following input formats and encodings on its internal | |
| 48bit bus. | |
| .PP | |
| .TS | |
| box; | |
| l l l. | |
| \fBFormat Name\fP \fBFormat Code\fP \fBEncodings\fP | |
| _ | |
| RGB 4:4:4 8bit ``MEDIA_BUS_FMT_RGB888_1X24 V4L2_YCBCR_ENC_DEFAULT | |
| RGB 4:4:4 10bits MEDIA_BUS_FMT_RGB101010_1X30 V4L2_YCBCR_ENC_DEFAULT`` | |
| .TE | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock.c\fR | |
| rst: |- | |
| .. _Supported input formats and encodings: | |
| **Supported input formats and encodings** | |
| Depending on the Hardware configuration of the Controller IP, it supports | |
| a subset of the following input formats and encodings on its internal | |
| 48bit bus. | |
| +----------------------+----------------------------------+------------------------------+ | |
| | Format Name | Format Code | Encodings | | |
| +======================+==================================+==============================+ | |
| | RGB 4:4:4 8bit | ``MEDIA_BUS_FMT_RGB888_1X24`` | ``V4L2_YCBCR_ENC_DEFAULT`` | | |
| +----------------------+----------------------------------+------------------------------+ | |
| | RGB 4:4:4 10bits | ``MEDIA_BUS_FMT_RGB101010_1X30`` | ``V4L2_YCBCR_ENC_DEFAULT`` | | |
| +----------------------+----------------------------------+------------------------------+ | |
| - name: func_with_ascii_artwork | |
| description: Test if ascii artwork is properly output | |
| fname: mock.c | |
| source: | | |
| /** | |
| * add_cxl_resources() - reflect CXL fixed memory windows in iomem_resource | |
| * @cxl_res: A standalone resource tree where each CXL window is a sibling | |
| * | |
| * Walk each CXL window in @cxl_res and add it to iomem_resource potentially | |
| * expanding its boundaries to ensure that any conflicting resources become | |
| * children. If a window is expanded it may then conflict with a another window | |
| * entry and require the window to be truncated or trimmed. Consider this | |
| * situation:: | |
| * | |
| * |-- "CXL Window 0" --||----- "CXL Window 1" -----| | |
| * |--------------- "System RAM" -------------| | |
| * | |
| * ...where platform firmware has established as System RAM resource across 2 | |
| * windows, but has left some portion of window 1 for dynamic CXL region | |
| * provisioning. In this case "Window 0" will span the entirety of the "System | |
| * RAM" span, and "CXL Window 1" is truncated to the remaining tail past the end | |
| * of that "System RAM" resource. | |
| */ | |
| static int add_cxl_resources(struct resource *cxl_res); | |
| expected: | |
| - man: |- | |
| .TH "add_cxl_resources" 9 "March 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| add_cxl_resources \- reflect CXL fixed memory windows in iomem_resource | |
| .SH SYNOPSIS | |
| .B "int" add_cxl_resources | |
| .BI "(struct resource *cxl_res " ");" | |
| .SH ARGUMENTS | |
| .IP "cxl_res" 12 | |
| A standalone resource tree where each CXL window is a sibling | |
| .SH "DESCRIPTION" | |
| Walk each CXL window in \fIcxl_res\fP and add it to iomem_resource potentially | |
| expanding its boundaries to ensure that any conflicting resources become | |
| children. If a window is expanded it may then conflict with a another window | |
| entry and require the window to be truncated or trimmed. Consider this | |
| situation: | |
| .nf | |
| |-- "CXL Window 0" --||----- "CXL Window 1" -----| | |
| |--------------- "System RAM" -------------| | |
| .fi | |
| .PP | |
| \&...where platform firmware has established as System RAM resource across 2 | |
| windows, but has left some portion of window 1 for dynamic CXL region | |
| provisioning. In this case "Window 0" will span the entirety of the "System | |
| RAM" span, and "CXL Window 1" is truncated to the remaining tail past the end | |
| of that "System RAM" resource. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock.c\fR | |
| rst: | | |
| .. c:function:: int add_cxl_resources (struct resource *cxl_res) | |
| reflect CXL fixed memory windows in iomem_resource | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``struct resource *cxl_res`` | |
| A standalone resource tree where each CXL window is a sibling | |
| **Description** | |
| Walk each CXL window in **cxl_res** and add it to iomem_resource potentially | |
| expanding its boundaries to ensure that any conflicting resources become | |
| children. If a window is expanded it may then conflict with a another window | |
| entry and require the window to be truncated or trimmed. Consider this | |
| situation:: | |
| |-- "CXL Window 0" --||----- "CXL Window 1" -----| | |
| |--------------- "System RAM" -------------| | |
| ...where platform firmware has established as System RAM resource across 2 | |
| windows, but has left some portion of window 1 for dynamic CXL region | |
| provisioning. In this case "Window 0" will span the entirety of the "System | |
| RAM" span, and "CXL Window 1" is truncated to the remaining tail past the end | |
| of that "System RAM" resource. | |
| - name: simple_tables | |
| description: Test formatting two simple tables | |
| fname: mock.c | |
| source: | | |
| /** | |
| * bitmap_onto - translate one bitmap relative to another | |
| * @dst: resulting translated bitmap | |
| * @orig: original untranslated bitmap | |
| * @relmap: bitmap relative to which translated | |
| * @bits: number of bits in each of these bitmaps | |
| * | |
| * =============== ============== ================= | |
| * @orig tmp @dst | |
| * 0 0 40 | |
| * 1 1 41 | |
| * =============== ============== ================= | |
| * | |
| * And: | |
| * | |
| * =============== ============== ================= | |
| * @orig tmp @dst | |
| * =============== ============== ================= | |
| * 9 9 95 | |
| * 10 0 40 [#f1]_ | |
| * =============== ============== ================= | |
| */ | |
| void bitmap_onto(unsigned long *dst, const unsigned long *orig, | |
| const unsigned long *relmap, unsigned int bits); | |
| expected: | |
| - man: | | |
| .TH "bitmap_onto" 9 "March 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| bitmap_onto \- translate one bitmap relative to another | |
| .SH SYNOPSIS | |
| .B "void" bitmap_onto | |
| .BI "(unsigned long *dst " "," | |
| .BI "const unsigned long *orig " "," | |
| .BI "const unsigned long *relmap " "," | |
| .BI "unsigned int bits " ");" | |
| .SH ARGUMENTS | |
| .IP "dst" 12 | |
| resulting translated bitmap | |
| .IP "orig" 12 | |
| original untranslated bitmap | |
| .IP "relmap" 12 | |
| bitmap relative to which translated | |
| .IP "bits" 12 | |
| number of bits in each of these bitmaps | |
| .SH "DESCRIPTION" | |
| .TS | |
| box; | |
| l l l. | |
| \fIorig\fP tmp \fIdst\fP | |
| 0 0 40 | |
| 1 1 41 | |
| .TE | |
| .PP | |
| And: | |
| .PP | |
| .TS | |
| box; | |
| l l l. | |
| \fIorig\fP tmp \fIdst\fP | |
| .TE | |
| 9 9 95 | |
| 10 0 40 [#f1]_ | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock.c\fR | |
| rst: | | |
| .. c:function:: void bitmap_onto (unsigned long *dst, const unsigned long *orig, const unsigned long *relmap, unsigned int bits) | |
| translate one bitmap relative to another | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``unsigned long *dst`` | |
| resulting translated bitmap | |
| ``const unsigned long *orig`` | |
| original untranslated bitmap | |
| ``const unsigned long *relmap`` | |
| bitmap relative to which translated | |
| ``unsigned int bits`` | |
| number of bits in each of these bitmaps | |
| **Description** | |
| =============== ============== ================= | |
| **orig** tmp **dst** | |
| 0 0 40 | |
| 1 1 41 | |
| =============== ============== ================= | |
| And: | |
| =============== ============== ================= | |
| **orig** tmp **dst** | |
| =============== ============== ================= | |
| 9 9 95 | |
| 10 0 40 [#f1]_ | |
| =============== ============== ================= | |
| # | |
| # Variable tests from Randy Dunlap's testset | |
| # | |
| - name: unsigned_long_var_on_uppercase | |
| description: Test an unsigned long varaible in uppercase | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var ROOT_DEV - system root device | |
| * | |
| * @ROOT_DEV is either the successful root device or the root device | |
| * that failed boot in the boot failure message. | |
| */ | |
| unsigned long ROOT_DEV; | |
| expected: | |
| - man: | | |
| .TH "var ROOT_DEV" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| ROOT_DEV \- system root device | |
| .SH SYNOPSIS | |
| unsigned long ROOT_DEV; | |
| .SH "Description" | |
| \fIROOT_DEV\fP is either the successful root device or the root device | |
| that failed boot in the boot failure message. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: ROOT_DEV | |
| ``unsigned long ROOT_DEV;`` | |
| system root device | |
| **Description** | |
| **ROOT_DEV** is either the successful root device or the root device | |
| that failed boot in the boot failure message. | |
| - name: enum_var | |
| description: Test an enum var with __read_mostly | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var system_state - system state used during boot or suspend/hibernate/resume | |
| * | |
| * @system_state can be used during boot to determine if it is safe to | |
| * make certain calls to other parts of the kernel. It can also be used | |
| * during suspend/hibernate or resume to determine the order of actions | |
| * that need to be executed. The numerical values of system_state are | |
| * sometimes used in numerical ordering tests, so the relative values | |
| * must not be altered. | |
| */ | |
| enum system_states system_state __read_mostly; | |
| expected: | |
| - man: | | |
| .TH "var system_state" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| system_state \- system state used during boot or suspend/hibernate/resume | |
| .SH SYNOPSIS | |
| enum system_states system_state __read_mostly; | |
| .SH "Description" | |
| \fIsystem_state\fP can be used during boot to determine if it is safe to | |
| make certain calls to other parts of the kernel. It can also be used | |
| during suspend/hibernate or resume to determine the order of actions | |
| that need to be executed. The numerical values of system_state are | |
| sometimes used in numerical ordering tests, so the relative values | |
| must not be altered. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: system_state | |
| ``enum system_states system_state __read_mostly;`` | |
| system state used during boot or suspend/hibernate/resume | |
| **Description** | |
| **system_state** can be used during boot to determine if it is safe to | |
| make certain calls to other parts of the kernel. It can also be used | |
| during suspend/hibernate or resume to determine the order of actions | |
| that need to be executed. The numerical values of system_state are | |
| sometimes used in numerical ordering tests, so the relative values | |
| must not be altered. | |
| - name: char_pointer_var | |
| description: Test char * var with __ro_after_init | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var saved_command_line - kernel's command line, saved from use at | |
| * any later time in the kernel. | |
| */ | |
| char *saved_command_line __ro_after_init; | |
| expected: | |
| - man: | | |
| .TH "var saved_command_line" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| saved_command_line \- kernel's command line, saved from use at any later time in the kernel. | |
| .SH SYNOPSIS | |
| char *saved_command_line __ro_after_init; | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: saved_command_line | |
| ``char *saved_command_line __ro_after_init;`` | |
| kernel's command line, saved from use at any later time in the kernel. | |
| - name: unsigned_long_with_default | |
| description: Test an unsigned long var that is set to a default value | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var loop_per_jiffy - calculated loop count needed to consume one jiffy | |
| * of time | |
| */ | |
| unsigned long loops_per_jiffy = (1<<12); | |
| expected: | |
| - man: | | |
| .TH "var loops_per_jiffy" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| loops_per_jiffy \- calculated loop count needed to consume one jiffy of time | |
| .SH SYNOPSIS | |
| unsigned long loops_per_jiffy = (1<<12); | |
| .SH "Initialization" | |
| default: (1<<12) | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: loops_per_jiffy | |
| ``unsigned long loops_per_jiffy = (1<<12);`` | |
| calculated loop count needed to consume one jiffy of time | |
| **Initialization** | |
| default: ``(1<<12)`` | |
| - name: unsigned_long | |
| description: test a simple unsigned long variable. | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var preset_lpj - lpj (loops per jiffy) value set from kernel | |
| * command line using "lpj=VALUE" | |
| * | |
| * See Documentation/admin-guide/kernel-parameters.txt ("lpj=") for details. | |
| */ | |
| unsigned long preset_lpj; | |
| expected: | |
| - man: | | |
| .TH "var preset_lpj" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| preset_lpj \- lpj (loops per jiffy) value set from kernel command line using "lpj=VALUE" | |
| .SH SYNOPSIS | |
| unsigned long preset_lpj; | |
| .SH "Description" | |
| See Documentation/admin-guide/kernel-parameters.txt ("lpj=") for details. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: preset_lpj | |
| ``unsigned long preset_lpj;`` | |
| lpj (loops per jiffy) value set from kernel command line using "lpj=VALUE" | |
| **Description** | |
| See Documentation/admin-guide/kernel-parameters.txt ("lpj=") for details. | |
| - name: char_array | |
| description: test a char array variable | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var linux_proc_banner - text used from /proc/version file | |
| * | |
| * * first %s is sysname (e.g., "Linux") | |
| * * second %s is release | |
| * * third %s is version | |
| */ | |
| char linux_proc_banner[]; | |
| expected: | |
| - man: | | |
| .TH "var linux_proc_banner" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| linux_proc_banner \- text used from /proc/version file | |
| .SH SYNOPSIS | |
| char linux_proc_banner[]; | |
| .SH "Description" | |
| .IP \[bu] | |
| first s is sysname (e.g., "Linux") | |
| .IP \[bu] | |
| second s is release | |
| .IP \[bu] | |
| third s is version | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: linux_proc_banner | |
| ``char linux_proc_banner[];`` | |
| text used from /proc/version file | |
| **Description** | |
| * first ``s`` is sysname (e.g., "Linux") | |
| * second ``s`` is release | |
| * third ``s`` is version | |
| - name: const_char_array | |
| description: test a const char array variable | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var linux_banner - Linux boot banner, usually printed at boot time | |
| */ | |
| const char linux_banner[]; | |
| expected: | |
| - man: | | |
| .TH "var linux_banner" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| linux_banner \- Linux boot banner, usually printed at boot time | |
| .SH SYNOPSIS | |
| const char linux_banner[]; | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: linux_banner | |
| ``const char linux_banner[];`` | |
| Linux boot banner, usually printed at boot time | |
| - name: static_atomic64_t_var | |
| description: test a static atomi64_t variable | |
| fname: mock-vars.c | |
| source: | | |
| /** | |
| * var diskseq - unique sequence number for block device instances | |
| * | |
| * Allows userspace to associate uevents to the lifetime of a device | |
| */ | |
| static atomic64_t diskseq; | |
| expected: | |
| - man: | | |
| .TH "var diskseq" 9 "February 2026" "" "Kernel API Manual" | |
| .SH NAME | |
| diskseq \- unique sequence number for block device instances | |
| .SH SYNOPSIS | |
| static atomic64_t diskseq; | |
| .SH "Description" | |
| Allows userspace to associate uevents to the lifetime of a device | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock-vars.c\fR | |
| rst: | | |
| .. c:macro:: diskseq | |
| ``static atomic64_t diskseq;`` | |
| unique sequence number for block device instances | |
| **Description** | |
| Allows userspace to associate uevents to the lifetime of a device | |
| - name: unsigned_long_on_init | |
| description: test an unsigned long var at "init" with a different timestamp. | |
| fname: init/mock-vars.c | |
| source: | | |
| /** | |
| * var rtnl_mutex - historical global lock for networking control operations. | |
| * | |
| * @rtnl_mutex is used to serialize rtnetlink requests | |
| * and protect all kernel internal data structures related to networking. | |
| * | |
| * See Documentation/networking/netdevices.rst for details. | |
| * Often known as the rtnl_lock, although rtnl_lock is a kernel function. | |
| */ | |
| unsigned long rtnl_mutex; | |
| expected: | |
| - man: | | |
| .TH "var rtnl_mutex" 9 "February 2026" "init" "Kernel API Manual" | |
| .SH NAME | |
| rtnl_mutex \- historical global lock for networking control operations. | |
| .SH SYNOPSIS | |
| unsigned long rtnl_mutex; | |
| .SH "Description" | |
| \fIrtnl_mutex\fP is used to serialize rtnetlink requests | |
| and protect all kernel internal data structures related to networking. | |
| .PP | |
| See Documentation/networking/netdevices.rst for details. | |
| Often known as the rtnl_lock, although rtnl_lock is a kernel function. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBinit/mock-vars.c\fR | |
| rst: | | |
| .. c:macro:: rtnl_mutex | |
| ``unsigned long rtnl_mutex;`` | |
| historical global lock for networking control operations. | |
| **Description** | |
| **rtnl_mutex** is used to serialize rtnetlink requests | |
| and protect all kernel internal data structures related to networking. | |
| See Documentation/networking/netdevices.rst for details. | |
| Often known as the rtnl_lock, although rtnl_lock is a kernel function. | |
| - name: struct_kcov | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * struct kcov - kcov descriptor (one per opened debugfs file). | |
| * State transitions of the descriptor: | |
| * | |
| * - initial state after open() | |
| * - then there must be a single ioctl(KCOV_INIT_TRACE) call | |
| * - then, mmap() call (several calls are allowed but not useful) | |
| * - then, ioctl(KCOV_ENABLE, arg), where arg is | |
| * KCOV_TRACE_PC - to trace only the PCs | |
| * or | |
| * KCOV_TRACE_CMP - to trace only the comparison operands | |
| * - then, ioctl(KCOV_DISABLE) to disable the task. | |
| * | |
| * Enabling/disabling ioctls can be repeated (only one task a time allowed). | |
| */ | |
| struct kcov { | |
| /** | |
| * @refcount: Reference counter. We keep one for: | |
| * - opened file descriptor | |
| * - task with enabled coverage (we can't unwire it from another task) | |
| * - each code section for remote coverage collection | |
| */ | |
| refcount_t refcount; | |
| /** | |
| * @lock: The lock protects mode, size, area and t. | |
| */ | |
| spinlock_t lock; | |
| /** | |
| * @mode: the kcov_mode | |
| */ | |
| enum kcov_mode mode __guarded_by(&lock); | |
| /** | |
| * @size: Size of arena (in long's). | |
| */ | |
| unsigned int size __guarded_by(&lock); | |
| /** | |
| * @area: Coverage buffer shared with user space. | |
| */ | |
| void *area __guarded_by(&lock); | |
| /** | |
| * @t: Task for which we collect coverage, or NULL. | |
| */ | |
| struct task_struct *t __guarded_by(&lock); | |
| /** | |
| * @remote: Collecting coverage from remote (background) threads. | |
| */ | |
| bool remote; | |
| /** | |
| * @remote_size: Size of remote area (in long's). | |
| */ | |
| unsigned int remote_size; | |
| /** | |
| * @sequence: Sequence is incremented each time kcov is reenabled, | |
| * used by kcov_remote_stop(), see the comment there. | |
| */ | |
| int sequence; | |
| }; | |
| expected: | |
| - man: | | |
| .TH "struct kcov" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| struct kcov \- kcov descriptor (one per opened debugfs file). State transitions of the descriptor: | |
| .SH SYNOPSIS | |
| struct kcov { | |
| .br | |
| .BI " refcount_t refcount;" | |
| .br | |
| .BI " spinlock_t lock;" | |
| .br | |
| .BI " enum kcov_mode mode;" | |
| .br | |
| .BI " unsigned int size;" | |
| .br | |
| .BI " void *area;" | |
| .br | |
| .BI " struct task_struct *t;" | |
| .br | |
| .BI " bool remote;" | |
| .br | |
| .BI " unsigned int remote_size;" | |
| .br | |
| .BI " int sequence;" | |
| .br | |
| .BI " | |
| }; | |
| .br | |
| .SH Members | |
| .IP "refcount" 12 | |
| Reference counter. We keep one for: | |
| .IP \[bu] | |
| opened file descriptor | |
| .IP \[bu] | |
| task with enabled coverage (we can't unwire it from another task) | |
| .IP \[bu] | |
| each code section for remote coverage collection | |
| .IP "lock" 12 | |
| The lock protects mode, size, area and t. | |
| .IP "mode" 12 | |
| the kcov_mode | |
| .IP "size" 12 | |
| Size of arena (in long's). | |
| .IP "area" 12 | |
| Coverage buffer shared with user space. | |
| .IP "t" 12 | |
| Task for which we collect coverage, or NULL. | |
| .IP "remote" 12 | |
| Collecting coverage from remote (background) threads. | |
| .IP "remote_size" 12 | |
| Size of remote area (in long's). | |
| .IP "sequence" 12 | |
| Sequence is incremented each time kcov is reenabled, | |
| used by \fBkcov_remote_stop\fP, see the comment there. | |
| .SH "Description" | |
| .IP \[bu] | |
| initial state after \fBopen\fP | |
| .IP \[bu] | |
| then there must be a single ioctl(KCOV_INIT_TRACE) call | |
| .IP \[bu] | |
| then, \fBmmap\fP call (several calls are allowed but not useful) | |
| .IP \[bu] | |
| then, ioctl(KCOV_ENABLE, arg), where arg is | |
| KCOV_TRACE_PC - to trace only the PCs | |
| or | |
| KCOV_TRACE_CMP - to trace only the comparison operands | |
| .IP \[bu] | |
| then, ioctl(KCOV_DISABLE) to disable the task. | |
| .PP | |
| Enabling/disabling ioctls can be repeated (only one task a time allowed). | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:struct:: kcov | |
| kcov descriptor (one per opened debugfs file). State transitions of the descriptor: | |
| .. container:: kernelindent | |
| **Definition**:: | |
| struct kcov { | |
| refcount_t refcount; | |
| spinlock_t lock; | |
| enum kcov_mode mode; | |
| unsigned int size; | |
| void *area; | |
| struct task_struct *t; | |
| bool remote; | |
| unsigned int remote_size; | |
| int sequence; | |
| }; | |
| **Members** | |
| ``refcount`` | |
| Reference counter. We keep one for: | |
| - opened file descriptor | |
| - task with enabled coverage (we can't unwire it from another task) | |
| - each code section for remote coverage collection | |
| ``lock`` | |
| The lock protects mode, size, area and t. | |
| ``mode`` | |
| the kcov_mode | |
| ``size`` | |
| Size of arena (in long's). | |
| ``area`` | |
| Coverage buffer shared with user space. | |
| ``t`` | |
| Task for which we collect coverage, or NULL. | |
| ``remote`` | |
| Collecting coverage from remote (background) threads. | |
| ``remote_size`` | |
| Size of remote area (in long's). | |
| ``sequence`` | |
| Sequence is incremented each time kcov is reenabled, | |
| used by kcov_remote_stop(), see the comment there. | |
| **Description** | |
| - initial state after open() | |
| - then there must be a single ioctl(KCOV_INIT_TRACE) call | |
| - then, mmap() call (several calls are allowed but not useful) | |
| - then, ioctl(KCOV_ENABLE, arg), where arg is | |
| KCOV_TRACE_PC - to trace only the PCs | |
| or | |
| KCOV_TRACE_CMP - to trace only the comparison operands | |
| - then, ioctl(KCOV_DISABLE) to disable the task. | |
| Enabling/disabling ioctls can be repeated (only one task a time allowed). | |
| - name: pool_offset | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 83 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * var pool_offset - Offset to the unused space in the currently used pool. | |
| * | |
| */ | |
| size_t pool_offset __guarded_by(&pool_lock) = DEPOT_POOL_SIZE; | |
| expected: | |
| - man: | | |
| .TH "var pool_offset" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| pool_offset \- Offset to the unused space in the currently used pool. | |
| .SH SYNOPSIS | |
| size_t pool_offset __guarded_by(&pool_lock) = DEPOT_POOL_SIZE; | |
| .SH "Initialization" | |
| default: DEPOT_POOL_SIZE | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:macro:: pool_offset | |
| ``size_t pool_offset __guarded_by(&pool_lock) = DEPOT_POOL_SIZE;`` | |
| Offset to the unused space in the currently used pool. | |
| **Initialization** | |
| default: ``DEPOT_POOL_SIZE`` | |
| - name: free_stacks | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 88 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * var free_stacks - Freelist of stack records within stack_pools. | |
| * | |
| */ | |
| __guarded_by(&pool_lock) LIST_HEAD(free_stacks); | |
| expected: | |
| - man: | | |
| .TH "var free_stacks" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| free_stacks \- Freelist of stack records within stack_pools. | |
| .SH SYNOPSIS | |
| __guarded_by(&pool_lock) LIST_HEAD(free_stacks); | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:macro:: free_stacks | |
| ``__guarded_by(&pool_lock) LIST_HEAD(free_stacks);`` | |
| Freelist of stack records within stack_pools. | |
| - name: stack_pools | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 94 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * var stack_pools - Array of memory regions that store stack records. | |
| * | |
| */ | |
| void **stack_pools __pt_guarded_by(&pool_lock); | |
| expected: | |
| - man: | | |
| .TH "var stack_pools" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| stack_pools \- Array of memory regions that store stack records. | |
| .SH SYNOPSIS | |
| void **stack_pools __pt_guarded_by(&pool_lock); | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:macro:: stack_pools | |
| ``void **stack_pools __pt_guarded_by(&pool_lock);`` | |
| Array of memory regions that store stack records. | |
| - name: prepare_report_consumer | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 103 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * prepare_report_consumer - prepare the report consumer | |
| * @flags: flags | |
| * @ai: not that AI | |
| * @other_info: yes that | |
| */ | |
| bool prepare_report_consumer(unsigned long *flags, | |
| const struct access_info *ai, | |
| struct other_info *other_info) | |
| __cond_acquires(true, &report_lock) | |
| { | |
| expected: | |
| - man: | | |
| .TH "prepare_report_consumer" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| prepare_report_consumer \- prepare the report consumer | |
| .SH SYNOPSIS | |
| .B "bool" prepare_report_consumer | |
| .BI "(unsigned long *flags " "," | |
| .BI "const struct access_info *ai " "," | |
| .BI "struct other_info *other_info " ");" | |
| .SH ARGUMENTS | |
| .IP "flags" 12 | |
| flags | |
| .IP "ai" 12 | |
| not that AI | |
| .IP "other_info" 12 | |
| yes that | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: bool prepare_report_consumer (unsigned long *flags, const struct access_info *ai, struct other_info *other_info) | |
| prepare the report consumer | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``unsigned long *flags`` | |
| flags | |
| ``const struct access_info *ai`` | |
| not that AI | |
| ``struct other_info *other_info`` | |
| yes that | |
| - name: tcp_sigpool_start | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 117 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * tcp_sigpool_start - start a tcp message of @id, using @c | |
| * @id: TCP message ID | |
| * @c: the &tcp_sigpool to use | |
| */ | |
| int tcp_sigpool_start(unsigned int id, struct tcp_sigpool *c) __cond_acquires(0, RCU_BH) | |
| { | |
| expected: | |
| - man: | | |
| .TH "tcp_sigpool_start" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| tcp_sigpool_start \- start a tcp message of @id, using @c | |
| .SH SYNOPSIS | |
| .B "int" tcp_sigpool_start | |
| .BI "(unsigned int id " "," | |
| .BI "struct tcp_sigpool *c " ");" | |
| .SH ARGUMENTS | |
| .IP "id" 12 | |
| TCP message ID | |
| .IP "c" 12 | |
| the \fItcp_sigpool\fP to use | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: int tcp_sigpool_start (unsigned int id, struct tcp_sigpool *c) | |
| start a tcp message of **id**, using **c** | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``unsigned int id`` | |
| TCP message ID | |
| ``struct tcp_sigpool *c`` | |
| the :c:type:`tcp_sigpool` to use | |
| - name: undo_report_consumer | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 129 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * undo_report_consumer - teardown a report consumer | |
| * @flags: those flags | |
| * @ai: not that AI | |
| * @other_info: yes that | |
| */ | |
| bool undo_report_consumer(unsigned long *flags, | |
| const struct access_info *ai, | |
| struct other_info *other_info) | |
| __cond_releases(true, &report_lock) | |
| { | |
| expected: | |
| - man: | | |
| .TH "undo_report_consumer" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| undo_report_consumer \- teardown a report consumer | |
| .SH SYNOPSIS | |
| .B "bool" undo_report_consumer | |
| .BI "(unsigned long *flags " "," | |
| .BI "const struct access_info *ai " "," | |
| .BI "struct other_info *other_info " ");" | |
| .SH ARGUMENTS | |
| .IP "flags" 12 | |
| those flags | |
| .IP "ai" 12 | |
| not that AI | |
| .IP "other_info" 12 | |
| yes that | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: bool undo_report_consumer (unsigned long *flags, const struct access_info *ai, struct other_info *other_info) | |
| teardown a report consumer | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``unsigned long *flags`` | |
| those flags | |
| ``const struct access_info *ai`` | |
| not that AI | |
| ``struct other_info *other_info`` | |
| yes that | |
| - name: debugfs_enter_cancellation | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 143 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * debugfs_enter_cancellation - begin a cancellation operation on @file | |
| * @file: the target file | |
| * @cancellation: the operation to execute | |
| */ | |
| void debugfs_enter_cancellation(struct file *file, | |
| struct debugfs_cancellation *cancellation) __acquires(cancellation) | |
| { } | |
| expected: | |
| - man: | | |
| .TH "debugfs_enter_cancellation" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| debugfs_enter_cancellation \- begin a cancellation operation on @file | |
| .SH SYNOPSIS | |
| .B "void" debugfs_enter_cancellation | |
| .BI "(struct file *file " "," | |
| .BI "struct debugfs_cancellation *cancellation " ");" | |
| .SH ARGUMENTS | |
| .IP "file" 12 | |
| the target file | |
| .IP "cancellation" 12 | |
| the operation to execute | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: void debugfs_enter_cancellation (struct file *file, struct debugfs_cancellation *cancellation) | |
| begin a cancellation operation on **file** | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``struct file *file`` | |
| the target file | |
| ``struct debugfs_cancellation *cancellation`` | |
| the operation to execute | |
| - name: debugfs_leave_cancellation | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 152 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * debugfs_leave_cancellation - wrapup the cancellation operation on @file | |
| * @file: the target file | |
| * @cancellation: the operation to wrapup | |
| */ | |
| void debugfs_leave_cancellation(struct file *file, | |
| struct debugfs_cancellation *cancellation) __releases(cancellation) | |
| { } | |
| expected: | |
| - man: | | |
| .TH "debugfs_leave_cancellation" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| debugfs_leave_cancellation \- wrapup the cancellation operation on @file | |
| .SH SYNOPSIS | |
| .B "void" debugfs_leave_cancellation | |
| .BI "(struct file *file " "," | |
| .BI "struct debugfs_cancellation *cancellation " ");" | |
| .SH ARGUMENTS | |
| .IP "file" 12 | |
| the target file | |
| .IP "cancellation" 12 | |
| the operation to wrapup | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: void debugfs_leave_cancellation (struct file *file, struct debugfs_cancellation *cancellation) | |
| wrapup the cancellation operation on **file** | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``struct file *file`` | |
| the target file | |
| ``struct debugfs_cancellation *cancellation`` | |
| the operation to wrapup | |
| - name: acpi_os_acquire_lock | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 161 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * acpi_os_acquire_lock - Acquire a spinlock. | |
| * @lockp: pointer to the spinlock_t. | |
| */ | |
| acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp) | |
| __acquires(lockp) | |
| { | |
| expected: | |
| - man: | | |
| .TH "acpi_os_acquire_lock" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| acpi_os_acquire_lock \- Acquire a spinlock. | |
| .SH SYNOPSIS | |
| .B "acpi_cpu_flags" acpi_os_acquire_lock | |
| .BI "(acpi_spinlock lockp " ");" | |
| .SH ARGUMENTS | |
| .IP "lockp" 12 | |
| pointer to the spinlock_t. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: acpi_cpu_flags acpi_os_acquire_lock (acpi_spinlock lockp) | |
| Acquire a spinlock. | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``acpi_spinlock lockp`` | |
| pointer to the spinlock_t. | |
| - name: acpi_os_release_lock | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 172 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * acpi_os_release_lock - Release a spinlock. | |
| * @lockp: pointer to the spinlock_t. | |
| * @not_used: these flags are not used. | |
| */ | |
| void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags not_used) | |
| __releases(lockp) | |
| { | |
| expected: | |
| - man: | | |
| .TH "acpi_os_release_lock" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| acpi_os_release_lock \- Release a spinlock. | |
| .SH SYNOPSIS | |
| .B "void" acpi_os_release_lock | |
| .BI "(acpi_spinlock lockp " "," | |
| .BI "acpi_cpu_flags not_used " ");" | |
| .SH ARGUMENTS | |
| .IP "lockp" 12 | |
| pointer to the spinlock_t. | |
| .IP "not_used" 12 | |
| these flags are not used. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: void acpi_os_release_lock (acpi_spinlock lockp, acpi_cpu_flags not_used) | |
| Release a spinlock. | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``acpi_spinlock lockp`` | |
| pointer to the spinlock_t. | |
| ``acpi_cpu_flags not_used`` | |
| these flags are not used. | |
| - name: tx | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 183 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * tx - transmit message ID @id | |
| * @id: message ID to transmit | |
| */ | |
| int tx(int id) __must_hold(&txlock) | |
| { | |
| expected: | |
| - man: | | |
| .TH "tx" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| tx \- transmit message ID @id | |
| .SH SYNOPSIS | |
| .B "int" tx | |
| .BI "(int id " ");" | |
| .SH ARGUMENTS | |
| .IP "id" 12 | |
| message ID to transmit | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: int tx (int id) | |
| transmit message ID **id** | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``int id`` | |
| message ID to transmit | |
| - name: contend_for_bm | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 192 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * contend_for_bm - try to become the bus master | |
| * @card: the &fw_card (describes the bus) | |
| */ | |
| enum bm_contention_outcome contend_for_bm(struct fw_card *card) | |
| __must_hold(&card->lock) | |
| { | |
| expected: | |
| - man: | | |
| .TH "contend_for_bm" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| contend_for_bm \- try to become the bus master | |
| .SH SYNOPSIS | |
| .B "enum bm_contention_outcome" contend_for_bm | |
| .BI "(struct fw_card *card " ");" | |
| .SH ARGUMENTS | |
| .IP "card" 12 | |
| the \fIfw_card\fP (describes the bus) | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: enum bm_contention_outcome contend_for_bm (struct fw_card *card) | |
| try to become the bus master | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``struct fw_card *card`` | |
| the :c:type:`fw_card` (describes the bus) | |
| - name: prepare_report_producer | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 202 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * prepare_report_producer - prepare the report producer | |
| * @flags: still flags | |
| * @ai: some AI | |
| * @other_info: Populate @other_info; requires that the provided | |
| * @other_info not in use. | |
| */ | |
| void prepare_report_producer(unsigned long *flags, | |
| const struct access_info *ai, | |
| struct other_info *other_info) | |
| __must_not_hold(&report_lock) | |
| { } | |
| expected: | |
| - man: | | |
| .TH "prepare_report_producer" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| prepare_report_producer \- prepare the report producer | |
| .SH SYNOPSIS | |
| .B "void" prepare_report_producer | |
| .BI "(unsigned long *flags " "," | |
| .BI "const struct access_info *ai " "," | |
| .BI "struct other_info *other_info " ");" | |
| .SH ARGUMENTS | |
| .IP "flags" 12 | |
| still flags | |
| .IP "ai" 12 | |
| some AI | |
| .IP "other_info" 12 | |
| Populate \fIother_info\fP; requires that the provided | |
| \fIother_info\fP not in use. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: void prepare_report_producer (unsigned long *flags, const struct access_info *ai, struct other_info *other_info) | |
| prepare the report producer | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``unsigned long *flags`` | |
| still flags | |
| ``const struct access_info *ai`` | |
| some AI | |
| ``struct other_info *other_info`` | |
| Populate **other_info**; requires that the provided | |
| **other_info** not in use. | |
| - name: crypto_alg_lookup | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 215 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * __crypto_alg_lookup() - lookup the algorithm by name/type/mask | |
| * @name: name to search for | |
| * @type: type to search for | |
| * @mask: mask to match | |
| */ | |
| struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type, | |
| u32 mask) | |
| __must_hold_shared(&crypto_alg_sem) | |
| { | |
| expected: | |
| - man: | | |
| .TH "__crypto_alg_lookup" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| __crypto_alg_lookup \- lookup the algorithm by name/type/mask | |
| .SH SYNOPSIS | |
| .B "struct crypto_alg *" __crypto_alg_lookup | |
| .BI "(const char *name " "," | |
| .BI "u32 type " "," | |
| .BI "u32 mask " ");" | |
| .SH ARGUMENTS | |
| .IP "name" 12 | |
| name to search for | |
| .IP "type" 12 | |
| type to search for | |
| .IP "mask" 12 | |
| mask to match | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: struct crypto_alg * __crypto_alg_lookup (const char *name, u32 type, u32 mask) | |
| lookup the algorithm by name/type/mask | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``const char *name`` | |
| name to search for | |
| ``u32 type`` | |
| type to search for | |
| ``u32 mask`` | |
| mask to match | |
| - name: down_read_trylock | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 228 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * down_read_trylock - trylock for reading | |
| * @sem: the semaphore to try to lock | |
| * | |
| * Returns: 1 if successful, 0 if contention | |
| */ | |
| extern int down_read_trylock(struct rw_semaphore *sem) __cond_acquires_shared(true, sem); | |
| expected: | |
| - man: | | |
| .TH "down_read_trylock" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| down_read_trylock \- trylock for reading | |
| .SH SYNOPSIS | |
| .B "int" down_read_trylock | |
| .BI "(struct rw_semaphore *sem " ");" | |
| .SH ARGUMENTS | |
| .IP "sem" 12 | |
| the semaphore to try to lock | |
| .SH "RETURN" | |
| 1 if successful, 0 if contention | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: int down_read_trylock (struct rw_semaphore *sem) | |
| trylock for reading | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``struct rw_semaphore *sem`` | |
| the semaphore to try to lock | |
| **Return** | |
| 1 if successful, 0 if contention | |
| - name: tomoyo_read_lock | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 236 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * tomoyo_read_lock - Take lock for protecting policy. | |
| * | |
| * Returns: index number for tomoyo_read_unlock(). | |
| */ | |
| int tomoyo_read_lock(void) | |
| __acquires_shared(&tomoyo_ss) | |
| { | |
| expected: | |
| - man: | | |
| .TH "tomoyo_read_lock" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| tomoyo_read_lock \- Take lock for protecting policy. | |
| .SH SYNOPSIS | |
| .B "int" tomoyo_read_lock | |
| .BI "(void " ");" | |
| .SH ARGUMENTS | |
| .IP "void" 12 | |
| no arguments | |
| .SH "RETURN" | |
| index number for \fBtomoyo_read_unlock\fP. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: int tomoyo_read_lock (void) | |
| Take lock for protecting policy. | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``void`` | |
| no arguments | |
| **Return** | |
| index number for tomoyo_read_unlock(). | |
| - name: tomoyo_read_unlock | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 247 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * tomoyo_read_unlock - Release lock for protecting policy. | |
| * | |
| * @idx: Index number returned by tomoyo_read_lock(). | |
| */ | |
| void tomoyo_read_unlock(int idx) | |
| __releases_shared(&tomoyo_ss) | |
| { } | |
| expected: | |
| - man: | | |
| .TH "tomoyo_read_unlock" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| tomoyo_read_unlock \- Release lock for protecting policy. | |
| .SH SYNOPSIS | |
| .B "void" tomoyo_read_unlock | |
| .BI "(int idx " ");" | |
| .SH ARGUMENTS | |
| .IP "idx" 12 | |
| Index number returned by \fBtomoyo_read_lock\fP. | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: void tomoyo_read_unlock (int idx) | |
| Release lock for protecting policy. | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``int idx`` | |
| Index number returned by tomoyo_read_lock(). | |
| - name: c_stop | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 256 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * c_stop - stop the seq_file iteration | |
| * @m: the &struct seq_file | |
| * @p: handle | |
| */ | |
| void c_stop(struct seq_file *m, void *p) | |
| __releases_shared(&crypto_alg_sem) | |
| { } | |
| expected: | |
| - man: | | |
| .TH "c_stop" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| c_stop \- stop the seq_file iteration | |
| .SH SYNOPSIS | |
| .B "void" c_stop | |
| .BI "(struct seq_file *m " "," | |
| .BI "void *p " ");" | |
| .SH ARGUMENTS | |
| .IP "m" 12 | |
| the \fIstruct seq_file\fP | |
| .IP "p" 12 | |
| handle | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: void c_stop (struct seq_file *m, void *p) | |
| stop the seq_file iteration | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``struct seq_file *m`` | |
| the :c:type:`struct seq_file <seq_file>` | |
| ``void *p`` | |
| handle | |
| - name: spin_lock | |
| description: mock_tests/kdoc-drop-ctx-lock.c line 265 | |
| fname: mock_tests/kdoc-drop-ctx-lock.c | |
| source: | | |
| /** | |
| * spin_lock - spin until the @lock is acquired | |
| * @lock: the spinlock | |
| */ | |
| void spin_lock(spinlock_t *lock) | |
| __acquires(lock) __no_context_analysis | |
| { } | |
| expected: | |
| - man: | | |
| .TH "spin_lock" 9 "February 2026" "mock_tests" "Kernel API Manual" | |
| .SH NAME | |
| spin_lock \- spin until the @lock is acquired | |
| .SH SYNOPSIS | |
| .B "void" spin_lock | |
| .BI "(spinlock_t *lock " ");" | |
| .SH ARGUMENTS | |
| .IP "lock" 12 | |
| the spinlock | |
| .SH "SEE ALSO" | |
| .PP | |
| Kernel file \fBmock_tests/kdoc-drop-ctx-lock.c\fR | |
| rst: | | |
| .. c:function:: void spin_lock (spinlock_t *lock) | |
| spin until the **lock** is acquired | |
| .. container:: kernelindent | |
| **Parameters** | |
| ``spinlock_t *lock`` | |
| the spinlock |