tripathysagar/man_text huggingface dataset:
# umad_set_grh

## NAME



           umad_set_grh - set GRH fields within umad buffer using host
           ordering
    


## SYNOPSIS



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


## DESCRIPTION



           **umad_set_grh()** sets the GRH fields (grh_present, gid, hop_limit,
           traffic_class, flow_label) within the specified _umad_ buffer based
           on the _mad_addr_ supplied. The provided _mad_addr_ fields are
           expected to be in host order.  If the _mad_addr_ pointer supplied is
           NULL, no GRH is set.  The argument _mad_addr_ is a pointer to an
           _ib_mad_addr_t_ struct, as specified in _< infiniband/umad.h>._  The
           argument _umad_ is a pointer to an _ib_user_mad_t_ struct, as
           specified in _< infiniband/umad.h>._
    
           typedef struct ib_mad_addr {
                   uint32_t qpn;
                   uint32_t qkey;
                   uint16_t lid;
                   uint8_t  sl;
                   uint8_t  path_bits;
                   uint8_t  grh_present;
                   uint8_t  gid_index;
                   uint8_t  hop_limit;
                   uint8_t  traffic_class;
                   uint8_t  gid[16];
                   uint32_t flow_label;
           } ib_mad_addr_t;
    
           typedef struct ib_user_mad {
                   uint32_t agent_id;
                   uint32_t status;
                   uint32_t timeout_ms;
                   uint32_t retries;
                   uint32_t length;
                   ib_mad_addr_t addr;
                   uint8_t  data[0];
           } ib_user_mad_t;
    


## RETURN VALUE



           **umad_set_grh()** returns 0 on success, and a negative value on
           errors. Currently, there are no errors indicated.
    


* * *
# getentropy

## NAME



           getentropy - fill a buffer with random bytes
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <unistd.h>**
    
           **int getentropy(** size_t length;
                          **void** _buffer_**[**_length_**], size_t** _length_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **getentropy**():
               _DEFAULT_SOURCE
    


## DESCRIPTION



           The **getentropy**() function writes _length_ bytes of high-quality
           random data to the buffer starting at the location pointed to by
           _buffer_.  The maximum permitted value for the _length_ argument is
           256.
    
           A successful call to **getentropy**() always provides the requested
           number of bytes of entropy.
    


## RETURN VALUE



           On success, this function returns zero.  On error, -1 is returned,
           and _errno_ is set to indicate the error.
    


## ERRORS



           **EFAULT** Part or all of the buffer specified by _buffer_ and _length_ is
                  not in valid addressable memory.
    
           **EIO** _length_ is greater than 256.
    
           **EIO** An unspecified error occurred while trying to overwrite
                  _buffer_ with random data.
    
           **ENOSYS** This kernel version does not implement the getrandom(2)
                  system call required to implement this function.
    


## STANDARDS



           None.
    


## NOTES



           The **getentropy**() function is implemented using getrandom(2).
    
           Whereas the glibc wrapper makes getrandom(2) a cancelation point,
           **getentropy**() is not a cancelation point.
    
           **getentropy**() is also declared in **< sys/random.h>**.  (No feature test
           macro need be defined to obtain the declaration from that header
           file.)
    
           A call to **getentropy**() may block if the system has just booted and
           the kernel has not yet collected enough randomness to initialize
           the entropy pool.  In this case, **getentropy**() will keep blocking
           even if a signal is handled, and will return only once the entropy
           pool has been initialized.
    


* * *
# get_auditfail_action

## NAME



           get_auditfail_action - Get failure_action tunable value
    


## SYNOPSIS



           **#include <libaudit.h>**
    
           **int get_auditfail_action(auditfail_t ***_failmode_**);**
    


## DESCRIPTION



           This function gets the failure_action tunable value stored in
           **/etc/libaudit.conf**. **get_auditfail_action** should be called after an
           **audit_open** call returns an error to see what action the admin
           prefers.
    
           The failure_action value found in **/etc/libaudit.conf** is copied
           into the _failmode_ argument upon function return.  This value
           should then be used by the calling application to determine what
           action should be taken when the audit subsystem is unavailable.
    


## RETURN VALUE



           Upon success, **get_auditfail_action** returns a zero, and the
           _failmode_ argument will hold the failure_action value.  The
           possible values for failure_action are: FAIL_IGNORE (0), FAIL_LOG
           (1), and FAIL_TERMINATE (2). Upon failure, **get_auditfail_action**
           returns a return code of one.
    


## ERRORS



           An error is returned if there is an error reading
           **/etc/libaudit.conf** or if the failure_action tunable is not found
           in the file.
    


## EXAMPLES



                  /* Sample code */
                  auditfail_t failmode;
    
                  if ((fd = audit_open() ) < 0 ) {
                       fprintf (stderr, "Cannot open netlink audit socket");
    
                       /* Get the failure_action */
                       if ((rc = get_auditfail_action(&failmode)) == 0) {
                           if (failmode == FAIL_LOG)
                                fprintf (stderr, "Audit subsystem
           unavailable");
                           else if (failmode == FAIL_TERMINATE)
                                exit (1);
                           /* If failmode == FAIL_IGNORE, do nothing */
                       }
                  }
    


* * *
# sethostent

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



           sethostent — network host database functions
    


## SYNOPSIS



           #include <netdb.h>
    
           void sethostent(int _stayopen_);
    


## DESCRIPTION



           Refer to endhostent(3p).
    


* * *
# gnutls_pubkey_print

## NAME



           gnutls_pubkey_print - API function
    


## SYNOPSIS



           **#include <gnutls/abstract.h>**
    
           **int gnutls_pubkey_print(gnutls_pubkey_t** _pubkey_**,**
           **gnutls_certificate_print_formats_t** _format_**, gnutls_datum_t ***_out_**);**
    


## ARGUMENTS



           gnutls_pubkey_t pubkey
                       The data to be printed
    
           gnutls_certificate_print_formats_t format
                       Indicate the format to use
    
           gnutls_datum_t * out
                       Newly allocated datum with null terminated string.
    


## DESCRIPTION



           This function will pretty print public key information, suitable
           for display to a human.
    
           Only **GNUTLS_CRT_PRINT_FULL** and **GNUTLS_CRT_PRINT_FULL_NUMBERS** are
           implemented.
    
           The output  _out_ needs to be deallocated using **gnutls_free()**.
    


## RETURNS



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


## SINCE



           3.1.5
    


* * *
# libpfm_intel_x86_arch

## NAME



           libpfm_intel_x86_arch - support for Intel X86 architectural PMU
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: ix86arch**
           **PMU desc: Intel X86 architectural PMU**
    


## DESCRIPTION



           The library supports any processor implementing the Intel
           architectural PMU. This is a minimal PMU with a variable number of
           counters but predefined set of events. It is implemented in all
           recent processors  starting with Intel Core Duo/Core Solo.
    
           It acts as a default PMU support in case the library is run on a
           very recent processor for which the specific support has not yet
           been implemented.
    


## MODIFIERS



           The following modifiers are supported on Intel architectural PMU:
    
           **u** Measure at user level which includes privilege levels 1, 2,
                  3. This corresponds to **PFM_PLM3**.  This is a boolean
                  modifier.
    
           **k** Measure at kernel level which includes privilege level 0.
                  This corresponds to **PFM_PLM0**.  This is a boolean modifier.
    
           **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].
    
           **t** Measure on both threads at the same time assuming hyper-
                  threading is enabled. This modifier requires at least
                  version 3 of the architectural PMU. This is a boolean
                  modifier.
    


* * *
# io_uring_prep_sendmsg

## NAME



           io_uring_prep_sendmsg - prepare a sendmsg request
    


## SYNOPSIS



           **#include <sys/types.h>**
           **#include <sys/socket.h>**
           **#include <liburing.h>**
    
           **void io_uring_prep_sendmsg(struct io_uring_sqe ***_sqe_**,**
                                      **int** _fd_**,**
                                      **const struct msghdr ***_msg_**,**
                                      **unsigned** _flags_**);**
    
           **void io_uring_prep_sendmsg_zc(struct io_uring_sqe ***_sqe_**,**
                                         **int** _fd_**,**
                                         **const struct msghdr ***_msg_**,**
                                         **unsigned** _flags_**);**
    


## DESCRIPTION



           The io_uring_prep_sendmsg(3) function prepares a sendmsg request.
           The submission queue entry _sqe_ is setup to use the file descriptor
           _fd_ to start sending the data indicated by _msg_ with the sendmsg(2)
           defined flags in the _flags_ argument.
    
           The io_uring_prep_sendmsg_zc(3) accepts the same parameters as
           io_uring_prep_sendmsg(3) but prepares a zerocopy sendmsg request.
    
           See io_uring_prep_send(3) for a description of flags that can be
           set in the SQE _ioprio_ field. In addition to those, the zero-copy
           send also supports setting **IORING_SEND_ZC_REPORT_USAGE .** If set,
           the notification CQE _res_ field will report the number of bytes
           that were copied rather than sent with zero copy. A value of **0**
           indicates success. If the value is **IORING_NOTIF_USAGE_ZC_COPIED ,**
           then data was copied.
    
           Note that using **IOSQE_IO_LINK** with this request type requires the
           setting of **MSG_WAITALL** in the _flags_ argument, as a short send
           isn't considered an error condition without that being set.
    
           This function prepares an async sendmsg(2) request. See that man
           page for details.
    


## RETURN VALUE



           None
    


## ERRORS



           The CQE _res_ field will contain the result of the operation. See
           the related man page for details on possible values. Note that
           where synchronous system calls will return **-1** on failure and set
           _errno_ to the actual error value, io_uring never uses _errno_.
           Instead it returns the negated _errno_ directly in the CQE _res_
           field.
    


## NOTES



           As with any request that passes in data in a struct, that data
           must remain valid until the request has been successfully
           submitted. It need not remain valid until completion. Once a
           request has been submitted, the in-kernel state is stable. Very
           early kernels (5.4 and earlier) required state to be stable until
           the completion occurred. Applications can test for this behavior
           by inspecting the **IORING_FEAT_SUBMIT_STABLE** flag passed back from
           io_uring_queue_init_params(3).
    


* * *
# mlx5dv_ts_to_ns

## NAME



           mlx5dv_ts_to_ns - Convert device timestamp from HCA core clock
           units to the corresponding nanosecond counts
    


## SYNOPSIS



           **#include <infiniband/mlx5dv.h>**
    
           **uint64_t mlx5dv_ts_to_ns(struct mlx5dv_clock_info *clock_info,**
                                **uint64_t device_timestamp);**
    


## DESCRIPTION



           mlx5dv_ts_to_ns(3) Converts a host byte order _device_timestamp_
           from HCA core clock units into the corresponding nanosecond
           wallclock time.
    
           **struct mlx5dv_clock_info** can be retrieved using
           mlx5dv_get_clock_info(3).
    
           The greater the difference between the device reporting a
           timestamp and the last mlx5dv_clock_info update, the greater the
           inaccuracy of the clock time conversion.
    


## RETURN VALUE



           Timestamp in nanoseconds
    


* * *
# gnutls_record_overhead_size

## NAME



           gnutls_record_overhead_size - API function
    


## SYNOPSIS



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


## ARGUMENTS



           gnutls_session_t session
                       is **gnutls_session_t**
    


## DESCRIPTION



           This function will return the size in bytes of the overhead due to
           TLS (or DTLS) per record. On certain occasions (e.g., CBC ciphers)
           the returned value is the maximum possible overhead.
    


## SINCE



           3.2.2
    


* * *
# gnutls_privkey_import_x509_raw

## NAME



           gnutls_privkey_import_x509_raw - API function
    


## SYNOPSIS



           **#include <gnutls/abstract.h>**
    
           **int gnutls_privkey_import_x509_raw(gnutls_privkey_t** _pkey_**, const**
           **gnutls_datum_t ***_data_**, gnutls_x509_crt_fmt_t** _format_**, const char ***
           _password_**, unsigned int** _flags_**);**
    


## ARGUMENTS



           gnutls_privkey_t pkey
                       The private key
    
           const gnutls_datum_t * data
                       The private key data to be imported
    
           gnutls_x509_crt_fmt_t format
                       The format of the private key
    
           const char * password
                       A password (optional)
    
           unsigned int flags
                       an ORed sequence of gnutls_pkcs_encrypt_flags_t
    


## DESCRIPTION



           This function will import the given private key to the abstract
           **gnutls_privkey_t** type.
    
           The supported formats are basic unencrypted key, PKCS8, PKCS12,
           TSS2, and the openssl format.
    


## RETURNS



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


## SINCE



           3.1.0
    


* * *
# acos

## NAME



           acos, acosf, acosl - arc cosine function
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



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


## DESCRIPTION



           These functions calculate the arc cosine of _x_ ; that is the value
           whose cosine is _x_.
    


## RETURN VALUE



           On success, these functions return the arc cosine of _x_ in radians;
           the return value is in the range [0, pi].
    
           If _x_ is a NaN, a NaN is returned.
    
           If _x_ is +1, +0 is returned.
    
           If _x_ is positive infinity or negative infinity, a domain error
           occurs, and a NaN is returned.
    
           If _x_ is outside the range [-1, 1], a domain error occurs, and a
           NaN is returned.
    


## ERRORS



           See math_error(7) for information on how to determine whether an
           error has occurred when calling these functions.
    
           The following errors can occur:
    
           Domain error: _x_ is outside the range [-1, 1]
                  _errno_ is set to **EDOM**.  An invalid floating-point exception
                  (**FE_INVALID**) is raised.
    


## ATTRIBUTES



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


## STANDARDS



           C11, POSIX.1-2008.
    


* * *
# function::sock_fam_num2str

## NAME



           function::sock_fam_num2str - Given a protocol family number,
           return a string representation
    


## SYNOPSIS



               sock_fam_num2str:string(family:long)
    


## ARGUMENTS



           _family_
               The family number
    


* * *
# aio_return

## NAME



           aio_return - get return status of asynchronous I/O operation
    


## LIBRARY



           Real-time library (_librt_ , _-lrt_)
    


## SYNOPSIS



           **#include <aio.h>**
    
           **ssize_t aio_return(struct aiocb ***_aiocbp_**);**
    


## DESCRIPTION



           The **aio_return**() function returns the final return status for the
           asynchronous I/O request with control block pointed to by _aiocbp_.
           (See aio(7) for a description of the _aiocb_ structure.)
    
           This function should be called only once for any given request,
           after aio_error(3) returns something other than **EINPROGRESS**.
    


## RETURN VALUE



           If the asynchronous I/O operation has completed, this function
           returns the value that would have been returned in case of a
           synchronous read(2), write(2), fsync(2), or fdatasync(2), call.
           On error, -1 is returned, and _errno_ is set to indicate the error.
    
           If the asynchronous I/O operation has not yet completed, the
           return value and effect of **aio_return**() are undefined.
    


## ERRORS



           **EINVAL** _aiocbp_ does not point at a control block for an
                  asynchronous I/O request of which the return status has not
                  been retrieved yet.
    
           **ENOSYS aio_return**() is not implemented.
    


## ATTRIBUTES



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


## STANDARDS



           POSIX.1-2008.
    


## EXAMPLES



           See aio(7).
    


* * *
# auparse_set_eoe_timeout

## NAME



           auparse_set_eoe_timeout - set the end of event timeout value
    


## SYNOPSIS



           **#include <auparse.h>**
    
           **int auparse_set_eoe_timeout(time_t** _new_tmo);"_
    


## DESCRIPTION



           auparse_set_eoe_timeout is used to set the end of event timeout
           value (seconds). The value should be a positive integer. If this
           function is called, it overrides any setting in /etc/auditd.conf.
           The function should be called after the _auparse_init()_ function
           call.
    
           For details on the timeout, see the **end_of_event_timeout**
           configuration item description in auditd.conf(5).
    


## RETURN VALUE



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


* * *
# gnutls_x509_crq_get_extension_info

## NAME



           gnutls_x509_crq_get_extension_info - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crq_get_extension_info(gnutls_x509_crq_t** _crq_**,**
           **unsigned** _indx_**, void ***_oid_**, size_t ***_sizeof_oid_**, unsigned int ***
           _critical_**);**
    


## ARGUMENTS



           gnutls_x509_crq_t crq
                       should contain a **gnutls_x509_crq_t** type
    
           unsigned indx
                       Specifies which extension number to get. Use (0) to
                       get the first one.
    
           void * oid  a pointer to store the OID
    
           size_t * sizeof_oid
                       initially holds the maximum size of  _oid_ , on return
                       holds actual size of  _oid_ .
    
           unsigned int * critical
                       output variable with critical flag, may be NULL.
    


## DESCRIPTION



           This function will return the requested extension OID in the
           certificate, and the critical flag for it.  The extension OID will
           be stored as a string in the provided buffer.  Use
           **gnutls_x509_crq_get_extension_data()** to extract the data.
    
           If the buffer provided is not long enough to hold the output, then
           * _sizeof_oid_ is updated and **GNUTLS_E_SHORT_MEMORY_BUFFER** will be
           returned.
    


## RETURNS



           On success, **GNUTLS_E_SUCCESS**(0) is returned, otherwise a negative
           error code in case of an error.  If your have reached the last
           extension available **GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE** will be
           returned.
    


## SINCE



           2.8.0
    


* * *
# keyctl_read

## NAME



           keyctl_read - read a key
    


## SYNOPSIS



           **#include <keyutils.h>**
    
           **long keyctl_read(key_serial_t** _key_**, char ***_buffer_**, size_t** _buflen_**);**
    
           **long keyctl_read_alloc(key_serial_t** _key_**, void ****__buffer_**);**
    


## DESCRIPTION



           **keyctl_read**() reads the payload of a key if the key type supports
           it.
    
           The caller must have **read** permission on a key to be able to read
           it.
    
           _buffer_ and _buflen_ specify the buffer into which the payload data
           will be placed.  If the buffer is too small, then the full size of
           the payload will be returned, and the contents of the buffer may
           be overwritten in some undefined way.
    
           **keyctl_read_alloc**() is similar to **keyctl_read**() except that it
           allocates a buffer big enough to hold the payload data and places
           the data in it.  If successful, a pointer to the buffer is placed
           in _*_buffer_.  The caller must free the buffer.
    
           **keyctl_read_alloc**() adds a NUL character after the data it
           retrieves, though this is not counted in the size value it
           returns.
    


## READING KEYRINGS



           This call can be used to list the contents of a keyring.  The data
           is presented to the user as an array of **key_serial_t** values, each
           of which corresponds to a key to which the keyring holds a link.
    
           The size of the keyring will be sizeof(key_serial_t) multiplied by
           the number of keys.  The size of key_serial_t is invariant across
           different word sizes, though the byte-ordering is as appropriate
           for the kernel.
    


## RETURN VALUE



           On success **keyctl_read**() returns the amount of data placed into
           the buffer.  If the buffer was too small, then the size of buffer
           required will be returned, and the contents of the buffer may have
           been overwritten in some undefined way.
    
           On success **keyctl_read_alloc**() returns the amount of data in the
           buffer.
    
           On error, both functions set _errno_ to an appropriate code and
           return the value **-1**.
    


## ERRORS



           **ENOKEY** The key specified is invalid.
    
           **EKEYEXPIRED**
                  The key specified has expired.
    
           **EKEYREVOKED**
                  The key specified had been revoked.
    
           **EACCES** The key exists, but is not **readable** by the calling process.
    
           **EOPNOTSUPP**
                  The key type does not support reading of the payload data.
    


## LINKING



           This is a library function that can be found in _libkeyutils_.  When
           linking, **-lkeyutils** should be specified to the linker.
    


* * *
# umad_alloc

## NAME



           umad_alloc - allocate memory for umad buffers
    


## SYNOPSIS



           **#include <infiniband/umad.h>**
    
           **void * umad_alloc(int** _num_**, size_t** _size_**);**
    


## DESCRIPTION



           **umad_alloc()** allocates memory for an array of _num_ umad buffers of
           _size_ bytes.  Note that _size_ should include the **umad_size()** plus
           the length (MAD_BLOCK_SIZE for normal MADs or the length returned
           from **umad_recv()** for RMPP MADs).
    


## RETURN VALUE



           **umad_alloc()** returns NULL if out of memory.
    


* * *
# selinux_boolean_sub

## NAME



           selinux_boolean_sub - Search the translated name for a
           boolean_name record
    


## SYNOPSIS



           **#include <selinux/selinux.h>**
    
           **char *selinux_boolean_sub(const char ***_boolean_name_**);**
    


## DESCRIPTION



           **selinux_boolean_sub**() searches the
           _/etc/selinux/{POLICYTYPE}/booleans.subs_dist_ file for a matching
           boolean_name record.  If the record exists the boolean
           substitution name is returned.  If not **selinux_boolean_sub**()
           returns the original _boolean_name_.
    


## RETURN VALUE



           **selinux_boolean_sub**() returns the _boolean_name_ or the substituted
           name on success.  The returned value must be freed with free(3).
           **selinux_boolean_sub**() returns NULL on error.
    


* * *
# getpt

## NAME



           getpt - open a new pseudoterminal master
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#define _GNU_SOURCE** /* See feature_test_macros(7) */
           **#include <stdlib.h>**
    
           **int getpt(void);**
    


## DESCRIPTION



           **getpt**() opens a new pseudoterminal device and returns a file
           descriptor that refers to that device.  It is equivalent to
           opening the pseudoterminal multiplexor device
    
               open("/dev/ptmx", O_RDWR);
    
           on Linux systems, though the pseudoterminal multiplexor device is
           located elsewhere on some systems that use the GNU C library.
    


## RETURN VALUE



           **getpt**() returns an open file descriptor upon successful
           completion.  Otherwise, it returns -1 and sets _errno_ to indicate
           the error.
    


## ERRORS



           **getpt**() can fail with various errors described in open(2).
    


## ATTRIBUTES



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


## VERSIONS



           Use posix_openpt(3) instead.
    


## STANDARDS



           GNU.
    


* * *
# probe::nfs.proc.write_done

## NAME



           probe::nfs.proc.write_done - NFS client response to a write RPC
           task
    


## SYNOPSIS



           nfs.proc.write_done
    


## VALUES



           _timestamp_
               V4 timestamp, which is used for lease renewal
    
           _prot_
               transfer protocol
    
           _count_
               number of bytes written
    
           _valid_
               fattr->valid, indicates which fields are valid
    
           _version_
               NFS version
    
           _server_ip_
               IP address of server
    
           _status_
               result of last operation
    


## DESCRIPTION



           Fires when a reply to a write RPC task is received or some write
           error occurs (timeout or socket shutdown).
    


* * *
# function::ns_pgrp

## NAME



           function::ns_pgrp - Returns the process group ID of the current
           process as seen in a pid namespace
    


## SYNOPSIS



               ns_pgrp:long()
    


## ARGUMENTS



           None
    


## DESCRIPTION



           This function returns the process group ID of the current process
           as seen in the target pid namespace if provided, or the stap
           process namespace.
    


* * *
# uselocale

## NAME



           uselocale - set/get the locale for the calling thread
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <locale.h>**
    
           **locale_t uselocale(locale_t** _newloc_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **uselocale**():
               Since glibc 2.10:
                   _XOPEN_SOURCE >= 700
               Before glibc 2.10:
                   _GNU_SOURCE
    


## DESCRIPTION



           The **uselocale**() function sets the current locale for the calling
           thread, and returns the thread's previously current locale.  After
           a successful call to **uselocale**(), any calls by this thread to
           functions that depend on the locale will operate as though the
           locale has been set to _newloc_.
    
           The _newloc_ argument can have one of the following values:
    
           A handle returned by a call to
                  newlocale(3) or duplocale(3) The calling thread's current
                  locale is set to the specified locale.
    
           The special locale object handle
                  **LC_GLOBAL_LOCALE** The calling thread's current locale is set
                  to the global locale determined by setlocale(3).
    
           _(locale_t) 0_
                  The calling thread's current locale is left unchanged (and
                  the current locale is returned as the function result).
    


## RETURN VALUE



           On success, **uselocale**() returns the locale handle that was set by
           the previous call to **uselocale**() in this thread, or
           **LC_GLOBAL_LOCALE** if there was no such previous call.  On error, it
           returns _(locale_t) 0_ , and sets _errno_ to indicate the error.
    


## ERRORS



           **EINVAL** _newloc_ does not refer to a valid locale object.
    


## STANDARDS



           POSIX.1-2008.
    


## NOTES



           Unlike setlocale(3), **uselocale**() does not allow selective
           replacement of individual locale categories.  To employ a locale
           that differs in only a few categories from the current locale, use
           calls to duplocale(3) and newlocale(3) to obtain a locale object
           equivalent to the current locale and modify the desired categories
           in that object.
    


## EXAMPLES



           See newlocale(3) and duplocale(3).
    


* * *
# getutxent

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



           getutxent, getutxid, getutxline — get user accounting database
           entries
    


## SYNOPSIS



           #include <utmpx.h>
    
           struct utmpx *getutxent(void);
           struct utmpx *getutxid(const struct utmpx *_id_);
           struct utmpx *getutxline(const struct utmpx *_line_);
    


## DESCRIPTION



           Refer to endutxent(3p).
    


* * *
# gnutls_ocsp_resp_verify_direct

## NAME



           gnutls_ocsp_resp_verify_direct - API function
    


## SYNOPSIS



           **#include <gnutls/ocsp.h>**
    
           **int gnutls_ocsp_resp_verify_direct(gnutls_ocsp_resp_const_t** _resp_**,**
           **gnutls_x509_crt_t** _issuer_**, unsigned int ***_verify_**, unsigned int**
           _flags_**);**
    


## ARGUMENTS



           gnutls_ocsp_resp_const_t resp
                       should contain a **gnutls_ocsp_resp_t** type
    
           gnutls_x509_crt_t issuer
                       certificate believed to have signed the response
    
           unsigned int * verify
                       output variable with verification status, an
                       **gnutls_ocsp_verify_reason_t**
    
           unsigned int flags
                       verification flags from
                       **gnutls_certificate_verify_flags**
    


## DESCRIPTION



           Verify signature of the Basic OCSP Response against the public key
           in the  _issuer_ certificate.
    
           The output  _verify_ variable will hold verification status codes
           (e.g., **GNUTLS_OCSP_VERIFY_SIGNER_NOT_FOUND** ,
           **GNUTLS_OCSP_VERIFY_INSECURE_ALGORITHM**) which are only valid if the
           function returned **GNUTLS_E_SUCCESS**.
    
           Note that the function returns **GNUTLS_E_SUCCESS** even when
           verification failed.  The caller must always inspect the  _verify_
           variable to find out the verification status.
    
           The  _flags_ variable should be 0 for now.
    


## RETURNS



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


* * *
# gnutls_ecc_curve_list

## NAME



           gnutls_ecc_curve_list - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **const gnutls_ecc_curve_t * gnutls_ecc_curve_list(**_void_**);**
    


## ARGUMENTS



            void
    


## DESCRIPTION



           Get the list of supported elliptic curves.
    
           This function is not thread safe.
    


## RETURNS



           Return a (0)-terminated list of **gnutls_ecc_curve_t** integers
           indicating the available curves.
    


* * *
# mlx5dv_devx_query_eqn

## NAME



           mlx5dv_devx_query_eqn - Query EQN for a given vector id.
    


## SYNOPSIS



                  #include <infiniband/mlx5dv.h>
    
                  int mlx5dv_devx_query_eqn(struct ibv_context *context, uint32_t vector,
                                            uint32_t *eqn);
    


## DESCRIPTION



           Query EQN for a given input vector, the EQN is needed for other
           device commands over the DEVX interface.
    
           The DEVX API enables direct access from the user space area to the
           mlx5 device driver, the EQN information is needed for few commands
           such as CQ creation.
    


## ARGUMENTS



           _context_
                  RDMA device context to work on.
    
           _vector_ Completion vector number.
    
           _eqn_    The device EQ number which relates to the given input
                  vector.
    


## RETURN VALUE



           returns 0 on success, or the value of errno on failure (which
           indicates the failure reason).
    


* * *
# io_uring_for_each_cqe

## NAME



           io_uring_for_each_cqe - iterate pending completion events
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **io_uring_for_each_cqe(struct io_uring ***_ring_**,**
                                 **unsigned** _head_**,**
                                 **struct io_uring_cqe ***_cqe_**) { }**
    


## DESCRIPTION



           The io_uring_for_each_cqe(3) is a macro helper that iterates
           completion events belonging to the _ring_ using _head_ as a temporary
           iterator, and points _cqe_ to each pending event when iterating.
    
           This helper provides an efficient way to iterate all pending
           events in the ring, and then advancing the CQ ring by calling
           io_uring_cq_advance(3) with the number of CQEs consumed when done.
           As updating the kernel visible CQ ring state involves an ordered
           write, doing it once for a number of events is more efficient than
           handling each completion separately and calling
           io_uring_cqe_seen(3) for each of them.
    


## EXAMPLE



           void handle_cqes(struct io_uring *ring)
           {
                struct io_uring_cqe *cqe;
                unsigned head;
                unsigned i = 0;
    
                io_uring_for_each_cqe(ring, head, cqe) {
                     /* handle completion */
                     printf("cqe: %d\n", cqe->res);
                     i++;
                }
    
                io_uring_cq_advance(ring, i);
           }
    


## RETURN VALUE



           None
    


* * *
# gnutls_x509_rdn_get2

## NAME



           gnutls_x509_rdn_get2 - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_rdn_get2(const gnutls_datum_t ***_idn_**,**
           **gnutls_datum_t ***_str_**, unsigned** _flags_**);**
    


## ARGUMENTS



           const gnutls_datum_t * idn
                       should contain a DER encoded RDN sequence
    
           gnutls_datum_t * str
                       a datum that will hold the name
    
           unsigned flags
                       zero of **GNUTLS_X509_DN_FLAG_COMPAT**
    


## DESCRIPTION



           This function will return the name of the given RDN sequence.  The
           name will be in the form "C=xxxx,O=yyyy,CN=zzzz" as described in
           RFC4514.
    
           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, or
           **GNUTLS_E_SHORT_MEMORY_BUFFER** is returned and * _buf_size_ is updated
           if the provided buffer is not long enough, otherwise a negative
           error value.
    


* * *
# gnutls_pkcs12_bag_set_key_id

## NAME



           gnutls_pkcs12_bag_set_key_id - API function
    


## SYNOPSIS



           **#include <gnutls/pkcs12.h>**
    
           **int gnutls_pkcs12_bag_set_key_id(gnutls_pkcs12_bag_t** _bag_**, unsigned**
           _indx_**, const gnutls_datum_t ***_id_**);**
    


## ARGUMENTS



           gnutls_pkcs12_bag_t bag
                       The bag
    
           unsigned indx
                       The bag's element to add the id
    
           const gnutls_datum_t * id
                       the ID
    


## DESCRIPTION



           This function will add the given key ID, to the specified, by the
           index, bag element. The key ID will be encoded as a 'Local key
           identifier' bag attribute, which is usually used to distinguish
           the local private key and the certificate pair.
    


## RETURNS



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


* * *
# audit_setloginuid

## NAME



           audit_setloginuid - Set a program's loginuid value
    


## SYNOPSIS



           **#include <libaudit.h>**
    
           **int audit_setloginuid(uid_t** _uid);"_
    


## DESCRIPTION



           This function sets the task attribute loginuid with the value of
           uid. The loginuid value may only be set by programs with the
           CAP_AUDIT_CONTROL capability. This normally means the root
           account.
    
           The loginuid value is part of the task structure and is inherited
           by child processes. It is used to track what account a user gained
           system access with. All system entry point programs should set
           this value right before changing to the uid of the user granted
           access so that audit events are properly attributed to the that
           user.
    


## RETURN VALUE



           This function returns 0 on success and non-zero otherwise.
    


* * *
# gnutls_x509_trust_list_add_named_crt

## NAME



           gnutls_x509_trust_list_add_named_crt - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_trust_list_add_named_crt(gnutls_x509_trust_list_t**
           _list_**, gnutls_x509_crt_t** _cert_**, const void ***_name_**, size_t** _name_size_**,**
           **unsigned int** _flags_**);**
    


## ARGUMENTS



           gnutls_x509_trust_list_t list
                       The list
    
           gnutls_x509_crt_t cert
                       A certificate
    
           const void * name
                       An identifier for the certificate
    
           size_t name_size
                       The size of the identifier
    
           unsigned int flags
                       should be 0.
    


## DESCRIPTION



           This function will add the given certificate to the trusted list
           and associate it with a name. The certificate will not be be used
           for verification with **gnutls_x509_trust_list_verify_crt()** but with
           **gnutls_x509_trust_list_verify_named_crt()** or
           **gnutls_x509_trust_list_verify_crt2()** - the latter only since
           GnuTLS 3.4.0 and if a hostname is provided.
    
           In principle this function can be used to set individual "server"
           certificates that are trusted by the user for that specific server
           but for no other purposes.
    
           The certificate  _cert_ must not be deinitialized during the
           lifetime of the  _list_ .
    


## RETURNS



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


## SINCE



           3.0.0
    


* * *
# function::sock_state_num2str

## NAME



           function::sock_state_num2str - Given a socket state number, return
           a string representation
    


## SYNOPSIS



               sock_state_num2str:string(state:long)
    


## ARGUMENTS



           _state_
               The state number
    


* * *
# gnutls_pk_get_id

## NAME



           gnutls_pk_get_id - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **gnutls_pk_algorithm_t gnutls_pk_get_id(const char ***_name_**);**
    


## ARGUMENTS



           const char * name
                       is a string containing a public key algorithm name.
    


## DESCRIPTION



           Convert a string to a **gnutls_pk_algorithm_t** value.  The names are
           compared in a case insensitive way.  For example,
           gnutls_pk_get_id("RSA") will return **GNUTLS_PK_RSA**.
    


## RETURNS



           a **gnutls_pk_algorithm_t** id of the specified public key algorithm
           string, or **GNUTLS_PK_UNKNOWN** on failures.
    


## SINCE



           2.6.0
    


* * *
# gnutls_dh_params_export_pkcs3

## NAME



           gnutls_dh_params_export_pkcs3 - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **int gnutls_dh_params_export_pkcs3(gnutls_dh_params_t** _params_**,**
           **gnutls_x509_crt_fmt_t** _format_**, unsigned char ***_params_data_**, size_t**
           *****_params_data_size_**);**
    


## ARGUMENTS



           gnutls_dh_params_t params
                       Holds the DH parameters
    
           gnutls_x509_crt_fmt_t format
                       the format of output params. One of PEM or DER.
    
           unsigned char * params_data
                       will contain a PKCS3 DHParams structure PEM or DER
                       encoded
    
           size_t * params_data_size
                       holds the size of params_data (and will be replaced by
                       the actual size of parameters)
    


## DESCRIPTION



           This function will export the given dh parameters to a PKCS3
           DHParams structure. This is the format generated by "openssl
           dhparam" tool.  If the buffer provided is not long enough to hold
           the output, then GNUTLS_E_SHORT_MEMORY_BUFFER will be returned.
    
           If the structure is PEM encoded, it will have a header of "BEGIN
           DH PARAMETERS".
    


## RETURNS



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


* * *
# auparse_add_callback

## NAME



           auparse_add_callback - add a callback handler for notifications
    


## SYNOPSIS



           **#include <auparse.h>**
    
           **void auparse_add_callback(auparse_state_t ***_au_**, auparse_callback_ptr** _callback_**, void ***_user_data_**, user_destroy** _user_destroy_func_**);**
    


## DESCRIPTION



           auparse_add_callback adds a callback function to the parse state
           which is invoked to notify the application of parsing events. This
           is part of the event feed API.
    
           The signature of the callback is:
    
           void
           auparse_callback(auparse_state_t *au, auparse_cb_event_t cb_event_type,
                            void *user_data);
    
           When the callback is invoked it is passed:
    
           _au_
                   a pointer to the parse_state
    
           _cb_event_type_
                  enumerated value indicating the reason why the callback was
                  invoked
    
           _user_data_
                  pointer to user supplied private data. May be NULL.
    
           _user_destroy_func_
                  pointer to function called when user_data is destroyed. May
                  be NULL.  The signature is:
    
                  void destroy(void *user_data);
    
                  The destroy() function should be prepared to accept
                  user_data possibly being NULL.
    
           The _cb_event_type_ argument indicates why the callback was invoked.
           It's possible values are:
    
           **AUPARSE_CB_EVENT_READY**
                  A complete event has been parsed and is ready to be
                  examined. This is logically equivalent to the parse state
                  immediately following _auparse_next_event()_
    
           See auparse_feed(3) for a complete code example.
    


## RETURN VALUE



           None.
    


* * *