tripathysagar/man_text huggingface dataset:
# io_uring_recvmsg_cmsg_firsthdr

## NAME



           io_uring_recvmsg_out - access data from multishot recvmsg
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **struct io_uring_recvmsg_out *io_uring_recvmsg_validate(void ***_buf_**,**
                                                                  **int** _buf_len_**,**
                                                                  **struct msghdr ***_msgh_**);**
    
           **void *io_uring_recvmsg_name(struct io_uring_recvmsg_out ***_o_**);**
    
           **struct cmsghdr *io_uring_recvmsg_cmsg_firsthdr(struct io_uring_recvmsg_out ***_o_**,**
                                                          **struct msghdr ***_msgh_**);**
           **struct cmsghdr *io_uring_recvmsg_cmsg_nexthdr(struct io_uring_recvmsg_out ***_o_**,**
                                                         **struct msghdr ***_msgh_**,**
                                                         **struct cmsghdr ***_cmsg_**);**
    
           **void *io_uring_recvmsg_payload(struct io_uring_recvmsg_out ***_o_**,**
                                          **struct msghdr ***_msgh_**);**
           **unsigned int io_uring_recvmsg_payload_length(struct io_uring_recvmsg_out ***_o_**,**
                                                        **int** _buf_len_**,**
                                                        **struct msghdr ***_msgh_**);**
    


## DESCRIPTION



           These functions are used to access data in the payload delivered
           by io_uring_prep_recvmsg_multishot(3).
    
           _msgh_ should point to the _struct msghdr_ submitted with the request.
    
           io_uring_recvmsg_validate(3) will validate a buffer delivered by
           io_uring_prep_recvmsg_multishot(3) and extract the
           _io_uring_recvmsg_out_ if it is valid, returning a pointer to it or
           else NULL.
    
           The structure is defined as follows:
    
               struct io_uring_recvmsg_out {
                       __u32 namelen;    /* Name byte count as would have been populated
                                          * by recvmsg(2) */
                       __u32 controllen; /* Control byte count */
                       __u32 payloadlen; /* Payload byte count as would have been returned
                                          * by recvmsg(2) */
                       __u32 flags;      /* Flags result as would have been populated
                                          * by recvmsg(2) */
               };
    
           *  io_uring_recvmsg_name(3)
              returns a pointer to the name in the buffer.
    
           *  io_uring_recvmsg_cmsg_firsthdr(3)
              returns a pointer to the first cmsg in the buffer, or NULL.
    
           *  io_uring_recvmsg_cmsg_nexthdr(3)
              returns a pointer to the next cmsg in the buffer, or NULL.
    
           *  io_uring_recvmsg_payload(3)
              returns a pointer to the payload in the buffer.
    
           *  io_uring_recvmsg_payload_length(3)
              Calculates the usable payload length in bytes.
    


* * *
# gnutls_supplemental_recv

## NAME



           gnutls_supplemental_recv - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **void gnutls_supplemental_recv(gnutls_session_t** _session_**, unsigned**
           _do_recv_supplemental_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    
           unsigned do_recv_supplemental
                       non-zero in order to expect supplemental data
    


## DESCRIPTION



           This function is to be called by an extension handler to instruct
           gnutls to attempt to receive supplemental data during the
           handshake process.
    


## SINCE



           3.4.0
    


* * *
# ibv_unimport_mr

## NAME



           ibv_import_mr - import an MR from a given ibv_pd
    
           ibv_unimport_mr - unimport an MR
    


## SYNOPSIS



                  #include <infiniband/verbs.h>
    
                  struct ibv_mr *ibv_import_mr(struct ibv_pd *pd, uint32_t mr_handle);
                  void ibv_unimport_mr(struct ibv_mr *mr)
    


## DESCRIPTION



           **ibv_import_mr()** returns a Memory region (MR) that is associated
           with the given _mr_handle_ in the RDMA context that assosicated with
           the given _pd_.
    
           The input _mr_handle_ value must be a valid kernel handle for an MR
           object in the assosicated RDMA context.  It can be achieved from
           the original MR by getting its ibv_mr->handle member value.
    
           **ibv_unimport_mr()** un import the MR.  Once the MR usage has been
           ended ibv_dereg_mr() or ibv_unimport_mr() should be called.  The
           first one will go to the kernel to destroy the object once the
           second one way cleanup what ever is needed/opposite of the import
           without calling the kernel.
    
           This is the responsibility of the application to coordinate
           between all ibv_context(s) that use this MR.  Once destroy is done
           no other process can touch the object except for unimport.  All
           users of the context must collaborate to ensure this.
    


## RETURN VALUE



           **ibv_import_mr()** returns a pointer to the allocated MR, or NULL if
           the request fails.
    


## NOTES



           The _addr_ field in the imported MR is not applicable, NULL value is
           expected.
    


* * *
# ibv_port_state_str

## NAME



           ibv_event_type_str - Return string describing event_type enum
           value
    
           ibv_node_type_str - Return string describing node_type enum value
    
           ibv_port_state_str - Return string describing port_state enum
           value
    


## SYNOPSIS



                  #include <infiniband/verbs.h>
    
                  const char *ibv_event_type_str(enum ibv_event_type event_type);
    
                  const char *ibv_node_type_str(enum ibv_node_type node_type);
    
                  const char *ibv_port_state_str(enum ibv_port_state port_state);
    


## DESCRIPTION



           **ibv_node_type_str()** returns a string describing the node type enum
           value _node_type_.
    
           **ibv_port_state_str()** returns a string describing the port state
           enum value _port_state_.
    
           **ibv_event_type_str()** returns a string describing the event type
           enum value _event_type_.
    


## RETURN VALUE



           These functions return a constant string that describes the enum
           value passed as their argument.
    


* * *
# function::kernel_pointer

## NAME



           function::kernel_pointer - Retrieves a pointer value stored in
           kernel memory
    


## SYNOPSIS



               kernel_pointer:long(addr:long)
    


## ARGUMENTS



           _addr_
               The kernel address to retrieve the pointer from
    


## DESCRIPTION



           Returns the pointer value from a given kernel memory address.
           Reports an error when reading from the given address fails.
    


* * *
# libpfm_intel_icx_unc_pcu

## NAME



           libpfm_intel_icx_unc_pcu - support for Intel IcelakeX Server PCU
           uncore PMU
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: icx_unc_pcu**
           **PMU desc: Intel IcelakeX PCU uncore PMU**
    


## DESCRIPTION



           The library supports the Intel IcelakeX PCU (Power Control Unit)
           uncore PMU. There is one PCU per system.  Each PCU PMU implements
           4 generic counters.
    


## MODIFIERS



           The following modifiers are supported on Intel IcelakeX PCU uncore
           PMU:
    
           **e** Enable edge detection, i.e., count only when there is a
                  state transition from no occurrence of the event to at
                  least one occurrence. This modifier must be combined with a
                  threshold modifier (t) with a value greater or equal to
                  one.  This is a boolean modifier.
    
           **t** Set the threshold value. When set to a non-zero value, the
                  counter counts the number of PCU clockticks in which the
                  number of occurrences of the event is greater or equal to
                  the threshold.  This is an integer modifier with values in
                  the range [0:63].
    
           **i** Invert the threshold (t) test from strictly greater than to
                  less or equal to. This is a boolean modifier.
    
           **occ_i** Invert the threshold (t) for occupancy events
                  **POWER_STATE_OCCUPANY** test from strictly greater than to
                  less or equal to. This is a boolean modifier.
    
           **occ_e** Enable edge detection for occupancy events
                  **POWER_STATE_OCCUPANCY** , i.e., count only when there is a
                  state transition from no occurrence of the event to at
                  least one occurrence. This modifier must be combined with a
                  threshold modifier (t) with a value greater or equal to
                  one.  This is a boolean modifier.
    


* * *
# gnutls_ocsp_req_init

## NAME



           gnutls_ocsp_req_init - API function
    


## SYNOPSIS



           **#include <gnutls/ocsp.h>**
    
           **int gnutls_ocsp_req_init(gnutls_ocsp_req_t ***_req_**);**
    


## ARGUMENTS



           gnutls_ocsp_req_t * req
                       A pointer to the type to be initialized
    


## DESCRIPTION



           This function will initialize an OCSP request structure.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error value.
    


* * *
# pmconvscale

## NAME



           **pmConvScale** - rescale a performance metric value
    


## C SYNOPSIS



           **#include <pcp/pmapi.h>**
    
           **int pmConvScale(int** _type_**, const pmAtomValue ***_ival_**,**
                           **const pmUnits ***_iunit_**, pmAtomValue ***_oval_**,**
                           **const pmUnits ***_ounit_**);**
    
           **cc ... -lpcp**
    


## DESCRIPTION



           All  performance  metric  values  may  be encoded in a _pmAtomValue_
           union, defined as follows;
    
                typedef union {
                    __int32_t    l;     /* 32-bit signed */
                    __uint32_t   ul;    /* 32-bit unsigned */
                    __int64_t    ll;    /* 64-bit signed */
                    __uint64_t   ull;   /* 64-bit unsigned */
                    float        f;     /* 32-bit floating point */
                    double       d;     /* 64-bit floating point */
                    char         *cp;   /* char ptr */
                    pmValueBlock *vbp;  /* pmValueBlock ptr */
                } pmAtomValue;
    
           The encoding of a performance metric's  dimensionality  and  scale
           uses a _pmUnits_ structure; see pmLookupDesc(3).
    
           Given a performance metric value pointed to by _ival_ multiply it by
           a  scale  factor  and return the value in _oval_.  The scaling takes
           place from the units defined by _iunit_ into the  units  defined  by
           _ounit_.   Both input and output units must have the same dimension‐
           ality.
    
           The performance metric type for both input and  output  values  is
           determined  by  _type_ ,  the  value for which is typically extracted
           from a _pmDesc_ structure, following a call to pmLookupDesc(3) for a
           particular performance metric.
    
           **pmConvScale** is most useful when values  returned  via  pmFetch(3),
           (and  possibly  extracted using pmExtractValue(3)) need to be nor‐
           malized into some canonical scale and units for  the  purposes  of
           computation.
    
           As  a  special  case, if all components of the dimension are zero,
           then this is treated as synonymous with a ``count''  dimension  of
           one,  and so the ``count'' scale components determine the relative
           scaling.  This accommodates the case where performance metrics are
           dimensionless, without special case handling on the  part  of  the
           caller.
    


## DIAGNOSTICS



           **PM_ERR_CONV**
    
                  _iunit_  and _ounit_ have different dimensionality, or have in‐
                  appropriate _type_
    
           **PM_ERR_UNIT**
    
                  Inappropriate _iunit_ or _ounit_ parameter
    


* * *
# gnutls_session_get_data2

## NAME



           gnutls_session_get_data2 - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_session_get_data2(gnutls_session_t** _session_**,**
           **gnutls_datum_t ***_data_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    
           gnutls_datum_t * data
                       is a pointer to a datum that will hold the session.
    


## DESCRIPTION



           Returns necessary parameters to support resumption. The client
           should call this function and store the returned session data. A
           session can be resumed later by calling **gnutls_session_set_data()**
           with the returned data. Note that under TLS 1.3, it is recommended
           for clients to use session parameters only once, to prevent
           passive-observers from correlating the different connections.
    
           The returned  _data_ are allocated and must be released using
           **gnutls_free()**.
    
           This function will fail if called prior to handshake completion.
           In case of false start TLS, the handshake completes only after
           data have been successfully received from the peer.
    
           Under TLS1.3 session resumption is possible only after a session
           ticket is received by the client. To ensure that such a ticket has
           been received use **gnutls_session_get_flags()** and check for flag
           **GNUTLS_SFLAGS_SESSION_TICKET** ; if this flag is not set, this
           function will wait for a new ticket within an estimated roundtrip,
           and if not received will return dummy data which cannot lead to
           resumption.
    
           To get notified when new tickets are received by the server use
           **gnutls_handshake_set_hook_function()** to wait for
           **GNUTLS_HANDSHAKE_NEW_SESSION_TICKET** messages. Each call of
           **gnutls_session_get_data2()** after a ticket is received, will return
           session resumption data corresponding to the last received ticket.
    
           Note that this function under TLS1.3 requires a callback to be set
           with **gnutls_transport_set_pull_timeout_function()** for successful
           operation. There was a bug before 3.6.10 which could make this
           function fail if that callback was not set. On later versions if
           not set, the function will return a successful error code, but
           will return dummy data that cannot lead to a resumption.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise an error
           code is returned.
    


* * *
# auparse_metrics

## NAME



           auparse_metrics - get some metrics about auparse
    


## SYNOPSIS



           **#include <auparse.h>**
    
           **char * auparse_metrics(const auparse_state_t ***_au);"_
    


## DESCRIPTION



           auparse_metrics gets some basic information about auparse's
           internal state. It returns a character string ready to print. It
           returns the current limit for storing building events, the maximum
           events building or ready, and the number of ready events for
           processing. This information is only useful when the feed api is
           being used.
    


## RETURN VALUE



           Returns a memory buffer of current metrics on success and NULL on
           error. The caller must free the string.
    


* * *
# function::pointer_arg

## NAME



           function::pointer_arg - Return function argument as pointer value
    


## SYNOPSIS



               pointer_arg:long(n:long)
    


## ARGUMENTS



           _n_
               index of argument to return
    


## DESCRIPTION



           Return the unsigned value of argument n, same as ulong_arg. Can be
           used with any type of pointer.
    


* * *
# FD_CLR

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           FD_CLR — macros for synchronous I/O multiplexing
    


## SYNOPSIS



           #include <sys/select.h>
    
           void FD_CLR(int _fd_ , fd_set *_fdset_);
           int FD_ISSET(int _fd_ , fd_set *_fdset_);
           void FD_SET(int _fd_ , fd_set *_fdset_);
           void FD_ZERO(fd_set *_fdset_);
    


## DESCRIPTION



           Refer to pselect(3p).
    


* * *
# libpfm_arm_ac55

## NAME



           libpfm_arm_ac55 - support for ARM Cortex A55 PMU
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: arm_ac55**
           **PMU desc: ARM Cortex A55**
    


## DESCRIPTION



           The library supports the ARM Cortex A55 core PMU.
    
           This PMU supports 6 counters and privilege levels filtering.  It
           can operate in both 32 and 64 bit modes.
    


## MODIFIERS



           The following modifiers are supported on ARM Cortex A55:
    
           **u** Measure at the user level. This corresponds to **PFM_PLM3**.
                  This is a boolean modifier.
    
           **k** Measure at the kernel level. This corresponds to **PFM_PLM0**.
                  This is a boolean modifier.
    
           **hv** Measure at the hypervisor level. This corresponds to
                  **PFM_PLMH**.  This is a boolean modifier.
    


* * *
# fputwc

## NAME



           fputwc, putwc - write a wide character to a FILE stream
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <stdio.h>**
           **#include <wchar.h>**
    
           **wint_t fputwc(wchar_t** _wc_**, FILE ***_stream_**);**
           **wint_t putwc(wchar_t** _wc_**, FILE ***_stream_**);**
    


## DESCRIPTION



           The **fputwc**() function is the wide-character equivalent of the
           fputc(3) function.  It writes the wide character _wc_ to _stream_.  If
           _ferror(stream)_ becomes true, it returns **WEOF**.  If a wide-character
           conversion error occurs, it sets _errno_ to **EILSEQ** and returns **WEOF**.
           Otherwise, it returns _wc_.
    
           The **putwc**() function or macro functions identically to **fputwc**().
           It may be implemented as a macro, and may evaluate its argument
           more than once.  There is no reason ever to use it.
    
           For nonlocking counterparts, see unlocked_stdio(3).
    


## RETURN VALUE



           On success, **fputwc**() function returns _wc_.  Otherwise, **WEOF** is
           returned, and _errno_ is set to indicate the error.
    


## ERRORS



           Apart from the usual ones, there is
    
           **EILSEQ** Conversion of _wc_ to the stream's encoding fails.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌──────────────────────────────────────┬───────────────┬─────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **fputwc**(), **putwc**()                    │ Thread safety │ MT-Safe │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           C11, POSIX.1-2008.
    


## NOTES



           The behavior of **fputwc**() depends on the **LC_CTYPE** category of the
           current locale.
    
           In the absence of additional information passed to the fopen(3)
           call, it is reasonable to expect that **fputwc**() will actually write
           the multibyte sequence corresponding to the wide character _wc_.
    


* * *
# umad_get_cas_names

## NAME



           umad_get_cas_names - get list of available InfiniBand device names
    


## SYNOPSIS



           **#include <infiniband/umad.h>**
    
           **int umad_get_cas_names(char** _cas[][UMAD_CA_NAME_LEN]_**, int** _max_**);**
    


## DESCRIPTION



           **umad_get_cas_names()** fills the _cas_ array with up to _max_ local IB
           devices (CAs) names.  The argument _cas_ is a character array with
           _max_ entries, each with **UMAD_CA_NAME_LEN** characters.
    


## RETURN VALUE



           **umad_get_cas_names()** returns a non-negative value equal to the
           number of entries filled, or -1 on errors.
    


* * *
# gnutls_record_can_use_length_hiding

## NAME



           gnutls_record_can_use_length_hiding - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **unsigned gnutls_record_can_use_length_hiding(gnutls_session_t**
           _session_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           If the session supports length-hiding padding, you can invoke
           **gnutls_record_send_range()** to send a message whose length is
           hidden in the given range. If the session does not support length
           hiding padding, you can use the standard **gnutls_record_send()**
           function, or **gnutls_record_send_range()** making sure that the range
           is the same as the length of the message you are trying to send.
    


## RETURNS



           true (1) if the current session supports length-hiding padding,
           false (0) if the current session does not.
    


* * *
# gnutls_session_set_data

## NAME



           gnutls_session_set_data - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_session_set_data(gnutls_session_t** _session_**, const void ***
           _session_data_**, size_t** _session_data_size_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    
           const void * session_data
                       is a pointer to space to hold the session.
    
           size_t session_data_size
                       is the session's size
    


## DESCRIPTION



           Sets all session parameters, in order to resume a previously
           established session.  The session data given must be the one
           returned by **gnutls_session_get_data()**.  This function should be
           called before **gnutls_handshake()**.
    
           Keep in mind that session resuming is advisory. The server may
           choose not to resume the session, thus a full handshake will be
           performed.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise an error
           code is returned.
    


* * *
# gnutls_handshake

## NAME



           gnutls_handshake - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_handshake(gnutls_session_t** _session_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           This function performs the handshake of the TLS/SSL protocol, and
           initializes the TLS session parameters.
    
           The non-fatal errors expected by this function are:
           **GNUTLS_E_INTERRUPTED** , **GNUTLS_E_AGAIN** ,
           **GNUTLS_E_WARNING_ALERT_RECEIVED**. When this function is called for
           re-handshake under TLS 1.2 or earlier, the non-fatal error code
           **GNUTLS_E_GOT_APPLICATION_DATA** may also be returned.
    
           The former two interrupt the handshake procedure due to the
           transport layer being interrupted, and the latter because of a
           "warning" alert that was sent by the peer (it is always a good
           idea to check any received alerts). On these non-fatal errors call
           this function again, until it returns 0; cf.
           **gnutls_record_get_direction()** and **gnutls_error_is_fatal()**. In DTLS
           sessions the non-fatal error **GNUTLS_E_LARGE_PACKET** is also
           possible, and indicates that the MTU should be adjusted.
    
           When this function is called by a server after a rehandshake
           request under TLS 1.2 or earlier the **GNUTLS_E_GOT_APPLICATION_DATA**
           error code indicates that some data were pending prior to peer
           initiating the handshake.  Under TLS 1.3 this function when called
           after a successful handshake, is a no-op and always succeeds in
           server side; in client side this function is equivalent to
           **gnutls_session_key_update()** with **GNUTLS_KU_PEER** flag.
    
           This function handles both full and abbreviated TLS handshakes
           (resumption).  For abbreviated handshakes, in client side, the
           **gnutls_session_set_data()** should be called prior to this function
           to set parameters from a previous session.  In server side,
           resumption is handled by either setting a DB back-end, or setting
           up keys for session tickets.
    


## RETURNS



           **GNUTLS_E_SUCCESS** on a successful handshake, otherwise a negative
           error code.
    


* * *
# gnutls_dh_params_import_raw3

## NAME



           gnutls_dh_params_import_raw3 - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_dh_params_import_raw3(gnutls_dh_params_t** _dh_params_**,**
           **const gnutls_datum_t ***_prime_**, const gnutls_datum_t ***_q_**, const**
           **gnutls_datum_t ***_generator_**);**
    


## ARGUMENTS



           gnutls_dh_params_t dh_params
                       The parameters
    
           const gnutls_datum_t * prime
                       holds the new prime
    
           const gnutls_datum_t * q
                       holds the subgroup if available, otherwise NULL
    
           const gnutls_datum_t * generator
                       holds the new generator
    


## DESCRIPTION



           This function will replace the pair of prime and generator for use
           in the Diffie-Hellman key exchange.  The new parameters should be
           stored in the appropriate gnutls_datum.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error code is returned.
    


* * *
# gnutls_certificate_set_x509_key_file

## NAME



           gnutls_certificate_set_x509_key_file - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int**
           **gnutls_certificate_set_x509_key_file(gnutls_certificate_credentials_t**
           _res_**, const char ***_certfile_**, const char ***_keyfile_**,**
           **gnutls_x509_crt_fmt_t** _type_**);**
    


## ARGUMENTS



           gnutls_certificate_credentials_t res
                       is a **gnutls_certificate_credentials_t** type.
    
           const char * certfile
                       is a file that containing the certificate list (path)
                       for the specified private key, in PKCS7 format, or a
                       list of certificates
    
           const char * keyfile
                       is a file that contains the private key
    
           gnutls_x509_crt_fmt_t type
                       is PEM or DER
    


## DESCRIPTION



           This function sets a certificate/private key pair in the
           gnutls_certificate_credentials_t type.  This function may be
           called more than once, in case multiple keys/certificates exist
           for the server.  For clients that need to send more than its own
           end entity certificate, e.g., also an intermediate CA cert, then
           the
            _certfile_ must contain the ordered certificate chain.
    
           Note that the names in the certificate provided will be considered
           when selecting the appropriate certificate to use (in case of
           multiple certificate/key pairs).
    
           This function can also accept URLs at  _keyfile_ and  _certfile_ . In
           that case it will use the private key and certificate indicated by
           the URLs. Note that the supported URLs are the ones indicated by
           **gnutls_url_is_supported()**.
    
           In case the  _certfile_ is provided as a PKCS **11** URL, then the
           certificate, and its present issuers in the token are imported
           (i.e., forming the required trust chain).
    
           If that function fails to load the  _res_ structure is at an
           undefined state, it must not be reused to load other keys or
           certificates.
    
           Note that, this function by default returns zero on success and a
           negative value on error.  Since 3.5.6, when the flag
           **GNUTLS_CERTIFICATE_API_V2** is set using
           **gnutls_certificate_set_flags()** it returns an index (greater or
           equal to zero). That index can be used to other functions to refer
           to the added key-pair.
    


## RETURNS



           On success this functions returns zero, and otherwise a negative
           value on error (see above for modifying that behavior).
    


## SINCE



           3.1.11
    


* * *
# gnutls_srtp_get_selected_profile

## NAME



           gnutls_srtp_get_selected_profile - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_srtp_get_selected_profile(gnutls_session_t** _session_**,**
           **gnutls_srtp_profile_t ***_profile_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    
           gnutls_srtp_profile_t * profile
                       will hold the profile
    


## DESCRIPTION



           This function allows you to get the negotiated SRTP profile.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error code is returned.
    
           Since 3.1.4
    


* * *
# abs

## NAME



           abs, labs, llabs, imaxabs, uabs, ulabs, ullabs, uimaxabs - compute
           the absolute value of an integer
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <stdlib.h>**
    
           **int abs(int** _j_**);**
           **long labs(long** _j_**);**
           **long long llabs(long long** _j_**);**
    
           **unsigned int uabs(int** _j_**);**
           **unsigned long ulabs(long** _j_**);**
           **unsigned long long ullabs(long long** _j_**);**
    
           **#include <inttypes.h>**
    
           **intmax_t imaxabs(intmax_t** _j_**);**
           **uintmax_t uimaxabs(intmax_t** _j_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **llabs**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
    
           **uabs**(), **ulabs**(), **ullabs**(), **uimaxabs**():
               _ISOC2Y_SOURCE
    


## DESCRIPTION



           These functions compute the absolute value of the argument _j_ of
           the appropriate integer type for the function.
    


## RETURN VALUE



           Returns the absolute value of the integer argument, of the
           appropriate integer type for the function.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌──────────────────────────────────────┬───────────────┬─────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **abs**(), **labs**(), **llabs**(), **imaxabs**(),   │ Thread safety │ MT-Safe │
           │ **uabs**(), **ulabs**(), **ullabs**(),           │               │         │
           │ **uimaxabs**()                           │               │         │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           **abs**()
           **labs**()
           **llabs**()
           **imaxabs**()
                  C23, POSIX.1-2024
    


## BUGS



           For **abs**(), **labs**(), **llabs**(), and **imaxabs**(), trying to take the
           absolute value of the most negative integer is not defined.
    


* * *
# curs_overlay

## NAME



           **overlay** , **overwrite** , **copywin** - overlay and manipulate overlapped
           **curses** windows
    


## SYNOPSIS



           **#include <curses.h>**
    
           **int overlay(const WINDOW ***_srcwin_**, WINDOW ***_dstwin_**);**
           **int overwrite(const WINDOW ***_srcwin_**, WINDOW ***_dstwin_**);**
           **int copywin(const WINDOW ***_srcwin_**, WINDOW ***_dstwin_**, int** _sminrow_**,**
                 **int** _smincol_**, int** _dminrow_**, int** _dmincol_**, int** _dmaxrow_**,**
                 **int** _dmaxcol_**, int** _overlay_**);**
    


## DESCRIPTION



       **overlay, overwrite**
           The  **overlay** and **overwrite** routines overlay _srcwin_ on top of _dst‐_
           _win_.  _scrwin_ and _dstwin_ are not required to be the same size; only
           text where the two windows overlap is copied.  The  difference  is
           that  **overlay** is  non-destructive (blanks are not copied) whereas
           **overwrite** is destructive.
    
       **copywin**
           The **copywin** routine provides a finer granularity of  control  over
           the **overlay** and **overwrite** routines.  As in the **prefresh** routine, a
           rectangle  is specified in the destination window, (_dminrow_ , _dmin‐_
           _col_) and (_dmaxrow_ , _dmaxcol_), and the upper-left-corner coordinates
           of the source window, (_sminrow_ , _smincol_).  If the argument _overlay_
           is **true** , then copying is non-destructive, as in **overlay**.
    


## RETURN VALUE



           Routines that return an integer return **ERR** upon  failure,  and  **OK**
           (SVr4  only specifies "an integer value other than **ERR** ") upon suc‐
           cessful completion.
    
           X/Open defines no error conditions.  In this implementation, **copy‐**
           **win** , **overlay** and **overwrite** return an error if either of the window
           pointers are null, or if some part of the window would  be  placed
           off-screen.
    


## NOTES



           Note that **overlay** and **overwrite** may be macros.
    


## PORTABILITY



           The XSI Curses standard, Issue 4 describes these functions (adding
           the const qualifiers).  It further specifies their behavior in the
           presence of characters with multibyte renditions (not yet support‐
           ed in this implementation).
    


* * *
# curs_deleteln

## NAME



           **deleteln** , **wdeleteln** , **insdelln** , **winsdelln** , **insertln** , **winsertln** -
           delete and insert lines in a **curses** window
    


## SYNOPSIS



           **#include <curses.h>**
    
           **int deleteln(void);**
           **int wdeleteln(WINDOW ***_win_**);**
    
           **int insdelln(int** _n_**);**
           **int winsdelln(WINDOW ***_win_**, int** _n_**);**
    
           **int insertln(void);**
           **int winsertln(WINDOW ***_win_**);**
    


## DESCRIPTION



           The **deleteln** and **wdeleteln** routines delete the line under the
           cursor in the window; all lines below the current line are moved
           up one line.  The bottom line of the window is cleared.  The
           cursor position does not change.
    
           The **insdelln** and **winsdelln** routines, for positive _n_ , insert _n_
           lines into the specified window above the current line.  The _n_
           bottom lines are lost.  For negative _n_ , delete _n_ lines (starting
           with the one under the cursor), and move the remaining lines up.
           The bottom _n_ lines are cleared.  The current cursor position
           remains the same.
    
           The **insertln** and **winsertln** routines insert a blank line above the
           current line and the bottom line is lost.
    


## RETURN VALUE



           All routines return the integer **ERR** upon failure and an **OK**(SVr4
           specifies only "an integer value other than **ERR** ") upon successful
           completion.
    
           X/Open defines no error conditions.  In this implementation, if
           the window parameter is null, an error is returned.
    


## PORTABILITY



           These functions are described in the XSI Curses standard, Issue 4.
           The standard specifies that they return **ERR** on failure, but
           specifies no error conditions.
    


## NOTES



           Note that all but **winsdelln** may be macros.
    
           These routines do not require a hardware line delete or insert
           feature in the terminal.  In fact, they will not use hardware line
           delete/insert unless **idlok(..., TRUE)** has been set on the current
           window.
    


* * *
# libpfm_intel_gnr_unc_imc

## NAME



           libpfm_intel_gnr_unc_imc - support for Intel GraniteRapids Server
           Integrated Memory Controller (IMC)  uncore PMU
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: gnr_unc_imc[0-11]**
           **PMU desc: Intel GraniteRapids Server IMC uncore PMU**
    


## DESCRIPTION



           The library supports the Intel  GraniteRapids Server Integrated
           Memory Controller (IMC) uncore PMU.
    


## MODIFIERS



           The following modifiers are supported on Intel GraniteRapids
           server IMC uncore PMU:
    
           **e** Enable edge detection, i.e., count only when there is a
                  state transition from no occurrence of the event to at
                  least one occurrence. This modifier must be combined with a
                  threshold modifier (t) with a value greater or equal to
                  one.  This is a boolean modifier.
    
           **t** Set the threshold value. When set to a non-zero value, the
                  counter counts the number of IMC cycles in which the number
                  of occurrences of the event is greater or equal to the
                  threshold.  This is an integer modifier with values in the
                  range [0:255].  **i** Invert the threshold (t) test from
                  strictly greater than to less or equal to. This is a
                  boolean modifier.
    


* * *
# probe::signal.syskill.return

## NAME



           probe::signal.syskill.return - Sending kill signal completed
    


## SYNOPSIS



           signal.syskill.return
    


## VALUES



           None
    


* * *
# function::long_arg

## NAME



           function::long_arg - Return function argument as signed long
    


## SYNOPSIS



               long_arg:long(n:long)
    


## ARGUMENTS



           _n_
               index of argument to return
    


## DESCRIPTION



           Return the value of argument n as a signed long. On architectures
           where a long is 32 bits, the value is sign-extended to 64 bits.
    


* * *
# audit_get_features

## NAME



           audit_get_features, audit_set_feature - query or change kernel
           audit features
    


## SYNOPSIS



           **#include <libaudit.h>**
    
           **uint32_t audit_get_features(void);**
           **int audit_set_feature(int** _fd_**, unsigned** _feature_**, unsigned** _value_**,**
           **unsigned** _lock_**);"**
    


## DESCRIPTION



           **audit_get_features**() returns a bitmap describing which kernel
           audit features are supported.  The bitmap is cached internally and
           retrieved from the kernel on the first call.
    
           **audit_set_feature**() changes a feature bit for the kernel using the
           descriptor _fd_ which must be an open audit netlink socket.  _feature_
           selects the bit to modify.  If _value_ is nonzero the feature is
           enabled, otherwise it is disabled.  If _lock_ is nonzero the feature
           setting is locked until reboot.
    
           The feature bits currently defined are:
    
           **AUDIT_FEATURE_BITMAP_BACKLOG_LIMIT**
                  Kernel supports changing the backlog queue depth.
    
           **AUDIT_FEATURE_BITMAP_BACKLOG_WAIT_TIME**
                  Kernel supports delaying syscalls when the queue is full.
    
           **AUDIT_FEATURE_BITMAP_EXECUTABLE_PATH**
                  Kernel will include the executable path on EXECVE records.
    
           **AUDIT_FEATURE_BITMAP_EXCLUDE_EXTEND**
                  Exclude rules may be used with more fields than just
                  message type.
    
           **AUDIT_FEATURE_BITMAP_SESSIONID_FILTER**
                  Session identifier filtering is supported.
    
           **AUDIT_FEATURE_BITMAP_LOST_RESET**
                  Allows resetting the lost event counter.
    
           **AUDIT_FEATURE_BITMAP_FILTER_FS**
                  Kernel supports file system field filtering.
    


## RETURN VALUE



           **audit_get_features** returns the feature bitmap or 0 if feature
           queries are unsupported.  **audit_set_feature** returns <= 0 on error,
           otherwise it is the netlink sequence id number.
    


* * *
# erfc

## NAME



           erfc, erfcf, erfcl - complementary error function
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



           **#include <math.h>**
    
           **double erfc(double** _x_**);**
           **float erfcf(float** _x_**);**
           **long double erfcl(long double** _x_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **erfc**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE
                   || /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    
           **erfcf**(), **erfcl**():
               _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
                   || /* Since glibc 2.19: */ _DEFAULT_SOURCE
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    


## DESCRIPTION



           These functions return the complementary error function of _x_ , that
           is, 1.0 - erf(x).
    


## RETURN VALUE



           On success, these functions return the complementary error
           function of _x_ , a value in the range [0,2].
    
           If _x_ is a NaN, a NaN is returned.
    
           If _x_ is +0 or -0, 1 is returned.
    
           If _x_ is positive infinity, +0 is returned.
    
           If _x_ is negative infinity, +2 is returned.
    
           If the function result underflows and produces an unrepresentable
           value, the return value is 0.0.
    
           If the function result underflows but produces a representable
           (i.e., subnormal) value, that value is returned, and a range error
           occurs.
    


## ERRORS



           See math_error(7) for information on how to determine whether an
           error has occurred when calling these functions.
    
           The following errors can occur:
    
           Range error: result underflow (result is subnormal)
                  An underflow floating-point exception (**FE_UNDERFLOW**) is
                  raised.
    
           These functions do not set _errno_.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌──────────────────────────────────────┬───────────────┬─────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **erfc**(), **erfcf**(), **erfcl**()             │ Thread safety │ MT-Safe │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           C11, POSIX.1-2008.
    


## NOTES



           The **erfc**(), **erfcf**(), and **erfcl**() functions are provided to avoid
           the loss accuracy that would occur for the calculation 1-erf(x)
           for large values of _x_ (for which the value of erf(x) approaches
           1).
    


* * *
# sd_bus_get_name_creds

## NAME



           sd_bus_get_name_creds, sd_bus_get_owner_creds - Query bus client
           credentials
    


## SYNOPSIS



           **#include <systemd/sd-bus.h>**
    
           **int sd_bus_get_name_creds(sd_bus ***_bus_**, const char ***_name_**,**
                                     **uint64_t** _mask_**, sd_bus_creds ****_creds_**);**
    
           **int sd_bus_get_owner_creds(sd_bus ***_bus_**, uint64_t** _mask_**,**
                                      **sd_bus_creds ****_creds_**);**
    


## DESCRIPTION



           **sd_bus_get_name_creds()** queries the credentials of the bus client
           identified by _name_. The _mask_ parameter is a combo of
           **SD_BUS_CREDS_*** flags that indicate which credential info the
           caller is interested in. See sd_bus_creds_new_from_pid(3) for a
           list of possible flags. On success, _creds_ contains a new
           sd_bus_creds instance with the requested information. Ownership of
           this instance belongs to the caller and it should be freed once no
           longer needed by calling sd_bus_creds_unref(3).
    
           **sd_bus_get_owner_creds()** queries the credentials of the creator of
           the given bus. The _mask_ and _creds_ parameters behave the same as in
           **sd_bus_get_name_creds()**.
    


## RETURN VALUE



           On success, these functions return a non-negative integer. On
           failure, they return a negative errno-style error code.
    
       **Errors**
           Returned errors may indicate the following problems:
    
           **-EINVAL**
               An argument is invalid.
    
           **-ENOPKG**
               The bus cannot be resolved.
    
           **-EPERM**
               The bus has already been started.
    
           **-ECHILD**
               The bus was created in a different process, library or module
               instance.
    
           **-ENOMEM**
               Memory allocation failed.
    


## NOTES



           Functions described here are available as a shared library, which
           can be compiled against and linked to with the
           **libsystemd pkg-config**(1) file.
    
           The code described here uses getenv(3), which is declared to be
           not multi-thread-safe. This means that the code calling the
           functions described here must not call setenv(3) from a parallel
           thread. It is recommended to only do calls to **setenv()** from an
           early phase of the program when no other threads have been
           started.
    


* * *