security/trusty/trusty-ref.html

<html devsite><head>
    <title>Trusty API </title>
    <meta name="project_path" value="/_project.yaml"/>
    <meta name="book_path" value="/_book.yaml"/>
  </head>
  <body>
  <!--
      Copyright 2017 The Android Open Source Project

      Licensed 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.
  -->

<p><a href="index.html">Trusty</a> API  Trusty  (IPC)  API </p>

<h2 id="ports_and_channels"></h2>

<p>Trusty  ID  DNS  <code>com.google.servicename</code></p>

<p></p>

<p> Trusty </p>

<p></p>

<h2 id="handle_api">Handle API</h2>

<p> UNIX </p>

<p> <code>set_cookie()</code> </p>

<h3 id="methods_handle_api">Handle API </h3>

<p> <code>INVALID_IPC_HANDLE #define,</code></p>

<h4 id="set_cookie">set_cookie()</h4>

<p></p>

<pre class="prettyprint">
long set_cookie(uint32_t handle, void *cookie)
</pre>

<p>[] <code>handle</code> API </p>

<p>[] <code>cookie</code> Trusty </p>

<p>[] <code>NO_ERROR</code> <code>&lt; 0</code> </p>

<p> Cookie </p>

<p> <code>wait()</code>  <code>wait_any()</code> </p>

<h4 id="wait">wait()</h4>

<p></p>

<pre class="prettyprint">
long wait(uint32_t handle_id, uevent_t *event, unsigned long timeout_msecs)
</pre>

<p>[] <code>handle_id</code> API </p>

<p>[] <code>event</code></p>

<p>[] <code>timeout_msecs</code>-1 </p>

<p>[] <code>NO_ERROR</code> <code>ERR_TIMED_OUT</code> <code>&lt; 0</code></p>

<h4 id="wait_any">wait_any()</h4>

<p></p>

<pre class="prettyprint">
long wait_any(uevent_t *event, unsigned long timeout_msecs);
</pre>

<p>[] <code>event</code></p>

<p>[] <code>timeout_msecs</code>-1 </p>

<p>[] <code>NO_ERROR</code> <code>ERR_TIMED_OUT</code> <code>&lt; 0</code></p>

<p> (<code>retval == NO_ERROR</code>)<code>wait()</code>  <code>wait_any()</code>  <code>uevent_t</code> </p>

<pre class="prettyprint">
typedef struct uevent {
    uint32_t handle; /* handle this event is related to */
    uint32_t event;  /* combination of IPC_HANDLE_POLL_XXX flags */
    void    *cookie; /* cookie associated with this handle */
} uevent_t;
</pre>

<p><code>event</code> </p>

<pre class="prettyprint">
enum {
  IPC_HANDLE_POLL_NONE    = 0x0,
  IPC_HANDLE_POLL_READY   = 0x1,
  IPC_HANDLE_POLL_ERROR   = 0x2,
  IPC_HANDLE_POLL_HUP     = 0x4,
  IPC_HANDLE_POLL_MSG     = 0x8,
  IPC_HANDLE_POLL_SEND_UNBLOCKED = 0x10,
   more values[TBD]
};
</pre>

<p><code>IPC_HANDLE_POLL_NONE</code> - </p>

<p><code>IPC_HANDLE_POLL_ERROR</code> - </p>

<p><code>IPC_HANDLE_POLL_READY</code> - </p>

<ul>
  <li></li><li> <code>connect()</code></li></ul>

<p></p>

<ul>
  <li><code>IPC_HANDLE_POLL_HUP</code> - </li><li><code>IPC_HANDLE_POLL_MSG</code> - </li><li><code>IPC_HANDLE_POLL_SEND_UNBLOCKED</code> -  <code>send_msg()</code> </li></ul>

<p></p>

<p><code>IPC_HANDLE_POLL_SEND_UNBLOCKED</code> </p>

<p> <code>close()</code> </p>

<h4 id="close">close()</h4>

<p></p>

<pre class="prettyprint">
long close(uint32_t handle_id);
</pre>

<p>[] <code>handle_id</code></p>

<p>[] 0</p>

<h2 id="server_api">Server API</h2>

<p><strong></strong></p>

<h3 id="methods_server_api">Server API </h3>

<h4 id="port_create">port_create()</h4>

<p></p>

<pre class="prettyprint">
long port_create (const char *path, uint num_recv_bufs, size_t recv_buf_size,
uint32_t flags)
</pre>

<p>[] <code>path</code></p>

<p>[] <code>num_recv_bufs</code> 1 1  1  1</p>

<p>[] <code>recv_buf_size</code></p>

<p>[] <code>flags</code></p>

<p></p>

<p><code>IPC_PORT_ALLOW_TA_CONNECT</code> - </p>

<p><code>IPC_PORT_ALLOW_NS_CONNECT</code> - </p>

<p>[]</p>

<p> <code>wait()</code>  <code>wait_any()</code>  <code>uevent_t</code>  <code>event</code>  <code>IPC_HANDLE_POLL_READY</code>  <code>accept()</code> </p>

<h4 id="accept">accept()</h4>

<p></p>

<pre class="prettyprint">
long accept(uint32_t handle_id, uuid_t *peer_uuid);
</pre>

<p>[] <code>handle_id</code></p>

<p>[] <code>peer_uuid</code> UUID  <code>uuud_t</code> </p>

<p>[]</p>

<h2 id="client_api">Client API</h2>

<p> Client API </p>

<h3 id="methods_client_api">Client API </h3>

<h4 id="connect">connect()</h4>

<p></p>

<pre class="prettyprint">
long connect(const char *path, uint flags);
</pre>

<p>[] <code>path</code> Trusty </p>

<p>[] <code>flags</code></p>

<p>[]</p>

<p> <code>flags</code><code>flags</code>  0 <code>connect()</code> </p>

<p></p>

<pre class="prettyprint">
enum {
IPC_CONNECT_WAIT_FOR_PORT = 0x1,
IPC_CONNECT_ASYNC = 0x2,
};
</pre>

<p><code>IPC_CONNECT_WAIT_FOR_PORT</code> -  <code>connect()</code> </p>

<p><code>IPC_CONNECT_ASYNC</code> -  <code>uevent_t</code>  event  <code>IPC_HANDLE_POLL_READY</code>  <code>wait()</code>  <code>wait_any()</code></p>

<h2 id="messaging_api">Messaging API</h2>

<p> Messaging API  Messaging API </p>

<p> <code>connect()</code>  <code>accept()</code> </p>

<h4 id="structure_of_a_trusty_message">Trusty </h4>

<p> Trusty API </p>

<pre class="prettyprint">
/*
 *  IPC message
 */
typedef struct iovec {
        void   *base;
        size_t  len;
} iovec_t;

typedef struct ipc_msg {
        uint     num_iov; /* number of iovs in this message */
        iovec_t  *iov;    /* pointer to iov array */

        uint     num_handles; /* reserved, currently not supported */
        handle_t *handles;    /* reserved, currently not supported */
} ipc_msg_t;
</pre>

<p> <code>iovec_t</code> Trusty  <code>iov</code> - <code>iov</code> </p>

<h3 id="methods_messaging_api">Messaging API </h3>

<h4 id="send_msg">send_msg()</h4>

<p></p>

<pre class="prettyprint">
long send_msg(uint32_t handle, ipc_msg_t *msg);
</pre>

<p>[] <code>handle</code></p>

<p>[] <code>msg</code> <code>ipc_msg_t structure</code></p>

<p>[]</p>

<p>/ <code>ERR_NOT_ENOUGH_BUFFER</code>  <code>wait()</code>  <code>wait_any()</code>  <code>uevent_t</code>  <code>event</code>  <code>IPC_HANDLE_POLL_SEND_UNBLOCKED</code> </p>

<h4 id="get_msg">get_msg()</h4>

<p></p>

<p></p>

<pre class="prettyprint">
long get_msg(uint32_t handle, ipc_msg_info_t *msg_info);
</pre>

<p>[] <code>handle</code></p>

<p>[] <code>msg_info</code></p>

<pre class="prettyprint">
typedef struct ipc_msg_info {
        size_t    len;  /* total message length */
        uint32_t  id;   /* message id */
} ipc_msg_info_t;
</pre>

<p> ID</p>

<p>[] <code>NO_ERROR</code></p>

<h4 id="read_msg">read_msg()</h4>

<p> ID </p>

<pre class="prettyprint">
long read_msg(uint32_t handle, uint32_t msg_id, uint32_t offset, ipc_msg_t
*msg);
</pre>

<p>[] <code>handle</code></p>

<p>[] <code>msg_id</code> ID</p>

<p>[] <code>offset</code></p>

<p>[] <code>msg</code> <code>ipc_msg_t</code> </p>

<p>[] <code>dst</code> </p>

<p> <code>read_msg</code> </p>

<h4 id="put_msg">put_msg()</h4>

<p> ID </p>

<pre class="prettyprint">
long put_msg(uint32_t handle, uint32_t msg_id);
</pre>

<p>[] <code>handle</code></p>

<p>[] <code>msg_id</code> ID</p>

<p>[] <code>NO_ERROR</code></p>

<p></p>

<h2 id="file_descriptor_api">File Descriptor API</h2>

<p>File Descriptor API  <code>read()</code><code>write()</code>  <code>ioctl()</code>  IPC Trusty  File Descriptor API  API </p>

<p> 3 </p>

<ul>
  <li>0 -  <code>fd</code>  <code>fd</code> 0  <code>ioctl()</code> <code>ERR_NOT_SUPPORTED</code>
  </li><li>1 -  LK  UART /<code>read()</code>  <code>ioctl()</code>  <code>ERR_NOT_SUPPORTED</code>
  </li><li>2 -  UART <code>read()</code>  <code>ioctl()</code>  <code>ERR_NOT_SUPPORTED</code>
</li></ul>

<p> <code>fds</code></p>

<h3 id="methods_file_descriptor_api">File Descriptor API </h3>

<h4 id="read">read()</h4>

<p> <code>count</code> </p>

<pre class="prettyprint">
long read(uint32_t fd, void *buf, uint32_t count);
</pre>

<p>[] <code>fd</code></p>

<p>[] <code>buf</code></p>

<p>[] <code>count</code></p>

<p>[]</p>

<h4 id="write">write()</h4>

<p> <code>count</code> </p>

<pre class="prettyprint">
long write(uint32_t fd, void *buf, uint32_t count);
</pre>

<p>[] <code>fd</code></p>

<p>[] <code>buf</code></p>

<p>[] <code>count</code></p>

<p>[]</p>

<h4 id="ioctl">ioctl()</h4>

<p> <code>ioctl</code> </p>

<pre class="prettyprint">
long ioctl(uint32_t fd, uint32_t cmd, void *args);
</pre>

<p>[] <code>fd</code> <code>ioctl()</code></p>

<p>[] <code>cmd</code><code>ioctl</code> </p>

<p>[in/out] <code>args</code> <code>ioctl()</code> </p>

<h2 id="miscellaneous_api">Miscellaneous API</h2>

<h3 id="methods_misc_api">Miscellaneous API </h3>

<h4 id="gettime">gettime()</h4>

<p></p>

<pre class="prettyprint">
long gettime(uint32_t clock_id, uint32_t flags, uint64_t *time);
</pre>

<p>[] <code>clock_id</code> 0</p>

<p>[] <code>flags</code> 0</p>

<p>[] <code>time</code> <code>int64_t</code> </p>

<p>[] <code>NO_ERROR</code></p>

<h4 id="nanosleep">nanosleep()</h4>

<p></p>

<pre class="prettyprint">
long nanosleep(uint32_t clock_id, uint32_t flags, uint64_t sleep_time)
</pre>

<p>[] <code>clock_id</code> 0</p>

<p>[] <code>flags</code> 0</p>

<p>[] <code>sleep_time</code></p>

<p>[] <code>NO_ERROR</code></p>

<h2 id="example_of_a_trusted_application_server"></h2>

<p> API </p>

<pre class="prettyprint">
#include &lt;assert.h&gt;
#include &lt;err.h&gt;
#include &lt;stddef.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;trusty_std.h&gt;

#include &lt;app/echo/uuids.h&gt;

#define LOG_TAG "echo_srv"

#define TLOGE(fmt, ...) \
    fprintf(stderr, "%s: %d: " fmt, LOG_TAG, __LINE__,  ## __VA_ARGS__)

#define MAX_ECHO_MSG_SIZE  64

static const char *srv_name = "com.android.echo.srv.echo";

static uint8_t msg_buf[MAX_ECHO_MSG_SIZE];

/*
 *  Message handler
 */
static int handle_msg(handle_t chan)
{
  int rc;
  iovec_t iov;
  ipc_msg_t msg;
  ipc_msg_info_t msg_inf;

  iov.base = msg_buf;
  iov.len  = sizeof(msg_buf);

  msg.num_iov = 1;
  msg.iov = &amp;iov;
  msg.num_handles = 0;
  msg.handles  = NULL;

  /* get message info */
  rc = get_msg(chan, &amp;msg_inf);
  if (rc == ERR_NO_MSG)
    return NO_ERROR; /* no new messages */

  if (rc != NO_ERROR) {
    TLOGE("failed (%d) to get_msg for chan (%d)\n",
          rc, chan);
    return rc;
  }

  /* read msg content */
  rc = read_msg(chan, msg_inf.id, 0, &amp;msg);
  if (rc &lt; 0) {
    TLOGE("failed (%d) to read_msg for chan (%d)\n",
          rc, chan);
    return rc;
  }

  /* update number of bytes received */
  iov.len = (size_t) rc;

  /* send message back to the caller */
  rc = send_msg(chan, &amp;msg);
  if (rc &lt; 0) {
    TLOGE("failed (%d) to send_msg for chan (%d)\n",
          rc, chan);
    return rc;
  }

  /* retire message */
  rc = put_msg(chan, msg_inf.id);
  if ( rc != NO_ERROR) {
    TLOGE("failed (%d) to put_msg for chan (%d)\n",
          rc, chan);
    return rc;
  }

  return NO_ERROR;
}

/*
 *  Channel event handler
 */
static void handle_channel_event(const uevent_t *ev)
{
  int rc;

  if (ev-&gt;event &amp; IPC_HANDLE_POLL_MSG) {
    rc = handle_msg(ev-&gt;handle);
    if (rc != NO_ERROR) {
      /* report an error and close channel */
      TLOGE("failed (%d) to handle event on channel %d\n",
             rc, ev-&gt;handle);
      close(ev-&gt;handle);
    }
    return;
  }
  if (ev-&gt;event &amp; IPC_HANDLE_POLL_HUP) {
    /* closed by peer. */
    close(ev-&gt;handle);
    return;
  }
}

/*
 *  Port event handler
 */
static void handle_port_event(const uevent_t *ev)
{
  uuid_t peer_uuid;

  if ((ev-&gt;event &amp; IPC_HANDLE_POLL_ERROR) ||
      (ev-&gt;event &amp; IPC_HANDLE_POLL_HUP) ||
      (ev-&gt;event &amp; IPC_HANDLE_POLL_MSG) ||
      (ev-&gt;event &amp; IPC_HANDLE_POLL_SEND_UNBLOCKED)) {
    /* should never happen with port handles */
    TLOGE("error event (0x%x) for port (%d)\n",
           ev-&gt;event, ev-&gt;handle);
    abort();
  }
  if (ev-&gt;event &amp; IPC_HANDLE_POLL_READY) {
    /* incoming connection: accept it */
    int rc = accept(ev-&gt;handle, &amp;peer_uuid);
    if (rc &lt; 0) {
      TLOGE("failed (%d) to accept on port %d\n",
             rc, ev-&gt;handle);
      return;
    }
  }
}

/*
 *  Main application entry point
 */
int main(void)
{
  int rc;
  handle_t port;

  /* Initialize service */
  rc = port_create(srv_name, 1, MAX_ECHO_MSG_SIZE,
       IPC_PORT_ALLOW_NS_CONNECT |
       IPC_PORT_ALLOW_TA_CONNECT );
  if (rc &lt; 0) {
    TLOGE("Failed (%d) to create port %s\n",
          rc, srv_name);
    abort();
  }
  port = (handle_t)rc;

  /* enter main event loop */
  while (true) {
    uevent_t ev;

    ev.handle = INVALID_IPC_HANDLE;
    ev.event  = 0;
    ev.cookie = NULL;

    /* wait forever */
    rc = wait_any(&amp;ev, -1);
    if (rc == NO_ERROR) {
      /* got an event */
      if (ev.handle == port) {
        handle_port_event(&amp;ev);
      } else {
        handle_channel_event(&amp;ev);
      }
    } else {
      TLOGE("wait_any returned (%d)\n", rc);
      abort();
    }
  }
  return 0;
}
</pre>

<h2 id="example_of_a_trusted_application_client"></h2>

<p> Trusty Messaging API <code>sync_connect()</code>  <code>connect()</code> </p>

<pre class="prettyprint">
/*
 *  Local wrapper on top of an async connect that provides a
 *  synchronous connect with timeout.
 */
int sync_connect(const char *path, uint timeout)
{
  int rc;
  uevent_t evt;
  handle_t chan;

  rc = connect(path, IPC_CONNECT_ASYNC | IPC_CONNECT_WAIT_FOR_PORT);
  if (rc &gt;= 0) {
    chan = (handle_t) rc;
    rc = wait(chan, &amp;evt, timeout);
    if (rc == 0) {
      rc = ERR_BAD_STATE;
      if (evt.handle == chan) {
        if (evt.event &amp; IPC_HANDLE_POLL_READY)
          return chan;
        if (evt.event &amp; IPC_HANDLE_POLL_HUP)
          rc = ERR_CHANNEL_CLOSED;
      }
    }
    close(chan);
  }
  return rc;
}
</pre>

<p><code>run_end_to_end_msg_test()</code>  10000 </p>

<pre class="prettyprint">
static int run_echo_test(void)
{
  int rc;
  handle_t chan;
  uevent_t uevt;
  uint8_t tx_buf[64];
  uint8_t rx_buf[64];
  ipc_msg_info_t inf;
  ipc_msg_t   tx_msg;
  iovec_t     tx_iov;
  ipc_msg_t   rx_msg;
  iovec_t     rx_iov;

  /* prepare tx message buffer */
  tx_iov.base = tx_buf;
  tx_iov.len  = sizeof(tx_buf);
  tx_msg.num_iov = 1;
  tx_msg.iov     = &amp;tx_iov;
  tx_msg.num_handles = 0;
  tx_msg.handles = NULL;

  memset (tx_buf, 0x55, sizeof(tx_buf));

  /* prepare rx message buffer */
  rx_iov.base = rx_buf;
  rx_iov.len  = sizeof(rx_buf);
  rx_msg.num_iov = 1;
  rx_msg.iov     = &amp;rx_iov;
  rx_msg.num_handles = 0;
  rx_msg.handles = NULL;

  /* open connection to echo service */
  rc = sync_connect(srv_name, 1000);
  if(rc &lt; 0)
    return rc;

  /* got channel */
  chan = (handle_t)rc;

  /* send/receive 10000 messages asynchronously. */
  uint tx_cnt = 10000;
  uint rx_cnt = 10000;

  while (tx_cnt || rx_cnt) {
    /* send messages until all buffers are full */
while (tx_cnt) {
    rc = send_msg(chan, &amp;tx_msg);
      if (rc == ERR_NOT_ENOUGH_BUFFER)
      break;  /* no more space */
    if (rc != 64) {
      if (rc &gt; 0) {
        /* incomplete send */
        rc = ERR_NOT_VALID;
}
      goto abort_test;
}
    tx_cnt--;
  }

  /* wait for reply msg or room */
  rc = wait(chan, &amp;uevt, 1000);
  if (rc != NO_ERROR)
    goto abort_test;

  /* drain all messages */
  while (rx_cnt) {
    /* get a reply */
      rc = get_msg(chan, &amp;inf);
    if (rc == ERR_NO_MSG)
        break;  /* no more messages  */
  if (rc != NO_ERROR)
goto abort_test;

  /* read reply data */
    rc = read_msg(chan, inf.id, 0, &amp;rx_msg);
  if (rc != 64) {
    /* unexpected reply length */
    rc = ERR_NOT_VALID;
    goto abort_test;
}

  /* discard reply */
  rc = put_msg(chan, inf.id);
  if (rc != NO_ERROR)
    goto abort_test;
  rx_cnt--;
  }
}

abort_test:
  close(chan);
  return rc;
}
</pre>

<h2 id="non-secure_world_apis_and_applications"> API </h2>

<p> <code>IPC_PORT_ALLOW_NS_CONNECT</code>  Trusty </p>

<p> APIClient API  Trusty-IPC </p>

<h3 id="user_space_trusty_ipc_client_api"> Trusty IPC Client API</h3>

<p> Trusty IPC Client API  <code>fd</code> </p>

<p> <code>tipc_connect()</code> Trusty <code>tipc_connect()</code>  <code>TIPC_IOC_CONNECT ioctl()</code>  <code>argp</code> </p>

<pre class="prettyprint">
#define TIPC_IOC_MAGIC  'r'
#define TIPC_IOC_CONNECT  _IOW(TIPC_IOC_MAGIC, 0x80, char *)
</pre>

<p> <code>tipc_close()</code> </p>

<p> <code>tipc_connect()</code> </p>

<ul>
  <li></li><li> <code>write()</code> </li><li> <code>poll()</code>  <code>select()</code> </li><li></li></ul>

<p> <code>fd</code>  Trusty Trusty-IPC  <code>write()</code>  Trusty  IPC  <code>IPC_HANDLE_POLL_MSG</code> Trusty  <code>read()</code> </p>

<h4 id="tipc_connect">tipc_connect()</h4>

<p> <code>tipc</code>  Trusty </p>

<pre class="prettyprint">
int tipc_connect(const char *dev_name, const char *srv_name);
</pre>

<p>[] <code>dev_name</code> Trusty IPC </p>

<p>[] <code>srv_name</code> Trusty </p>

<p>[] -1</p>

<h4 id="tipc_close">tipc_close()</h4>

<p> Trusty </p>

<pre class="prettyprint">
int tipc_close(int fd);
</pre>

<p>[] <code>fd</code> <code>tipc_connect()</code> </p>

<h2 id="kernel_trusty_ipc_client_api"> Trusty IPC Client API</h2>

<p> Trusty IPC Client API  Trusty IPC API  API </p>

<p> API  <code>tipc_create_channel()</code>  <code>struct tipc_chan</code>  <code>tipc_chan_connect()</code>  Trusty IPC  <code>tipc_chan_shutdown()</code>  <code>tipc_chan_destroy()</code> </p>

<p> <code>handle_event()</code> </p>

<ul>
  <li> <code>tipc_chan_get_txbuf_timeout()</code> </li><li></li><li> <code>tipc_chan_queue_msg()</code>  Trusty </li></ul>

<p> <code>tipc_chan_put_txbuf()</code> </p>

<p> <code>handle_msg()</code>  Trusty-IPC <code>rx</code>  <code>rx</code> API </p>

<p><code>handle_msg()</code>  <code>struct tipc_msg_buf</code>  <code>tipc_chan_get_rxbuf()</code>  <code>rx</code>  <code>tipc_chan_put_rxbuf()</code> </p>

<h3 id="methods_ktic_api"> Trusty IPC Client API </h3>

<h4 id="tipc_create_channel">tipc_create_channel()</h4>

<p> Trusty-IPC  Trusty IPC </p>

<pre class="prettyprint">
struct tipc_chan *tipc_create_channel(struct device *dev,
                          const struct tipc_chan_ops *ops,
                              void *cb_arg);
</pre>

<p>[] <code>dev</code> Trusty-IPC</p>

<p>[] <code>ops</code> <code>struct tipc_chan_ops</code></p>

<p>[] <code>cb_arg</code> <code>tipc_chan_ops</code> </p>

<p>[] <code>struct tipc_chan</code>  <code>ERR_PTR(err)</code></p>

<p></p>

<p> <code>void (*handle_event)(void *cb_arg, int event)</code> </p>

<p>[] <code>cb_arg</code> <code>tipc_create_channel()</code> </p>

<p>[] <code>event</code></p>

<ul>
  <li><code>TIPC_CHANNEL_CONNECTED</code> - </li><li><code>TIPC_CHANNEL_DISCONNECTED</code> - </li><li><code>TIPC_CHANNEL_SHUTDOWN</code> - </li></ul>

<p> <code>struct tipc_msg_buf *(*handle_msg)(void *cb_arg, struct tipc_msg_buf *mb)</code> </p>

<ul>
  <li>[] <code>cb_arg</code> <code>tipc_create_channel()</code> </li><li>[] <code>mb</code> <code>struct tipc_msg_buf</code></li><li>[] <code>struct tipc_msg_buf</code>  <code>mb</code>  <code>tipc_chan_get_rxbuf()</code> </li></ul>

<h4 id="tipc_chan_connect">tipc_chan_connect()</h4>

<p> Trusty IPC </p>

<pre class="prettyprint">
int tipc_chan_connect(struct tipc_chan *chan, const char *port);
</pre>

<p>[] <code>chan</code> <code>tipc_create_chan()</code> </p>

<p>[] <code>port</code></p>

<p>[] 0</p>

<p> <code>handle_event</code> </p>

<h4 id="tipc_chan_shutdown">tipc_chan_shutdown()</h4>

<p> <code>tipc_chan_connect()</code>  Trusty IPC </p>

<pre class="prettyprint">
int tipc_chan_shutdown(struct tipc_chan *chan);
</pre>

<p>[] <code>chan</code> <code>tipc_create_chan()</code> </p>

<h4 id="tipc_chan_destroy">tipc_chan_destroy()</h4>

<p> Trusty IPC </p>

<pre class="prettyprint">
void tipc_chan_destroy(struct tipc_chan *chan);
</pre>

<p>[] <code>chan</code> <code>tipc_create_chan()</code> </p>

<h4 id="tipc_chan_get_txbuf_timeout">tipc_chan_get_txbuf_timeout()</h4>

<p></p>

<pre class="prettyprint">
struct tipc_msg_buf *
tipc_chan_get_txbuf_timeout(struct tipc_chan *chan, long timeout);
</pre>

<p>[] <code>chan</code></p>

<p>[] <code>chan</code><code>tx</code> </p>

<p>[] <code>ERR_PTR(err)</code></p>

<h4 id="tipc_chan_queue_msg">tipc_chan_queue_msg()</h4>

<p> Trusty IPC </p>

<pre class="prettyprint">
int tipc_chan_queue_msg(struct tipc_chan *chan, struct tipc_msg_buf *mb);
</pre>

<p>[] <code>chan</code></p>

<p>[] <code>mb:</code>  <code>tipc_chan_get_txbuf_timeout()</code> </p>

<p>[] 0</p>

<h4 id="tipc_chan_put_txbuf">tipc_chan_put_txbuf()</h4>

<p> <code>tipc_chan_get_txbuf_timeout()</code>  <code>Tx</code> </p>

<pre class="prettyprint">
void tipc_chan_put_txbuf(struct tipc_chan *chan,
                         struct tipc_msg_buf *mb);
</pre>

<p>[] <code>chan</code></p>

<p>[] <code>mb</code></p>

<p>[]</p>

<h4 id="tipc_chan_get_rxbuf">tipc_chan_get_rxbuf()</h4>

<p></p>

<pre class="prettyprint">
struct tipc_msg_buf *tipc_chan_get_rxbuf(struct tipc_chan *chan);
</pre>

<p>[] <code>chan</code></p>

<p>[] <code>ERR_PTR(err)</code></p>

<h4 id="tipc_chan_put_rxbuf">tipc_chan_put_rxbuf()</h4>

<p> <code>tipc_chan_get_rxbuf()</code> </p>

<pre class="prettyprint">
void tipc_chan_put_rxbuf(struct tipc_chan *chan,
                         struct tipc_msg_buf *mb);
</pre>

<p>[] <code>chan</code></p>

<p>[] <code>mb</code></p>

<p>[]</p>

</body></html>