tripathysagar/man_text huggingface dataset:
# keyctl_chown

## NAME



           keyctl_chown - change the ownership of a key
    


## SYNOPSIS



           **#include <keyutils.h>**
    
           **long keyctl_chown(key_serial_t** _key_**, uid_t** _uid_**, gid_t** _gid_**);**
    


## DESCRIPTION



           **keyctl_chown**() changes the user and group ownership details of a
           key.
    
           A setting of **-1** on either _uid_ or _gid_ will cause that setting to be
           ignored.
    
           A process that does not have the **SysAdmin** capability may not
           change a key's UID or set the key's GID to a value that does not
           match the process's GID or one of its group list.
    
           The caller must have **setattr** permission on a key to be able to
           change its ownership.
    


## RETURN VALUE



           On success **keyctl_chown**() returns **0 .** On error, the value **-1** will
           be returned and _errno_ will have been set to an appropriate error.
    


## ERRORS



           **ENOKEY** The specified key does not exist.
    
           **EKEYEXPIRED**
                  The specified key has expired.
    
           **EKEYREVOKED**
                  The specified key has been revoked.
    
           **EDQUOT** Changing the UID to the one specified would run that UID
                  out of quota.
    
           **EACCES** The key exists, but does not grant **setattr** permission to
                  the calling process.
    


## LINKING



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


* * *
# getutmp

## NAME



           getutmp, getutmpx - copy utmp structure to utmpx, and vice versa
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#define _GNU_SOURCE** /* See feature_test_macros(7) */
           **#include <utmpx.h>**
    
           **void getutmp(const struct utmpx ***_ux_**, struct utmp ***_u_**);**
           **void getutmpx(const struct utmp ***_u_**, struct utmpx ***_ux_**);**
    


## DESCRIPTION



           The **getutmp**() function copies the fields of the _utmpx_ structure
           pointed to by _ux_ to the corresponding fields of the _utmp_ structure
           pointed to by _u_.  The **getutmpx**() function performs the converse
           operation.
    


## RETURN VALUE



           These functions do not return a value.
    


## ATTRIBUTES



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


## STANDARDS



           None.
    


## NOTES



           These functions exist primarily for compatibility with other
           systems where the _utmp_ and _utmpx_ structures contain different
           fields, or the size of corresponding fields differs.  On Linux,
           the two structures contain the same fields, and the fields have
           the same sizes.
    


* * *
# io_uring_cq_ready

## NAME



           io_uring_cq_ready - returns number of unconsumed ready entries in
           the CQ ring
    


## SYNOPSIS



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


## DESCRIPTION



           The io_uring_cq_ready(3) function returns the number of unconsumed
           entries that are ready belonging to the _ring_ param.
    


## RETURN VALUE



           Returns the number of unconsumed ready entries in the CQ ring.
    


* * *
# libpfm_intel_snbep_unc_pcu

## NAME



           libpfm_intel_snbep_unc_pcu - support for Intel Sandy Bridge-EP
           Power Controller Unit (PCU) uncore PMU
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: snbep_unc_pcu**
           **PMU desc: Intel Sandy Bridge-EP PCU uncore PMU**
    


## DESCRIPTION



           The library supports the Intel Sandy Bridge Power Controller Unit
           uncore PMU.  This PMU model only exists on Sandy Bridge model 45.
           There is only one PCU PMU per processor socket.
    


## MODIFIERS



           The following modifiers are supported on Intel Sandy Bridge C-Box
           uncore PMU:
    
           **i** Invert the meaning of the event. The counter will now count
                  HA 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 from no occurrence of the event to at
                  least one occurrence. This modifier must be combined with a
                  threshold modifier (t) with a value greater or equal to
                  one.  This is a boolean modifier.
    
           **t** Set the threshold value. When set to a non-zero value, the
                  counter counts the number of HA 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:15].
    
           **ff** Enable frequency band filtering. This modifier applies only
                  to the UNC_P_FREQ_BANDx_CYCLES events, where x is [0-3].
                  The modifiers expects an integer in the range [0-255]. The
                  value is interpreted as a frequency value to be multiplied
                  by 100Mhz. Thus if the value is 32, then all cycles where
                  the processor is running at 3.2GHz and more are counted.
    


## Frequency band filtering



           There are 3 events which support frequency band filtering, namely,
           UNC_P_FREQ_BAND0_CYCLES, UNC_P_FREQ_BAND1_CYCLES,
           UNC_P_FREQ_BAND2_CYCLES, UNC_P_FREQ_BAND3_CYCLES. The frequency
           filter (available via the ff modifier) is stored into a PMU shared
           register which hold all 4 possible frequency bands, one per event.
           However, the library generate the encoding for each event
           individually because it processes events one at a time. The caller
           or the underlying kernel interface may have to merge the band
           filter settings to program the filter register properly.
    


* * *
# program_invocation_name

## NAME



           program_invocation_name, program_invocation_short_name - obtain
           name used to invoke calling program
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#define _GNU_SOURCE** /* See feature_test_macros(7) */
           **#include <errno.h>**
    
           **extern char ***_program_invocation_name_**;**
           **extern char ***_program_invocation_short_name_**;**
    


## DESCRIPTION



           _program_invocation_name_ contains the name that was used to invoke
           the calling program.  This is the same as the value of _argv[0]_ in
           _main_(), with the difference that the scope of
           _program_invocation_name_ is global.
    
           _program_invocation_short_name_ contains the basename component of
           name that was used to invoke the calling program.  That is, it is
           the same value as _program_invocation_name_ , with all text up to and
           including the final slash (/), if any, removed.
    
           These variables are automatically initialized by the glibc run-
           time startup code.
    


## VERSIONS



           The Linux-specific _/proc/_ pid _/cmdline_ file provides access to
           similar information.
    


## STANDARDS



           GNU.
    


* * *
# probe::netfilter.ip.local_out

## NAME



           probe::netfilter.ip.local_out - Called on an outgoing IP packet
    


## SYNOPSIS



           netfilter.ip.local_out
    


## VALUES



           _syn_
               TCP SYN flag (if protocol is TCP; ipv4 only)
    
           _daddr_
               A string representing the destination IP address
    
           _fin_
               TCP FIN flag (if protocol is TCP; ipv4 only)
    
           _saddr_
               A string representing the source IP address
    
           _nf_stolen_
               Constant used to signify a 'stolen' verdict
    
           _ipproto_tcp_
               Constant used to signify that the packet protocol is TCP
    
           _outdev_name_
               Name of network device packet will be routed to (if known)
    
           _nf_queue_
               Constant used to signify a 'queue' verdict
    
           _rst_
               TCP RST flag (if protocol is TCP; ipv4 only)
    
           _urg_
               TCP URG flag (if protocol is TCP; ipv4 only)
    
           _indev_name_
               Name of network device packet was received on (if known)
    
           _dport_
               TCP or UDP destination port (ipv4 only)
    
           _iphdr_
               Address of IP header
    
           _pf_
               Protocol family -- either “ipv4” or “ipv6”
    
           _sport_
               TCP or UDP source port (ipv4 only)
    
           _length_
               The length of the packet buffer contents, in bytes
    
           _ipproto_udp_
               Constant used to signify that the packet protocol is UDP
    
           _psh_
               TCP PSH flag (if protocol is TCP; ipv4 only)
    
           _family_
               IP address family
    
           _nf_drop_
               Constant used to signify a 'drop' verdict
    
           _ack_
               TCP ACK flag (if protocol is TCP; ipv4 only)
    
           _protocol_
               Packet protocol from driver (ipv4 only)
    
           _indev_
               Address of net_device representing input device, 0 if unknown
    
           _data_str_
               A string representing the packet buffer contents
    
           _nf_repeat_
               Constant used to signify a 'repeat' verdict
    
           _nf_stop_
               Constant used to signify a 'stop' verdict
    
           _nf_accept_
               Constant used to signify an 'accept' verdict
    
           _data_hex_
               A hexadecimal string representing the packet buffer contents
    
           _outdev_
               Address of net_device representing output device, 0 if unknown
    


* * *
# probe::staprun.send_control_message

## NAME



           probe::staprun.send_control_message - Sending a control message
    


## SYNOPSIS



           staprun.send_control_message
    


## VALUES



           _data_
               a ptr to a binary blob of data sent as the control message
    
           _len_
               the length (in bytes) of the data blob
    
           _type_
               type of message being send; defined in
               runtime/transport/transport_msgs.h
    


## DESCRIPTION



           Fires at the beginning of the send_request function.
    


* * *
# function::set_user_long

## NAME



           function::set_user_long - Writes a long value to user memory
    


## SYNOPSIS



               set_user_long(addr:long,val:long)
    


## ARGUMENTS



           _addr_
               The user address to write the long to
    
           _val_
               The long which is to be written
    


## DESCRIPTION



           Writes the long value to a given user memory address. Reports an
           error when writing to the given address fails. Requires the use of
           guru mode (-g).
    


* * *
# io_uring_prep_fadvise

## NAME



           io_uring_prep_fadvise - prepare a fadvise request
    


## SYNOPSIS



           **#include <fcntl.h>**
           **#include <liburing.h>**
    
           **void io_uring_prep_fadvise(struct io_uring_sqe ***_sqe_**,**
                                      **int** _fd_**,**
                                      **__u64** _offset_**,**
                                      **__u32** _len_**,**
                                      **int** _advice_**);**
    
           **void io_uring_prep_fadvise64(struct io_uring_sqe ***_sqe_**,**
                                        **int** _fd_**,**
                                        **__u64** _offset_**,**
                                        **off_t** _len_**,**
                                        **int** _advice_**);**
    


## DESCRIPTION



           The io_uring_prep_fadvise(3) function prepares an fadvise request.
           The submission queue entry _sqe_ is setup to use the file descriptor
           pointed to by _fd_ to start an fadvise operation at _offset_ and of
           _len_ length in bytes, giving it the advise located in _advice_.
    
           The io_uring_prep_fadvise64(3) function works like
           io_uring_prep_fadvise(3) except that it takes a 64-bit length
           rather than just a 32-bit one. Older kernels may not support the
           64-bit length variant. If this variant is attempted used on a
           kernel that doesn't support 64-bit lengths, then the request will
           get errored with **-EINVAL** in the results field of the CQE.
    
           This function prepares an async posix_fadvise(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.
    


* * *
# function::symline

## NAME



           function::symline - Return the line number of an address.
    


## SYNOPSIS



               symline:string(addr:long)
    


## ARGUMENTS



           _addr_
               The address to translate.
    


## DESCRIPTION



           Returns the (approximate) line number of the given address, if
           known. If the line number cannot be found, the hex string
           representation of the address will be returned.
    


* * *
# ungetc

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



           ungetc — push byte back into input stream
    


## SYNOPSIS



           #include <stdio.h>
    
           int ungetc(int _c_ , FILE *_stream_);
    


## DESCRIPTION



           The functionality described on this reference page is aligned with
           the ISO C standard. Any conflict between the requirements
           described here and the ISO C standard is unintentional. This
           volume of POSIX.1‐2017 defers to the ISO C standard.
    
           The _ungetc_() function shall push the byte specified by _c_
           (converted to an **unsigned char**) back onto the input stream pointed
           to by _stream_.  The pushed-back bytes shall be returned by
           subsequent reads on that stream in the reverse order of their
           pushing. A successful intervening call (with the stream pointed to
           by _stream_) to a file-positioning function (_fseek_(), _fseeko_(),
           _fsetpos_(), or _rewind_()) or _fflush_() shall discard any pushed-back
           bytes for the stream. The external storage corresponding to the
           stream shall be unchanged.
    
           One byte of push-back shall be provided. If _ungetc_() is called too
           many times on the same stream without an intervening read or file-
           positioning operation on that stream, the operation may fail.
    
           If the value of _c_ equals that of the macro EOF, the operation
           shall fail and the input stream shall be left unchanged.
    
           A successful call to _ungetc_() shall clear the end-of-file
           indicator for the stream. The value of the file-position indicator
           for the stream after all pushed-back bytes have been read, or
           discarded by calling _fseek_(), _fseeko_(), _fsetpos_(), or _rewind_()
           (but not _fflush_()), shall be the same as it was before the bytes
           were pushed back. The file-position indicator is decremented by
           each successful call to _ungetc_(); if its value was 0 before a
           call, its value is unspecified after the call.
    


## RETURN VALUE



           Upon successful completion, _ungetc_() shall return the byte pushed
           back after conversion. Otherwise, it shall return EOF.
    


## ERRORS



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


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# selinux_check_securetty_context

## NAME



           selinux_check_securetty_context - check whether a SELinux tty
           security context is defined as a securetty context
    


## SYNOPSIS



           **#include <selinux/selinux.h>**
    
           **int selinux_check_securetty_context(const char ***_tty_context_**);**
    


## DESCRIPTION



           **selinux_check_securetty_context**() returns 0 if tty_context is a
           securetty context, returns < 0 otherwise.
    


* * *
# gnutls_record_get_max_early_data_size

## NAME



           gnutls_record_get_max_early_data_size - API function
    


## SYNOPSIS



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


## ARGUMENTS



           gnutls_session_t session
                       is a **gnutls_session_t** type.
    


## DESCRIPTION



           This function returns the maximum early data size in this
           connection.  This property can only be set to servers.  The client
           may be provided with the maximum allowed size through the
           "early_data" extension of the NewSessionTicket handshake message.
    


## RETURNS



           The maximum early data size in this connection.
    


## SINCE



           3.6.5
    


* * *
# sinh

## NAME



           sinh, sinhf, sinhl - hyperbolic sine function
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



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


## DESCRIPTION



           These functions return the hyperbolic sine of _x_ , which is defined
           mathematically as:
    
               sinh(x) = (exp(x) - exp(-x)) / 2
    


## RETURN VALUE



           On success, these functions return the hyperbolic sine of _x_.
    
           If _x_ is a NaN, a NaN is returned.
    
           If _x_ is +0 (-0), +0 (-0) is returned.
    
           If _x_ is positive infinity (negative infinity), positive infinity
           (negative infinity) is returned.
    
           If the result overflows, a range error occurs, and the functions
           return **HUGE_VAL** , **HUGE_VALF** , or **HUGE_VALL** , respectively, with the
           same sign as _x_.
    


## ERRORS



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


## ATTRIBUTES



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


## STANDARDS



           C11, POSIX.1-2008.
    


* * *
# __pmlookupipc

## NAME



           **__pmOverrideLastFd** , **__pmPrintIPC** , **__pmResetIPC** - IPC version
           infrastructure support
    


## C SYNOPSIS



           **#include "pmapi.h"**
           **#include "libpcp.h"**
    
           **void __pmOverrideLastFd(int** _fd_**);**
           **void __pmPrintIPC(void);**
           **void __pmResetIPC(int** _fd_**);**
    
           **cc ... -lpcp**
    


## CAVEAT



           This  documentation  is intended for internal Performance Co-Pilot
           (PCP) developer use.
    
           These interfaces are not part of the PCP APIs that are  guaranteed
           to  remain  fixed  across  releases, and they may not work, or may
           provide different semantics at some point in the future.
    


## DESCRIPTION



           IPC channels throughout the distributed PCP framework are affected
           by the PCP 2.0 (and later) PDU changes.  These functions  are  the
           interface  to  the  libpcp  IPC connection management global data.
           This data consists of a hash table of __pmIPC structures  (indexed
           by file descriptor) and a cached, most-recently-used file descrip‐
           tor.
    
           The  **__pmOverrideLastFd** is  an  escape mechanism for use in those
           situations where the last PDU fetch did not go through  the  usual
           channels  (i.e.  __pmGetPDU), so as to ensure that the cached file
           descriptor is the correct file descriptor for  the  PDU  which  is
           currently  being  processed.   This  will  typically  be  used for
           archive PDU processing or where version information is not  avail‐
           able  for a given file descriptor (e.g. immediately prior to a PDU
           version exchange).
    
           **__pmPrintIPC** is a useful debugging routine for displaying a  table
           mapping all currently registered file descriptors to their associ‐
           ated  PDU  version  numbers.   Unused entries in this table should
           display the value zero in the version column.
    
           **__pmResetIPC** resets the version information  associated  with  the
           given  file descriptor to some known (invalid) number.  Subsequent
           lookups on this file descriptor will return an UNKNOWN_VERSION em‐
           bedded within the __pmIPC structure.
    


## DIAGNOSTICS



           A negative return value from **__pmOverrideLastFd** indicates that the
           file descriptor argument is not  registered  in  the  hash  table.
           This  typically indicates closure of an IPC channel, so PM_ERR_IPC
           is returned if this is the case.
    


* * *
# mlx5dv_devx_create_cmd_comp

## NAME



           mlx5dv_devx_create_cmd_comp - Create a command completion to be
           used for DEVX asynchronous commands.
    
           mlx5dv_devx_destroy_cmd_comp - Destroy a devx command completion.
    
           mlx5dv_devx_get_async_cmd_comp - Get an asynchronous command
           completion.  # SYNOPSIS
    
                  #include <infiniband/mlx5dv.h>
    
                  struct mlx5dv_devx_cmd_comp {
                      int fd;
                  };
    
                  struct mlx5dv_devx_cmd_comp *
                  mlx5dv_devx_create_cmd_comp(struct ibv_context *context)
    
                  void mlx5dv_devx_destroy_cmd_comp(struct mlx5dv_devx_cmd_comp *cmd_comp)
    
                  struct mlx5dv_devx_async_cmd_hdr {
                      uint64_t    wr_id;
                      uint8_t     out_data[];
                  };
    
                  int mlx5dv_devx_get_async_cmd_comp(struct mlx5dv_devx_cmd_comp *cmd_comp,
                                     struct mlx5dv_devx_async_cmd_hdr *cmd_resp,
                                     size_t cmd_resp_len)
    


## DESCRIPTION



           Create or destroy a command completion to be used for DEVX
           asynchronous commands.
    
           The create verb exposes an mlx5dv_devx_cmd_comp object that can be
           used as part of asynchronous DEVX commands.  This lets an
           application run asynchronously without blocking and once the
           response is ready read it from this object.
    
           The response can be read by the mlx5dv_devx_get_async_cmd_comp()
           API, upon response the _wr_id_ that was supplied upon the
           asynchronous command is returned and the _out_data_ includes the
           data itself.  The application must supply a large enough buffer to
           match any command that was issued on the _cmd_comp_ , its size is
           given by the input _cmd_resp_len_ parameter.
    


## ARGUMENTS



           _context_
    
                  RDMA device context to create the action on.
    
           _cmd_comp_
                  The command completion object.
    
           _cmd_resp_
                  The output data from the asynchronous command.
    
           _cmd_resp_len_
                  The output buffer size to hold the response.
    


## RETURN VALUE



           Upon success _mlx5dv_devx_create_cmd_comp_ will return a new _struct_
           _mlx5dv_devx_cmd_comp_ object, on error NULL will be returned and
           errno will be set.
    
           Upon success _mlx5dv_devx_get_async_cmd_comp_ will return 0,
           otherwise errno will be returned.
    


* * *
# pcap_create

## NAME



           pcap_create - create a live capture handle
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **char errbuf[PCAP_ERRBUF_SIZE];**
    
           **pcap_t *pcap_create(const char *source, char *errbuf);**
    


## DESCRIPTION



           **pcap_create**() is used to create a packet capture handle to capture
           packets on a device (typically a network interface, see
           **pcap_findalldevs**(3PCAP) for a more detailed explanation).  _source_
           is a string that specifies the capture device to open, in this
           function **NULL** means the same as the string "any".  _errbuf_ is a
           buffer large enough to hold at least **PCAP_ERRBUF_SIZE** chars.
    
           The returned handle must be activated with **pcap_activate**(3PCAP)
           before packets can be captured with it; options for the capture,
           such as promiscuous mode, can be set on the handle before
           activating it.
    


## RETURN VALUE



           **pcap_create**() returns a **pcap_t *** on success and **NULL** on failure.
           If **NULL** is returned, _errbuf_ is filled in with an appropriate error
           message.
    


* * *
# gnutls_x509_trust_list_verify_named_crt

## NAME



           gnutls_x509_trust_list_verify_named_crt - API function
    


## SYNOPSIS



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


## ARGUMENTS



           gnutls_x509_trust_list_t list
                       The list
    
           gnutls_x509_crt_t cert
                       is the certificate to be verified
    
           const void * name
                       is the certificate's name
    
           size_t name_size
                       is the certificate's name size
    
           unsigned int flags
                       Flags that may be used to change the verification
                       algorithm. Use OR of the
                       gnutls_certificate_verify_flags enumerations.
    
           unsigned int * voutput
                       will hold the certificate verification output.
    
           gnutls_verify_output_function func
                       If non-null will be called on each chain element
                       verification with the output.
    


## DESCRIPTION



           This function will try to find a certificate that is associated
           with the provided name --see
           **gnutls_x509_trust_list_add_named_crt()**. If a match is found the
           certificate is considered valid. In addition to that this function
           will also check CRLs. The  _voutput_ parameter will hold an OR'ed
           sequence of **gnutls_certificate_status_t** flags.
    
           Additionally a certificate verification profile can be specified
           from the ones in **gnutls_certificate_verification_profiles_t** by
           ORing the result of **GNUTLS_PROFILE_TO_VFLAGS()** to the verification
           flags.
    


## RETURNS



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


## SINCE



           3.0.0
    


* * *
# catan

## NAME



           catan, catanf, catanl - complex arc tangents
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



           **#include <complex.h>**
    
           **double complex catan(double complex** _z_**);**
           **float complex catanf(float complex** _z_**);**
           **long double complex catanl(long double complex** _z_**);**
    


## DESCRIPTION



           These functions calculate the complex arc tangent of _z_.  If
           _y = catan(z)_ , then _z = ctan(y)_.  The real part of _y_ is chosen in
           the interval [-pi/2, pi/2].
    
           One has:
    
               catan(z) = (clog(1 + i * z) - clog(1 - i * z)) / (2 * i)
    


## ATTRIBUTES



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


## STANDARDS



           C11, POSIX.1-2008.
    


## EXAMPLES



           /* Link with "-lm" */
    
           #include <complex.h>
           #include <stdio.h>
           #include <stdlib.h>
           #include <unistd.h>
    
           int
           main(int argc, char *argv[])
           {
               double complex z, c, f;
               double complex i = I;
    
               if (argc != 3) {
                   fprintf(stderr, "Usage: %s <real> <imag>\n", argv[0]);
                   exit(EXIT_FAILURE);
               }
    
               z = atof(argv[1]) + atof(argv[2]) * I;
    
               c = catan(z);
               printf("catan() = %6.3f %6.3f*i\n", creal(c), cimag(c));
    
               f = (clog(1 + i * z) - clog(1 - i * z)) / (2 * i);
               printf("formula = %6.3f %6.3f*i\n", creal(f), cimag(f));
    
               exit(EXIT_SUCCESS);
           }
    


* * *
# auparse_next_event

## NAME



           auparse_next_event - get the next event
    


## SYNOPSIS



           **#include <auparse.h>**
    
           **int auparse_next_event(auparse_state_t ***_au);"_
    


## DESCRIPTION



           auparse_next_event will position the cursors at the first field of
           the first record of the next event in a file or buffer. It does
           not skip events or honor any search criteria that may be stored.
    


## RETURN VALUE



           Returns -1 if an error occurs, 0 if there's no data, 1 for
           success.
    


* * *
# __pmServerNotifyServiceManagerReady

## NAME



           **__pmServerNotifyServiceManagerReady** ,
           **__pmServerNotifyServiceManagerStopping** - notify service start and
           stop
    


## C SYNOPSIS



           **#include "pmapi.h"**
           **#include "libpcp.h"**
    
           **int __pmServerNotifyServiceManagerReady(pid_t** _mainpid_**);**
           **int __pmServerNotifyServiceManagerStopping(pid_t** _mainpid_**);**
    
           **cc ... -lpcp**
    


## CAVEAT



           This  documentation  is intended for internal Performance Co-Pilot
           (PCP) developer use.
    
           These interfaces are not part of the PCP APIs that are  guaranteed
           to  remain  fixed  across  releases, and they may not work, or may
           provide different semantics at some point in the future.
    


## DESCRIPTION



           Within the libraries and applications of the Performance  Co-Pilot
           (PCP)  these  routines provide a convenient and portable interface
           to service manager APIs, such as sd_notify(3).
    
           PCP service daemons  should  call  **__pmServerNotifyServiceManager‐**
           **Ready** immediately prior to entering their main loop, regardless of
           whether  or  not they have forked or daemonised.  This will notify
           the service manager (if any, depending on the platform)  that  the
           daemon  service  has  started,  and  that  the  main process to be
           tracked is **mainpid**.
    
           Similarly when shutting down, service daemons  should  call  **__pm‐**
           **ServerNotifyServiceManagerStopping** to  notify the service manager
           (if any) that the tracked process of the service has returned from
           it's main loop and is about to shut down.
    
           These routines are intended to be portable and thus no conditional
           code should be needed for any service daemon on any platform.
    


## DIAGNOSTICS



           These functions will print diagnostics to  the  **stderr** stream  if
           **pmDebugOptions.services** is set.
    


## RETURN CODE



           If successful, **__pmServerNotifyServiceManagerReady** returns a posi‐
           tive integer that depends on the platform service manager.  In the
           case  of systemd(1), the return code is from sd_notify(3).  If the
           platform supports systemd(1)  but  the  **NOTIFY_SOCKET** environment
           variable  is  not set (as may be the case if the server program is
           started manually rather than by systemd(1)), the return code  will
           be  **PM_ERR_GENERIC** which will normally be ignored but a diagnostic
           will be printed if **pmDebugOptions.services** is set.   On  platforms
           that  have no service manager, the return code will be **PM_ERR_NYI**.
           For backward compatibility on these  platforms,  the  return  code
           should be ignored.
    


* * *
# function::remote_uri

## NAME



           function::remote_uri - The name of this instance in a remote
           execution.
    


## SYNOPSIS



               remote_uri:string()
    


## ARGUMENTS



           None
    


## DESCRIPTION



           This function returns the remote host used to invoke this
           particular script execution from a swarm of “stap --remote” runs.
           It may not be unique among the swarm. The function returns an
           empty string if the script was not launched with “stap --remote”.
    


* * *
# mlx5dv_open_device

## NAME



           mlx5dv_open_device - Open an RDMA device context for the mlx5
           provider
    


## SYNOPSIS



                  #include <infiniband/mlx5dv.h>
    
                  struct ibv_context *
                  mlx5dv_open_device(struct ibv_device *device, struct mlx5dv_context_attr *attr);
    


## DESCRIPTION



           Open an RDMA device context with specific mlx5 provider
           attributes.
    


## ARGUMENTS



           _device_ RDMA device to open.
    
           _attr_
    
       **mlx5dv_context_attr**
                  struct mlx5dv_context_attr {
                          uint32_t flags;
                          uint64_t comp_mask;
                          struct ibv_fd_arr *fds;
                  };
    
           _flags_
    
                  A bitwise OR of the various values described below.
    
                  *MLX5DV_CONTEXT_FLAGS_DEVX*:
                  Allocate a DEVX context
    
           _comp_mask_
    
                  Bitmask specifying what fields in the structure are valid
    
                  *MLX5DV_CONTEXT_ATTR_MASK_FD_ARRAY*:
                  Valid value in *fds*
    
           _fds_
    
                  Used to pass a file descriptor array.
    
       **ibv_fd_arr**
                  struct ibv_fd_arr {
                          int *arr;
                          uint32_t count;
                  };
    
           _arr_    Pointer to the file descriptor array.
    
           _count_  Number of elements in the array.
    


## RETURN VALUE



           Returns a pointer to the allocated device context, or NULL if the
           request fails.
    


* * *
# pcap_file

## NAME



           pcap_file - get the standard I/O stream for a savefile being read
    


## SYNOPSIS



           **#include <pcap/pcap.h>**
    
           **FILE *pcap_file(pcap_t *p);**
    


## DESCRIPTION



           **pcap_file**() returns the standard I/O stream of the ``savefile'',
           if a ``savefile'' was opened with **pcap_open_offline**(3PCAP), or
           **NULL** , if a network device was opened with **pcap_create**(3PCAP) and
           **pcap_activate**(3PCAP), or with **pcap_open_live**(3PCAP).
    
           Note that the Packet Capture library is usually built with large
           file support, so the standard I/O stream of the ``savefile'' might
           refer to a file larger than 2 gigabytes; applications that use
           **pcap_file**() should, if possible, use calls that support large
           files on the return value of **pcap_file**() or the value returned by
           fileno(3) when passed the return value of **pcap_file**().
    


* * *
# gnutls_x509_crq_sign2

## NAME



           gnutls_x509_crq_sign2 - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crq_sign2(gnutls_x509_crq_t** _crq_**,**
           **gnutls_x509_privkey_t** _key_**, gnutls_digest_algorithm_t** _dig_**, unsigned**
           **int** _flags_**);**
    


## ARGUMENTS



           gnutls_x509_crq_t crq
                       should contain a **gnutls_x509_crq_t** type
    
           gnutls_x509_privkey_t key
                       holds a private key
    
           gnutls_digest_algorithm_t dig
                       The message digest to use, i.e., **GNUTLS_DIG_SHA256**
    
           unsigned int flags
                       must be 0
    


## DESCRIPTION



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


## RETURNS



           **GNUTLS_E_SUCCESS** on success, otherwise a negative error code.
           **GNUTLS_E_ASN1_VALUE_NOT_FOUND** is returned if you didn't set all
           information in the certificate request (e.g., the version using
           **gnutls_x509_crq_set_version()**).
    


* * *
# strcasecmp

## NAME



           strcasecmp, strncasecmp - compare two strings ignoring case
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <strings.h>**
    
           **int strcasecmp(const char ***_s1_**, const char ***_s2_**);**
           **int strncasecmp(** size_t n;
                           **const char** _s1_**[**_n_**], const char** _s2_**[**_n_**], size_t** _n_**);**
    


## DESCRIPTION



           The **strcasecmp**() function performs a byte-by-byte comparison of
           the strings _s1_ and _s2_ , ignoring the case of the characters.  It
           returns an integer less than, equal to, or greater than zero if _s1_
           is found, respectively, to be less than, to match, or be greater
           than _s2_.
    
           The **strncasecmp**() function is similar, except that it compares no
           more than _n_ bytes of _s1_ and _s2_.
    


## RETURN VALUE



           The **strcasecmp**() and **strncasecmp**() functions return an integer
           less than, equal to, or greater than zero if _s1_ is, after ignoring
           case, found to be less than, to match, or be greater than _s2_ ,
           respectively.
    


## ATTRIBUTES



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


## STANDARDS



           POSIX.1-2008.
    


* * *
# udev_enumerate_new

## NAME



           udev_enumerate_new, udev_enumerate_ref, udev_enumerate_unref -
           Create, acquire and release a udev enumerate object
    


## SYNOPSIS



           **#include <libudev.h>**
    
           **struct udev_enumerate *udev_enumerate_new(struct udev ***_udev_**);**
    
           **struct udev_enumerate**
                                                     ***udev_enumerate_ref(struct udev_enumerate ***_udev_enumerate_**);**
    
           **struct udev_enumerate**
                                                       ***udev_enumerate_unref(struct udev_enumerate ***_udev_enumerate_**);**
    


## RETURN VALUE



           On success, **udev_enumerate_new()** returns a pointer to the
           allocated enumeration object. On failure, **NULL** is returned.
           **udev_enumerate_ref()** returns the argument that it was passed,
           unmodified.  **udev_enumerate_unref()** always returns **NULL**.
    


* * *
# strdup

## NAME



           strdup, strndup, strdupa, strndupa - duplicate a string
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <string.h>**
    
           **char *strdup(const char ***_s_**);**
    
           **char *strndup(** size_t n;
                         **const char** _s_**[**_n_**], size_t** _n_**);**
           **char *strdupa(const char ***_s_**);**
           **char *strndupa(** size_t n;
                         **const char** _s_**[**_n_**], size_t** _n_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **strdup**():
               _XOPEN_SOURCE >= 500
                   || /* Since glibc 2.12: */ _POSIX_C_SOURCE >= 200809L
                   || /* glibc <= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
    
           **strndup**():
               Since glibc 2.10:
                   _POSIX_C_SOURCE >= 200809L
               Before glibc 2.10:
                   _GNU_SOURCE
    
           **strdupa**(), **strndupa**():
               _GNU_SOURCE
    


## DESCRIPTION



           The **strdup**() function returns a pointer to a new string which is a
           duplicate of the string _s_.  Memory for the new string is obtained
           with malloc(3), and can be freed with free(3).
    
           The **strndup**() function is similar, but copies at most _n_ bytes.  If
           _s_ is longer than _n_ , only _n_ bytes are copied, and a terminating
           null byte ('\0') is added.
    
           **strdupa**() and **strndupa**() are similar, but use alloca(3) to
           allocate the buffer.
    


## RETURN VALUE



           On success, the **strdup**() function returns a pointer to the
           duplicated string.  It returns NULL if insufficient memory was
           available, with _errno_ set to indicate the error.
    


## ERRORS



           **ENOMEM** Insufficient memory available to allocate duplicate string.
    


## ATTRIBUTES



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


## STANDARDS



           **strdup**()
           **strndup**()
                  POSIX.1-2008.
    
           **strdupa**()
           **strndupa**()
                  GNU.
    


* * *
# gnutls_x509_ext_import_crl_dist_points

## NAME



           gnutls_x509_ext_import_crl_dist_points - API function
    


## SYNOPSIS



           **#include <gnutls/x509-ext.h>**
    
           **int gnutls_x509_ext_import_crl_dist_points(const gnutls_datum_t ***
           _ext_**, gnutls_x509_crl_dist_points_t** _cdp_**, unsigned int** _flags_**);**
    


## ARGUMENTS



           const gnutls_datum_t * ext
                       the DER encoded extension data
    
           gnutls_x509_crl_dist_points_t cdp
                       A pointer to an initialized CRL distribution points.
    
           unsigned int flags
                       should be zero
    


## DESCRIPTION



           This function will extract the CRL distribution points extension
           (2.5.29.31) and store it into the provided type.
    


## RETURNS



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


## SINCE



           3.3.0
    


* * *