tripathysagar/man_text huggingface dataset:
# memcmp

## NAME



           memcmp - compare memory areas
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <string.h>**
    
           **int memcmp(** size_t n;
                      **const void** _s1_**[**_n_**], const void** _s2_**[**_n_**], size_t** _n_**);**
    


## DESCRIPTION



           The **memcmp**() function compares the first _n_ bytes (each interpreted
           as _unsigned char_) of the memory areas _s1_ and _s2_.
    


## RETURN VALUE



           The **memcmp**() function returns an integer less than, equal to, or
           greater than zero if the first _n_ bytes of _s1_ is found,
           respectively, to be less than, to match, or be greater than the
           first _n_ bytes of _s2_.
    
           For a nonzero return value, the sign is determined by the sign of
           the difference between the first pair of bytes (interpreted as
           _unsigned char_) that differ in _s1_ and _s2_.
    
           If _n_ is zero, the return value is zero.
    


## ATTRIBUTES



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


## STANDARDS



           C11, POSIX.1-2008.
    


## CAVEATS



           Do not use **memcmp**() to compare confidential data, such as
           cryptographic secrets, because the CPU time required for the
           comparison depends on the contents of the addresses compared, this
           function is subject to timing-based side-channel attacks.  In such
           cases, a function that performs comparisons in deterministic time,
           depending only on _n_ (the quantity of bytes compared) is required.
           Some operating systems provide such a function (e.g., NetBSD's
           **consttime_memequal**()), but no such function is specified in POSIX.
           On Linux, you may need to implement such a function yourself.
    


* * *
# gnutls_alert_get_strname

## NAME



           gnutls_alert_get_strname - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **const char * gnutls_alert_get_strname(gnutls_alert_description_t**
           _alert_**);**
    


## ARGUMENTS



           gnutls_alert_description_t alert
                       is an alert number.
    


## DESCRIPTION



           This function will return a string of the name of the alert.
    


## RETURNS



           string corresponding to **gnutls_alert_description_t** value.
    


## SINCE



           3.0
    


* * *
# gnutls_credentials_get

## NAME



           gnutls_credentials_get - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_credentials_get(gnutls_session_t** _session_**,**
           **gnutls_credentials_type_t** _type_**, void ****_cred_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    
           gnutls_credentials_type_t type
                       is the type of the credentials to return
    
           void ** cred
                       will contain the credentials.
    


## DESCRIPTION



           Returns the previously provided credentials structures.
    
           For **GNUTLS_CRD_ANON** ,  _cred_ will be
           **gnutls_anon_client_credentials_t** in case of a client.  In case of
           a server it should be **gnutls_anon_server_credentials_t**.
    
           For **GNUTLS_CRD_SRP** ,  _cred_ will be **gnutls_srp_client_credentials_t**
           in case of a client, and **gnutls_srp_server_credentials_t** , in case
           of a server.
    
           For **GNUTLS_CRD_PSK** ,  _cred_ will be **gnutls_psk_client_credentials_t**
           in case of a client, and **gnutls_psk_server_credentials_t** , in case
           of a server.
    
           For **GNUTLS_CRD_CERTIFICATE** ,  _cred_ will be
           **gnutls_certificate_credentials_t**.
    


## RETURNS



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


## SINCE



           3.3.3
    


* * *
# probe::nfs.aop.readpage

## NAME



           probe::nfs.aop.readpage - NFS client synchronously reading a page
    


## SYNOPSIS



           nfs.aop.readpage
    


## VALUES



           _sb_flag_
               super block flags
    
           _page_index_
               offset within mapping, can used a page identifier and position
               identifier in the page frame
    
           _i_flag_
               file flags
    
           _i_size_
               file length in bytes
    
           _file_
               file argument
    
           ___page_
               the address of page
    
           _size_
               number of pages to be read in this execution
    
           _rsize_
               read size (in bytes)
    
           _ino_
               inode number
    
           _dev_
               device identifier
    


## DESCRIPTION



           Read the page over, only fires when a previous async read
           operation failed
    


* * *
# gnutls_privkey_set_pin_function

## NAME



           gnutls_privkey_set_pin_function - API function
    


## SYNOPSIS



           **#include <gnutls/abstract.h>**
    
           **void gnutls_privkey_set_pin_function(gnutls_privkey_t** _key_**,**
           **gnutls_pin_callback_t** _fn_**, void ***_userdata_**);**
    


## ARGUMENTS



           gnutls_privkey_t key
                       A key of type **gnutls_privkey_t**
    
           gnutls_pin_callback_t fn
                       the callback
    
           void * userdata
                       data associated with the callback
    


## DESCRIPTION



           This function will set a callback function to be used when
           required to access the object. This function overrides any other
           global PIN functions.
    
           Note that this function must be called right after initialization
           to have effect.
    


## SINCE



           3.1.0
    


* * *
# gnutls_x509_crq_get_key_id

## NAME



           gnutls_x509_crq_get_key_id - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crq_get_key_id(gnutls_x509_crq_t** _crq_**, unsigned int**
           _flags_**, unsigned char ***_output_data_**, size_t ***_output_data_size_**);**
    


## ARGUMENTS



           gnutls_x509_crq_t crq
                       a certificate of type **gnutls_x509_crq_t**
    
           unsigned int flags
                       should be one of the flags from **gnutls_keyid_flags_t**
    
           unsigned char * output_data
                       will contain the key ID
    
           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 return a unique ID that depends on the public
           key parameters.  This ID can be used in checking whether a
           certificate corresponds to the given private key.
    
           If the buffer provided is not long enough to hold the output, then
           * _output_data_size_ is updated and GNUTLS_E_SHORT_MEMORY_BUFFER
           will be returned.  The output will normally be a SHA-1 hash
           output, which is 20 bytes.
    


## RETURNS



           In case of failure a negative error code will be returned, and 0
           on success.
    


## SINCE



           2.8.0
    


* * *
# gnutls_certificate_set_verify_function

## NAME



           gnutls_certificate_set_verify_function - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **void**
           **gnutls_certificate_set_verify_function(gnutls_certificate_credentials_t**
           _cred_**, gnutls_certificate_verify_function ***_func_**);**
    


## ARGUMENTS



           gnutls_certificate_credentials_t cred
                       is a **gnutls_certificate_credentials_t** type.
    
           gnutls_certificate_verify_function * func
                       is the callback function
    


## DESCRIPTION



           This function sets a callback to be called when peer's certificate
           has been received in order to verify it on receipt rather than
           doing after the handshake is completed.
    
           The callback's function prototype is: int
           (*callback)(gnutls_session_t);
    
           If the callback function is provided then gnutls will call it, in
           the handshake, just after the certificate message has been
           received.  To verify or obtain the certificate the
           **gnutls_certificate_verify_peers2()** , **gnutls_certificate_type_get()** ,
           **gnutls_certificate_get_peers()** functions can be used.
    
           The callback function should return 0 for the handshake to
           continue or non-zero to terminate.
    


## SINCE



           2.10.0
    


* * *
# probe::tcp.sendmsg.return

## NAME



           probe::tcp.sendmsg.return - Sending TCP message is done
    


## SYNOPSIS



           tcp.sendmsg.return
    


## VALUES



           _size_
               Number of bytes sent or error code if an error occurred.
    
           _name_
               Name of this probe
    


## CONTEXT



           The process which sends a tcp message
    


* * *
# probe::scsi.set_state

## NAME



           probe::scsi.set_state - Order SCSI device state change
    


## SYNOPSIS



           scsi.set_state
    


## VALUES



           _host_no_
               The host number
    
           _channel_
               The channel number
    
           _old_state_
               The current state of the device
    
           _lun_
               The lun number
    
           _state_
               The new state of the device
    
           _state_str_
               The new state of the device, as a string
    
           _dev_id_
               The scsi device id
    
           _old_state_str_
               The current state of the device, as a string
    


* * *
# gnutls_x509_crt_check_issuer

## NAME



           gnutls_x509_crt_check_issuer - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **unsigned gnutls_x509_crt_check_issuer(gnutls_x509_crt_t** _cert_**,**
           **gnutls_x509_crt_t** _issuer_**);**
    


## ARGUMENTS



           gnutls_x509_crt_t cert
                       is the certificate to be checked
    
           gnutls_x509_crt_t issuer
                       is the certificate of a possible issuer
    


## DESCRIPTION



           This function will check if the given certificate was issued by
           the given issuer. It checks the DN fields and the authority key
           identifier and subject key identifier fields match.
    
           If the same certificate is provided at the  _cert_ and  _issuer_
           fields, it will check whether the certificate is self-signed.
    


## RETURNS



           It will return true (1) if the given certificate is issued by the
           given issuer, and false (0) if not.
    


* * *
# pmiputtext

## NAME



           **pmiPutText** - add help text for an metric or instance domain
    


## C SYNOPSIS



           **#include <pcp/pmapi.h>**
           **#include <pcp/import.h>**
    
           **int pmiPutText(unsigned int** _type_**, unsigned int** _class_**,**
                          **unsigned int** _id_**, const char ***_content_**);**
    
           **cc ... -lpcp_import -lpcp**
    


## Perl SYNOPSIS



           **use PCP::LogImport;**
    
           **pmiPutText($**_type_**, $**_class_**, $**_id_**, $**_content_**);**
    


## DESCRIPTION



           As   part   of  the  Performance  Co-Pilot  Log  Import  API  (see
           LOGIMPORT(3)), **pmiPutText** adds help text for a given metric or in‐
           stance domain.
    
           The _type_ must be one of **PM_TEXT_PMID** or **PM_TEXT_INDOM**.
    
           The _class_ must be one of **PM_TEXT_ONELINE** or **PM_TEXT_HELP**.
    
           If _type_ is **PM_TEXT_PMID** , then _id_ should match a pmid defined  ear‐
           lier in a call to pmiAddMetric(3).  If _type_ is **PM_TEXT_INDOM** , then
           _id_  should  match  an instance domain defined earlier in a call to
           pmiAddMetric(3).
    
           _content_ is a string containing the content of the help text.
    
           No data will be written until pmiWrite(3) is called,  so  multiple
           calls to **pmiPutText** are typically used to accumulate help text for
           several metrics or instance domains before calling pmiWrite(3).
    


## DIAGNOSTICS



           **pmiPutText** returns zero on success else a negative value that can
           be turned into an error message by calling pmiErrStr(3).
    


* * *
# ualarm

## NAME



           ualarm - schedule signal after given number of microseconds
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <unistd.h>**
    
           **useconds_t ualarm(useconds_t** _usecs_**, useconds_t** _interval_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **ualarm**():
               Since glibc 2.12:
                   (_XOPEN_SOURCE >= 500) && ! (_POSIX_C_SOURCE >= 200809L)
                       || /* glibc >= 2.19: */ _DEFAULT_SOURCE
                       || /* glibc <= 2.19: */ _BSD_SOURCE
               Before glibc 2.12:
                   _BSD_SOURCE || _XOPEN_SOURCE >= 500
    


## DESCRIPTION



           The **ualarm**() function causes the signal **SIGALRM** to be sent to the
           invoking process after (not less than) _usecs_ microseconds.  The
           delay may be lengthened slightly by any system activity or by the
           time spent processing the call or by the granularity of system
           timers.
    
           Unless caught or ignored, the **SIGALRM** signal will terminate the
           process.
    
           If the _interval_ argument is nonzero, further **SIGALRM** signals will
           be sent every _interval_ microseconds after the first.
    


## RETURN VALUE



           This function returns the number of microseconds remaining for any
           alarm that was previously set, or 0 if no alarm was pending.
    


## ERRORS



           **EINTR** Interrupted by a signal; see signal(7).
    
           **EINVAL** _usecs_ or _interval_ is not smaller than **1000000**.  (On systems
                  where that is considered an error.)
    


## ATTRIBUTES



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


## STANDARDS



           None.
    


* * *
# tapset::timestamp

## NAME



           tapset::timestamp - systemtap timestamp tapset
    


## DESCRIPTION



            Each timestamp function returns a value to indicate when a
           function is executed. These returned values can then be used to
           indicate when an event occurred, provide an ordering for events,
           or compute the amount of time elapsed between two time stamps.
    
           **get_cycles**
                  Processor cycle count
    
                  See function::get_cycles(3stap)
                   for details.
    
           **jiffies**
                  Kernel jiffies count
    
                  See function::jiffies(3stap)
                   for details.
    
           **HZ** Kernel HZ
    
                  See function::HZ(3stap)
                   for details.
    


* * *
# gnutls_ocsp_resp_get_responder2

## NAME



           gnutls_ocsp_resp_get_responder2 - API function
    


## SYNOPSIS



           **#include <gnutls/ocsp.h>**
    
           **int gnutls_ocsp_resp_get_responder2(gnutls_ocsp_resp_const_t** _resp_**,**
           **gnutls_datum_t ***_dn_**, unsigned** _flags_**);**
    


## ARGUMENTS



           gnutls_ocsp_resp_const_t resp
                       should contain a **gnutls_ocsp_resp_t** type
    
           gnutls_datum_t * dn
                       newly allocated buffer with name
    
           unsigned flags
                       zero or **GNUTLS_X509_DN_FLAG_COMPAT**
    


## DESCRIPTION



           This function will extract the name of the Basic OCSP Response in
           the provided buffer. The name will be in the form
           "C=xxxx,O=yyyy,CN=zzzz" as described in RFC2253. The output string
           will be ASCII or UTF-8 encoded, depending on the certificate data.
    
           If the responder ID is not a name but a hash, this function will
           return zero and the  _dn_ elements will be set to **NULL**.
    
           The caller needs to deallocate memory by calling **gnutls_free()** on
            _dn_ ->data.
    
           When the flag **GNUTLS_X509_DN_FLAG_COMPAT** is specified, the output
           format will match the format output by previous to 3.5.6 versions
           of GnuTLS which was not not fully RFC4514-compliant.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error code is returned. When no data exist it will return
           **GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE**.
    


* * *
# gnutls_x509_crq_verify

## NAME



           gnutls_x509_crq_verify - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crq_verify(gnutls_x509_crq_t** _crq_**, unsigned int**
           _flags_**);**
    


## ARGUMENTS



           gnutls_x509_crq_t crq
                       is the crq to be verified
    
           unsigned int flags
                       Flags that may be used to change the verification
                       algorithm. Use OR of the
                       gnutls_certificate_verify_flags enumerations.
    


## DESCRIPTION



           This function will verify self signature in the certificate
           request and return its status.
    


## RETURNS



           In case of a verification failure **GNUTLS_E_PK_SIG_VERIFY_FAILED** is
           returned, and zero or positive code on success.
    
           Since 2.12.0
    


* * *
# umad_status

## NAME



           umad_status - get the status of a umad buffer
    


## SYNOPSIS



           **#include <infiniband/umad.h>**
    
           **int umad_status(void** _*umad_**);**
    


## DESCRIPTION



           **umad_status()** get the internal _umad_ status field.
    


## RETURN VALUE



           After a packet is received, **umad_status()** returns 0 on a
           successful receive, or a non zero status.  ETIMEDOUT means that
           the packet had a send-timeout indication. In this case, the
           transaction ID will be set to the TID of the original request.
    


* * *
# capng_clear

## NAME



           capng_clear - clear chosen capabilities set
    


## SYNOPSIS



           **#include <cap-ng.h>**
    
           void capng_clear(capng_select_t set);
    


## DESCRIPTION



           capng_clear sets to 0 all bits in the selected POSIX capabilities
           set. The options are CAPNG_SELECT_CAPS for the traditional
           capabilities, CAPNG_SELECT_BOUNDS for the bounding set,
           CAPNG_SELECT_BOTH if clearing both is desired,
           CAPNG_SELECT_AMBIENT if only operating on the ambient
           capabilities, or CAPNG_SELECT_ALL if clearing all is desired.
    


## RETURN VALUE



           None.
    


* * *
# gnutls_dtls_get_timeout

## NAME



           gnutls_dtls_get_timeout - API function
    


## SYNOPSIS



           **#include <gnutls/dtls.h>**
    
           **unsigned int gnutls_dtls_get_timeout(gnutls_session_t** _session_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           This function will return the milliseconds remaining for a
           retransmission of the previously sent handshake message. This
           function is useful when DTLS is used in non-blocking mode, to
           estimate when to call **gnutls_handshake()** if no packets have been
           received.
    


## RETURNS



           the remaining time in milliseconds.
    


## SINCE



           3.0
    


* * *
# seteuid

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



           seteuid — set effective user ID
    


## SYNOPSIS



           #include <unistd.h>
    
           int seteuid(uid_t _uid_);
    


## DESCRIPTION



           If _uid_ is equal to the real user ID or the saved set-user-ID, or
           if the process has appropriate privileges, _seteuid_() shall set the
           effective user ID of the calling process to _uid_ ; the real user ID
           and saved set-user-ID shall remain unchanged.
    
           The _seteuid_() function shall not affect the supplementary group
           list in any way.
    


## RETURN VALUE



           Upon successful completion, 0 shall be returned; otherwise, -1
           shall be returned and _errno_ set to indicate the error.
    


## ERRORS



           The _seteuid_() function shall fail if:
    
           **EINVAL** The value of the _uid_ argument is invalid and is not
                  supported by the implementation.
    
           **EPERM** The process does not have appropriate privileges and _uid_
                  does not match the real user ID or the saved set-user-ID.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           Refer to the RATIONALE section in setuid(3p).
    


## FUTURE DIRECTIONS



           None.
    


* * *
# function::pid2task

## NAME



           function::pid2task - The task_struct of the given process
           identifier
    


## SYNOPSIS



               pid2task:long(pid:long)
    


## ARGUMENTS



           _pid_
               process identifier
    


## DESCRIPTION



           Return the task struct of the given process id.
    


* * *
# function::json_add_numeric_metric

## NAME



           function::json_add_numeric_metric - Add a numeric metric
    


## SYNOPSIS



               json_add_numeric_metric:long(name:string,description:string,units:string)
    


## ARGUMENTS



           _name_
               The name of the numeric metric.
    
           _description_
               Metric description. An empty string can be used.
    
           _units_
               Metic units. An empty string can be used.
    


## DESCRIPTION



           This function adds a numeric metric, setting up everything needed.
    


* * *
# gnutls_compression_list

## NAME



           gnutls_compression_list - API function
    


## SYNOPSIS



           **#include <gnutls/compat.h>**
    
           **const gnutls_compression_method_t * gnutls_compression_list(**
           _void_**);**
    


## ARGUMENTS



            void
    


## DESCRIPTION



           Get a list of compression methods.
    


## RETURNS



           a zero-terminated list of **gnutls_compression_method_t** integers
           indicating the available compression methods.
    


* * *
# function::sprint_loadavg

## NAME



           function::sprint_loadavg - Report a pretty-printed load average
    


## SYNOPSIS



               sprint_loadavg:string()
    


## ARGUMENTS



           None
    


## DESCRIPTION



           Returns the a string with three decimal numbers in the usual
           format for 1-, 5- and 15-minute load averages.
    


* * *
# io_uring_sq_ready

## NAME



           io_uring_sq_ready - number of unconsumed or unsubmitted entries in
           the SQ ring
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **unsigned io_uring_sq_ready(const struct io_uring ***_ring_**);**
    


## DESCRIPTION



           The io_uring_sq_ready(3) function returns the number of unconsumed
           (if SQPOLL) or unsubmitted entries that exist in the SQ ring
           belonging to the _ring_ param.
    
           Usage of this function only applies if the ring has been setup
           with **IORING_SETUP_SQPOLL,** where request submissions, and hence
           consumption from the SQ ring, happens through a polling thread.
    


## RETURN VALUE



           Returns the number of unconsumed or unsubmitted entries in the  SQ
           ring.
    


* * *
# gnutls_record_check_pending

## NAME



           gnutls_record_check_pending - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **size_t gnutls_record_check_pending(gnutls_session_t** _session_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           This function checks if there are unread data in the gnutls
           buffers. If the return value is non-zero the next call to
           **gnutls_record_recv()** is guaranteed not to block.
    


## RETURNS



           Returns the size of the data or zero.
    


* * *
# io_uring_cqe_get_data

## NAME



           io_uring_cqe_get_data - get user data for completion event
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **void *io_uring_cqe_get_data(struct io_uring_cqe ***_cqe_**);**
    
           **__u64 io_uring_cqe_get_data64(struct io_uring_cqe ***_cqe_**);**
    


## DESCRIPTION



           The io_uring_cqe_get_data(3) function returns the user_data with
           the completion queue entry _cqe_ as a data pointer.
    
           The io_uring_cqe_get_data64(3) function returns the user_data with
           the completion queue entry _cqe_ as a 64-bit data value.
    
           After the caller has received a completion queue entry (CQE) with
           io_uring_wait_cqe(3), the application can call
           io_uring_cqe_get_data(3) or io_uring_cqe_get_data64(3) function to
           retrieve the _user_data_ value. This requires that _user_data_ has
           been set earlier with the function io_uring_sqe_set_data(3) or
           io_uring_sqe_set_data64(3).
    


## RETURN VALUE



           If the _user_data_ value has been set before submitting the request,
           it will be returned.  Otherwise, the return value is undefined.
    


* * *
# gnutls_priority_set_direct

## NAME



           gnutls_priority_set_direct - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_priority_set_direct(gnutls_session_t** _session_**, const**
           **char ***_priorities_**, const char ****_err_pos_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    
           const char * priorities
                       is a string describing priorities
    
           const char ** err_pos
                       In case of an error this will have the position in the
                       string the error occurred
    


## DESCRIPTION



           Sets the priorities to use on the ciphers, key exchange methods,
           and macs.  This function avoids keeping a priority cache and is
           used to directly set string priorities to a TLS session.  For
           documentation check the **gnutls_priority_init()**.
    
           To use a reasonable default, consider using
           **gnutls_set_default_priority()** , or
           **gnutls_set_default_priority_append()** instead of this function.
    


## RETURNS



           On syntax error **GNUTLS_E_INVALID_REQUEST** is returned,
           **GNUTLS_E_SUCCESS** on success, or an error code.
    


* * *
# posix_spawnattr_init

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



           posix_spawnattr_init — initialize the spawn attributes object
           (**ADVANCED REALTIME**)
    


## SYNOPSIS



           #include <spawn.h>
    
           int posix_spawnattr_init(posix_spawnattr_t *_attr_);
    


## DESCRIPTION



           Refer to posix_spawnattr_destroy(3p).
    


* * *
# auparse_get_node

## NAME



           auparse_get_node - get the event's machine node name
    


## SYNOPSIS



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


## DESCRIPTION



           auparse_get_node gets the machine's node name if it exists in the
           audit event from the current event's timestamp data structure. Not
           all records have node names since its an admin configurable
           option.
    


## RETURN VALUE



           Returns a copy of the node name or NULL if it does not exist or
           there was an error. The caller must free the string.
    


* * *
# gnutls_x509_crt_get_name_constraints

## NAME



           gnutls_x509_crt_get_name_constraints - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crt_get_name_constraints(gnutls_x509_crt_t** _crt_**,**
           **gnutls_x509_name_constraints_t** _nc_**, unsigned int** _flags_**, unsigned**
           **int ***_critical_**);**
    


## ARGUMENTS



           gnutls_x509_crt_t crt
                       should contain a **gnutls_x509_crt_t** type
    
           gnutls_x509_name_constraints_t nc
                       The nameconstraints intermediate type
    
           unsigned int flags
                       zero or **GNUTLS_EXT_FLAG_APPEND**
    
           unsigned int * critical
                       the extension status
    


## DESCRIPTION



           This function will return an intermediate type containing the name
           constraints of the provided CA certificate. That structure can be
           used in combination with **gnutls_x509_name_constraints_check()** to
           verify whether a server's name is in accordance with the
           constraints.
    
           When the  _flags_ is set to **GNUTLS_EXT_FLAG_APPEND** , then if the  _nc_
           structure is empty this function will behave identically as if the
           flag was not set.  Otherwise if there are elements in the  _nc_
           structure then the constraints will be merged with the existing
           constraints following RFC5280 p6.1.4 (excluded constraints will be
           appended, permitted will be intersected).
    
           Note that  _nc_ must be initialized prior to calling this function.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned,
           **GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE** if the extension is not
           present, otherwise a negative error value.
    


## SINCE



           3.3.0
    


* * *
# io_uring_buf_ring_add

## NAME



           io_uring_buf_ring_add - add buffers to a shared buffer ring
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **void io_uring_buf_ring_add(struct io_uring_buf_ring ***_br_**,**
                                      **void ***_addr_**,**
                                      **unsigned int** _len_**,**
                                      **unsigned short** _bid_**,**
                                      **int** _mask_**,**
                                      **int** _buf_offset_**);**
    


## DESCRIPTION



           The io_uring_buf_ring_add(3) adds a new buffer to the shared
           buffer ring _br_.  The buffer address is indicated by _addr_ and is of
           _len_ bytes of length.  _bid_ is the buffer ID, which will be returned
           in the CQE.  _mask_ is the size mask of the ring, available from
           io_uring_buf_ring_mask(3).  _buf_offset_ is the offset to insert at
           from the current tail. If just one buffer is provided before the
           ring tail is committed with io_uring_buf_ring_advance(3) or
           io_uring_buf_ring_cq_advance(3), then _buf_offset_ should be 0. If
           buffers are provided in a loop before being committed, the
           _buf_offset_ must be incremented by one for each buffer added.
    


## RETURN VALUE



           None
    


## NOTES



           liburing (or the kernel, for that matter) doesn't care about what
           buffer ID maps to what buffer, and in fact when recycling buffers
           after use, the application is free to add a different buffer into
           the same buffer ID location. All that matters is that the
           application knows what a given buffer ID in time corresponds to in
           terms of virtual memory. There's no liburing or kernel assumption
           that these mappings are persistent over time, they can very well
           be different every time a given buffer ID is added to the provided
           buffer ring.
    


* * *
# function::task_cwd_path

## NAME



           function::task_cwd_path - get the path struct pointer for a task's
           current working directory
    


## SYNOPSIS



               task_cwd_path:long(task:long)
    


## ARGUMENTS



           _task_
               task_struct pointer.
    


* * *
# gnutls_ocsp_resp_print

## NAME



           gnutls_ocsp_resp_print - API function
    


## SYNOPSIS



           **#include <gnutls/ocsp.h>**
    
           **int gnutls_ocsp_resp_print(gnutls_ocsp_resp_const_t** _resp_**,**
           **gnutls_ocsp_print_formats_t** _format_**, gnutls_datum_t ***_out_**);**
    


## ARGUMENTS



           gnutls_ocsp_resp_const_t resp
                       The data to be printed
    
           gnutls_ocsp_print_formats_t format
                       Indicate the format to use
    
           gnutls_datum_t * out
                       Newly allocated datum with (0) terminated string.
    


## DESCRIPTION



           This function will pretty print a OCSP response, suitable for
           display to a human.
    
           If the format is **GNUTLS_OCSP_PRINT_FULL** then all fields of the
           response will be output, on multiple lines.
    
           The output  _out_ ->data needs to be deallocate using **gnutls_free()**.
    


## RETURNS



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


* * *
# function::qsq_wait_queue_length

## NAME



           function::qsq_wait_queue_length - length of wait queue
    


## SYNOPSIS



               qsq_wait_queue_length:long(qname:string,scale:long)
    


## ARGUMENTS



           _qname_
               queue name
    
           _scale_
               scale variable to take account for interval fraction
    


## DESCRIPTION



           This function returns the average length of the wait queue
    


* * *
# probe::workqueue.destroy

## NAME



           probe::workqueue.destroy - Destroying workqueue
    


## SYNOPSIS



           workqueue.destroy
    


## VALUES



           _wq_thread_
               task_struct of the workqueue thread
    


* * *
# pcre2_substring_free

## NAME



           PCRE2 - Perl-compatible regular expressions (revised API)
    


## SYNOPSIS



    
           **#include <pcre2.h>**
    
           **void pcre2_substring_free(PCRE2_UCHAR ***_buffer_**);**
    


## DESCRIPTION



    
           This is a convenience function for freeing the memory obtained by
           a previous call to **pcre2_substring_get_byname()** or
           **pcre2_substring_get_bynumber()**. Its only argument is a pointer to
           the string. If the argument is NULL, the function does nothing.
    
           There is a complete description of the PCRE2 native API in the
           **pcre2api** page and a description of the POSIX API in the **pcre2posix**
           page.
    


* * *
# function::dump_stack

## NAME



           function::dump_stack - Send the kernel backtrace to the kernel
           trace buffer
    


## SYNOPSIS



               dump_stack()
    


## ARGUMENTS



           None
    


## DESCRIPTION



           Print the current kernel backtrace to the kernel trace buffer. not
           be safely called from all kernel probe contexts, so is restricted
           to guru mode only. Under the hood, it calls the kernel C API
           function dump_stack directly.
    


* * *
# io_uring_recvmsg_validate

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

## NAME



           gnutls_group_get_id - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **gnutls_group_t gnutls_group_get_id(const char ***_name_**);**
    


## ARGUMENTS



           const char * name
                       is a group name
    


## DESCRIPTION



           The names are compared in a case insensitive way.
    


## RETURNS



           return a **gnutls_group_t** value corresponding to the specified
           group, or **GNUTLS_GROUP_INVALID** on error.
    


## SINCE



           3.6.0
    


* * *
# probe::nfs.fop.read_iter

## NAME



           probe::nfs.fop.read_iter - NFS client read_iter file operation
    


## SYNOPSIS



           nfs.fop.read_iter
    


## VALUES



           _pos_
               current position of file
    
           _cache_time_
               when we started read-caching this inode
    
           _ino_
               inode number
    
           _parent_name_
               parent dir name
    
           _count_
               read bytes
    
           _dev_
               device identifier
    
           _file_name_
               file name
    
           _attrtimeo_
               how long the cached information is assumed to be valid. We
               need to revalidate the cached attrs for this inode if jiffies
               - read_cache_jiffies > attrtimeo.
    
           _cache_valid_
               cache related bit mask flag
    


* * *
# pthread_rwlockattr_init

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



           pthread_rwlockattr_init — initialize the read-write lock
           attributes object
    


## SYNOPSIS



           #include <pthread.h>
    
           int pthread_rwlockattr_init(pthread_rwlockattr_t *_attr_);
    


## DESCRIPTION



           Refer to pthread_rwlockattr_destroy(3p).
    


* * *
# function::target_set_pid

## NAME



           function::target_set_pid - Does pid descend from target process?
    


## SYNOPSIS



               target_set_pid(pid:)
    


## ARGUMENTS



           _pid_
               The pid of the process to query
    


## DESCRIPTION



           This function returns whether the given process-id is within the
           “target set”, that is whether it is a descendant of the top-level
           **target** process.
    


* * *
# function::task_execname

## NAME



           function::task_execname - The name of the task
    


## SYNOPSIS



               task_execname:string(task:long)
    


## ARGUMENTS



           _task_
               task_struct pointer
    


## DESCRIPTION



           Return the name of the given task.
    


* * *
# mq_timedsend

## 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_timedsend — send a message to a message queue (**ADVANCED**
           **REALTIME**)
    


## SYNOPSIS



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


## DESCRIPTION



           Refer to mq_send(3p).
    


* * *
# gnutls_session_set_verify_cert2

## NAME



           gnutls_session_set_verify_cert2 - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **void gnutls_session_set_verify_cert2(gnutls_session_t** _session_**,**
           **gnutls_typed_vdata_st ***_data_**, unsigned** _elements_**, unsigned** _flags_**);**
    


## ARGUMENTS



           gnutls_session_t session
                       is a gnutls session
    
           gnutls_typed_vdata_st * data
                       an array of typed data
    
           unsigned elements
                       the number of data elements
    
           unsigned flags
                       flags for certificate verification --
                       **gnutls_certificate_verify_flags**
    


## DESCRIPTION



           This function instructs GnuTLS to verify the peer's certificate
           using the provided typed data information. If the verification
           fails the handshake will also fail with
           **GNUTLS_E_CERTIFICATE_VERIFICATION_ERROR**. In that case the
           verification result can be obtained using
           **gnutls_session_get_verify_cert_status()**.
    
           The acceptable typed data are the same as in
           **gnutls_certificate_verify_peers()** , and once set must remain valid
           for the lifetime of the session. More precisely they should be
           available during any subsequent handshakes.
    
           If  _flags_ is provided which contain a profile, this function
           should be called after any session priority setting functions.
    


## SINCE



           3.4.6
    


* * *
# pcap_open_dead

## NAME



           pcap_open_dead, pcap_open_dead_with_tstamp_precision - open a fake
           pcap_t for compiling filters or opening a capture for output
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **pcap_t *pcap_open_dead(int linktype, int snaplen);**
           **pcap_t *pcap_open_dead_with_tstamp_precision(int linktype, int snaplen,**
               **u_int precision);**
    


## DESCRIPTION



           **pcap_open_dead**() and **pcap_open_dead_with_tstamp_precision**() are
           used for creating a **pcap_t** structure to use when calling the other
           functions in libpcap.  It is typically used when just using
           libpcap for compiling BPF code; it can also be used if using
           **pcap_dump_open**(3PCAP), **pcap_dump**(3PCAP), and
           **pcap_dump_close**(3PCAP) to write a savefile if there is no **pcap_t**
           that supplies the packets to be written.
    
           _linktype_ specifies the link-layer type for the **pcap_t**.
    
           _snaplen_ specifies the snapshot length for the **pcap_t**.
    
           When **pcap_open_dead_with_tstamp_precision**(), is used to create a
           **pcap_t** for use with **pcap_dump_open**(), _precision_ specifies the time
           stamp precision for packets; **PCAP_TSTAMP_PRECISION_MICRO** should be
           specified if the packets to be written have time stamps in seconds
           and microseconds, and **PCAP_TSTAMP_PRECISION_NANO** should be
           specified if the packets to be written have time stamps in seconds
           and nanoseconds.  Its value does not affect **pcap_compile**(3PCAP).
    


## BACKWARD COMPATIBILITY



           The **pcap_open_dead_with_tstamp_precision**() function became
           available in libpcap release 1.5.1.  In previous releases, there
           was no mechanism to open a savefile for writing with time stamps
           given in seconds and nanoseconds.
    


* * *