<!DOCTYPE html>
<html lang="en" data-content_root="../">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
<title>BPF cpumask kfuncs — The Linux Kernel documentation</title>
<link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=fa44fd50" />
<link rel="stylesheet" type="text/css" href="../_static/alabaster.css?v=3918102e" />
<script src="../_static/documentation_options.js?v=5929fcd5"></script>
<script src="../_static/doctools.js?v=9bcbadda"></script>
<script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
<link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" />
<link rel="next" title="BPF filesystem kfuncs" href="fs_kfuncs.html" />
<link rel="prev" title="BPF Kernel Functions (kfuncs)" href="kfuncs.html" />
<link rel="stylesheet" href="../_static/custom.css" type="text/css" />
</head><body>
<div class="document">
<div class="sphinxsidebar" role="navigation" aria-label="Main">
<div class="sphinxsidebarwrapper">
<p class="logo"><a href="../index.html">
<img class="logo" src="../_static/logo.svg" alt="Logo of The Linux Kernel"/>
</a></p>
<h1 class="logo"><a href="../index.html">The Linux Kernel</a></h1>
<p class="blurb">6.18.50</p>
<search id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="../search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" />
</form>
</div>
</search>
<script>document.getElementById('searchbox').style.display = "block"</script>
<p>
<h3 class="kernel-toc-contents">Contents</h3>
<input type="checkbox" class="kernel-toc-toggle" id = "kernel-toc-toggle" checked>
<label class="kernel-toc-title" for="kernel-toc-toggle"></label>
<div class="kerneltoc" id="kerneltoc">
<ul>
<li class="toctree-l1"><a class="reference internal" href="../process/development-process.html">Development process</a></li>
<li class="toctree-l1"><a class="reference internal" href="../process/submitting-patches.html">Submitting patches</a></li>
<li class="toctree-l1"><a class="reference internal" href="../process/code-of-conduct.html">Code of conduct</a></li>
<li class="toctree-l1"><a class="reference internal" href="../maintainer/index.html">Maintainer handbook</a></li>
<li class="toctree-l1"><a class="reference internal" href="../process/index.html">All development-process docs</a></li>
</ul>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="../core-api/index.html">Core API</a></li>
<li class="toctree-l1"><a class="reference internal" href="../driver-api/index.html">Driver APIs</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="../subsystem-apis.html">Subsystems</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="../subsystem-apis.html#core-subsystems">Core subsystems</a></li>
<li class="toctree-l2"><a class="reference internal" href="../subsystem-apis.html#human-interfaces">Human interfaces</a></li>
<li class="toctree-l2"><a class="reference internal" href="../subsystem-apis.html#networking-interfaces">Networking interfaces</a></li>
<li class="toctree-l2"><a class="reference internal" href="../subsystem-apis.html#storage-interfaces">Storage interfaces</a></li>
<li class="toctree-l2 current"><a class="reference internal" href="../subsystem-apis.html#other-subsystems">Other subsystems</a><ul class="current">
<li class="toctree-l3"><a class="reference internal" href="../accounting/index.html">Accounting</a></li>
<li class="toctree-l3"><a class="reference internal" href="../cpu-freq/index.html">CPUFreq - CPU frequency and voltage scaling code in the Linux(TM) kernel</a></li>
<li class="toctree-l3"><a class="reference internal" href="../edac/index.html">EDAC Subsystem</a></li>
<li class="toctree-l3"><a class="reference internal" href="../fpga/index.html">FPGA</a></li>
<li class="toctree-l3"><a class="reference internal" href="../i2c/index.html">I2C/SMBus Subsystem</a></li>
<li class="toctree-l3"><a class="reference internal" href="../iio/index.html">Industrial I/O</a></li>
<li class="toctree-l3"><a class="reference internal" href="../pcmcia/index.html">PCMCIA</a></li>
<li class="toctree-l3"><a class="reference internal" href="../spi/index.html">Serial Peripheral Interface (SPI)</a></li>
<li class="toctree-l3"><a class="reference internal" href="../w1/index.html">1-Wire Subsystem</a></li>
<li class="toctree-l3"><a class="reference internal" href="../watchdog/index.html">Watchdog Support</a></li>
<li class="toctree-l3"><a class="reference internal" href="../virt/index.html">Virtualization Support</a></li>
<li class="toctree-l3"><a class="reference internal" href="../hwmon/index.html">Hardware Monitoring</a></li>
<li class="toctree-l3"><a class="reference internal" href="../accel/index.html">Compute Accelerators</a></li>
<li class="toctree-l3"><a class="reference internal" href="../security/index.html">Security Documentation</a></li>
<li class="toctree-l3"><a class="reference internal" href="../crypto/index.html">Crypto API</a></li>
<li class="toctree-l3 current"><a class="reference internal" href="index.html">BPF Documentation</a></li>
<li class="toctree-l3"><a class="reference internal" href="../usb/index.html">USB support</a></li>
<li class="toctree-l3"><a class="reference internal" href="../PCI/index.html">PCI Bus Subsystem</a></li>
<li class="toctree-l3"><a class="reference internal" href="../misc-devices/index.html">Assorted Miscellaneous Devices Documentation</a></li>
<li class="toctree-l3"><a class="reference internal" href="../peci/index.html">PECI Subsystem</a></li>
<li class="toctree-l3"><a class="reference internal" href="../wmi/index.html">WMI Subsystem</a></li>
<li class="toctree-l3"><a class="reference internal" href="../tee/index.html">TEE Subsystem</a></li>
</ul>
</li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../locking/index.html">Locking</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../process/license-rules.html">Licensing rules</a></li>
<li class="toctree-l1"><a class="reference internal" href="../doc-guide/index.html">Writing documentation</a></li>
<li class="toctree-l1"><a class="reference internal" href="../dev-tools/index.html">Development tools</a></li>
<li class="toctree-l1"><a class="reference internal" href="../dev-tools/testing-overview.html">Testing guide</a></li>
<li class="toctree-l1"><a class="reference internal" href="../kernel-hacking/index.html">Hacking guide</a></li>
<li class="toctree-l1"><a class="reference internal" href="../trace/index.html">Tracing</a></li>
<li class="toctree-l1"><a class="reference internal" href="../fault-injection/index.html">Fault injection</a></li>
<li class="toctree-l1"><a class="reference internal" href="../livepatch/index.html">Livepatching</a></li>
<li class="toctree-l1"><a class="reference internal" href="../rust/index.html">Rust</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../admin-guide/index.html">Administration</a></li>
<li class="toctree-l1"><a class="reference internal" href="../kbuild/index.html">Build system</a></li>
<li class="toctree-l1"><a class="reference internal" href="../admin-guide/reporting-issues.html">Reporting issues</a></li>
<li class="toctree-l1"><a class="reference internal" href="../tools/index.html">Userspace tools</a></li>
<li class="toctree-l1"><a class="reference internal" href="../userspace-api/index.html">Userspace API</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../firmware-guide/index.html">Firmware</a></li>
<li class="toctree-l1"><a class="reference internal" href="../devicetree/index.html">Firmware and Devicetree</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../arch/index.html">CPU architectures</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../staging/index.html">Unsorted documentation</a></li>
</ul>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../translations/index.html">Translations</a></li>
</ul>
</div>
<script type="text/javascript"> <!--
var sbar = document.getElementsByClassName("sphinxsidebar")[0];
let currents = document.getElementsByClassName("current")
if (currents.length) {
sbar.scrollTop = currents[currents.length - 1].offsetTop;
}
--> </script>
<div role="note" aria-label="source link">
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/bpf/cpumasks.rst.txt"
rel="nofollow">Show Source</a></li>
</ul>
</div>
</div>
</div>
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<section id="bpf-cpumask-kfuncs">
<span id="cpumasks-header-label"></span><h1>BPF cpumask kfuncs<a class="headerlink" href="#bpf-cpumask-kfuncs" title="Link to this heading">¶</a></h1>
<section id="introduction">
<h2>1. Introduction<a class="headerlink" href="#introduction" title="Link to this heading">¶</a></h2>
<p><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span></code> is a bitmap data structure in the kernel whose indices
reflect the CPUs on the system. Commonly, cpumasks are used to track which CPUs
a task is affinitized to, but they can also be used to e.g. track which cores
are associated with a scheduling domain, which cores on a machine are idle,
etc.</p>
<p>BPF provides programs with a set of <a class="reference internal" href="kfuncs.html#kfuncs-header-label"><span class="std std-ref">BPF Kernel Functions (kfuncs)</span></a> that can be
used to allocate, mutate, query, and free cpumasks.</p>
</section>
<section id="bpf-cpumask-objects">
<h2>2. BPF cpumask objects<a class="headerlink" href="#bpf-cpumask-objects" title="Link to this heading">¶</a></h2>
<p>There are two different types of cpumasks that can be used by BPF programs.</p>
<section id="struct-bpf-cpumask">
<h3>2.1 <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code><a class="headerlink" href="#struct-bpf-cpumask" title="Link to this heading">¶</a></h3>
<p><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> is a cpumask that is allocated by BPF, on behalf of a
BPF program, and whose lifecycle is entirely controlled by BPF. These cpumasks
are RCU-protected, can be mutated, can be used as kptrs, and can be safely cast
to a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*</span></code>.</p>
</section>
<section id="struct-bpf-cpumask-lifecycle">
<h3>2.1.1 <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> lifecycle<a class="headerlink" href="#struct-bpf-cpumask-lifecycle" title="Link to this heading">¶</a></h3>
<p>A <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> is allocated, acquired, and released, using the
following functions:</p>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_create">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_create</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">void</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_create" title="Link to this definition">¶</a><br /></dt>
<dd><p>Create a mutable BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">void</span></code></dt><dd><p>no arguments</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Allocates a cpumask that can be queried, mutated, acquired, and released by
a BPF program. The cpumask returned by this function must either be embedded
in a map as a kptr, or freed with <a class="reference internal" href="#c.bpf_cpumask_release" title="bpf_cpumask_release"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_release()</span></code></a>.</p>
<p><a class="reference internal" href="#c.bpf_cpumask_create" title="bpf_cpumask_create"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_create()</span></code></a> allocates memory using the BPF memory allocator, and
will not block. It may return NULL if no memory is available.</p>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>A pointer to a new <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> instance on success.</p></li>
<li><p>NULL if the BPF memory allocator is out of memory.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_acquire">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_acquire</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_acquire" title="Link to this definition">¶</a><br /></dt>
<dd><p>Acquire a reference to a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The BPF cpumask being acquired. The cpumask must be a trusted
pointer.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Acquires a reference to a BPF cpumask. The cpumask returned by this function
must either be embedded in a map as a kptr, or freed with
<a class="reference internal" href="#c.bpf_cpumask_release" title="bpf_cpumask_release"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_release()</span></code></a>.</p>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>The <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointer passed to the function.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_release">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_release</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_release" title="Link to this definition">¶</a><br /></dt>
<dd><p>Release a previously acquired BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being released.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Releases a previously acquired reference to a BPF cpumask. When the final
reference of the BPF cpumask has been released, it is subsequently freed in
an RCU callback in the BPF memory allocator.</p>
</div>
<p>For example:</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask_map_value</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="n">__kptr</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">cpumask</span><span class="p">;</span>
<span class="p">};</span>
<span class="k">struct</span><span class="w"> </span><span class="nc">array_map</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">__uint</span><span class="p">(</span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">BPF_MAP_TYPE_ARRAY</span><span class="p">);</span>
<span class="w"> </span><span class="n">__type</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">);</span>
<span class="w"> </span><span class="n">__type</span><span class="p">(</span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask_map_value</span><span class="p">);</span>
<span class="w"> </span><span class="n">__uint</span><span class="p">(</span><span class="n">max_entries</span><span class="p">,</span><span class="w"> </span><span class="mi">65536</span><span class="p">);</span>
<span class="p">}</span><span class="w"> </span><span class="n">cpumask_map</span><span class="w"> </span><span class="n">SEC</span><span class="p">(</span><span class="s">".maps"</span><span class="p">);</span>
<span class="k">static</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">cpumask_map_insert</span><span class="p">(</span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="o">*</span><span class="n">mask</span><span class="p">,</span><span class="w"> </span><span class="n">u32</span><span class="w"> </span><span class="n">pid</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask_map_value</span><span class="w"> </span><span class="n">local</span><span class="p">,</span><span class="w"> </span><span class="o">*</span><span class="n">v</span><span class="p">;</span>
<span class="w"> </span><span class="kt">long</span><span class="w"> </span><span class="n">status</span><span class="p">;</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="o">*</span><span class="n">old</span><span class="p">;</span>
<span class="w"> </span><span class="n">u32</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pid</span><span class="p">;</span>
<span class="w"> </span><span class="n">local</span><span class="p">.</span><span class="n">cpumask</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nb">NULL</span><span class="p">;</span>
<span class="w"> </span><span class="n">status</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_map_update_elem</span><span class="p">(</span><span class="o">&</span><span class="n">cpumask_map</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">local</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">status</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">mask</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">status</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_map_lookup_elem</span><span class="p">(</span><span class="o">&</span><span class="n">cpumask_map</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">key</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">v</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">mask</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">ENOENT</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="n">old</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_kptr_xchg</span><span class="p">(</span><span class="o">&</span><span class="n">v</span><span class="o">-></span><span class="n">cpumask</span><span class="p">,</span><span class="w"> </span><span class="n">mask</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">old</span><span class="p">)</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">old</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
<span class="cm">/**</span>
<span class="cm"> * A sample tracepoint showing how a task's cpumask can be queried and</span>
<span class="cm"> * recorded as a kptr.</span>
<span class="cm"> */</span>
<span class="n">SEC</span><span class="p">(</span><span class="s">"tp_btf/task_newtask"</span><span class="p">)</span>
<span class="kt">int</span><span class="w"> </span><span class="n">BPF_PROG</span><span class="p">(</span><span class="n">record_task_cpumask</span><span class="p">,</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">task_struct</span><span class="w"> </span><span class="o">*</span><span class="n">task</span><span class="p">,</span><span class="w"> </span><span class="n">u64</span><span class="w"> </span><span class="n">clone_flags</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="o">*</span><span class="n">cpumask</span><span class="p">;</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">ret</span><span class="p">;</span>
<span class="w"> </span><span class="n">cpumask</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_cpumask_create</span><span class="p">();</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">cpumask</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">ENOMEM</span><span class="p">;</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">bpf_cpumask_full</span><span class="p">(</span><span class="n">task</span><span class="o">-></span><span class="n">cpus_ptr</span><span class="p">))</span>
<span class="w"> </span><span class="n">bpf_printk</span><span class="p">(</span><span class="s">"task %s has CPU affinity"</span><span class="p">,</span><span class="w"> </span><span class="n">task</span><span class="o">-></span><span class="n">comm</span><span class="p">);</span>
<span class="w"> </span><span class="n">bpf_cpumask_copy</span><span class="p">(</span><span class="n">cpumask</span><span class="p">,</span><span class="w"> </span><span class="n">task</span><span class="o">-></span><span class="n">cpus_ptr</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">cpumask_map_insert</span><span class="p">(</span><span class="n">cpumask</span><span class="p">,</span><span class="w"> </span><span class="n">task</span><span class="o">-></span><span class="n">pid</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
</div>
</section>
<hr class="docutils" />
<section id="struct-bpf-cpumask-as-kptrs">
<h3>2.1.1 <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> as kptrs<a class="headerlink" href="#struct-bpf-cpumask-as-kptrs" title="Link to this heading">¶</a></h3>
<p>As mentioned and illustrated above, these <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> objects can
also be stored in a map and used as kptrs. If a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> is in
a map, the reference can be removed from the map with <code class="xref c c-func broken_xref docutils literal notranslate"><span class="pre">bpf_kptr_xchg()</span></code>, or
opportunistically acquired using RCU:</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cm">/* struct containing the struct bpf_cpumask kptr which is stored in the map. */</span>
<span class="k">struct</span><span class="w"> </span><span class="nc">cpumasks_kfunc_map_value</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="n">__kptr</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">bpf_cpumask</span><span class="p">;</span>
<span class="p">};</span>
<span class="cm">/* The map containing struct cpumasks_kfunc_map_value entries. */</span>
<span class="k">struct</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">__uint</span><span class="p">(</span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">BPF_MAP_TYPE_ARRAY</span><span class="p">);</span>
<span class="w"> </span><span class="n">__type</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">);</span>
<span class="w"> </span><span class="n">__type</span><span class="p">(</span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumasks_kfunc_map_value</span><span class="p">);</span>
<span class="w"> </span><span class="n">__uint</span><span class="p">(</span><span class="n">max_entries</span><span class="p">,</span><span class="w"> </span><span class="mi">1</span><span class="p">);</span>
<span class="p">}</span><span class="w"> </span><span class="n">cpumasks_kfunc_map</span><span class="w"> </span><span class="n">SEC</span><span class="p">(</span><span class="s">".maps"</span><span class="p">);</span>
<span class="cm">/* ... */</span>
<span class="cm">/**</span>
<span class="cm"> * A simple example tracepoint program showing how a</span>
<span class="cm"> * struct bpf_cpumask * kptr that is stored in a map can</span>
<span class="cm"> * be passed to kfuncs using RCU protection.</span>
<span class="cm"> */</span>
<span class="n">SEC</span><span class="p">(</span><span class="s">"tp_btf/cgroup_mkdir"</span><span class="p">)</span>
<span class="kt">int</span><span class="w"> </span><span class="n">BPF_PROG</span><span class="p">(</span><span class="n">cgrp_ancestor_example</span><span class="p">,</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cgroup</span><span class="w"> </span><span class="o">*</span><span class="n">cgrp</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">path</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="o">*</span><span class="n">kptr</span><span class="p">;</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumasks_kfunc_map_value</span><span class="w"> </span><span class="o">*</span><span class="n">v</span><span class="p">;</span>
<span class="w"> </span><span class="n">u32</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="w"> </span><span class="cm">/* Assume a bpf_cpumask * kptr was previously stored in the map. */</span>
<span class="w"> </span><span class="n">v</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_map_lookup_elem</span><span class="p">(</span><span class="o">&</span><span class="n">cpumasks_kfunc_map</span><span class="p">,</span><span class="w"> </span><span class="o">&</span><span class="n">key</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">v</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">ENOENT</span><span class="p">;</span>
<span class="w"> </span><span class="n">bpf_rcu_read_lock</span><span class="p">();</span>
<span class="w"> </span><span class="cm">/* Acquire a reference to the bpf_cpumask * kptr that's already stored in the map. */</span>
<span class="w"> </span><span class="n">kptr</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">v</span><span class="o">-></span><span class="n">cpumask</span><span class="p">;</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">kptr</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="cm">/* If no bpf_cpumask was present in the map, it's because</span>
<span class="cm"> * we're racing with another CPU that removed it with</span>
<span class="cm"> * bpf_kptr_xchg() between the bpf_map_lookup_elem()</span>
<span class="cm"> * above, and our load of the pointer from the map.</span>
<span class="cm"> */</span>
<span class="w"> </span><span class="n">bpf_rcu_read_unlock</span><span class="p">();</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">EBUSY</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="n">bpf_cpumask_setall</span><span class="p">(</span><span class="n">kptr</span><span class="p">);</span>
<span class="w"> </span><span class="n">bpf_rcu_read_unlock</span><span class="p">();</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</div>
</section>
<hr class="docutils" />
<section id="struct-cpumask">
<h3>2.2 <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span></code><a class="headerlink" href="#struct-cpumask" title="Link to this heading">¶</a></h3>
<p><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span></code> is the object that actually contains the cpumask bitmap
being queried, mutated, etc. A <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> wraps a <code class="docutils literal notranslate"><span class="pre">struct</span>
<span class="pre">cpumask</span></code>, which is why it’s safe to cast it as such (note however that it is
<strong>not</strong> safe to cast a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*</span></code> to a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code>, and
the verifier will reject any program that tries to do so).</p>
<p>As we’ll see below, any kfunc that mutates its cpumask argument will take a
<code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> as that argument. Any argument that simply queries the
cpumask will instead take a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*</span></code>.</p>
</section>
</section>
<section id="cpumask-kfuncs">
<h2>3. cpumask kfuncs<a class="headerlink" href="#cpumask-kfuncs" title="Link to this heading">¶</a></h2>
<p>Above, we described the kfuncs that can be used to allocate, acquire, release,
etc a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code>. This section of the document will describe the
kfuncs for mutating and querying cpumasks.</p>
<section id="mutating-cpumasks">
<h3>3.1 Mutating cpumasks<a class="headerlink" href="#mutating-cpumasks" title="Link to this heading">¶</a></h3>
<p>Some cpumask kfuncs are “read-only” in that they don’t mutate any of their
arguments, whereas others mutate at least one argument (which means that the
argument must be a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code>, as described above).</p>
<p>This section will describe all of the cpumask kfuncs which mutate at least one
argument. <a class="reference internal" href="#cpumasks-querying-label"><span class="std std-ref">3.2 Querying cpumasks</span></a> below describes the read-only kfuncs.</p>
</section>
<section id="setting-and-clearing-cpus">
<h3>3.1.1 Setting and clearing CPUs<a class="headerlink" href="#setting-and-clearing-cpus" title="Link to this heading">¶</a></h3>
<p><a class="reference internal" href="#c.bpf_cpumask_set_cpu" title="bpf_cpumask_set_cpu"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_set_cpu()</span></code></a> and <a class="reference internal" href="#c.bpf_cpumask_clear_cpu" title="bpf_cpumask_clear_cpu"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_clear_cpu()</span></code></a> can be used to set and clear
a CPU in a <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> respectively:</p>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_set_cpu">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_set_cpu</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="n"><span class="pre">cpu</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_set_cpu" title="Link to this definition">¶</a><br /></dt>
<dd><p>Set a bit for a CPU in a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">u32</span> <span class="pre">cpu</span></code></dt><dd><p>The CPU to be set in the cpumask.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The BPF cpumask in which a bit is being set.</p>
</dd>
</dl>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_clear_cpu">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_clear_cpu</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="n"><span class="pre">cpu</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_clear_cpu" title="Link to this definition">¶</a><br /></dt>
<dd><p>Clear a bit for a CPU in a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">u32</span> <span class="pre">cpu</span></code></dt><dd><p>The CPU to be cleared from the cpumask.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The BPF cpumask in which a bit is being cleared.</p>
</dd>
</dl>
</div>
<p>These kfuncs are pretty straightforward, and can be used, for example, as
follows:</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cm">/**</span>
<span class="cm"> * A sample tracepoint showing how a cpumask can be queried.</span>
<span class="cm"> */</span>
<span class="n">SEC</span><span class="p">(</span><span class="s">"tp_btf/task_newtask"</span><span class="p">)</span>
<span class="kt">int</span><span class="w"> </span><span class="n">BPF_PROG</span><span class="p">(</span><span class="n">test_set_clear_cpu</span><span class="p">,</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">task_struct</span><span class="w"> </span><span class="o">*</span><span class="n">task</span><span class="p">,</span><span class="w"> </span><span class="n">u64</span><span class="w"> </span><span class="n">clone_flags</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="o">*</span><span class="n">cpumask</span><span class="p">;</span>
<span class="w"> </span><span class="n">cpumask</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_cpumask_create</span><span class="p">();</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">cpumask</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">ENOMEM</span><span class="p">;</span>
<span class="w"> </span><span class="n">bpf_cpumask_set_cpu</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">cpumask</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">bpf_cpumask_test_cpu</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">cast</span><span class="p">(</span><span class="n">cpumask</span><span class="p">)))</span>
<span class="w"> </span><span class="cm">/* Should never happen. */</span>
<span class="w"> </span><span class="k">goto</span><span class="w"> </span><span class="n">release_exit</span><span class="p">;</span>
<span class="w"> </span><span class="n">bpf_cpumask_clear_cpu</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">cpumask</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">bpf_cpumask_test_cpu</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">cast</span><span class="p">(</span><span class="n">cpumask</span><span class="p">)))</span>
<span class="w"> </span><span class="cm">/* Should never happen. */</span>
<span class="w"> </span><span class="k">goto</span><span class="w"> </span><span class="n">release_exit</span><span class="p">;</span>
<span class="w"> </span><span class="cm">/* struct cpumask * pointers such as task->cpus_ptr can also be queried. */</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">bpf_cpumask_test_cpu</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">task</span><span class="o">-></span><span class="n">cpus_ptr</span><span class="p">))</span>
<span class="w"> </span><span class="n">bpf_printk</span><span class="p">(</span><span class="s">"task %s can use CPU %d"</span><span class="p">,</span><span class="w"> </span><span class="n">task</span><span class="o">-></span><span class="n">comm</span><span class="p">,</span><span class="w"> </span><span class="mi">0</span><span class="p">);</span>
<span class="nl">release_exit</span><span class="p">:</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">cpumask</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</div>
<hr class="docutils" />
<p><a class="reference internal" href="#c.bpf_cpumask_test_and_set_cpu" title="bpf_cpumask_test_and_set_cpu"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_test_and_set_cpu()</span></code></a> and <a class="reference internal" href="#c.bpf_cpumask_test_and_clear_cpu" title="bpf_cpumask_test_and_clear_cpu"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_test_and_clear_cpu()</span></code></a> are
complementary kfuncs that allow callers to atomically test and set (or clear)
CPUs:</p>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_test_and_set_cpu">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_test_and_set_cpu</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="n"><span class="pre">cpu</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_test_and_set_cpu" title="Link to this definition">¶</a><br /></dt>
<dd><p>Atomically test and set a CPU in a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">u32</span> <span class="pre">cpu</span></code></dt><dd><p>The CPU being set and queried for.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The BPF cpumask being set and queried for containing a CPU.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - <strong>cpu</strong> is set in the cpumask</p></li>
<li><p>false - <strong>cpu</strong> was not set in the cpumask, or <strong>cpu</strong> is invalid.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_test_and_clear_cpu">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_test_and_clear_cpu</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="n"><span class="pre">cpu</span></span>, <span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_test_and_clear_cpu" title="Link to this definition">¶</a><br /></dt>
<dd><p>Atomically test and clear a CPU in a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">u32</span> <span class="pre">cpu</span></code></dt><dd><p>The CPU being cleared and queried for.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The BPF cpumask being cleared and queried for containing a CPU.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - <strong>cpu</strong> is set in the cpumask</p></li>
<li><p>false - <strong>cpu</strong> was not set in the cpumask, or <strong>cpu</strong> is invalid.</p></li>
</ul>
</div>
<hr class="docutils" />
<p>We can also set and clear entire <code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*</span></code> objects in one
operation using <a class="reference internal" href="#c.bpf_cpumask_setall" title="bpf_cpumask_setall"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_setall()</span></code></a> and <a class="reference internal" href="#c.bpf_cpumask_clear" title="bpf_cpumask_clear"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_clear()</span></code></a>:</p>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_setall">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_setall</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_setall" title="Link to this definition">¶</a><br /></dt>
<dd><p>Set all of the bits in a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The BPF cpumask having all of its bits set.</p>
</dd>
</dl>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_clear">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_clear</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_clear" title="Link to this definition">¶</a><br /></dt>
<dd><p>Clear all of the bits in a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The BPF cpumask being cleared.</p>
</dd>
</dl>
</div>
</section>
<section id="operations-between-cpumasks">
<h3>3.1.2 Operations between cpumasks<a class="headerlink" href="#operations-between-cpumasks" title="Link to this heading">¶</a></h3>
<p>In addition to setting and clearing individual CPUs in a single cpumask,
callers can also perform bitwise operations between multiple cpumasks using
<a class="reference internal" href="#c.bpf_cpumask_and" title="bpf_cpumask_and"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_and()</span></code></a>, <a class="reference internal" href="#c.bpf_cpumask_or" title="bpf_cpumask_or"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_or()</span></code></a>, and <a class="reference internal" href="#c.bpf_cpumask_xor" title="bpf_cpumask_xor"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_xor()</span></code></a>:</p>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_and">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_and</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dst</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_and" title="Link to this definition">¶</a><br /></dt>
<dd><p>AND two cpumasks and store the result.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*dst</span></code></dt><dd><p>The BPF cpumask where the result is being stored.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first input.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second input.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - <strong>dst</strong> has at least one bit set following the operation</p></li>
<li><p>false - <strong>dst</strong> is empty following the operation</p></li>
</ul>
<p><strong>Description</strong></p>
<p><code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_or">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_or</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dst</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_or" title="Link to this definition">¶</a><br /></dt>
<dd><p>OR two cpumasks and store the result.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*dst</span></code></dt><dd><p>The BPF cpumask where the result is being stored.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first input.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second input.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p><code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_xor">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_xor</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dst</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_xor" title="Link to this definition">¶</a><br /></dt>
<dd><p>XOR two cpumasks and store the result.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*dst</span></code></dt><dd><p>The BPF cpumask where the result is being stored.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first input.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second input.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p><code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
</div>
<p>The following is an example of how they may be used. Note that some of the
kfuncs shown in this example will be covered in more detail below.</p>
<div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cm">/**</span>
<span class="cm"> * A sample tracepoint showing how a cpumask can be mutated using</span>
<span class="cm"> bitwise operators (and queried).</span>
<span class="cm"> */</span>
<span class="n">SEC</span><span class="p">(</span><span class="s">"tp_btf/task_newtask"</span><span class="p">)</span>
<span class="kt">int</span><span class="w"> </span><span class="n">BPF_PROG</span><span class="p">(</span><span class="n">test_and_or_xor</span><span class="p">,</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">task_struct</span><span class="w"> </span><span class="o">*</span><span class="n">task</span><span class="p">,</span><span class="w"> </span><span class="n">u64</span><span class="w"> </span><span class="n">clone_flags</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">bpf_cpumask</span><span class="w"> </span><span class="o">*</span><span class="n">mask1</span><span class="p">,</span><span class="w"> </span><span class="o">*</span><span class="n">mask2</span><span class="p">,</span><span class="w"> </span><span class="o">*</span><span class="n">dst1</span><span class="p">,</span><span class="w"> </span><span class="o">*</span><span class="n">dst2</span><span class="p">;</span>
<span class="w"> </span><span class="n">mask1</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_cpumask_create</span><span class="p">();</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">mask1</span><span class="p">)</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">ENOMEM</span><span class="p">;</span>
<span class="w"> </span><span class="n">mask2</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bpf_cpumask_create</span><span class="p">();</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">mask2</span><span class="p">)</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">mask1</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">ENOMEM</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="c1">// ...Safely create the other two masks... */</span>
<span class="w"> </span><span class="n">bpf_cpumask_set_cpu</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="n">mask1</span><span class="p">);</span>
<span class="w"> </span><span class="n">bpf_cpumask_set_cpu</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="n">mask2</span><span class="p">);</span>
<span class="w"> </span><span class="n">bpf_cpumask_and</span><span class="p">(</span><span class="n">dst1</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">mask1</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">mask2</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">bpf_cpumask_empty</span><span class="p">((</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">dst1</span><span class="p">))</span>
<span class="w"> </span><span class="cm">/* Should never happen. */</span>
<span class="w"> </span><span class="k">goto</span><span class="w"> </span><span class="n">release_exit</span><span class="p">;</span>
<span class="w"> </span><span class="n">bpf_cpumask_or</span><span class="p">(</span><span class="n">dst1</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">mask1</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">mask2</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">bpf_cpumask_test_cpu</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">dst1</span><span class="p">))</span>
<span class="w"> </span><span class="cm">/* Should never happen. */</span>
<span class="w"> </span><span class="k">goto</span><span class="w"> </span><span class="n">release_exit</span><span class="p">;</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">bpf_cpumask_test_cpu</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">dst1</span><span class="p">))</span>
<span class="w"> </span><span class="cm">/* Should never happen. */</span>
<span class="w"> </span><span class="k">goto</span><span class="w"> </span><span class="n">release_exit</span><span class="p">;</span>
<span class="w"> </span><span class="n">bpf_cpumask_xor</span><span class="p">(</span><span class="n">dst2</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">mask1</span><span class="p">,</span><span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">mask2</span><span class="p">);</span>
<span class="w"> </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="o">!</span><span class="n">bpf_cpumask_equal</span><span class="p">((</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">dst1</span><span class="p">,</span>
<span class="w"> </span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">cpumask</span><span class="w"> </span><span class="o">*</span><span class="p">)</span><span class="n">dst2</span><span class="p">))</span>
<span class="w"> </span><span class="cm">/* Should never happen. */</span>
<span class="w"> </span><span class="k">goto</span><span class="w"> </span><span class="n">release_exit</span><span class="p">;</span>
<span class="w"> </span><span class="nl">release_exit</span><span class="p">:</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">mask1</span><span class="p">);</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">mask2</span><span class="p">);</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">dst1</span><span class="p">);</span>
<span class="w"> </span><span class="n">bpf_cpumask_release</span><span class="p">(</span><span class="n">dst2</span><span class="p">);</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</div>
<hr class="docutils" />
<p>The contents of an entire cpumask may be copied to another using
<a class="reference internal" href="#c.bpf_cpumask_copy" title="bpf_cpumask_copy"><code class="xref c c-func docutils literal notranslate"><span class="pre">bpf_cpumask_copy()</span></code></a>:</p>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_copy">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_copy</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">bpf_cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dst</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_copy" title="Link to this definition">¶</a><br /></dt>
<dd><p>Copy the contents of a cpumask into a BPF cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span> <span class="pre">*dst</span></code></dt><dd><p>The BPF cpumask being copied into.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src</span></code></dt><dd><p>The cpumask being copied.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>A <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointer may be safely passed to <strong>src</strong>.</p>
</div>
<hr class="docutils" />
</section>
<section id="querying-cpumasks">
<span id="cpumasks-querying-label"></span><h3>3.2 Querying cpumasks<a class="headerlink" href="#querying-cpumasks" title="Link to this heading">¶</a></h3>
<p>In addition to the above kfuncs, there is also a set of read-only kfuncs that
can be used to query the contents of cpumasks.</p>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_first">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_first</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.bpf_cpumask_first" title="cpumask"><span class="n"><span class="pre">cpumask</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_first" title="Link to this definition">¶</a><br /></dt>
<dd><p>Get the index of the first nonzero bit in the cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being queried.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Find the index of the first nonzero bit of the cpumask. A <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code>
pointer may be safely passed to this function.</p>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>The index of the first nonzero bit in the <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span></code>.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_first_zero">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_first_zero</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.bpf_cpumask_first_zero" title="cpumask"><span class="n"><span class="pre">cpumask</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_first_zero" title="Link to this definition">¶</a><br /></dt>
<dd><p>Get the index of the first unset bit in the cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being queried.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Find the index of the first unset bit of the cpumask. A <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code>
pointer may be safely passed to this function.</p>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>The index of the first zero bit in the <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">cpumask</span></code>.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_first_and">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_first_and</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_first_and" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return the index of the first nonzero bit from the AND of two cpumasks.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first cpumask.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second cpumask.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Find the index of the first nonzero bit of the AND of two cpumasks.
<code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>The index of the first bit that is nonzero in both cpumask instances.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_test_cpu">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_test_cpu</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="n"><span class="pre">cpu</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.bpf_cpumask_test_cpu" title="cpumask"><span class="n"><span class="pre">cpumask</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_test_cpu" title="Link to this definition">¶</a><br /></dt>
<dd><p>Test whether a CPU is set in a cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">u32</span> <span class="pre">cpu</span></code></dt><dd><p>The CPU being queried for.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being queried for containing a CPU.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - <strong>cpu</strong> is set in the cpumask</p></li>
<li><p>false - <strong>cpu</strong> was not set in the cpumask, or <strong>cpu</strong> is an invalid cpu.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_weight">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_weight</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.bpf_cpumask_weight" title="cpumask"><span class="n"><span class="pre">cpumask</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_weight" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return the number of bits in <strong>cpumask</strong>.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being queried.</p>
</dd>
</dl>
<p><strong>Description</strong></p>
<p>Count the number of set bits in the given cpumask.</p>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>The number of bits set in the mask.</p></li>
</ul>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_equal">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_equal</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_equal" title="Link to this definition">¶</a><br /></dt>
<dd><p>Check two cpumasks for equality.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first input.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second input.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - <strong>src1</strong> and <strong>src2</strong> have the same bits set.</p></li>
<li><p>false - <strong>src1</strong> and <strong>src2</strong> differ in at least one bit.</p></li>
</ul>
<p><strong>Description</strong></p>
<p><code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_intersects">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_intersects</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_intersects" title="Link to this definition">¶</a><br /></dt>
<dd><p>Check two cpumasks for overlap.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first input.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second input.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - <strong>src1</strong> and <strong>src2</strong> have at least one of the same bits set.</p></li>
<li><p>false - <strong>src1</strong> and <strong>src2</strong> don’t have any of the same bits set.</p></li>
</ul>
<p><strong>Description</strong></p>
<p><code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_subset">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_subset</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_subset" title="Link to this definition">¶</a><br /></dt>
<dd><p>Check if a cpumask is a subset of another.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first cpumask being checked as a subset.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second cpumask being checked as a superset.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - All of the bits of <strong>src1</strong> are set in <strong>src2</strong>.</p></li>
<li><p>false - At least one bit in <strong>src1</strong> is not set in <strong>src2</strong>.</p></li>
</ul>
<p><strong>Description</strong></p>
<p><code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_empty">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_empty</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.bpf_cpumask_empty" title="cpumask"><span class="n"><span class="pre">cpumask</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_empty" title="Link to this definition">¶</a><br /></dt>
<dd><p>Check if a cpumask is empty.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being checked.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - None of the bits in <strong>cpumask</strong> are set.</p></li>
<li><p>false - At least one bit in <strong>cpumask</strong> is set.</p></li>
</ul>
<p><strong>Description</strong></p>
<p>A <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointer may be safely passed to <strong>cpumask</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_full">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="kt"><span class="pre">bool</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_full</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.bpf_cpumask_full" title="cpumask"><span class="n"><span class="pre">cpumask</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_full" title="Link to this definition">¶</a><br /></dt>
<dd><p>Check if a cpumask has all bits set.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being checked.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>true - All of the bits in <strong>cpumask</strong> are set.</p></li>
<li><p>false - At least one bit in <strong>cpumask</strong> is cleared.</p></li>
</ul>
<p><strong>Description</strong></p>
<p>A <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointer may be safely passed to <strong>cpumask</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_any_distribute">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_any_distribute</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><a class="reference internal" href="#c.bpf_cpumask_any_distribute" title="cpumask"><span class="n"><span class="pre">cpumask</span></span></a><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">cpumask</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_any_distribute" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return a random set CPU from a cpumask.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*cpumask</span></code></dt><dd><p>The cpumask being queried.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>A random set bit within [0, num_cpus) if at least one bit is set.</p></li>
<li><p>>= num_cpus if no bit is set.</p></li>
</ul>
<p><strong>Description</strong></p>
<p>A <code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointer may be safely passed to <strong>src</strong>.</p>
</div>
<dl class="c function">
<dt class="sig sig-object c" id="c.bpf_cpumask_any_and_distribute">
<span class="pre">__bpf_kfunc</span><span class="w"> </span><span class="n"><span class="pre">u32</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">bpf_cpumask_any_and_distribute</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src1</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">cpumask</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">src2</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.bpf_cpumask_any_and_distribute" title="Link to this definition">¶</a><br /></dt>
<dd><p>Return a random set CPU from the AND of two cpumasks.</p>
</dd></dl>
<div class="kernelindent docutils container">
<p><strong>Parameters</strong></p>
<dl class="simple">
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src1</span></code></dt><dd><p>The first cpumask.</p>
</dd>
<dt><code class="docutils literal notranslate"><span class="pre">const</span> <span class="pre">struct</span> <span class="pre">cpumask</span> <span class="pre">*src2</span></code></dt><dd><p>The second cpumask.</p>
</dd>
</dl>
<p><strong>Return</strong></p>
<ul class="simple">
<li><p>A random set bit within [0, num_cpus) from the AND of two cpumasks, if at
least one bit is set.</p></li>
<li><p>>= num_cpus if no bit is set.</p></li>
</ul>
<p><strong>Description</strong></p>
<p><code class="xref c c-struct broken_xref docutils literal notranslate"><span class="pre">struct</span> <span class="pre">bpf_cpumask</span></code> pointers may be safely passed to <strong>src1</strong> and <strong>src2</strong>.</p>
</div>
<hr class="docutils" />
<p>Some example usages of these querying kfuncs were shown above. We will not
replicate those examples here. Note, however, that all of the aforementioned
kfuncs are tested in <a class="reference external" href="https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/tools/testing/selftests/bpf/progs/cpumask_success.c">tools/testing/selftests/bpf/progs/cpumask_success.c</a>, so
please take a look there if you’re looking for more examples of how they can be
used.</p>
</section>
</section>
<section id="adding-bpf-cpumask-kfuncs">
<h2>4. Adding BPF cpumask kfuncs<a class="headerlink" href="#adding-bpf-cpumask-kfuncs" title="Link to this heading">¶</a></h2>
<p>The set of supported BPF cpumask kfuncs are not (yet) a 1-1 match with the
cpumask operations in include/linux/cpumask.h. Any of those cpumask operations
could easily be encapsulated in a new kfunc if and when required. If you’d like
to support a new cpumask operation, please feel free to submit a patch. If you
do add a new cpumask kfunc, please document it here, and add any relevant
selftest testcases to the cpumask selftest suite.</p>
</section>
</section>
</div>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
©The kernel development community.
|
Powered by <a href="https://www.sphinx-doc.org/">Sphinx 8.1.3</a>
& <a href="https://alabaster.readthedocs.io">Alabaster 0.7.16</a>
|
<a href="../_sources/bpf/cpumasks.rst.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>