content/docs/12.2.1/reference/user/10_filesystem.html - nuttx-website - Git at Google

 <!--
  Documentation/_templates/layout.html

  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.  The
  ASF licenses this file to you under the Apache License, Version 2.0 (the
  "License"); you may not use this file except in compliance with the
  License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
  License for the specific language governing permissions and limitations
  under the License.
 -->

 <!DOCTYPE html>
 <html class="writer-html5" lang="en" >
 <head>
   <meta charset="utf-8" /><meta name="generator" content="Docutils 0.18.1: http://docutils.sourceforge.net/" />

   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>File System Interfaces &mdash; NuttX latest documentation</title>
       <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
       <link rel="stylesheet" href="../../_static/css/theme.css" type="text/css" />
       <link rel="stylesheet" href="../../_static/copybutton.css" type="text/css" />
       <link rel="stylesheet" href="../../_static/tabs.css" type="text/css" />
       <link rel="stylesheet" href="../../_static/custom.css" type="text/css" />
     <link rel="shortcut icon" href="../../_static/favicon.ico"/>
   <!--[if lt IE 9]>
     <script src="../../_static/js/html5shiv.min.js"></script>
   <![endif]-->

         <script src="../../_static/jquery.js"></script>
         <script src="../../_static/_sphinx_javascript_frameworks_compat.js"></script>
         <script data-url_root="../../" id="documentation_options" src="../../_static/documentation_options.js"></script>
         <script src="../../_static/doctools.js"></script>
         <script src="../../_static/sphinx_highlight.js"></script>
         <script src="../../_static/clipboard.min.js"></script>
         <script src="../../_static/copybutton.js"></script>
     <script src="../../_static/js/theme.js"></script>
     <link rel="index" title="Index" href="../../genindex.html" />
     <link rel="search" title="Search" href="../../search.html" />
     <link rel="next" title="Network Interfaces" href="11_network.html" />
     <link rel="prev" title="Environment Variables" href="09_env_vars.html" />
 </head>

 <body class="wy-body-for-nav">
   <div class="wy-grid-for-nav">
     <nav data-toggle="wy-nav-shift" class="wy-nav-side">
       <div class="wy-side-scroll">
         <div class="wy-side-nav-search" >

     <a href="../../index.html" class="icon icon-home"> NuttX


   </a>

   <!-- this version selector is quite ugly, should be probably replaced by something
        more modern -->

   <div class="version-selector">
     <select onchange="javascript:location.href = this.value;">

     <option value="../../../latest" selected="selected">latest</option>

     <option value="../../../10.0.0" >10.0.0</option>

     <option value="../../../10.0.1" >10.0.1</option>

     <option value="../../../10.1.0" >10.1.0</option>

     <option value="../../../10.2.0" >10.2.0</option>

     <option value="../../../10.3.0" >10.3.0</option>

     <option value="../../../11.0.0" >11.0.0</option>

     <option value="../../../12.0.0" >12.0.0</option>

     <option value="../../../12.1.0" >12.1.0</option>

     <option value="../../../12.2.0" >12.2.0</option>

     <option value="../../../12.2.1" >12.2.1</option>

     <option value="../../../12.3.0" >12.3.0</option>

     <option value="../../../12.4.0" >12.4.0</option>

     <option value="../../../12.5.0" >12.5.0</option>

     <option value="../../../12.5.1" >12.5.1</option>

     <option value="../../../12.6.0" >12.6.0</option>

     <option value="../../../12.7.0" >12.7.0</option>

     <option value="../../../12.8.0" >12.8.0</option>

     <option value="../../../12.9.0" >12.9.0</option>

     <option value="../../../12.10.0" >12.10.0</option>

     <option value="../../../12.11.0" >12.11.0</option>

     </select>
   </div>


 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="../../search.html" method="get">
     <input type="text" name="q" placeholder="Search docs" aria-label="Search docs" />
     <input type="hidden" name="check_keywords" value="yes" />
     <input type="hidden" name="area" value="default" />
   </form>
 </div>

         </div><div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="Navigation menu">
               <p class="caption" role="heading"><span class="caption-text">Table of Contents</span></p>
 <ul class="current">
 <li class="toctree-l1"><a class="reference internal" href="../../index.html">Home</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../introduction/index.html">Introduction</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../quickstart/index.html">Getting Started</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../contributing/index.html">Contributing</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../introduction/inviolables.html">The Inviolable Principles of NuttX</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../platforms/index.html">Supported Platforms</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../components/index.html">OS Components</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../applications/index.html">Applications</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="../index.html">API Reference</a><ul class="current">
 <li class="toctree-l2 current"><a class="reference internal" href="index.html">Userspace API</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="01_task_control.html">Task Control Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="02_task_scheduling.html">Task Scheduling Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="03_task_control.html">Task Control Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="04_message_queue.html">Named Message Queue Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="05_counting_semaphore.html">Counting Semaphore Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="06_clocks_timers.html">Clocks and Timers</a></li>
 <li class="toctree-l3"><a class="reference internal" href="07_signals.html">Signal Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="08_pthread.html">Pthread Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="09_env_vars.html">Environment Variables</a></li>
 <li class="toctree-l3 current"><a class="current reference internal" href="#">File System Interfaces</a><ul>
 <li class="toctree-l4"><a class="reference internal" href="#nuttx-file-system-overview">NuttX File System Overview</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#driver-operations">Driver Operations</a><ul>
 <li class="toctree-l5"><a class="reference internal" href="#fcntl-h"><code class="docutils literal notranslate"><span class="pre">fcntl.h</span></code></a></li>
 <li class="toctree-l5"><a class="reference internal" href="#unistd-h"><code class="docutils literal notranslate"><span class="pre">unistd.h</span></code></a></li>
 <li class="toctree-l5"><a class="reference internal" href="#sys-ioctl-h"><code class="docutils literal notranslate"><span class="pre">sys/ioctl.h</span></code></a></li>
 <li class="toctree-l5"><a class="reference internal" href="#poll-h"><code class="docutils literal notranslate"><span class="pre">poll.h</span></code></a></li>
 <li class="toctree-l5"><a class="reference internal" href="#sys-select-h"><code class="docutils literal notranslate"><span class="pre">sys/select.h</span></code></a></li>
 <li class="toctree-l5"><a class="reference internal" href="#directory-operations-dirent-h">Directory Operations (<code class="docutils literal notranslate"><span class="pre">dirent.h</span></code>)</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#unix-standard-operations-unistd-h">UNIX Standard Operations (<code class="docutils literal notranslate"><span class="pre">unistd.h</span></code>)</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#standard-i-o">Standard I/O</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#standard-library-stdlib-h">Standard Library (<code class="docutils literal notranslate"><span class="pre">stdlib.h</span></code>)</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#asynchronous-i-o">Asynchronous I/O</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#standard-string-operations">Standard String Operations</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#pipes-and-fifos">Pipes and FIFOs</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#mmap-and-execute-in-place-xip"><code class="docutils literal notranslate"><span class="pre">mmap()</span></code> and eXecute In Place (XIP)</a></li>
 <li class="toctree-l5"><a class="reference internal" href="#fdsan">Fdsan</a></li>
 </ul>
 </li>
 </ul>
 </li>
 <li class="toctree-l3"><a class="reference internal" href="11_network.html">Network Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="12_shared_memory.html">Shared Memory Interfaces</a></li>
 <li class="toctree-l3"><a class="reference internal" href="13_boardctl.html">Board IOCTL</a></li>
 <li class="toctree-l3"><a class="reference internal" href="13_logging.html">Logging</a></li>
 <li class="toctree-l3"><a class="reference internal" href="structures.html">OS Data Structures</a></li>
 </ul>
 </li>
 <li class="toctree-l2"><a class="reference internal" href="../os/index.html">Architecture APIs</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="../../faq/index.html">FAQ</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../guides/index.html">Guides</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../glossary.html">Glossary</a></li>
 </ul>

         </div>
       </div>
     </nav>

     <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap"><nav class="wy-nav-top" aria-label="Mobile navigation menu" >
           <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
           <a href="../../index.html">NuttX</a>
       </nav>

       <div class="wy-nav-content">
         <div class="rst-content">
           <div role="navigation" aria-label="Page navigation">
   <ul class="wy-breadcrumbs">
       <li><a href="../../index.html" class="icon icon-home" aria-label="Home"></a></li>
           <li class="breadcrumb-item"><a href="../index.html">API Reference</a></li>
           <li class="breadcrumb-item"><a href="index.html">Userspace API</a></li>
       <li class="breadcrumb-item active">File System Interfaces</li>
       <li class="wy-breadcrumbs-aside">
             <a href="../../_sources/reference/user/10_filesystem.rst.txt" rel="nofollow"> View page source</a>
       </li>
   </ul>
   <hr/>
 </div>
           <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
            <div itemprop="articleBody">

   <section id="file-system-interfaces">
 <h1>File System Interfaces<a class="headerlink" href="#file-system-interfaces" title="Permalink to this heading"></a></h1>
 <section id="nuttx-file-system-overview">
 <span id="file-system-overview"></span><h2>NuttX File System Overview<a class="headerlink" href="#nuttx-file-system-overview" title="Permalink to this heading"></a></h2>
 <p><strong>Overview</strong>. NuttX includes an optional, scalable file system. This
 file-system may be omitted altogether; NuttX does not depend on the
 presence of any file system.</p>
 <p><strong>Pseudo Root File System</strong>. A simple <em>in-memory</em>, <em>pseudo</em> file system
 can be enabled by default. This is an <em>in-memory</em> file system because it
 does not require any storage medium or block driver support. Rather,
 file system contents are generated on-the-fly as referenced via standard
 file system operations (open, close, read, write, etc.). In this sense,
 the file system is <em>pseudo</em> file system (in the same sense that the
 Linux <code class="docutils literal notranslate"><span class="pre">/proc</span></code> file system is also referred to as a pseudo file
 system).</p>
 <p>Any user supplied data or logic can be accessed via the pseudo-file
 system. Built in support is provided for character and block
 <a class="reference internal" href="../../guides/drivers.html#drivers-porting"><span class="std std-ref">driver</span></a> <em>nodes</em> in the any
 pseudo file system directory. (By convention, however, all driver nodes
 should be in the <code class="docutils literal notranslate"><span class="pre">/dev</span></code> pseudo file system directory).</p>
 <p><strong>Mounted File Systems</strong> The simple in-memory file system can be
 extended my mounting block devices that provide access to true file
 systems backed up via some mass storage device. NuttX supports the
 standard <code class="docutils literal notranslate"><span class="pre">mount()</span></code> command that allows a block driver to be bound to a
 mount-point within the pseudo file system and to a a file system. At
 present, NuttX supports only the VFAT file system.</p>
 <p><strong>Comparison to Linux</strong> From a programming perspective, the NuttX file
 system appears very similar to a Linux file system. However, there is a
 fundamental difference: The NuttX root file system is a pseudo file
 system and true file systems may be mounted in the pseudo file system.
 In the typical Linux installation by comparison, the Linux root file
 system is a true file system and pseudo file systems may be mounted in
 the true, root file system. The approach selected by NuttX is intended
 to support greater scalability from the very tiny platform to the
 moderate platform.</p>
 <p><strong>File System Interfaces</strong>. The NuttX file system simply supports a set
 of standard, file system APIs (<code class="docutils literal notranslate"><span class="pre">open()</span></code>, <code class="docutils literal notranslate"><span class="pre">close()</span></code>, <code class="docutils literal notranslate"><span class="pre">read()</span></code>,
 <code class="docutils literal notranslate"><span class="pre">write</span></code>, etc.) and a registration mechanism that allows devices
 drivers to a associated with <em>nodes</em> in a file-system-like name space.</p>
 </section>
 <section id="driver-operations">
 <h2>Driver Operations<a class="headerlink" href="#driver-operations" title="Permalink to this heading"></a></h2>
 <section id="fcntl-h">
 <h3><code class="docutils literal notranslate"><span class="pre">fcntl.h</span></code><a class="headerlink" href="#fcntl-h" title="Permalink to this heading"></a></h3>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.creat">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">creat</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">path</span></span>, <span class="n"><span class="pre">mode_t</span></span><span class="w"> </span><span class="n"><span class="pre">mode</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.creat" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.open">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">open</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">path</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">oflag</span></span>, <span class="p"><span class="pre">...</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.open" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.fcntl">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">fcntl</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">cmd</span></span>, <span class="p"><span class="pre">...</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.fcntl" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 </section>
 <section id="unistd-h">
 <h3><code class="docutils literal notranslate"><span class="pre">unistd.h</span></code><a class="headerlink" href="#unistd-h" title="Permalink to this heading"></a></h3>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.close">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">close</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.close" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.dup">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">dup</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.dup" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.dup2">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">dup2</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd1</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd2</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.dup2" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.lseek">
 <span class="n"><span class="pre">off_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">lseek</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="n"><span class="pre">off_t</span></span><span class="w"> </span><span class="n"><span class="pre">offset</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">whence</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.lseek" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.pread">
 <span class="n"><span class="pre">ssize_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">pread</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">buf</span></span>, <a class="reference internal" href="structures.html#c.size_t" title="size_t"><span class="n"><span class="pre">size_t</span></span></a><span class="w"> </span><span class="n"><span class="pre">nbytes</span></span>, <span class="n"><span class="pre">off_t</span></span><span class="w"> </span><span class="n"><span class="pre">offset</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.pread" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.pwrite">
 <span class="n"><span class="pre">ssize_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">pwrite</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">buf</span></span>, <a class="reference internal" href="structures.html#c.size_t" title="size_t"><span class="n"><span class="pre">size_t</span></span></a><span class="w"> </span><span class="n"><span class="pre">nbytes</span></span>, <span class="n"><span class="pre">off_t</span></span><span class="w"> </span><span class="n"><span class="pre">offset</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.pwrite" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.read">
 <span class="n"><span class="pre">ssize_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">read</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">buf</span></span>, <a class="reference internal" href="structures.html#c.size_t" title="size_t"><span class="n"><span class="pre">size_t</span></span></a><span class="w"> </span><span class="n"><span class="pre">nbytes</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.read" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.unlink">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">unlink</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">path</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.unlink" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.write">
 <span class="n"><span class="pre">ssize_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">write</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">buf</span></span>, <a class="reference internal" href="structures.html#c.size_t" title="size_t"><span class="n"><span class="pre">size_t</span></span></a><span class="w"> </span><span class="n"><span class="pre">nbytes</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.write" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 </section>
 <section id="sys-ioctl-h">
 <h3><code class="docutils literal notranslate"><span class="pre">sys/ioctl.h</span></code><a class="headerlink" href="#sys-ioctl-h" title="Permalink to this heading"></a></h3>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.ioctl">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">ioctl</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">req</span></span>, <span class="p"><span class="pre">...</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.ioctl" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 </section>
 <section id="poll-h">
 <h3><code class="docutils literal notranslate"><span class="pre">poll.h</span></code><a class="headerlink" href="#poll-h" title="Permalink to this heading"></a></h3>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.poll">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">poll</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">pollfd</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">fds</span></span>, <span class="n"><span class="pre">nfds_t</span></span><span class="w"> </span><span class="n"><span class="pre">nfds</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">timeout</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.poll" title="Permalink to this definition"></a><br /></dt>
 <dd><p>Waits for one of a set of file descriptors
 to become ready to perform I/O. If none of the events requested (and no
 error) has occurred for any of the file descriptors, then <code class="docutils literal notranslate"><span class="pre">poll()</span></code>
 blocks until one of the events occurs.</p>
 <p><strong>Configuration Settings</strong>. In order to use the select with TCP/IP
 sockets test, you must have the following things selected in your NuttX
 configuration file:</p>
 <blockquote>
 <div><ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">CONFIG_NET</span></code> Defined for general network support</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">CONFIG_NET_TCP</span></code> Defined for TCP/IP support</p></li>
 </ul>
 </div></blockquote>
 <p>In order to for select to work with incoming connections, you must also
 select:</p>
 <blockquote>
 <div><ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">CONFIG_NET_TCPBACKLOG</span></code> Incoming connections pend in a backlog
 until <code class="docutils literal notranslate"><span class="pre">accept()</span></code> is called. The size of the backlog is selected
 when <code class="docutils literal notranslate"><span class="pre">listen()</span></code> is called.</p></li>
 </ul>
 </div></blockquote>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>fds</strong> – List of structures describing file descriptors to be
 monitored.</p></li>
 <li><p><strong>nfds</strong> – The number of entries in the list.</p></li>
 <li><p><strong>timeout</strong> – Specifies an upper limit on the time for which
 <code class="docutils literal notranslate"><span class="pre">poll()</span></code> will block in milliseconds. A negative value of
 <code class="docutils literal notranslate"><span class="pre">timeout</span></code> means an infinite timeout.</p></li>
 </ul>
 </dd>
 <dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><p>On success, the number of structures that have nonzero <code class="docutils literal notranslate"><span class="pre">revents</span></code>
 fields. A value of 0 indicates that the call timed out and no file
 descriptors were ready. On error, -1 is returned, and <code class="docutils literal notranslate"><span class="pre">errno</span></code> is set
 appropriately:</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">EBADF</span></code>. An invalid file descriptor was given in one of the sets.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">EFAULT</span></code>. The fds address is invalid</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">EINTR</span></code>. A signal occurred before any requested event.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">EINVAL</span></code>. The nfds value exceeds a system limit.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ENOMEM</span></code>. There was no space to allocate internal data structures.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ENOSYS</span></code>. One or more of the drivers supporting the file descriptor
 does not support the poll method.</p></li>
 </ul>
 </p>
 </dd>
 </dl>
 </dd></dl>

 </section>
 <section id="sys-select-h">
 <h3><code class="docutils literal notranslate"><span class="pre">sys/select.h</span></code><a class="headerlink" href="#sys-select-h" title="Permalink to this heading"></a></h3>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.select">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">select</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">nfds</span></span>, <span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">fd_set</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">readfds</span></span>, <span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">fd_set</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">writefds</span></span>, <span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">fd_set</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">exceptfds</span></span>, <span class="pre">FAR</span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">timeval</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">timeout</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.select" title="Permalink to this definition"></a><br /></dt>
 <dd><p>Allows a program to monitor multiple file
 descriptors, waiting until one or more of the file descriptors become
 “ready” for some class of I/O operation (e.g., input possible). A file
 descriptor is considered ready if it is possible to perform the
 corresponding I/O operation (e.g., read(2)) without blocking.</p>
 <p><strong>NOTE:</strong> <code class="docutils literal notranslate"><span class="pre">`poll()</span></code> &lt;#poll&gt;`__ is the fundamental API for performing
 such monitoring operation under NuttX. <code class="docutils literal notranslate"><span class="pre">select()</span></code> is provided for
 compatibility and is simply a layer of added logic on top of <code class="docutils literal notranslate"><span class="pre">poll()</span></code>.
 As such, <code class="docutils literal notranslate"><span class="pre">select()</span></code> is more wasteful of resources and
 <code class="docutils literal notranslate"><span class="pre">`poll()</span></code> &lt;#poll&gt;`__ is the recommended API to be used.</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>nfds</strong> – the maximum file descriptor number (+1) of any descriptor
 in any of the three sets.</p></li>
 <li><p><strong>readfds</strong> – the set of descriptions to monitor for read-ready events</p></li>
 <li><p><strong>writefds</strong> – the set of descriptions to monitor for write-ready
 events</p></li>
 <li><p><strong>exceptfds</strong> – the set of descriptions to monitor for error events</p></li>
 <li><p><strong>timeout</strong> – Return at this time if none of these events of interest
 occur.</p></li>
 </ul>
 </dd>
 <dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">0:</span></code> Timer expired</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">&gt;0:</span></code> The number of bits set in the three sets of descriptors</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">-1:</span></code> An error occurred (<code class="docutils literal notranslate"><span class="pre">errno</span></code> will be set appropriately, see
 <code class="docutils literal notranslate"><span class="pre">`poll()</span></code> &lt;#poll&gt;`__).</p></li>
 </ul>
 </p>
 </dd>
 </dl>
 </dd></dl>

 </section>
 <section id="directory-operations-dirent-h">
 <h3>Directory Operations (<code class="docutils literal notranslate"><span class="pre">dirent.h</span></code>)<a class="headerlink" href="#directory-operations-dirent-h" title="Permalink to this heading"></a></h3>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.closedir">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">closedir</span></span></span><span class="sig-paren">(</span><span class="n"><span class="pre">DIR</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dirp</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.closedir" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.opendir">
 <span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">DIR</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">opendir</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">path</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.opendir" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.readdir">
 <span class="pre">FAR</span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">dirent</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">readdir</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">DIR</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dirp</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.readdir" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.readdir_r">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">readdir_r</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">DIR</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dirp</span></span>, <span class="pre">FAR</span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">dirent</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">entry</span></span>, <span class="pre">FAR</span><span class="w"> </span><span class="k"><span class="pre">struct</span></span><span class="w"> </span><span class="n"><span class="pre">dirent</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">result</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.readdir_r" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.rewinddir">
 <span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">rewinddir</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">DIR</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dirp</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.rewinddir" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.seekdir">
 <span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">seekdir</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">DIR</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dirp</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">loc</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.seekdir" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.telldir">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">telldir</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="n"><span class="pre">DIR</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">dirp</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.telldir" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 </section>
 <section id="unix-standard-operations-unistd-h">
 <h3>UNIX Standard Operations (<code class="docutils literal notranslate"><span class="pre">unistd.h</span></code>)<a class="headerlink" href="#unix-standard-operations-unistd-h" title="Permalink to this heading"></a></h3>
 <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;unistd.h&gt;</span>

 <span class="cm">/* Task Control Interfaces */</span>

 <span class="kt">pid_t</span><span class="w">   </span><span class="nf">vfork</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
 <span class="kt">pid_t</span><span class="w">   </span><span class="nf">getpid</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>
 <span class="kt">void</span><span class="w">    </span><span class="nf">_exit</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">status</span><span class="p">)</span><span class="w"> </span><span class="n">noreturn_function</span><span class="p">;</span>
 <span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">sleep</span><span class="p">(</span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">seconds</span><span class="p">);</span>
 <span class="kt">void</span><span class="w">    </span><span class="nf">usleep</span><span class="p">(</span><span class="kt">unsigned</span><span class="w"> </span><span class="kt">long</span><span class="w"> </span><span class="n">usec</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">pause</span><span class="p">(</span><span class="kt">void</span><span class="p">);</span>

 <span class="cm">/* File descriptor operations */</span>

 <span class="kt">int</span><span class="w">     </span><span class="nf">close</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">dup</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">dup2</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd1</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">fd2</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">fsync</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">);</span>
 <span class="kt">off_t</span><span class="w">   </span><span class="nf">lseek</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="kt">off_t</span><span class="w"> </span><span class="n">offset</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">whence</span><span class="p">);</span>
 <span class="kt">ssize_t</span><span class="w"> </span><span class="nf">read</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">nbytes</span><span class="p">);</span>
 <span class="kt">ssize_t</span><span class="w"> </span><span class="nf">write</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">nbytes</span><span class="p">);</span>
 <span class="kt">ssize_t</span><span class="w"> </span><span class="nf">pread</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">nbytes</span><span class="p">,</span><span class="w"> </span><span class="kt">off_t</span><span class="w"> </span><span class="n">offset</span><span class="p">);</span>
 <span class="kt">ssize_t</span><span class="w"> </span><span class="nf">pwrite</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">nbytes</span><span class="p">,</span><span class="w"> </span><span class="kt">off_t</span><span class="w"> </span><span class="n">offset</span><span class="p">);</span>

 <span class="cm">/* Check if a file descriptor corresponds to a terminal I/O file */</span>

 <span class="kt">int</span><span class="w">     </span><span class="nf">isatty</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">);</span>

 <span class="cm">/* Memory management */</span>

 <span class="cp">#if defined(CONFIG_ARCH_ADDRENV) &amp;&amp; defined(CONFIG_MM_PGALLOC) &amp;&amp; \</span>
 <span class="cp">    defined(CONFIG_ARCH_USE_MMU)</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">sbrk</span><span class="p">(</span><span class="kt">intptr_t</span><span class="w"> </span><span class="n">incr</span><span class="p">);</span>
 <span class="cp">#endif</span>

 <span class="cm">/* Special devices */</span>

 <span class="kt">int</span><span class="w">     </span><span class="nf">pipe</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">[</span><span class="mi">2</span><span class="p">]);</span>

 <span class="cm">/* Working directory operations */</span>

 <span class="kt">int</span><span class="w">     </span><span class="nf">chdir</span><span class="p">(</span><span class="n">FAR</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="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">getcwd</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">size</span><span class="p">);</span>

 <span class="cm">/* File path operations */</span>

 <span class="kt">int</span><span class="w">     </span><span class="nf">access</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">amode</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">rmdir</span><span class="p">(</span><span class="n">FAR</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">pathname</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">unlink</span><span class="p">(</span><span class="n">FAR</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">pathname</span><span class="p">);</span>

 <span class="cp">#ifdef CONFIG_PSEUDOFS_SOFTLINKS</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">link</span><span class="p">(</span><span class="n">FAR</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">path1</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</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">path2</span><span class="p">);</span>
 <span class="kt">ssize_t</span><span class="w"> </span><span class="nf">readlink</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">bufsize</span><span class="p">);</span>
 <span class="cp">#endif</span>

 <span class="cm">/* Execution of programs from files */</span>

 <span class="cp">#ifdef CONFIG_LIBC_EXECFUNCS</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">execl</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="p">...);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">execv</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="n">argv</span><span class="p">[]);</span>
 <span class="cp">#endif</span>

 <span class="cm">/* Networking */</span>

 <span class="cp">#ifdef CONFIG_NET</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">gethostname</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">size</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">     </span><span class="nf">sethostname</span><span class="p">(</span><span class="n">FAR</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">name</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">size</span><span class="p">);</span>
 <span class="cp">#endif</span>

 <span class="cm">/* Other */</span>

 <span class="kt">int</span><span class="w">     </span><span class="nf">getopt</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">argc</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="n">argv</span><span class="p">[],</span><span class="w"> </span><span class="n">FAR</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">optstring</span><span class="p">);</span>
 </pre></div>
 </div>
 </section>
 <section id="standard-i-o">
 <h3>Standard I/O<a class="headerlink" href="#standard-i-o" title="Permalink to this heading"></a></h3>
 <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;stdio.h&gt;</span>

 <span class="cm">/* Operations on streams (FILE) */</span>

 <span class="kt">void</span><span class="w">   </span><span class="nf">clearerr</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fclose</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fflush</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">feof</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">ferror</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fileno</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fgetc</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fgetpos</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">fpos_t</span><span class="w"> </span><span class="o">*</span><span class="n">pos</span><span class="p">);</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">fgets</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">s</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">n</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">void</span><span class="w">   </span><span class="nf">flockfile</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">fopen</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="n">FAR</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">type</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fprintf</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</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">format</span><span class="p">,</span><span class="w"> </span><span class="p">...);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fputc</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">c</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fputs</span><span class="p">(</span><span class="n">FAR</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">s</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">size_t</span><span class="w"> </span><span class="nf">fread</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">ptr</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">size</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">n_items</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">freopen</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="n">FAR</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">mode</span><span class="p">,</span>
 <span class="w">         </span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fseek</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">,</span><span class="w"> </span><span class="kt">long</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">offset</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">whence</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">fsetpos</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">fpos_t</span><span class="w"> </span><span class="o">*</span><span class="n">pos</span><span class="p">);</span>
 <span class="kt">long</span><span class="w">   </span><span class="nf">ftell</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">ftrylockfile</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">void</span><span class="w">   </span><span class="nf">funlockfile</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="kt">size_t</span><span class="w"> </span><span class="nf">fwrite</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">ptr</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">size</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">n_items</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">gets</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">s</span><span class="p">);</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">gets_s</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">s</span><span class="p">,</span><span class="w"> </span><span class="n">rsize_t</span><span class="w"> </span><span class="n">n</span><span class="p">);</span>
 <span class="kt">void</span><span class="w">   </span><span class="nf">setbuf</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">setvbuf</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">buffer</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">mode</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">size</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">ungetc</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">c</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">stream</span><span class="p">);</span>

 <span class="cm">/* Operations on the stdout stream, buffers, paths, and the whole printf-family *    /</span>

 <span class="cm">int    printf(FAR const char *format, ...);</span>
 <span class="cm">int    puts(FAR const char *s);</span>
 <span class="cm">int    rename(FAR const char *source, FAR const char *target);</span>
 <span class="cm">int    sprintf(FAR char *dest, FAR const char *format, ...);</span>
 <span class="cm">int    asprintf(FAR char **ptr, FAR const char *fmt, ...);</span>
 <span class="cm">int    snprintf(FAR char *buf, size_t size, FAR const char *format, ...);</span>
 <span class="cm">int    sscanf(FAR const char *buf, FAR const char *fmt, ...);</span>
 <span class="cm">void   perror(FAR const char *s);</span>

 <span class="cm">int    vprintf(FAR const char *s, va_list ap);</span>
 <span class="cm">int    vfprintf(FAR FILE *stream, FAR const char *s, va_list ap);</span>
 <span class="cm">int    vsprintf(FAR char *buf, FAR const char *s, va_list ap);</span>
 <span class="cm">int    vasprintf(FAR char **ptr, FAR const char *fmt, va_list ap);</span>
 <span class="cm">int    vsnprintf(FAR char *buf, size_t size, FAR const char *format, va_list ap);</span>
 <span class="cm">int    vsscanf(FAR char *buf, FAR const char *s, va_list ap);</span>

 <span class="cm">/* Operations on file descriptors including:</span>
 <span class="cm"> *</span>
 <span class="cm"> * POSIX-like File System Interfaces (fdopen), and</span>
 <span class="cm"> * Extensions from the Open Group Technical Standard, 2006, Extended API Set</span>
 <span class="cm"> *   Part 1 (dprintf and vdprintf)</span>
 <span class="cm"> */</span>

 <span class="n">FAR</span><span class="w"> </span><span class="kt">FILE</span><span class="w"> </span><span class="o">*</span><span class="n">fdopen</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</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">type</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">dprintf</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</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">fmt</span><span class="p">,</span><span class="w"> </span><span class="p">...);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">vdprintf</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</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">fmt</span><span class="p">,</span><span class="w"> </span><span class="kt">va_list</span><span class="w"> </span><span class="n">ap</span><span class="p">);</span>

 <span class="cm">/* Operations on paths */</span>

 <span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">tmpnam</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">s</span><span class="p">);</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">tempnam</span><span class="p">(</span><span class="n">FAR</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">dir</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</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">pfx</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">       </span><span class="nf">remove</span><span class="p">(</span><span class="n">FAR</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="cp">#include</span><span class="w"> </span><span class="cpf">&lt;sys/stat.h&gt;</span>

 <span class="kt">int</span><span class="w"> </span><span class="nf">mkdir</span><span class="p">(</span><span class="n">FAR</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">pathname</span><span class="p">,</span><span class="w"> </span><span class="kt">mode_t</span><span class="w"> </span><span class="n">mode</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">mkfifo</span><span class="p">(</span><span class="n">FAR</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">pathname</span><span class="p">,</span><span class="w"> </span><span class="kt">mode_t</span><span class="w"> </span><span class="n">mode</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">stat</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">stat</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">fstat</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">stat</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">);</span>

 <span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;sys/statfs.h&gt;</span>

 <span class="kt">int</span><span class="w"> </span><span class="nf">statfs</span><span class="p">(</span><span class="n">FAR</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="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">statfs</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">fstatfs</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fd</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">statfs</span><span class="w"> </span><span class="o">*</span><span class="n">buf</span><span class="p">);</span>
 </pre></div>
 </div>
 </section>
 <section id="standard-library-stdlib-h">
 <h3>Standard Library (<code class="docutils literal notranslate"><span class="pre">stdlib.h</span></code>)<a class="headerlink" href="#standard-library-stdlib-h" title="Permalink to this heading"></a></h3>
 <p>Generally addresses other operating system interfaces.
 However, the following may also be considered as file system interfaces:</p>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.mktemp">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">mktemp</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">template</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.mktemp" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.mkstemp">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">mkstemp</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">template</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.mkstemp" title="Permalink to this definition"></a><br /></dt>
 <dd></dd></dl>

 </section>
 <section id="asynchronous-i-o">
 <h3>Asynchronous I/O<a class="headerlink" href="#asynchronous-i-o" title="Permalink to this heading"></a></h3>
 <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;aio.h&gt;</span>

 <span class="kt">int</span><span class="w"> </span><span class="nf">aio_cancel</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="n">aiocbp</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">aio_error</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="n">aiocbp</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">aio_fsync</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="n">aiocbp</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">aio_read</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="n">aiocbp</span><span class="p">);</span>
 <span class="kt">ssize_t</span><span class="w"> </span><span class="nf">aio_return</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="n">aiocbp</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">aio_suspend</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="n">list</span><span class="p">[],</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">nent</span><span class="p">,</span>
 <span class="w">                </span><span class="n">FAR</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">timespec</span><span class="w"> </span><span class="o">*</span><span class="n">timeout</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">aio_write</span><span class="p">(</span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="n">aiocbp</span><span class="p">);</span>
 <span class="kt">int</span><span class="w"> </span><span class="nf">lio_listio</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">mode</span><span class="p">,</span><span class="w"> </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">aiocb</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="n">list</span><span class="p">[],</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">nent</span><span class="p">,</span>
 <span class="w">               </span><span class="n">FAR</span><span class="w"> </span><span class="k">struct</span><span class="w"> </span><span class="nc">sigevent</span><span class="w"> </span><span class="o">*</span><span class="n">sig</span><span class="p">);</span>
 </pre></div>
 </div>
 </section>
 <section id="standard-string-operations">
 <h3>Standard String Operations<a class="headerlink" href="#standard-string-operations" title="Permalink to this heading"></a></h3>
 <div class="highlight-c notranslate"><div class="highlight"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string.h&gt;</span>

 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strchr</span><span class="p">(</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">s</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">c</span><span class="p">);</span>
 <span class="n">FAR</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">strdup</span><span class="p">(</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">s</span><span class="p">);</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="nf">strerror</span><span class="p">(</span><span class="kt">int</span><span class="p">);</span>
 <span class="kt">size_t</span><span class="w"> </span><span class="nf">strlen</span><span class="p">(</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="p">);</span>
 <span class="kt">size_t</span><span class="w"> </span><span class="nf">strnlen</span><span class="p">(</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="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strcat</span><span class="p">(</span><span class="kt">char</span><span class="w"> </span><span class="o">*</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="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strncat</span><span class="p">(</span><span class="kt">char</span><span class="w"> </span><span class="o">*</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="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">strcmp</span><span class="p">(</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="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="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">strncmp</span><span class="p">(</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="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="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">strcasecmp</span><span class="p">(</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="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="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">strncasecmp</span><span class="p">(</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="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="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strcpy</span><span class="p">(</span><span class="kt">char</span><span class="w"> </span><span class="o">*</span><span class="n">dest</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">src</span><span class="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strncpy</span><span class="p">(</span><span class="kt">char</span><span class="w"> </span><span class="o">*</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="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strpbrk</span><span class="p">(</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="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="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strchr</span><span class="p">(</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="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strrchr</span><span class="p">(</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="p">,</span><span class="w"> </span><span class="kt">int</span><span class="p">);</span>
 <span class="kt">size_t</span><span class="w"> </span><span class="nf">strspn</span><span class="p">(</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="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="p">);</span>
 <span class="kt">size_t</span><span class="w"> </span><span class="nf">strcspn</span><span class="p">(</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="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="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strstr</span><span class="p">(</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="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="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strtok</span><span class="p">(</span><span class="kt">char</span><span class="w"> </span><span class="o">*</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="p">);</span>
 <span class="kt">char</span><span class="w">  </span><span class="o">*</span><span class="nf">strtok_r</span><span class="p">(</span><span class="kt">char</span><span class="w"> </span><span class="o">*</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="p">,</span><span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="o">**</span><span class="p">);</span>

 <span class="kt">void</span><span class="w">  </span><span class="o">*</span><span class="nf">memset</span><span class="p">(</span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">s</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">c</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">n</span><span class="p">);</span>
 <span class="kt">void</span><span class="w">  </span><span class="o">*</span><span class="nf">memcpy</span><span class="p">(</span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">dest</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">src</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">n</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">memcmp</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">s1</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">s2</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">n</span><span class="p">);</span>
 <span class="kt">void</span><span class="w">  </span><span class="o">*</span><span class="nf">memmove</span><span class="p">(</span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">dest</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="o">*</span><span class="n">src</span><span class="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="w"> </span><span class="n">count</span><span class="p">);</span>

 <span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;strings.h&gt;</span>

 <span class="cp">#define bcmp(b1,b2,len)  memcmp(b1,b2,(size_t)len)</span>
 <span class="cp">#define bcopy(b1,b2,len) memmove(b2,b1,len)</span>
 <span class="cp">#define bzero(s,n)       memset(s,0,n)</span>
 <span class="cp">#define index(s,c)       strchr(s,c)</span>
 <span class="cp">#define rindex(s,c)      strrchr(s,c)</span>

 <span class="kt">int</span><span class="w">    </span><span class="nf">ffs</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">j</span><span class="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">strcasecmp</span><span class="p">(</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="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="p">);</span>
 <span class="kt">int</span><span class="w">    </span><span class="nf">strncasecmp</span><span class="p">(</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="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="p">,</span><span class="w"> </span><span class="kt">size_t</span><span class="p">);</span>
 </pre></div>
 </div>
 </section>
 <section id="pipes-and-fifos">
 <h3>Pipes and FIFOs<a class="headerlink" href="#pipes-and-fifos" title="Permalink to this heading"></a></h3>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.pipe">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">pipe</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span><span class="p"><span class="pre">[</span></span><span class="m"><span class="pre">2</span></span><span class="p"><span class="pre">]</span></span><span class="sig-paren">)</span><a class="headerlink" href="#c.pipe" title="Permalink to this definition"></a><br /></dt>
 <dd><p>Creates a pair of file descriptors, pointing to a pipe inode,
 and places them in the array pointed to by <code class="docutils literal notranslate"><span class="pre">fd</span></code>.</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>fd</strong> – The user provided array in which to catch the pipe file
 descriptors. <code class="docutils literal notranslate"><span class="pre">fd[0]</span></code> is for reading, <code class="docutils literal notranslate"><span class="pre">fd[1]</span></code> is for writing.</p></li>
 </ul>
 </dd>
 <dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p>0 is returned on success; otherwise, -1 is returned with errno set appropriately.</p>
 </dd>
 </dl>
 </dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.mkfifo">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">mkfifo</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="k"><span class="pre">const</span></span><span class="w"> </span><span class="kt"><span class="pre">char</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">pathname</span></span>, <span class="n"><span class="pre">mode_t</span></span><span class="w"> </span><span class="n"><span class="pre">mode</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.mkfifo" title="Permalink to this definition"></a><br /></dt>
 <dd><p>mkfifo() makes a FIFO device driver file with name pathname. Unlike Linux,
 a NuttX FIFO is not a special file type but simply a device driver instance.
 mode specifies the FIFO’s permissions (but is ignored in the current implementation).</p>
 <p>Once the FIFO has been created by mkfifo(), any thread can open it for reading
 or writing, in the same way as an ordinary file. However, it must have been
 opened from both reading and writing before input or output can be performed.
 This FIFO implementation will block all attempts to open a FIFO read-only
 until at least one thread has opened the FIFO for writing.</p>
 <p>If all threads that write to the FIFO have closed, subsequent calls to
 read() on the FIFO will return 0 (end-of-file).</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>pathname</strong> – The full path to the FIFO instance to attach to or to
 create (if not already created).</p></li>
 <li><p><strong>mode</strong> – Ignored for now</p></li>
 </ul>
 </dd>
 <dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p>0 is returned on success; otherwise, -1 is returned with errno set appropriately.</p>
 </dd>
 </dl>
 </dd></dl>

 </section>
 <section id="mmap-and-execute-in-place-xip">
 <h3><code class="docutils literal notranslate"><span class="pre">mmap()</span></code> and eXecute In Place (XIP)<a class="headerlink" href="#mmap-and-execute-in-place-xip" title="Permalink to this heading"></a></h3>
 <p>NuttX operates in a flat open address space and is focused on MCUs that
 do support Memory Management Units (MMUs). Therefore, NuttX generally
 does not require <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> functionality and the MCUs generally cannot
 support true memory-mapped files.</p>
 <p>However, memory mapping of files is the mechanism used by NXFLAT, the
 NuttX tiny binary format, to get files into memory in order to execute
 them. <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> support is therefore required to support NXFLAT. There
 are two conditions where <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> can be supported:</p>
 <ol class="arabic">
 <li><p><code class="docutils literal notranslate"><span class="pre">mmap()</span></code> can be used to support <em>eXecute In Place</em> (XIP) on random
 access media under the following very restrictive conditions:</p>
 <ol class="loweralpha simple">
 <li><p>Any file system that maps files contiguously on the media
 should implement the mmap file operation. By comparison, most
 file system scatter files over the media in non-contiguous
 sectors. As of this writing, ROMFS is the only file system
 that meets this requirement.</p></li>
 <li><p>The underlying block driver supports the <code class="docutils literal notranslate"><span class="pre">BIOC_XIPBASE</span></code>
 <code class="docutils literal notranslate"><span class="pre">ioctl</span></code> command that maps the underlying media to a randomly
 accessible address. At present, only the RAM/ROM disk driver does
 this.</p></li>
 </ol>
 <p>Some limitations of this approach are as follows:</p>
 <ol class="loweralpha simple">
 <li><p>Since no real mapping occurs, all of the file contents are
 “mapped” into memory.</p></li>
 <li><p>All mapped files are read-only.</p></li>
 <li><p>There are no access privileges.</p></li>
 </ol>
 </li>
 <li><p>If <code class="docutils literal notranslate"><span class="pre">CONFIG_FS_RAMMAP</span></code> is defined in the configuration, then
 <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> will support simulation of memory mapped files by copying
 files whole into RAM. These copied files have some of the properties
 of standard memory mapped files. There are many, many exceptions
 exceptions, however. Some of these include:</p>
 <ol class="loweralpha">
 <li><p>The goal is to have a single region of memory that represents a
 single file and can be shared by many threads. That is, given a
 filename a thread should be able to open the file, get a file
 descriptor, and call <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> to get a memory region. Different
 file descriptors opened with the same file path should get the
 same memory region when mapped.</p>
 <p>The limitation in the current design is that there is insufficient
 knowledge to know that these different file descriptors correspond
 to the same file. So, for the time being, a new memory region is
 created each time that <code class="docutils literal notranslate"><span class="pre">rammmap()</span></code> is called. Not very useful!</p>
 </li>
 <li><p>The entire mapped portion of the file must be present in memory.
 Since it is assumed that the MCU does not have an MMU,
 on-demanding paging in of file blocks cannot be supported. Since
 the while mapped portion of the file must be present in memory,
 there are limitations in the size of files that may be memory
 mapped (especially on MCUs with no significant RAM resources).</p></li>
 <li><p>All mapped files are read-only. You can write to the in-memory
 image, but the file contents will not change.</p></li>
 <li><p>There are no access privileges.</p></li>
 <li><p>Since there are no processes in NuttX, all <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> and
 <code class="docutils literal notranslate"><span class="pre">munmap()</span></code> operations have immediate, global effects. Under
 Linux, for example, <code class="docutils literal notranslate"><span class="pre">munmap()</span></code> would eliminate only the mapping
 with a process; the mappings to the same file in other processes
 would not be effected.</p></li>
 <li><p>Like true mapped file, the region will persist after closing the
 file descriptor. However, at present, these ram copied file
 regions are <em>not</em> automatically “unmapped” (i.e., freed) when a
 thread is terminated. This is primarily because it is not possible
 to know how many users of the mapped region there are and,
 therefore, when would be the appropriate time to free the region
 (other than when munmap is called).</p>
 <p>NOTE: Note, if the design limitation of a) were solved, then it
 would be easy to solve exception d) as well.</p>
 </li>
 </ol>
 </li>
 </ol>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.mmap">
 <span class="pre">FAR</span><span class="w"> </span><span class="kt"><span class="pre">void</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">mmap</span></span></span><span class="sig-paren">(</span><span class="pre">FAR</span><span class="w"> </span><span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="p"><span class="pre">*</span></span><span class="n"><span class="pre">start</span></span>, <a class="reference internal" href="structures.html#c.size_t" title="size_t"><span class="n"><span class="pre">size_t</span></span></a><span class="w"> </span><span class="n"><span class="pre">length</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">prot</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">flags</span></span>, <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="n"><span class="pre">off_t</span></span><span class="w"> </span><span class="n"><span class="pre">offset</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.mmap" title="Permalink to this definition"></a><br /></dt>
 <dd><p>Provides minimal mmap() as needed to support eXecute In Place (XIP) operation (as described above).</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>start</strong> – A hint at where to map the memory – ignored. The address
 of the underlying media is fixed and cannot be re-mapped without MMU
 support.</p></li>
 <li><p><strong>length</strong> – The length of the mapping – ignored. The entire
 underlying media is always accessible.</p></li>
 <li><p><strong>prot</strong> – <p>See the <code class="docutils literal notranslate"><span class="pre">PROT_*</span></code> definitions in <code class="docutils literal notranslate"><span class="pre">sys/mman.h</span></code>.</p>
 <ul>
 <li><p><code class="docutils literal notranslate"><span class="pre">PROT_NONE</span></code> - Will cause an error.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">PROT_READ</span></code> - <code class="docutils literal notranslate"><span class="pre">PROT_WRITE</span></code> and <code class="docutils literal notranslate"><span class="pre">PROT_EXEC</span></code> also assumed.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">PROT_WRITE</span></code> - <code class="docutils literal notranslate"><span class="pre">PROT_READ</span></code> and <code class="docutils literal notranslate"><span class="pre">PROT_EXEC</span></code> also assumed.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">PROT_EXEC</span></code> - <code class="docutils literal notranslate"><span class="pre">PROT_READ</span></code> and <code class="docutils literal notranslate"><span class="pre">PROT_WRITE</span></code> also assumed.</p></li>
 </ul>
 </p></li>
 <li><p><strong>flags</strong> – <p>See the <code class="docutils literal notranslate"><span class="pre">MAP_*</span></code> definitions in <code class="docutils literal notranslate"><span class="pre">sys/mman.h</span></code>.</p>
 <ul>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_SHARED</span></code> - Required</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_PRIVATE</span></code> - Will cause an error</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_FIXED</span></code> - Will cause an error</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_FILE</span></code> - Ignored</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_ANONYMOUS</span></code> - Will cause an error</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_ANON</span></code> - Will cause an error</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_GROWSDOWN</span></code> - Ignored</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_DENYWRITE</span></code> - Will cause an error</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_EXECUTABLE</span></code> - Ignored</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_LOCKED</span></code> - Ignored</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_NORESERVE</span></code> - Ignored</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">MAP_POPULATE</span></code> - Ignored</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">AP_NONBLOCK</span></code> - Ignored</p></li>
 </ul>
 </p></li>
 <li><p><strong>fd</strong> – file descriptor of the backing file – required.</p></li>
 <li><p><strong>offset</strong> – The offset into the file to map.</p></li>
 </ul>
 </dd>
 <dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p><p>On success, <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> returns a pointer to the mapped area. On error,
 the value <code class="docutils literal notranslate"><span class="pre">MAP_FAILED</span></code> is returned, and <code class="docutils literal notranslate"><span class="pre">errno</span></code> is set
 appropriately.</p>
 <ul class="simple">
 <li><p><code class="docutils literal notranslate"><span class="pre">ENOSYS</span></code> - Returned if any of the unsupported <code class="docutils literal notranslate"><span class="pre">mmap()</span></code> features
 are attempted.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">EBADF</span></code> - <code class="docutils literal notranslate"><span class="pre">fd</span></code> is not a valid file descriptor.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">EINVAL</span></code> - Length is 0. flags contained neither <code class="docutils literal notranslate"><span class="pre">MAP_PRIVATE</span></code> or
 <code class="docutils literal notranslate"><span class="pre">MAP_SHARED</span></code>, or contained both of these values.</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ENODEV</span></code> - The underlying file-system of the specified file does
 not support memory mapping.</p></li>
 </ul>
 </p>
 </dd>
 </dl>
 </dd></dl>

 </section>
 <section id="fdsan">
 <h3>Fdsan<a class="headerlink" href="#fdsan" title="Permalink to this heading"></a></h3>
 <p>FD (file descriptor) is widely used in system software development,
 and almost all implementations of posix os (including nuttx) use FD as an index.
 the value of fd needs to be allocated starting from the minimum available value of 3, and each process has a copy,
 so the same fd value is very easy to reuse in the program.</p>
 <p>In multi threaded or multi process environments without address isolation,
 If the ownership, global variables, and competition relationships of fd are not properly handled,
 there may be issues with fd duplication or accidental closure.
 Further leading to the following issues, which are difficult to troubleshoot.</p>
 <ol class="arabic simple">
 <li><p>Security vulnerability: the fd we wrote is not the expected fd and will be accessed by hackers to obtain data</p></li>
 <li><p>Program exceptions or crashes: write or read fd failures, and program logic errors</p></li>
 <li><p>The structured file XML or database is damaged: the data format written to the database is not the expected format.</p></li>
 </ol>
 <p>The implementation principle of fdsan is based on the implementation of Android
 <a class="reference external" href="https://android.googlesource.com/platform/bionic/+/master/docs/fdsan.md">https://android.googlesource.com/platform/bionic/+/master/docs/fdsan.md</a></p>
 <dl class="c function">
 <dt class="sig sig-object c" id="c.android_fdsan_create_owner_tag">
 <span class="n"><span class="pre">uint64_t</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">android_fdsan_create_owner_tag</span></span></span><span class="sig-paren">(</span><span class="k"><span class="pre">enum</span></span><span class="w"> </span><span class="n"><span class="pre">android_fdsan_owner_type</span></span><span class="w"> </span><span class="n"><span class="pre">type</span></span>, <span class="n"><span class="pre">uint64_t</span></span><span class="w"> </span><span class="n"><span class="pre">tag</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.android_fdsan_create_owner_tag" title="Permalink to this definition"></a><br /></dt>
 <dd><p>Create an owner tag with the specified type and least significant 56 bits of tag.</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>type</strong> – <p>See the ANDROID_* definitions in include/android/fdsan.h.</p>
 <ul>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_FILE</span></code> - FILE</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_DIR</span></code> - DIR</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_UNIQUE_FD</span></code> - android::base::unique_fd</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_SQLITE</span></code> - sqlite-owned file descriptors</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_FILEINPUTSTREAM</span></code> - java.io.FileInputStream</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_FILEOUTPUTSTREAM</span></code> - java.io.FileOutputStream</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_RANDOMACCESSFILE</span></code> - java.io.RandomAccessFile</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_PARCELFILEDESCRIPTOR</span></code> - android.os.ParcelFileDescriptor</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_ART_FDFILE</span></code> - ART FdFile</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_DATAGRAMSOCKETIMPL</span></code> - java.net.DatagramSocketImpl</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_SOCKETIMPL</span></code> - java.net.SocketImpl</p></li>
 <li><p><code class="docutils literal notranslate"><span class="pre">ANDROID_FDSAN_OWNER_TYPE_ZIPARCHIVE</span></code> - libziparchive’s ZipArchive</p></li>
 </ul>
 </p></li>
 <li><p><strong>tag</strong> – least significant 56 bits of tag. Typically, it is a pointer to the object/structure where fd is located</p></li>
 </ul>
 </dd>
 </dl>
 </dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.android_fdsan_exchange_owner_tag">
 <span class="kt"><span class="pre">void</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">android_fdsan_exchange_owner_tag</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="n"><span class="pre">uint64_t</span></span><span class="w"> </span><span class="n"><span class="pre">expected_tag</span></span>, <span class="n"><span class="pre">uint64_t</span></span><span class="w"> </span><span class="n"><span class="pre">new_tag</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.android_fdsan_exchange_owner_tag" title="Permalink to this definition"></a><br /></dt>
 <dd><p>Exchange a file descriptor’s tag. Logs and aborts if the fd’s tag does not match expected_tag.</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>fd</strong> – The fd we want to protect</p></li>
 <li><p><strong>expected_tag</strong> – The tag corresponding to the current fd</p></li>
 <li><p><strong>new_tag</strong> – A new tag for fd binding</p></li>
 </ul>
 </dd>
 </dl>
 </dd></dl>

 <dl class="c function">
 <dt class="sig sig-object c" id="c.android_fdsan_close_with_tag">
 <span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="sig-name descname"><span class="n"><span class="pre">android_fdsan_close_with_tag</span></span></span><span class="sig-paren">(</span><span class="kt"><span class="pre">int</span></span><span class="w"> </span><span class="n"><span class="pre">fd</span></span>, <span class="n"><span class="pre">uint64_t</span></span><span class="w"> </span><span class="n"><span class="pre">tag</span></span><span class="sig-paren">)</span><span class="p"><span class="pre">;</span></span><a class="headerlink" href="#c.android_fdsan_close_with_tag" title="Permalink to this definition"></a><br /></dt>
 <dd><p>Close a file descriptor with a tag, and resets the tag to 0. Logs and aborts if the tag is incorrect.</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters<span class="colon">:</span></dt>
 <dd class="field-odd"><ul class="simple">
 <li><p><strong>fd</strong> – The fd we want to protect.</p></li>
 <li><p><strong>tag</strong> – The tag corresponding to the current fd.</p></li>
 </ul>
 </dd>
 <dt class="field-even">Returns<span class="colon">:</span></dt>
 <dd class="field-even"><p>Consistent with the return value of close.</p>
 </dd>
 </dl>
 </dd></dl>

 </section>
 </section>
 </section>


            </div>
           </div>
           <footer><div class="rst-footer-buttons" role="navigation" aria-label="Footer">
         <a href="09_env_vars.html" class="btn btn-neutral float-left" title="Environment Variables" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left" aria-hidden="true"></span> Previous</a>
         <a href="11_network.html" class="btn btn-neutral float-right" title="Network Interfaces" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right" aria-hidden="true"></span></a>
     </div>

   <hr/>

   <div role="contentinfo">
     <p>&#169; Copyright 2020, The Apache Software Foundation.</p>
   </div>


 </footer>
         </div>
       </div>
     </section>
   </div>
   <script>
       jQuery(function () {
           SphinxRtdTheme.Navigation.enable(true);
       });
   </script>

 </body>
 </html>