Linux Kernel

https://docs.kernel.org/
Admin
The Linux Kernel is the core component of the Linux operating system that manages hardware resources...
Tokens:6,776,408
Snippets:90,150
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Userspace Watch Queue Setup

Source: https://docs.kernel.org/core-api/watch_queue.html

Example of creating a buffer and configuring it for keyring change notifications.

```c
pipe2(fds, O_TMPFILE);
ioctl(fds[1], IOC_WATCH_QUEUE_SET_SIZE, 256);
```

```c
keyctl(KEYCTL_WATCH_KEY, KEY_SPEC_SESSION_KEYRING, fds[1], 0x01);
```

--------------------------------

### Example driver path

Source: https://docs.kernel.org/_sources/power/energy-model.rst.txt

Path to the example CPUFreq driver implementation.

```text
-> drivers/cpufreq/foo_cpufreq.c
```

--------------------------------

### Bootstrap and Run Source-Built Server

Source: https://docs.kernel.org/_sources/filesystems/orangefs.rst.txt

Initialize the server, start it, and verify with the ls utility.

```bash
/opt/ofs/sbin/pvfs2-server -f /etc/pvfs2.conf
```

```bash
/opt/ofs/sbin/pvfs2-server /etc/pvfs2.conf
```

```bash
/opt/ofs/bin/pvfs2-ls /pvfsmnt
```

--------------------------------

### Get Version with Repeated Start

Source: https://docs.kernel.org/i2c/slave-testunit-backend.html

Examples of retrieving the version string using repeated start and a failing example using separate messages.

```bash
# i2ctransfer -y 0 w3@0x30 4 0 0 r128
0x76 0x36 0x2e 0x31 0x31 0x2e 0x30 0x2d 0x72 0x63 0x31 0x2d 0x30 0x30 0x30 0x30 ...
```

```bash
# i2ctransfer -y -b 0 w3@0x30 4 0 0 r128
v6.11.0-rc1-00009-gd37a1b4d3fd0
```

```bash
# i2cset -y 0 0x30 4 0 0 i; i2cget -y 0 0x30
0x00
```

--------------------------------

### Reconsider Example 2 Configuration

Source: https://docs.kernel.org/filesystems/idmappings.html

Configuration setup for the reconsidered example.

```text
caller id:            u1000
caller idmapping:     u0:k10000:r10000
filesystem idmapping: u0:k20000:r10000
mount idmapping:      u0:v10000:r10000
```

--------------------------------

### Module Configuration Examples

Source: https://docs.kernel.org/networking/device_drivers/ethernet/intel/ice.html

Examples for setting log levels for single, multiple, or all modules, and reading current configurations.

```bash
# echo verbose > /sys/kernel/debug/ice/0000\:18\:00.0/fwlog/modules/link
```

```bash
# echo verbose > /sys/kernel/debug/ice/0000\:18\:00.0/fwlog/modules/link
# echo warning > /sys/kernel/debug/ice/0000\:18\:00.0/fwlog/modules/ctrl
# echo none > /sys/kernel/debug/ice/0000\:18\:00.0/fwlog/modules/dcb
```

```bash
# echo normal > /sys/kernel/debug/ice/0000\:18\:00.0/fwlog/modules/all
```

```bash
# cat /sys/kernel/debug/ice/0000\:18\:00.0/fwlog/modules/general
```

```bash
# cat /sys/kernel/debug/ice/0000\:18\:00.0/fwlog/modules/all
```

--------------------------------

### Get Feature RPC Implementation

Source: https://docs.kernel.org/userspace-api/fwctl/fwctl-cxl.html

Example implementation of a Get Feature command using the fwctl RPC interface.

```c
static int cxl_fwctl_rpc_get_test_feature(int fd, struct test_feature *feat_ctx,
                                          const uint32_t expected_data)
{
        struct cxl_mbox_get_feat_in *feat_in;
        struct fwctl_rpc_cxl_out *out;
        struct fwctl_rpc rpc = {0};
        struct fwctl_rpc_cxl *in;
        size_t out_size, in_size;
        uint32_t val;
        void *data;
        int rc;

        in_size = sizeof(*in) + sizeof(*feat_in);
        rc = posix_memalign((void **)&in, 16, in_size);
        if (rc)
                return -ENOMEM;
        memset(in, 0, in_size);
        feat_in = &in->get_feat_in;

        uuid_copy(feat_in->uuid, feat_ctx->uuid);
        feat_in->count = feat_ctx->get_size;

        out_size = sizeof(*out) + feat_ctx->get_size;
        rc = posix_memalign((void **)&out, 16, out_size);
        if (rc)
                goto free_in;
        memset(out, 0, out_size);

        in->opcode = CXL_MBOX_OPCODE_GET_FEATURE;
        in->op_size = sizeof(*feat_in);

        rpc.size = sizeof(rpc);
        rpc.scope = FWCTL_RPC_CONFIGURATION;
        rpc.in_len = in_size;
        rpc.out_len = out_size;
        rpc.in = (uint64_t)(uint64_t *)in;
        rpc.out = (uint64_t)(uint64_t *)out;

        rc = send_command(fd, &rpc, out);
        if (rc)
                goto free_all;

        data = out->payload;
        val = le32toh(*(__le32 *)data);
        if (memcmp(&val, &expected_data, sizeof(val)) != 0) {
                rc = -ENXIO;
                goto free_all;
        }

free_all:
        free(out);
free_in:
        free(in);
        return rc;
}
```

--------------------------------

### Example bootconfig file structure

Source: https://docs.kernel.org/_sources/admin-guide/bootconfig.rst.txt

A sample configuration file defining kernel and init parameters.

```text
kernel {
  root = 01234567-89ab-cdef-0123-456789abcd
}
init {
 splash
}
```

--------------------------------

### tty_standard_install

Source: https://docs.kernel.org/driver-api/tty/tty_struct.html

Performs standard TTY installation operations. This is typically used when a driver overrides the install operation but still requires standard setup.

```APIDOC
## int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)

### Description
Performs standard TTY installation operations. If the driver overrides tty->ops->install, it can still call this function to perform the standard install.

### Parameters
- **driver** (struct tty_driver *) - Required - The driver for the tty.
- **tty** (struct tty_struct *) - Required - The tty structure.
```

--------------------------------

### Example modules.conf Configuration

Source: https://docs.kernel.org/_sources/networking/bonding.rst.txt

A sample modules.conf file demonstrating bonding and network interface aliases.

```text
alias bond0 bonding
	options bond0 mode=some-mode miimon=50
	alias eth0 tg3
	alias eth1 tg3
	alias eth2 e1000
	alias eth3 e1000
```

--------------------------------

### EDAC Device Path

Source: https://docs.kernel.org/admin-guide/RAS/main.html

Example path for an installed EDAC device instance in sysfs.

```text
/sys/devices/system/edac/test-instance
```

--------------------------------

### Start s390 QEMU guest

Source: https://docs.kernel.org/_sources/bpf/s390.rst.txt

Launch the s390 virtual machine with appropriate hardware emulation settings.

```bash
qemu-system-s390x \
  -cpu max,zpci=on \
  -smp 2 \
  -m 4G \
  -kernel linux/arch/s390/boot/compressed/vmlinux \
  -drive file=./s390.img,if=virtio,format=raw \
  -nographic \
  -append 'root=/dev/vda rw console=ttyS1' \
  -virtfs local,path=./linux,security_model=none,mount_tag=linux \
  -object rng-random,filename=/dev/urandom,id=rng0 \
  -device virtio-rng-ccw,rng=rng0 \
  -netdev user,id=net0 \
  -device virtio-net-ccw,netdev=net0
```

--------------------------------

### Kernel command line boot-args example

Source: https://docs.kernel.org/_sources/admin-guide/dynamic-debug-howto.rst.txt

Example of complex boot-time configuration for dynamic debug.

```text
Kernel command line: ...
    // see what's going on in dyndbg=value processing
    dynamic_debug.verbose=3
    // enable pr_debugs in the btrfs module (can be builtin or loadable)
    btrfs.dyndbg="+p"
    // enable pr_debugs in all files under init/
    // and the function parse_one, #cmt is stripped
    dyndbg="file init/* +p #cmt ; func parse_one +p"
    // enable pr_debugs in 2 functions in a module loaded later
    pc87360.dyndbg="func pc87360_init_device +p; func pc87360_find +p"
```

--------------------------------

### Setup an IIO Trigger

Source: https://docs.kernel.org/driver-api/iio/triggers.html

Example of allocating, configuring, and registering an IIO trigger within a driver.

```c
struct iio_trigger_ops trigger_ops = {
    .set_trigger_state = sample_trigger_state,
    .validate_device = sample_validate_device,
}

struct iio_trigger *trig;

/* first, allocate memory for our trigger */
trig = iio_trigger_alloc(dev, "trig-%s-%d", name, idx);

/* setup trigger operations field */
trig->ops = &trigger_ops;

/* now register the trigger with the IIO core */
iio_trigger_register(trig);
```

--------------------------------

### Example of setup_indirect usage

Source: https://docs.kernel.org/_sources/arch/x86/boot.rst.txt

Demonstrates how to point to SETUP_E820_EXT data using the setup_indirect structure.

```c
struct setup_data {
	.next = 0,	/* or <addr_of_next_setup_data_struct> */
	.type = SETUP_INDIRECT,
	.len = sizeof(setup_indirect),
	.data[sizeof(setup_indirect)] = (struct setup_indirect) {
		.type = SETUP_INDIRECT | SETUP_E820_EXT,
		.reserved = 0,
		.len = <len_of_SETUP_E820_EXT_data>,
		.addr = <addr_of_SETUP_E820_EXT_data>,
	},
   }
```

--------------------------------

### Patch Subject Line Example

Source: https://docs.kernel.org/process/5.Posting.html

A standard one-line description format for a patch, starting with the subsystem name.

```text
gpio: fix build on CONFIG_GPIO_SYSFS=n
```

--------------------------------

### Initialize and Configure a Cpuset

Source: https://docs.kernel.org/_sources/admin-guide/cgroup-v1/cpusets.rst.txt

Demonstrates the sequence of mounting the cpuset filesystem, creating a directory, and assigning resources to a new cpuset.

```bash
mount -t cgroup -ocpuset cpuset /sys/fs/cgroup/cpuset
cd /sys/fs/cgroup/cpuset
mkdir Charlie
cd Charlie
/bin/echo 2-3 > cpuset.cpus
/bin/echo 1 > cpuset.mems
/bin/echo $$ > tasks
sh
# The subshell 'sh' is now running in cpuset Charlie
# The next line should display '/Charlie'
cat /proc/self/cpuset
```

--------------------------------

### GPM Configuration

Source: https://docs.kernel.org/input/input.html

Example command to start the GPM tool using the PS/2 protocol on the input device.

```bash
gpm -t ps2 -m /dev/input/mice
```

--------------------------------

### Implement platform setup callback

Source: https://docs.kernel.org/_sources/fb/ep93xx-fb.rst.txt

Access platform data and driver data within the setup callback function.

```c
static int some_board_fb_setup(struct platform_device *pdev)
	{
		struct ep93xxfb_mach_info *mach_info = pdev->dev.platform_data;
		struct fb_info *fb_info = platform_get_drvdata(pdev);

		/* Board specific framebuffer setup */
	}
```

--------------------------------

### Format a patch summary line

Source: https://docs.kernel.org/_sources/process/5.Posting.rst.txt

Example of a concise one-line description for a patch, starting with the relevant subsystem.

```text
gpio: fix build on CONFIG_GPIO_SYSFS=n
```

--------------------------------

### Create trace instances

Source: https://docs.kernel.org/admin-guide/kernel-parameters.html

Examples for creating and configuring ring buffer instances at boot time.

```text
/sys/kernel/tracing/instances
```

```text
trace_instance=<name>,<system1>:<event1>,<system2>:<event2>
```

```text
trace_instance=foo,sched:sched_switch,irq_handler_entry,initcall
```

```text
trace_instance=foo^traceoff^traceprintk,sched,irq
```

--------------------------------

### Hierarchical GPIO IRQ Chip Setup

Source: https://docs.kernel.org/_sources/driver-api/gpio/driver.rst.txt

Example of setting up a GPIO driver with a hierarchical interrupt controller.

```c
/* Typical state container with dynamic irqchip */
struct my_gpio {
    struct gpio_chip gc;
    struct fwnode_handle *fwnode;
};

static void my_gpio_mask_irq(struct irq_data *d)
{
    struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
    irq_hw_number_t hwirq = irqd_to_hwirq(d);

    /*
     * Perform any necessary action to mask the interrupt,
     * and then call into the core code to synchronise the
     * state.
     */

    gpiochip_disable_irq(gc, hwirq);
    irq_mask_mask_parent(d);
}

static void my_gpio_unmask_irq(struct irq_data *d)
{
    struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
    irq_hw_number_t hwirq = irqd_to_hwirq(d);

    gpiochip_enable_irq(gc, hwirq);

    /*
     * Perform any necessary action to unmask the interrupt,
     * after having called into the core code to synchronise
     * the state.
     */

    irq_mask_unmask_parent(d);
}

/*
 * Statically populate the irqchip. Note that it is made const
 * (further indicated by the IRQCHIP_IMMUTABLE flag), and that
 * the GPIOCHIP_IRQ_RESOURCE_HELPER macro adds some extra
 * callbacks to the structure.
 */
static const struct irq_chip my_gpio_irq_chip = {
    .name		= "my_gpio_irq",
    .irq_ack		= my_gpio_ack_irq,
    .irq_mask		= my_gpio_mask_irq,
    .irq_unmask	= my_gpio_unmask_irq,
    .irq_set_type	= my_gpio_set_irq_type,
    .flags		= IRQCHIP_IMMUTABLE,
    /* Provide the gpio resource callbacks */
    GPIOCHIP_IRQ_RESOURCE_HELPERS,
};

struct my_gpio *g;
struct gpio_irq_chip *girq;

/* Get a pointer to the gpio_irq_chip */
girq = &g->gc.irq;
gpio_irq_chip_set_chip(girq, &my_gpio_irq_chip);
girq->default_type = IRQ_TYPE_NONE;
girq->handler = handle_bad_irq;
girq->fwnode = g->fwnode;
girq->parent_domain = parent;
girq->child_to_parent_hwirq = my_gpio_child_to_parent_hwirq;

return devm_gpiochip_add_data(dev, &g->gc, g);
```

--------------------------------

### Implement setup platform callback

Source: https://docs.kernel.org/fb/ep93xx-fb.html

Access fb_info and ep93xxfb_mach_info structures within the setup callback.

```c
static int some_board_fb_setup(struct platform_device *pdev)
{
        struct ep93xxfb_mach_info *mach_info = pdev->dev.platform_data;
        struct fb_info *fb_info = platform_get_drvdata(pdev);

        /* Board specific framebuffer setup */
}
```

--------------------------------

### Create and Test a Minimal Initramfs

Source: https://docs.kernel.org/_sources/filesystems/ramfs-rootfs-initramfs.rst.txt

Demonstrates creating a simple statically linked C program as an init process and packaging it into a cpio.gz archive for testing with QEMU.

```bash
cat > hello.c << EOF
#include <stdio.h>
#include <unistd.h>

int main(int argc, char *argv[])
{
  printf("Hello world!\n");
  sleep(999999999);
}
EOF
gcc -static hello.c -o init
echo init | cpio -o -H newc | gzip > test.cpio.gz
# Testing external initramfs using the initrd loading mechanism.
qemu -kernel /boot/vmlinuz -initrd test.cpio.gz /dev/zero
```

--------------------------------

### Property Ordering Example

Source: https://docs.kernel.org/_sources/devicetree/bindings/dts-coding-style.rst.txt

Shows the preferred sequence of properties within a device node, starting with compatible and reg.

```dts
	/* SoC DTSI */

	device_node: device-class@6789abc {
		compatible = "vendor,device";
		reg = <0x0 0x06789abc 0x0 0xa123>;
		ranges = <0x0 0x0 0x06789abc 0x1000>;
		#dma-cells = <1>;
		clocks = <&clock_controller 0>, <&clock_controller 1>;
		clock-names = "bus", "host";
		#address-cells = <1>;
		#size-cells = <1>;
		vendor,custom-property = <2>;

		status = "disabled";

		child_node: child-class@100 {
			reg = <0x100 0x200>;
			/* ... */
		};
	};

	/* Board DTS */

	&device_node {
		vdd-0v9-supply = <&board_vreg1>;
		vdd-1v8-supply = <&board_vreg4>;
		vdd-3v3-supply = <&board_vreg2>;
		vdd-12v-supply = <&board_vreg3>;

		status = "okay";
	}
```

--------------------------------

### USBG Transport Setup

Source: https://docs.kernel.org/filesystems/9p.html

Commands to start the 9P server and the Python forwarder tool for USB gadget transport.

```bash
$ diod -f -n -d 0 -S -l 0.0.0.0:9999 -e $PWD
```

```bash
$ python $kernel_dir/tools/usb/p9_fwd.py list
```

```bash
$ python $kernel_dir/tools/usb/p9_fwd.py --path 2-1.1.2 connect -p 9999
```

--------------------------------

### Start Client Core and Mount Source-Built Filesystem

Source: https://docs.kernel.org/_sources/filesystems/orangefs.rst.txt

Load the client core and mount the filesystem using the hostname.

```bash
/opt/ofs/sbin/pvfs2-client -p /opt/ofs/sbin/pvfs2-client-core
```

```bash
mount -t pvfs2 tcp://`hostname`:3334/orangefs /pvfsmnt
```

--------------------------------

### Get Unmap Range from Remap Operation

Source: https://docs.kernel.org/gpu/drm-mm.html

Retrieves the start address and range for the unmap stage of a remap operation.

```c
void drm_gpuva_op_remap_to_unmap_range(const struct drm_gpuva_op_remap *op, u64 *start_addr, u64 *range)
```

--------------------------------

### Min-heap usage example

Source: https://docs.kernel.org/_sources/core-api/min_heap.rst.txt

Demonstrates defining, initializing, and building a min-heap with custom callbacks.

```c
#include <linux/min_heap.h>

int my_less_function(const void *lhs, const void *rhs, void *args) {
    return (*(int *)lhs < *(int *)rhs);
}

struct min_heap_callbacks heap_cb = {
    .less = my_less_function,    /* Comparison function for heap order */
    .swp  = NULL,                /* Use default swap function */
};

void example_usage(void) {
    /* Pre-populate the buffer with elements */
    int buffer[5] = {5, 2, 8, 1, 3};
    /* Declare a min-heap */
    DEFINE_MIN_HEAP(int, my_heap);

    /* Initialize the heap with preallocated buffer and size */
    min_heap_init(&my_heap, buffer, 5);

    /* Build the heap using min_heapify_all */
    my_heap.nr = 5;  /* Set the number of elements in the heap */
    min_heapify_all(&my_heap, &heap_cb, NULL);

```

--------------------------------

### Seek in Page Owner File

Source: https://docs.kernel.org/_sources/mm/page_owner.rst.txt

Example of using fseek to start reading the page_owner debug file from a specific PFN.

```c
FILE *fp = fopen("/sys/kernel/debug/page_owner", "r");
fseek(fp, pfn_start, SEEK_SET);
```

--------------------------------

### Perform asynchronous userptr bind

Source: https://docs.kernel.org/gpu/driver-uapi.html

Example demonstrating a minimal setup to asynchronously bind buffer data using DRM_IOCTL_XE_VM_BIND.

```c
data = aligned_alloc(ALIGNMENT, BO_SIZE);
struct drm_xe_vm_bind bind = {
    .vm_id = vm,
    .num_binds = 1,
    .bind.obj = 0,
    .bind.obj_offset = to_user_pointer(data),
    .bind.range = BO_SIZE,
    .bind.addr = BIND_ADDRESS,
    .bind.op = DRM_XE_VM_BIND_OP_MAP_USERPTR,
    .bind.flags = 0,
    .num_syncs = 1,
    .syncs = &sync,
    .exec_queue_id = 0,
};
ioctl(fd, DRM_IOCTL_XE_VM_BIND, &bind);
```

--------------------------------

### Build, install, and boot the kernel

Source: https://docs.kernel.org/admin-guide/verify-bugs-and-bisect-regressions.html

Compiles the kernel using the working configuration, installs it, and verifies the running version.

```bash
cp ~/kernel-config-working .config
make olddefconfig
make -j $(nproc --all)
df -h /boot/ /lib/modules/
sudo make modules_install
command -v installkernel && sudo make install
du -ch /boot/*$(make -s kernelrelease)* | tail -n 1
du -sh /lib/modules/$(make -s kernelrelease)/
make -s kernelrelease | tee -a ~/kernels-built
reboot
tail -n 1 ~/kernels-built
uname -r
cat /proc/sys/kernel/tainted
```

--------------------------------

### Example console configuration

Source: https://docs.kernel.org/_sources/admin-guide/serial-console.rst.txt

Example of specifying multiple console devices on the kernel command line.

```text
console=ttyS1,9600 console=tty0
```

--------------------------------

### Setup and teardown a static CPU hotplug state

Source: https://docs.kernel.org/_sources/core-api/cpu_hotplug.rst.txt

Registers a statically allocated state in the STARTING section and removes it when finished.

```c
ret = cpuhp_setup_state(CPUHP_SUBSYS_STARTING, "subsys:starting", subsys_cpu_starting, subsys_cpu_dying);
   if (ret < 0)
        return ret;
   ....
   cpuhp_remove_state(CPUHP_SUBSYS_STARTING);
```

--------------------------------

### Get possible output sizes

Source: https://docs.kernel.org/driver-api/generic_pt.html

Returns a bitmap of possible output sizes that can be installed as leaf entries at the current level.

```c
pt_vaddr_t pt_possible_sizes(const struct pt_state *pts)
```

--------------------------------

### Define example header and source

Source: https://docs.kernel.org/_sources/dev-tools/kunit/start.rst.txt

Basic C header and implementation files for a sample kernel component to be tested.

```c
int misc_example_add(int left, int right);
```

```c
#include <linux/errno.h>

#include "example.h"

int misc_example_add(int left, int right)
{
	return left + right;
}
```

--------------------------------

### Exclude Adapter via insmod

Source: https://docs.kernel.org/scsi/ncr53c8xx.html

Example of installing drivers on specific adapters while excluding one based on its IO port address.

```bash
insmod sym53c8xx sym53c8xx=excl:0x1400
insmod ncr53c8xx
```

--------------------------------

### Configure Kernel Boot Parameters

Source: https://docs.kernel.org/_sources/fb/intel810.rst.txt

Example syntax for passing configuration options to the i810fb driver during kernel boot.

```text
video=i810fb:option1,option2:value2
```

--------------------------------

### Execute perf record in default mode

Source: https://docs.kernel.org/_sources/userspace-api/perf_ring_buffer.rst.txt

Example command to start profiling a program using the default perf record mode.

```bash
perf record test_program
```

--------------------------------

### Execute Kernel Entry Point

Source: https://docs.kernel.org/_sources/arch/x86/boot.rst.txt

Example of setting up registers and jumping to the kernel entry point in real mode.

```c
  /*
   * Note: in the case of the "old" kernel protocol, base_ptr must
   * be == 0x90000 at this point; see the previous sample code.
   */
  seg = base_ptr >> 4;

  cli();			/* Enter with interrupts disabled! */

  /* Set up the real-mode kernel stack */
  _SS = seg;
  _SP = heap_end;

  _DS = _ES = _FS = _GS = seg;
  jmp_far(seg + 0x20, 0);	/* Run the kernel */
```

--------------------------------

### Implement TPACKET_V3 packet capture

Source: https://docs.kernel.org/networking/packet_mmap.html

A complete example demonstrating the setup, polling, and processing of packets using TPACKET_V3 ring buffers.

```c
static void walk_block(struct block_desc *pbd, const int block_num)
{
        int num_pkts = pbd->h1.num_pkts, i;
        unsigned long bytes = 0;
        struct tpacket3_hdr *ppd;

        ppd = (struct tpacket3_hdr *) ((uint8_t *) pbd +
                                    pbd->h1.offset_to_first_pkt);
        for (i = 0; i < num_pkts; ++i) {
                bytes += ppd->tp_snaplen;
                display(ppd);

                ppd = (struct tpacket3_hdr *) ((uint8_t *) ppd +
                                            ppd->tp_next_offset);
        }

        packets_total += num_pkts;
        bytes_total += bytes;
}

static void flush_block(struct block_desc *pbd)
{
        pbd->h1.block_status = TP_STATUS_KERNEL;
}

static void teardown_socket(struct ring *ring, int fd)
{
        munmap(ring->map, ring->req.tp_block_size * ring->req.tp_block_nr);
        free(ring->rd);
        close(fd);
}

int main(int argc, char **argp)
{
        int fd, err;
        socklen_t len;
        struct ring ring;
        struct pollfd pfd;
        unsigned int block_num = 0, blocks = 64;
        struct block_desc *pbd;
        struct tpacket_stats_v3 stats;

        if (argc != 2) {
                fprintf(stderr, "Usage: %s INTERFACE\n", argp[0]);
                return EXIT_FAILURE;
        }

        signal(SIGINT, sighandler);

        memset(&ring, 0, sizeof(ring));
        fd = setup_socket(&ring, argp[argc - 1]);
        assert(fd > 0);

        memset(&pfd, 0, sizeof(pfd));
        pfd.fd = fd;
        pfd.events = POLLIN | POLLERR;
        pfd.revents = 0;

        while (likely(!sigint)) {
                pbd = (struct block_desc *) ring.rd[block_num].iov_base;

                if ((pbd->h1.block_status & TP_STATUS_USER) == 0) {
                        poll(&pfd, 1, -1);
                        continue;
                }

                walk_block(pbd, block_num);
                flush_block(pbd);
                block_num = (block_num + 1) % blocks;
        }

        len = sizeof(stats);
        err = getsockopt(fd, SOL_PACKET, PACKET_STATISTICS, &stats, &len);
        if (err < 0) {
                perror("getsockopt");
                exit(1);
        }

        fflush(stdout);
        printf("\nReceived %u packets, %lu bytes, %u dropped, freeze_q_cnt: %u\n",
            stats.tp_packets, bytes_total, stats.tp_drops,
            stats.tp_freeze_q_cnt);

        teardown_socket(&ring, fd);
        return 0;
}
```

--------------------------------

### WIP monitor enable implementation

Source: https://docs.kernel.org/trace/rv/da_monitor_instrumentation.html

Example of initializing a monitor and attaching trace probes to kernel events.

```c
static int enable_wip(void)
{
      int retval;

      retval = da_monitor_init_wip();
      if (retval)
              return retval;

      rv_attach_trace_probe("wip", /* XXX: tracepoint */, handle_preempt_enable);
      rv_attach_trace_probe("wip", /* XXX: tracepoint */, handle_sched_waking);
      rv_attach_trace_probe("wip", /* XXX: tracepoint */, handle_preempt_disable);

      return 0;
}
```

--------------------------------

### Start and Verify Source-Built OrangeFS

Source: https://docs.kernel.org/filesystems/orangefs.html

Start the server, verify with ls, and mount the filesystem.

```bash
/opt/ofs/sbin/pvfs2-server /etc/pvfs2.conf
```

```bash
/opt/ofs/bin/pvfs2-ls /pvfsmnt
```

```bash
/opt/ofs/sbin/pvfs2-client -p /opt/ofs/sbin/pvfs2-client-core
```

```bash
mount -t pvfs2 tcp://`hostname`:3334/orangefs /pvfsmnt
```

--------------------------------

### Record PTT Trace Data

Source: https://docs.kernel.org/trace/hisi-ptt.html

Example command to start a PTT trace session with specific filter, type, direction, and format parameters.

```bash
$ perf record -e hisi_ptt0_2/filter=0x80001,type=1,direction=1,
  format=1/ -- sleep 5
```

--------------------------------

### Configure driver via boot parameters

Source: https://docs.kernel.org/_sources/scsi/sym53c8xx_2.rst.txt

Examples of passing configuration parameters to the driver at boot time or via module loading.

```bash
lilo: linux root=/dev/sda2 sym53c8xx.cmd_per_lun=4 sym53c8xx.sync=10 sym53c8xx.debug=0x200
```

```bash
modprobe sym53c8xx cmd_per_lun=4 sync=10 debug=0x200
```

--------------------------------

### Define Minimal IPE Rule

Source: https://docs.kernel.org/_sources/admin-guide/LSM/ipe.rst.txt

Rules must start with an operation property and end with an action property. This example permits all execution requests.

```text
op=EXECUTE action=ALLOW
```

--------------------------------

### zynqmp_dp_setup

Source: https://docs.kernel.org/gpu/zynqmp.html

Sets up major link parameters.

```APIDOC
## int zynqmp_dp_setup(struct zynqmp_dp *dp, u8 bw_code, u8 lane_cnt, bool enhanced, bool downspread)

### Description
Set up major link parameters.

### Parameters
- **dp** (struct zynqmp_dp *) - DisplayPort IP core structure
- **bw_code** (u8) - The link bandwidth as a multiple of 270 MHz
- **lane_cnt** (u8) - The number of lanes to use
- **enhanced** (bool) - Use enhanced framing
- **downspread** (bool) - Enable spread-spectrum clocking

### Return
0 on success, or -errno on failure.
```

--------------------------------

### GICv3 and CPU Setup Assembly

Source: https://docs.kernel.org/_sources/arch/arm/zte/zx297520v3.rst.txt

Example assembly code for configuring the GICv3 and CPU to meet Linux booting requirements on the zx297520v3 SoC.

```assembly
#include <linux/irqchip/arm-gic-v3.h>
 #include <asm/assembler.h>
 #include <asm/cp15.h>
```

--------------------------------

### Start a UML Instance

Source: https://docs.kernel.org/_sources/virt/uml/user_mode_linux_howto_v2.rst.txt

Launch a UML instance with specific memory, filesystem, network, and console configurations.

```bash
# linux mem=2048M umid=TEST \
    ubd0=Filesystem.img \
    vec0:transport=tap,ifname=tap0,depth=128,gro=1 \
    root=/dev/ubda con=null con0=null,fd:2 con1=fd:0,fd:1
```

--------------------------------

### int ib_sa_service_rec_get(...)

Source: https://docs.kernel.org/driver-api/infiniband.html

Starts a Service Record Get query to the SA. Returns a query ID on success or a negative error code.

```APIDOC
## int ib_sa_service_rec_get(struct ib_sa_client *client, struct ib_device *device, u32 port_num, struct sa_service_rec *rec, ib_sa_comp_mask comp_mask, unsigned long timeout_ms, gfp_t gfp_mask, void (*callback)(int status, struct sa_service_rec *resp, unsigned int num_services, void *context), void *context, struct ib_sa_query **sa_query)

### Description
Send a Service Record Get query to the SA to look up a service. The callback function is invoked upon completion, timeout, or cancellation.

### Parameters
- **client** (struct ib_sa_client *) - SA client
- **device** (struct ib_device *) - device to send query on
- **port_num** (u32) - port number to send query on
- **rec** (struct sa_service_rec *) - Service Record to send in query
- **comp_mask** (ib_sa_comp_mask) - component mask to send in query
- **timeout_ms** (unsigned long) - time to wait for response
- **gfp_mask** (gfp_t) - GFP mask to use for internal allocations
- **callback** (void (*)(int, struct sa_service_rec *, unsigned int, void *)) - function called when query completes
- **context** (void *) - opaque user context passed to callback
- **sa_query** (struct ib_sa_query **) - query context, used to cancel query
```

--------------------------------

### int ib_sa_path_rec_get(...)

Source: https://docs.kernel.org/driver-api/infiniband.html

Starts a Path Record Get query to the SA. Returns a query ID on success or a negative error code.

```APIDOC
## int ib_sa_path_rec_get(struct ib_sa_client *client, struct ib_device *device, u32 port_num, struct sa_path_rec *rec, ib_sa_comp_mask comp_mask, unsigned long timeout_ms, gfp_t gfp_mask, void (*callback)(int status, struct sa_path_rec *resp, unsigned int num_paths, void *context), void *context, struct ib_sa_query **sa_query)

### Description
Send a Path Record Get query to the SA to look up a path. The callback function is invoked upon completion, timeout, or cancellation.

### Parameters
- **client** (struct ib_sa_client *) - SA client
- **device** (struct ib_device *) - device to send query on
- **port_num** (u32) - port number to send query on
- **rec** (struct sa_path_rec *) - Path Record to send in query
- **comp_mask** (ib_sa_comp_mask) - component mask to send in query
- **timeout_ms** (unsigned long) - time to wait for response
- **gfp_mask** (gfp_t) - GFP mask to use for internal allocations
- **callback** (void (*)(int, struct sa_path_rec *, unsigned int, void *)) - function called when query completes
- **context** (void *) - opaque user context passed to callback
- **sa_query** (struct ib_sa_query **) - query context, used to cancel query
```

--------------------------------

### Configure LILO Boot

Source: https://docs.kernel.org/_sources/admin-guide/initrd.rst.txt

Example configuration snippet for /etc/lilo.conf.

```text
image = /bzImage
  initrd = /boot/initrd.gz
  append = "root=/dev/ram0 rw"
```

--------------------------------

### Setup IIO Hardware Consumer

Source: https://docs.kernel.org/driver-api/iio/hw-consumer.html

Example demonstrating the typical lifecycle of an IIO hardware consumer, including allocation in the probe function and enabling/disabling during data acquisition.

```c
static struct iio_hw_consumer *hwc;

static const struct iio_info adc_info = {
        .read_raw = adc_read_raw,
};

static int adc_read_raw(struct iio_dev *indio_dev,
                        struct iio_chan_spec const *chan, int *val,
                        int *val2, long mask)
{
        ret = iio_hw_consumer_enable(hwc);

        /* Acquire data */

        ret = iio_hw_consumer_disable(hwc);
}

static int adc_probe(struct platform_device *pdev)
{
        hwc = devm_iio_hw_consumer_alloc(&iio->dev);
}
```

--------------------------------

### Sample configuration commands

Source: https://docs.kernel.org/admin-guide/gpio/gpio-aggregator.html

Example shell commands for configuring a GPIO aggregator via configfs.

```bash
cd /config/gpio-aggregator
mkdir agg0
cd agg0
mkdir line0
echo "e6000000.gpio" > line0/key
echo 15 > line0/offset
echo "my-line" > line0/name
echo 1 > live
```

--------------------------------

### Implement AF_PACKET TPACKET_V3 Ring Buffer

Source: https://docs.kernel.org/networking/packet_mmap.html

This example demonstrates the setup of a TPACKET_V3 socket, including memory mapping the ring buffer and binding to a network interface. Compile with 'gcc -Wall -O2 blob.c' and execute with a network interface argument.

```c
/* Written from scratch, but kernel-to-user space API usage
* dissected from lolpcap:
*  Copyright 2011, Chetan Loke <loke.chetan@gmail.com>
*  License: GPL, version 2.0
*/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
#include <net/if.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <poll.h>
#include <unistd.h>
#include <signal.h>
#include <inttypes.h>
#include <sys/socket.h>
#include <sys/mman.h>
#include <linux/if_packet.h>
#include <linux/if_ether.h>
#include <linux/ip.h>

#ifndef likely
# define likely(x)          __builtin_expect(!!(x), 1)
#endif
#ifndef unlikely
# define unlikely(x)                __builtin_expect(!!(x), 0)
#endif

struct block_desc {
        uint32_t version;
        uint32_t offset_to_priv;
        struct tpacket_hdr_v1 h1;
};

struct ring {
        struct iovec *rd;
        uint8_t *map;
        struct tpacket_req3 req;
};

static unsigned long packets_total = 0, bytes_total = 0;
static sig_atomic_t sigint = 0;

static void sighandler(int num)
{
        sigint = 1;
}

static int setup_socket(struct ring *ring, char *netdev)
{
        int err, i, fd, v = TPACKET_V3;
        struct sockaddr_ll ll;
        unsigned int blocksiz = 1 << 22, framesiz = 1 << 11;
        unsigned int blocknum = 64;

        fd = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
        if (fd < 0) {
                perror("socket");
                exit(1);
        }

        err = setsockopt(fd, SOL_PACKET, PACKET_VERSION, &v, sizeof(v));
        if (err < 0) {
                perror("setsockopt");
                exit(1);
        }

        memset(&ring->req, 0, sizeof(ring->req));
        ring->req.tp_block_size = blocksiz;
        ring->req.tp_frame_size = framesiz;
        ring->req.tp_block_nr = blocknum;
        ring->req.tp_frame_nr = (blocksiz * blocknum) / framesiz;
        ring->req.tp_retire_blk_tov = 60;
        ring->req.tp_feature_req_word = TP_FT_REQ_FILL_RXHASH;

        err = setsockopt(fd, SOL_PACKET, PACKET_RX_RING, &ring->req,
                        sizeof(ring->req));
        if (err < 0) {
                perror("setsockopt");
                exit(1);
        }

        ring->map = mmap(NULL, ring->req.tp_block_size * ring->req.tp_block_nr,
                        PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED, fd, 0);
        if (ring->map == MAP_FAILED) {
                perror("mmap");
                exit(1);
        }

        ring->rd = malloc(ring->req.tp_block_nr * sizeof(*ring->rd));
        assert(ring->rd);
        for (i = 0; i < ring->req.tp_block_nr; ++i) {
                ring->rd[i].iov_base = ring->map + (i * ring->req.tp_block_size);
                ring->rd[i].iov_len = ring->req.tp_block_size;
        }

        memset(&ll, 0, sizeof(ll));
        ll.sll_family = PF_PACKET;
        ll.sll_protocol = htons(ETH_P_ALL);
        ll.sll_ifindex = if_nametoindex(netdev);
        ll.sll_hatype = 0;
        ll.sll_pkttype = 0;
        ll.sll_halen = 0;

        err = bind(fd, (struct sockaddr *) &ll, sizeof(ll));
        if (err < 0) {
                perror("bind");
                exit(1);
        }

        return fd;
}

static void display(struct tpacket3_hdr *ppd)
{
        struct ethhdr *eth = (struct ethhdr *) ((uint8_t *) ppd + ppd->tp_mac);
        struct iphdr *ip = (struct iphdr *) ((uint8_t *) eth + ETH_HLEN);

        if (eth->h_proto == htons(ETH_P_IP)) {
                struct sockaddr_in ss, sd;
                char sbuff[NI_MAXHOST], dbuff[NI_MAXHOST];

                memset(&ss, 0, sizeof(ss));
                ss.sin_family = PF_INET;
                ss.sin_addr.s_addr = ip->saddr;
                getnameinfo((struct sockaddr *) &ss, sizeof(ss),
                            sbuff, sizeof(sbuff), NULL, 0, NI_NUMERICHOST);

                memset(&sd, 0, sizeof(sd));
                sd.sin_family = PF_INET;
                sd.sin_addr.s_addr = ip->daddr;
                getnameinfo((struct sockaddr *) &sd, sizeof(sd),
                            dbuff, sizeof(dbuff), NULL, 0, NI_NUMERICHOST);

                printf("%s -> %s, ", sbuff, dbuff);
        }

        printf("rxhash: 0x%x\n", ppd->hv1.tp_rxhash);
}
```

--------------------------------

### Example parameters for i386 architecture

Source: https://docs.kernel.org/networking/packet_mmap.html

Sample configuration values for a 2.6 kernel on i386 architecture.

```text
<size-max> = 131072 bytes
<pointer size> = 4 bytes
<pagesize> = 4096 bytes
<max-order> = 11
```

```text
<block number> = 131072/4 = 32768 blocks
<block size> = 4096 << 11 = 8 MiB.
```

--------------------------------

### Install dtschema dependencies on Debian/Ubuntu

Source: https://docs.kernel.org/_sources/devicetree/bindings/writing-schema.rst.txt

Install system-level dependencies required for dtschema installation.

```bash
apt install swig python3-dev
```

--------------------------------

### Load Module with Parameters

Source: https://docs.kernel.org/_sources/fb/intel810.rst.txt

Example of loading the i810fb module manually with specific hardware parameters.

```bash
modprobe i810fb vram=2 xres=1024 bpp=8 hsync1=30 hsync2=55 vsync1=50 \
		 vsync2=85 accel=1 mtrr=1
```
Tokens:
Raw