tripathysagar/man_text huggingface dataset:
# audit_get_reply

## NAME



           audit_get_reply - Get the audit system's reply
    


## SYNOPSIS



           **#include <libaudit.h>**
    
           **int audit_get_reply(int** _fd_**, struct audit_reply ***_rep_**, reply_t** _block_**, int** _peek_**);"**
    


## DESCRIPTION



           This function gets the next data packet sent on the audit netlink
           socket. This function is usually called after sending a command to
           the audit system. _fd_ should be an open file descriptor returned by
           audit_open. _rep_ should be a data structure to put the reply in.
           _block_ is of type reply_t which is either: GET_REPLY_BLOCKING and
           GET_REPLY_NONBLOCKING. _peek_ , if non-zero, gets the data without
           dequeueing it from the netlink socket.
    


## RETURN VALUE



           This function returns -errno on error, 0 if error response
           received, and positive value on success.
    


* * *
# gnutls_ocsp_resp_import

## NAME



           gnutls_ocsp_resp_import - API function
    


## SYNOPSIS



           **#include <gnutls/ocsp.h>**
    
           **int gnutls_ocsp_resp_import(gnutls_ocsp_resp_t** _resp_**, const**
           **gnutls_datum_t ***_data_**);**
    


## ARGUMENTS



           gnutls_ocsp_resp_t resp
                       The data to store the parsed response.
    
           const gnutls_datum_t * data
                       DER encoded OCSP response.
    


## DESCRIPTION



           This function will convert the given DER encoded OCSP response to
           the native **gnutls_ocsp_resp_t** format.  It also decodes the Basic
           OCSP Response part, if any.  The output will be stored in  _resp_ .
    


## RETURNS



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


* * *
# audit_add_watch

## NAME



           audit_add_watch - create a rule layout for a watch
    


## SYNOPSIS



           **#include <libaudit.h>**
    
           **int audit_add_watch(struct audit_rule_data ****_rulep_**, const char ***_path_**);"**
    


## DESCRIPTION



           audit_add_watch will create a watch rule in the pointer to a
           pointer _rulep_. All that you need to pass it is the full _path_ to a
           file and it will initialize the audit_rule_data structure for a
           watch.
    


## RETURN VALUE



           Returns -1 if an error occurs; otherwise, 0 for success.
    


* * *
# gnutls_x509_privkey_export

## NAME



           gnutls_x509_privkey_export - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_privkey_export(gnutls_x509_privkey_t** _key_**,**
           **gnutls_x509_crt_fmt_t** _format_**, void ***_output_data_**, size_t ***
           _output_data_size_**);**
    


## ARGUMENTS



           gnutls_x509_privkey_t key
                       Holds the key
    
           gnutls_x509_crt_fmt_t format
                       the format of output params. One of PEM or DER.
    
           void * output_data
                       will contain a private key PEM or DER encoded
    
           size_t * output_data_size
                       holds the size of output_data (and will be replaced by
                       the actual size of parameters)
    


## DESCRIPTION



           This function will export the private key to a PKCS**1** structure for
           RSA or RSA-PSS keys, and integer sequence for DSA keys. Other keys
           types will be exported in PKCS**8** form.
    
           If the structure is PEM encoded, it will have a header of "BEGIN
           RSA PRIVATE KEY".
    
           It is recommended to use **gnutls_x509_privkey_export_pkcs8()**
           instead of this function, when a consistent output format is
           required.
    


## RETURNS



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


* * *
# function::ftrace

## NAME



           function::ftrace - Send a message to the ftrace ring-buffer
    


## SYNOPSIS



               ftrace(msg:string)
    


## ARGUMENTS



           _msg_
               The formatted message string
    


## DESCRIPTION



           If the ftrace ring-buffer is configured & available, see
           /debugfs/tracing/trace for the message. Otherwise, the message may
           be quietly dropped. An implicit end-of-line is added.
    


* * *
# tapset::ctime

## NAME



           tapset::ctime - systemtap ctime tapset
    


## DESCRIPTION



           **ctime** Convert seconds since epoch into human readable date/time
                  string
    
                  See function::ctime(3stap)
                   for details.
    
           **ctime** Convert seconds since epoch into human readable date/time
                  string
    
                  See function::ctime(3stap)
                   for details.
    


* * *
# acl_cmp

## NAME



           **acl_cmp** — compare two ACLs
    


## LIBRARY



           Linux Access Control Lists library (libacl, -lacl).
    


## SYNOPSIS



           <_sys/types.h_ > <_acl/libacl.h_ > _int_ **acl_cmp**(_acl_t acl1_ , _acl_t acl2_)
    


## DESCRIPTION



           The **acl_cmp**() function compares the ACLs pointed to by the
           arguments _acl1_ and _acl2_ for equality. The two ACLs are considered
           equal if for each entry in _acl1_ there is an entry in _acl2_ with
           matching tag type, qualifier, and permissions, and vice versa.
    


## RETURN VALUE



           If successful, the **acl_cmp**() function returns **0** if the two ACLs
           _acl1_ and _acl2_ are equal, and **1** if they differ. Otherwise, the
           value **-1** is returned and the global variable _errno_ is set to
           indicate the error.
    


## ERRORS



           If any of the following conditions occur, the **acl_cmp**() function
           returns **-1** and sets _errno_ to the corresponding value:
    
           [EINVAL]           The argument _acl1_ is not a valid pointer to an
                              ACL.
    
                              The argument _acl2_ is not a valid pointer to an
                              ACL.
    


## STANDARDS



           This is a non-portable, Linux specific extension to the ACL
           manipulation functions defined in IEEE Std 1003.1e draft 17
           (“POSIX.1e”, abandoned).
    


* * *
# probe::scheduler.ctxswitch

## NAME



           probe::scheduler.ctxswitch - A context switch is occuring.
    


## SYNOPSIS



           scheduler.ctxswitch
    


## VALUES



           _prev_pid_
               The PID of the process to be switched out
    
           _prevtsk_state_
               the state of the process to be switched out
    
           _next_task_name_
               The name of the process to be switched in
    
           _prev_tid_
               The TID of the process to be switched out
    
           _prev_priority_
               The priority of the process to be switched out
    
           _name_
               name of the probe point
    
           _next_pid_
               The PID of the process to be switched in
    
           _nexttsk_state_
               the state of the process to be switched in
    
           _next_tid_
               The TID of the process to be switched in
    
           _next_priority_
               The priority of the process to be switched in
    
           _prev_task_name_
               The name of the process to be switched out
    


* * *
# freelocale

## 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



           freelocale — free resources allocated for a locale object
    


## SYNOPSIS



           #include <locale.h>
    
           void freelocale(locale_t _locobj_);
    


## DESCRIPTION



           The _freelocale_() function shall cause the resources allocated for
           a locale object returned by a call to the _newlocale_() or
           _duplocale_() functions to be released.
    
           The behavior is undefined if the _locobj_ argument is the special
           locale object LC_GLOBAL_LOCALE or is not a valid locale object
           handle.
    
           Any use of a locale object that has been freed results in
           undefined behavior.
    


## RETURN VALUE



           None.
    


## ERRORS



           None.
    
           _The following sections are informative._
    


## EXAMPLES



       **Freeing Up a Locale Object**
           The following example shows a code fragment to free a locale
           object created by _newlocale_():
    
               #include <locale.h>
               ...
    
               /* Every locale object allocated with newlocale() should be
                * freed using freelocale():
                */
    
               locale_t loc;
    
               /* Get the locale. */
    
               loc = newlocale (LC_CTYPE_MASK | LC_TIME_MASK, "locname", NULL);
    
               /* ... Use the locale object ... */
               ...
    
               /* Free the locale object resources. */
               freelocale (loc);
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# sd_bus_message_seal

## NAME



           sd_bus_message_seal - Prepare a D-Bus message for transmission
    


## SYNOPSIS



           **#include <systemd/sd-bus.h>**
    
           **int sd_bus_message_seal(sd_bus_message ***_m_**, uint64_t** _cookie_**,**
                                   **uint64_t** _timeout_usec_**);**
    


## DESCRIPTION



           **sd_bus_message_seal()** finishes the message _m_ and prepares it for
           transmission using sd_bus_send(3).  _cookie_ specifies the
           identifier used to match the message reply to its corresponding
           request.  _timeout_usec_ specifies the maximum time in microseconds
           to wait for a reply to arrive.
    
           Note that in most scenarios, it is not necessary to call this
           function directly.  sd_bus_call(3), sd_bus_call_async(3) and
           sd_bus_send(3) will seal any given messages if they have not been
           sealed yet.
    


## RETURN VALUE



           On success, this function returns a non-negative integer. On
           failure, it returns a negative errno-style error code.
    
       **Errors**
           Returned errors may indicate the following problems:
    
           **-EINVAL**
               The _m_ parameter is **NULL**.
    
               Added in version 246.
    
           **-EBADMSG**
               The D-Bus message _m_ has open containers.
    
               Added in version 246.
    
           **-ENOMSG**
               The D-Bus message _m_ is a reply but its type signature does not
               match the return type signature of its corresponding member in
               the object vtable.
    
               Added in version 246.
    


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


* * *
# gnutls_pkcs11_token_get_mechanism

## NAME



           gnutls_pkcs11_token_get_mechanism - API function
    


## SYNOPSIS



           **#include <gnutls/pkcs11.h>**
    
           **int gnutls_pkcs11_token_get_mechanism(const char ***_url_**, unsigned**
           **int** _idx_**, unsigned long ***_mechanism_**);**
    


## ARGUMENTS



           const char * url
                       should contain a PKCS 11 URL
    
           unsigned int idx
                       The index of the mechanism
    
           unsigned long * mechanism
                       The PKCS **11** mechanism ID
    


## DESCRIPTION



           This function will return the names of the supported mechanisms by
           the token. It should be called with an increasing index until it
           return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE.
    


## RETURNS



           **GNUTLS_E_SUCCESS**(0) on success or a negative error code on error.
    


## SINCE



           2.12.0
    


* * *
# gnutls_x509_crt_sign2

## NAME



           gnutls_x509_crt_sign2 - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crt_sign2(gnutls_x509_crt_t** _crt_**, gnutls_x509_crt_t**
           _issuer_**, gnutls_x509_privkey_t** _issuer_key_**,**
           **gnutls_digest_algorithm_t** _dig_**, unsigned int** _flags_**);**
    


## ARGUMENTS



           gnutls_x509_crt_t crt
                       a certificate of type **gnutls_x509_crt_t**
    
           gnutls_x509_crt_t issuer
                       is the certificate of the certificate issuer
    
           gnutls_x509_privkey_t issuer_key
                       holds the issuer's private key
    
           gnutls_digest_algorithm_t dig
                       The message digest to use, **GNUTLS_DIG_SHA256** is a safe
                       choice
    
           unsigned int flags
                       must be 0
    


## DESCRIPTION



           This function will sign the certificate with the issuer's private
           key, and will copy the issuer's information into the certificate.
    
           This must be the last step in a certificate generation since all
           the previously set parameters are now signed.
    
           A known limitation of this function is, that a newly-signed
           certificate will not be fully functional (e.g., for signature
           verification), until it is exported an re-imported.
    
           After GnuTLS 3.6.1 the value of  _dig_ may be **GNUTLS_DIG_UNKNOWN** ,
           and in that case, a suitable but reasonable for the key algorithm
           will be selected.
    


## RETURNS



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


* * *
# mq_timedreceive

## 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



           mq_timedreceive — receive a message from a message queue (**ADVANCED**
           **REALTIME**)
    


## SYNOPSIS



           #include <mqueue.h>
           #include <time.h>
    
           ssize_t mq_timedreceive(mqd_t _mqdes_ , char *restrict _msg_ptr_ ,
               size_t _msg_len_ , unsigned *restrict _msg_prio_ ,
               const struct timespec *restrict _abstime_);
    


## DESCRIPTION



           Refer to mq_receive(3p).
    


* * *
# function::ansi_set_color

## NAME



           function::ansi_set_color - Set the ansi Select Graphic Rendition
           mode.
    


## SYNOPSIS



           1) ansi_set_color(fg:long)
    
           2) ansi_set_color(fg:long,bg:long)
    
           3) ansi_set_color(fg:long,bg:long,attr:long)
    


## ARGUMENTS



           _fg_
               Foreground color to set.
    
           _bg_
               Background color to set.
    
           _attr_
               Color attribute to set.
    


## DESCRIPTION



           1) Sends ansi code for Select Graphic Rendition mode for the given
           forground color. Black (30), Blue (34), Green (32), Cyan (36), Red
           (31), Purple (35), Brown (33), Light Gray (37).
    
           2) Sends ansi code for Select Graphic Rendition mode for the given
           forground color, Black (30), Blue (34), Green (32), Cyan (36), Red
           (31), Purple (35), Brown (33), Light Gray (37) and the given
           background color, Black (40), Red (41), Green (42), Yellow (43),
           Blue (44), Magenta (45), Cyan (46), White (47).
    
           3) Sends ansi code for Select Graphic Rendition mode for the given
           forground color, Black (30), Blue (34), Green (32), Cyan (36), Red
           (31), Purple (35), Brown (33), Light Gray (37), the given
           background color, Black (40), Red (41), Green (42), Yellow (43),
           Blue (44), Magenta (45), Cyan (46), White (47) and the color
           attribute All attributes off (0), Intensity Bold (1), Underline
           Single (4), Blink Slow (5), Blink Rapid (6), Image Negative (7).
    


* * *
# seccomp_release

## NAME



           seccomp_release - Release the seccomp filter state
    


## SYNOPSIS



           **#include <seccomp.h>**
    
           **typedef void * scmp_filter_ctx;**
    
           **void seccomp_release(scmp_filter_ctx** _ctx_**);**
    
           Link with _-lseccomp_.
    


## DESCRIPTION



           Releases the seccomp filter in _ctx_ which was first initialized by
           seccomp_init(3) or seccomp_reset(3) and frees any memory
           associated with the given seccomp filter context.  Any seccomp
           filters loaded into the kernel are not affected.
    


## RETURN VALUE



           Does not return a value.
    


## EXAMPLES



           #include <seccomp.h>
    
           int main(int argc, char *argv[])
           {
                int rc;
                scmp_filter_ctx ctx;
    
                ctx = seccomp_init(SCMP_ACT_KILL);
                if (ctx == NULL)
                     return 1;
    
                /* ... */
    
                seccomp_release(ctx);
                return 0;
           }
    


## NOTES



           While the seccomp filter can be generated independent of the
           kernel, kernel support is required to load and enforce the seccomp
           filter generated by libseccomp.
    
           The libseccomp project site, with more information and the source
           code repository, can be found at
           https://github.com/seccomp/libseccomp.  This tool, as well as the
           libseccomp library, is currently under development, please report
           any bugs at the project site or directly to the author.
    


* * *
# gnutls_x509_crl_iter_crt_serial

## NAME



           gnutls_x509_crl_iter_crt_serial - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crl_iter_crt_serial(gnutls_x509_crl_t** _crl_**,**
           **gnutls_x509_crl_iter_t ***_iter_**, unsigned char ***_serial_**, size_t ***
           _serial_size_**, time_t ***_t_**);**
    


## ARGUMENTS



           gnutls_x509_crl_t crl
                       should contain a **gnutls_x509_crl_t** type
    
           gnutls_x509_crl_iter_t * iter
                       A pointer to an iterator (initially the iterator
                       should be **NULL**)
    
           unsigned char * serial
                       where the serial number will be copied
    
           size_t * serial_size
                       initially holds the size of serial
    
           time_t * t  if non null, will hold the time this certificate was
                       revoked
    


## DESCRIPTION



           This function performs the same as
           **gnutls_x509_crl_get_crt_serial()** , but reads sequentially and keeps
           state in the iterator between calls. That allows it to provide
           better performance in sequences with many elements (50000+).
    
           When past the last element is accessed
           **GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE** is returned and the iterator
           is reset.
    
           After use, the iterator must be deinitialized using
           **gnutls_x509_crl_iter_deinit()**.
    


## RETURNS



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


* * *
# tapset::json

## NAME



           tapset::json - systemtap json tapset
    


## DESCRIPTION



            The JSON tapset provides probes, functions, and macros to
           generate
            a JSON metadata and data file. The JSON metadata file is located
           in
            /proc/systemtap/MODULE/metadata.json. The JSON data file is
           located
            in /proc/systemtap/MODULE/data.json. The JSON data file is
           updated
            with current data every time the file is read.
    
           **json_set_prefix**
                  Set the metric prefix.
    
                  See function::json_set_prefix(3stap)
                   for details.
    
           **json_add_numeric_metric**
                  Add a numeric metric
    
                  See function::json_add_numeric_metric(3stap)
                   for details.
    
           **json_add_string_metric**
                  Add a string metric
    
                  See function::json_add_string_metric(3stap)
                   for details.
    
           **json_add_array**
                  Add an array
    
                  See function::json_add_array(3stap)
                   for details.
    
           **json_add_array_numeric_metric**
                  Add a numeric metric to an array
    
                  See function::json_add_array_numeric_metric(3stap)
                   for details.
    
           **json_add_array_string_metric**
                  Add a string metric to an array
    
                  See function::json_add_array_string_metric(3stap)
                   for details.
    
           **json_data**
                  Fires whenever JSON data is wanted by a reader.
    
                   See probe::json_data(3stap)
                   for details.
    
           **@json_output_data_start**
                  Start the json output.
    
                   See macro::json_output_data_start(3stap)
                   for details.
    
           **@json_output_string_value**
                  Output a string value.
    
                   See macro::json_output_string_value(3stap)
                   for details.
    
           **@json_output_numeric_value**
                  Output a numeric value.
    
                   See macro::json_output_numeric_value(3stap)
                   for details.
    
           **@json_output_array_string_value**
                  Output a string value for metric in an array.
    
                   See macro::json_output_array_string_value(3stap)
                   for details.
    
           **@json_output_array_numeric_value**
                  Output a numeric value for metric in an array.
    
                   See macro::json_output_array_numeric_value(3stap)
                   for details.
    
           **@json_output_data_end**
                  End the json output.
    
                   See macro::json_output_data_end(3stap)
                   for details.
    


* * *
# ibv_open_device

## NAME



           ibv_open_device, ibv_close_device - open and close an RDMA device
           context
    


## SYNOPSIS



           **#include <infiniband/verbs.h>**
    
           **struct ibv_context *ibv_open_device(struct ibv_device** _*device_**);**
    
           **int ibv_close_device(struct ibv_context** _*context_**);**
    


## DESCRIPTION



           **ibv_open_device()** opens the device _device_ and creates a context
           for further use.
    
           **ibv_close_device()** closes the device context _context_.
    


## RETURN VALUE



           **ibv_open_device()** returns a pointer to the allocated device
           context, or NULL if the request fails.
    
           **ibv_close_device()** returns 0 on success, -1 on failure.
    


## NOTES



           **ibv_close_device()** does not release all the resources allocated
           using context _context_.  To avoid resource leaks, the user should
           release all associated resources before closing a context.
    
           Setting the environment variable **RDMAV_ALLOW_DISASSOC_DESTROY**
           tells the library to relate an EIO from destroy commands as a
           success as the kernel resources were already released. This comes
           to prevent memory leakage in the user space area upon device
           disassociation. Applications using this flag cannot call
           ibv_get_cq_event or ibv_get_async_event concurrently with any call
           to an object destruction function.
    


* * *
# gnutls_kx_get_name

## NAME



           gnutls_kx_get_name - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **const char * gnutls_kx_get_name(gnutls_kx_algorithm_t** _algorithm_**);**
    


## ARGUMENTS



           gnutls_kx_algorithm_t algorithm
                       is a key exchange algorithm
    


## DESCRIPTION



           Convert a **gnutls_kx_algorithm_t** value to a string.
    


## RETURNS



           a pointer to a string that contains the name of the specified key
           exchange algorithm, or **NULL**.
    


* * *
# function::stack_size

## NAME



           function::stack_size - Return the size of the kernel stack
    


## SYNOPSIS



               stack_size:long()
    


## ARGUMENTS



           None
    


## DESCRIPTION



           This function returns the size of the kernel stack.
    


* * *
# gnutls_x509_tlsfeatures_check_crt

## NAME



           gnutls_x509_tlsfeatures_check_crt - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **unsigned**
           **gnutls_x509_tlsfeatures_check_crt(gnutls_x509_tlsfeatures_t** _feat_**,**
           **gnutls_x509_crt_t** _cert_**);**
    


## ARGUMENTS



           gnutls_x509_tlsfeatures_t feat
                       a set of TLSFeatures
    
           gnutls_x509_crt_t cert
                       the certificate to be checked
    


## DESCRIPTION



           This function will check the provided certificate against the
           TLSFeatures set in  _feat_ using the RFC7633 p.4.2.2 rules. It will
           check whether the certificate contains the features in  _feat_ or a
           superset.
    


## RETURNS



           non-zero if the provided certificate complies, and zero otherwise.
    


## SINCE



           3.5.1
    


* * *
# gnutls_x509_crl_get_this_update

## NAME



           gnutls_x509_crl_get_this_update - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **time_t gnutls_x509_crl_get_this_update(gnutls_x509_crl_t** _crl_**);**
    


## ARGUMENTS



           gnutls_x509_crl_t crl
                       should contain a **gnutls_x509_crl_t** type
    


## DESCRIPTION



           This function will return the time this CRL was issued.
    


## RETURNS



           when the CRL was issued, or (time_t)-1 on error.
    


* * *
# gnutls_pubkey_import_dsa_raw

## NAME



           gnutls_pubkey_import_dsa_raw - API function
    


## SYNOPSIS



           **#include <gnutls/abstract.h>**
    
           **int gnutls_pubkey_import_dsa_raw(gnutls_pubkey_t** _key_**, const**
           **gnutls_datum_t ***_p_**, const gnutls_datum_t ***_q_**, const gnutls_datum_t**
           *****_g_**, const gnutls_datum_t ***_y_**);**
    


## ARGUMENTS



           gnutls_pubkey_t key
                       The structure to store the parsed key
    
           const gnutls_datum_t * p
                       holds the p
    
           const gnutls_datum_t * q
                       holds the q
    
           const gnutls_datum_t * g
                       holds the g
    
           const gnutls_datum_t * y
                       holds the y
    


## DESCRIPTION



           This function will convert the given DSA raw parameters to the
           native **gnutls_pubkey_t** format.  The output will be stored in  _key_
           .
    


## RETURNS



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


## SINCE



           2.12.0
    


* * *
# probe::sunrpc.svc.process

## NAME



           probe::sunrpc.svc.process - Process an RPC request
    


## SYNOPSIS



           sunrpc.svc.process
    


## VALUES



           _sv_nrthreads_
               the number of concurrent threads
    
           _rq_proc_
               the procedure number in the request
    
           _sv_name_
               the service name
    
           _rq_vers_
               the program version in the request
    
           _rq_prog_
               the program number in the request
    
           _rq_xid_
               the transmission id in the request
    
           _rq_prot_
               the IP protocol of the reqeust
    
           _peer_ip_
               the peer address where the request is from
    
           _sv_prog_
               the number of the program
    


* * *
# gnutls_dh_params_import_raw

## NAME



           gnutls_dh_params_import_raw - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_dh_params_import_raw(gnutls_dh_params_t** _dh_params_**,**
           **const gnutls_datum_t ***_prime_**, 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 * 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_aead_cipher_encryptv

## NAME



           gnutls_aead_cipher_encryptv - API function
    


## SYNOPSIS



           **#include <gnutls/crypto.h>**
    
           **int gnutls_aead_cipher_encryptv(gnutls_aead_cipher_hd_t** _handle_**,**
           **const void ***_nonce_**, size_t** _nonce_len_**, const giovec_t ***_auth_iov_**,**
           **int** _auth_iovcnt_**, size_t** _tag_size_**, const giovec_t ***_iov_**, int**
           _iovcnt_**, void ***_ctext_**, size_t ***_ctext_len_**);**
    


## ARGUMENTS



           gnutls_aead_cipher_hd_t handle
                       is a **gnutls_aead_cipher_hd_t** type.
    
           const void * nonce
                       the nonce to set
    
           size_t nonce_len
                       The length of the nonce
    
           const giovec_t * auth_iov
                       additional data to be authenticated
    
           int auth_iovcnt
                       The number of buffers in  _auth_iov_
    
           size_t tag_size
                       The size of the tag to use (use zero for the default)
    
           const giovec_t * iov
                       the data to be encrypted
    
           int iovcnt  The number of buffers in  _iov_
    
           void * ctext
                       the encrypted data including authentication tag
    
           size_t * ctext_len
                       the length of encrypted data (initially must hold the
                       maximum available size, including space for tag)
    


## DESCRIPTION



           This function will encrypt the provided data buffers using the
           algorithm specified by the context. The output data will contain
           the authentication tag.
    


## RETURNS



           Zero or a negative error code on error.
    


## SINCE



           3.6.3
    


* * *
# aio_fsync

## NAME



           aio_fsync - asynchronous file synchronization
    


## LIBRARY



           Real-time library (_librt_ , _-lrt_)
    


## SYNOPSIS



           **#include <aio.h>**
    
           **int aio_fsync(int** _op_**, struct aiocb ***_aiocbp_**);**
    


## DESCRIPTION



           The **aio_fsync**() function does a sync on all outstanding
           asynchronous I/O operations associated with _aiocbp- >aio_fildes_.
           (See aio(7) for a description of the _aiocb_ structure.)
    
           More precisely, if _op_ is **O_SYNC** , then all currently queued I/O
           operations shall be completed as if by a call of fsync(2), and if
           _op_ is **O_DSYNC** , this call is the asynchronous analog of
           fdatasync(2).
    
           Note that this is a request only; it does not wait for I/O
           completion.
    
           Apart from _aio_fildes_ , the only field in the structure pointed to
           by _aiocbp_ that is used by this call is the _aio_sigevent_ field (a
           _sigevent_ structure, described in sigevent(3type)), which indicates
           the desired type of asynchronous notification at completion.  All
           other fields are ignored.
    


## RETURN VALUE



           On success (the sync request was successfully queued) this
           function returns 0.  On error, -1 is returned, and _errno_ is set to
           indicate the error.
    


## ERRORS



           **EAGAIN** Out of resources.
    
           **EBADF** _aio_fildes_ is not a valid file descriptor open for writing.
    
           **EINVAL** Synchronized I/O is not supported for this file, or _op_ is
                  not **O_SYNC** or **O_DSYNC**.
    
           **ENOSYS aio_fsync**() is not implemented.
    


## ATTRIBUTES



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


## STANDARDS



           POSIX.1-2008.
    


* * *
# bindtextdomain

## NAME



           bindtextdomain - set directory containing message catalogs
    


## SYNOPSIS



           **#include <libintl.h>**
    
           **char * bindtextdomain (const char ***_domainname_**, const char ***_dirname_**);**
    


## DESCRIPTION



           The **bindtextdomain** function sets the base directory of the
           hierarchy containing message catalogs for a given message domain.
    
           A message domain is a set of translatable _msgid_ messages. Usually,
           every software package has its own message domain. The need for
           calling **bindtextdomain** arises because packages are not always
           installed with the same prefix as the <libintl.h> header and the
           libc/libintl libraries.
    
           Message catalogs will be expected at the pathnames
           _dirname_ /_locale_ /_category_ /_domainname_.mo, where _locale_ is a locale
           name and _category_ is a locale facet such as **LC_MESSAGES**.
    
           _domainname_ must be a non-empty string.
    
           If _dirname_ is not NULL, the base directory for message catalogs
           belonging to domain _domainname_ is set to _dirname_. The function
           makes copies of the argument strings as needed. If the program
           wishes to call the **chdir** function, it is important that _dirname_ be
           an absolute pathname; otherwise it cannot be guaranteed that the
           message catalogs will be found.
    
           If _dirname_ is NULL, the function returns the previously set base
           directory for domain _domainname_.
    


## RETURN VALUE



           If successful, the **bindtextdomain** function returns the current
           base directory for domain _domainname_ , after possibly changing it.
           The resulting string is valid until the next **bindtextdomain** call
           for the same _domainname_ and must not be modified or freed. If a
           memory allocation failure occurs, it sets **errno** to **ENOMEM** and
           returns NULL.
    


## ERRORS



           The following error can occur, among others:
    
           **ENOMEM** Not enough memory available.
    


## BUGS



           The return type ought to be **const char *** , but is **char *** to avoid
           warnings in C code predating ANSI C.
    


* * *
# probe::nfs.aop.write_begin

## NAME



           probe::nfs.aop.write_begin - NFS client begin to write data
    


## SYNOPSIS



           nfs.aop.write_begin
    


## VALUES



           _size_
               write bytes
    
           _to_
               end address of this write operation
    
           _page_index_
               offset within mapping, can used a page identifier and position
               identifier in the page frame
    
           _offset_
               start address of this write operation
    
           _ino_
               inode number
    
           _dev_
               device identifier
    
           ___page_
               the address of page
    


## DESCRIPTION



           Occurs when write operation occurs on nfs. It prepare a page for
           writing, look for a request corresponding to the page. If there is
           one, and it belongs to another file, it flush it out before it
           tries to copy anything into the page. Also do the same if it finds
           a request from an existing dropped page
    


* * *
# function::ipmib_get_proto

## NAME



           function::ipmib_get_proto - Get the protocol value
    


## SYNOPSIS



               ipmib_get_proto:long(skb:long)
    


## ARGUMENTS



           _skb_
               pointer to a struct sk_buff
    


## DESCRIPTION



           Returns the protocol value from _skb_.
    


* * *
# free

## 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



           free — free allocated memory
    


## SYNOPSIS



           #include <stdlib.h>
    
           void free(void *_ptr_);
    


## DESCRIPTION



           The functionality described on this reference page is aligned with
           the ISO C standard. Any conflict between the requirements
           described here and the ISO C standard is unintentional. This
           volume of POSIX.1‐2017 defers to the ISO C standard.
    
           The _free_() function shall cause the space pointed to by _ptr_ to be
           deallocated; that is, made available for further allocation. If
           _ptr_ is a null pointer, no action shall occur. Otherwise, if the
           argument does not match a pointer earlier returned by a function
           in POSIX.1‐2008 that allocates memory as if by _malloc_(), or if the
           space has been deallocated by a call to _free_() or _realloc_(), the
           behavior is undefined.
    
           Any use of a pointer that refers to freed space results in
           undefined behavior.
    


## RETURN VALUE



           The _free_() function shall not return a value.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           There is now no requirement for the implementation to support the
           inclusion of _< malloc.h>_.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# pcap_sendpacket

## NAME



           pcap_inject, pcap_sendpacket - transmit a packet
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **int pcap_inject(pcap_t *p, const void *buf, size_t size);**
           **int pcap_sendpacket(pcap_t *p, const u_char *buf, int size);**
    


## DESCRIPTION



           **pcap_inject**() sends a raw packet through the network interface;
           _buf_ points to the data of the packet, including the link-layer
           header, and _size_ is the number of bytes in the packet.
    
           Note that, even if you successfully open the network interface,
           you might not have permission to send packets on it, or it might
           not support sending packets; as **pcap_open_live**(3PCAP) doesn't have
           a flag to indicate whether to open for capturing, sending, or
           capturing and sending, you cannot request an open that supports
           sending and be notified at open time whether sending will be
           possible.  The same limitation applies to **pcap_create**(3PCAP) and
           **pcap_activate**(3PCAP).  Note also that some devices might not
           support sending packets.
    
           Note that, on some platforms, the link-layer header of the packet
           that's sent might not be the same as the link-layer header of the
           packet supplied to **pcap_inject**(), as the source link-layer
           address, if the header contains such an address, might be changed
           to be the address assigned to the interface on which the packet it
           sent, if the platform doesn't support sending completely raw and
           unchanged packets.  Even worse, some drivers on some platforms
           might change the link-layer type field to whatever value libpcap
           used when attaching to the device, even on platforms that _do_
           nominally support sending completely raw and unchanged packets.
    
           **pcap_sendpacket**() is like **pcap_inject**(), but it returns **0** on
           success, rather than returning the number of bytes written.
           (**pcap_inject**() comes from OpenBSD; **pcap_sendpacket**() comes from
           WinPcap/Npcap.  Both are provided for compatibility.)
    


## RETURN VALUE



           **pcap_inject**() returns the number of bytes written on success,
           **PCAP_ERROR_NOT_ACTIVATED** if called on a capture handle that has
           been created but not activated, and **PCAP_ERROR** on other errors.
    
           **pcap_sendpacket**() returns **0** on success, **PCAP_ERROR_NOT_ACTIVATED**
           if called on a capture handle that has been created but not
           activated, and **PCAP_ERROR** on other errors.
    
           If **PCAP_ERROR** is returned, **pcap_geterr**(3PCAP) or
           **pcap_perror**(3PCAP) may be called with _p_ as an argument to fetch or
           display the error text.
    


* * *
# gnutls_certificate_set_trust_list

## NAME



           gnutls_certificate_set_trust_list - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **void**
           **gnutls_certificate_set_trust_list(gnutls_certificate_credentials_t**
           _res_**, gnutls_x509_trust_list_t** _tlist_**, unsigned** _flags_**);**
    


## ARGUMENTS



           gnutls_certificate_credentials_t res
                       is a **gnutls_certificate_credentials_t** type.
    
           gnutls_x509_trust_list_t tlist
                       is a **gnutls_x509_trust_list_t** type
    
           unsigned flags
                       must be zero
    


## DESCRIPTION



           This function sets a trust list in the
           gnutls_certificate_credentials_t type.
    
           Note that the  _tlist_ will become part of the credentials structure
           and must not be deallocated. It will be automatically deallocated
           when the  _res_ structure is deinitialized.
    


## SINCE



           3.2.2
    


* * *
# islessgreater

## 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



           islessgreater — test if x is less than or greater than y
    


## SYNOPSIS



           #include <math.h>
    
           int islessgreater(real-floating _x_ , real-floating _y_);
    


## DESCRIPTION



           The functionality described on this reference page is aligned with
           the ISO C standard. Any conflict between the requirements
           described here and the ISO C standard is unintentional. This
           volume of POSIX.1‐2017 defers to the ISO C standard.
    
           The _islessgreater_() macro shall determine whether its first
           argument is less than or greater than its second argument. The
           _islessgreater_(_x_ , _y_) macro is similar to (_x_) < (_y_) || (_x_) > (_y_);
           however, _islessgreater_(_x_ , _y_) shall not raise the invalid floating-
           point exception when _x_ and _y_ are unordered (nor shall it evaluate
           _x_ and _y_ twice).
    


## RETURN VALUE



           Upon successful completion, the _islessgreater_() macro shall return
           the value of (_x_) < (_y_) || (_x_) > (_y_).
    
           If _x_ or _y_ is NaN, 0 shall be returned.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           The relational and equality operators support the usual
           mathematical relationships between numeric values. For any ordered
           pair of numeric values, exactly one of the relationships (less,
           greater, and equal) is true. Relational operators may raise the
           invalid floating-point exception when argument values are NaNs.
           For a NaN and a numeric value, or for two NaNs, just the unordered
           relationship is true. This macro is a quiet (non-floating-point
           exception raising) version of a relational operator. It
           facilitates writing efficient code that accounts for NaNs without
           suffering the invalid floating-point exception. In the SYNOPSIS
           section, **real-floating** indicates that the argument shall be an
           expression of **real-floating** type.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# libpfm_intel_nhm_unc

## NAME



           libpfm_intel_nhm_unc - support for Intel Nehalem uncore PMU
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: nhm_unc**
           **PMU desc: Intel Nehalem uncore**
    


## DESCRIPTION



           The library supports the Nehalem uncore PMU as implemented by
           processors such as Intel Core i7, and Intel Core i5.
    
           The PMU is located at the socket-level and is therefore shared
           between the various cores. By construction it can only measure at
           all privilege levels.
    


## MODIFIERS



           The following modifiers are supported on Intel Nehalem processors:
    
           **i** Invert the meaning of the event. The counter will now count
                  cycles in which the event is **not** occurring. This is a
                  boolean modifier
    
           **e** Enable edge detection, i.e., count only when there is a
                  state transition. This is a boolean modifier.
    
           **c** Set the counter mask value. The mask acts as a threshold.
                  The counter will count the number of 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].
    
           **o** Causes the queue occupancy counter associated with the
                  event to be cleared (zeroed). This is a boolean modifier.
    


* * *