tripathysagar/man_text huggingface dataset:
# gnutls_aead_cipher_set_key

## NAME



           gnutls_aead_cipher_set_key - API function
    


## SYNOPSIS



           **#include <gnutls/crypto.h>**
    
           **int gnutls_aead_cipher_set_key(gnutls_aead_cipher_hd_t** _handle_**,**
           **const gnutls_datum_t ***_key_**);**
    


## ARGUMENTS



           gnutls_aead_cipher_hd_t handle
                       is a **gnutls_aead_cipher_hd_t** type.
    
           const gnutls_datum_t * key
                       The key to be used for encryption
    


## DESCRIPTION



           This function will set a new key without re-initializing the
           context.
    


## RETURNS



           Zero or a negative error code on error.
    


## SINCE



           3.7.5
    


* * *
# sd_bus_message_copy

## NAME



           sd_bus_message_copy - Copy the contents of one message to another
    


## SYNOPSIS



           **#include <systemd/sd-bus.h>**
    
           **int sd_bus_message_copy(sd_bus_message ***_m_**, sd_bus_message ***_source_**,**
                                   **int** _all_**);**
    


## DESCRIPTION



           **sd_bus_message_copy()** copies the contents from message _source_ to
           _m_. If _all_ is false, a single complete type is copied (basic or
           container). If _all_ is true, the contents are copied until the end
           of the currently open container or the end of _source_.
    


## RETURN VALUE



           On success, this call returns true if anything was copied, and
           false if there was nothing to copy. On failure, it returns a
           negative errno-style error code.
    
       **Errors**
           Returned errors may indicate the following problems:
    
           **-EINVAL**
               _source_ or _m_ are **NULL**.
    
           **-EPERM**
               Message _m_ has been sealed or _source_ has _not_ been sealed.
    
           **-ESTALE**
               Destination message is in invalid state.
    
           **-ENXIO**
               Destination message cannot be appended to.
    
           **-ENOMEM**
               Memory allocation failed.
    


## NOTES



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


* * *
# acosh

## NAME



           acosh, acoshf, acoshl - inverse hyperbolic cosine function
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



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


## DESCRIPTION



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


## RETURN VALUE



           On success, these functions return the inverse hyperbolic cosine
           of _x_.
    
           If _x_ is a NaN, a NaN is returned.
    
           If _x_ is +1, +0 is returned.
    
           If _x_ is positive infinity, positive infinity is returned.
    
           If _x_ is less than 1, a domain error occurs, and the functions
           return a NaN.
    


## 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 less than 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** │
           ├──────────────────────────────────────┼───────────────┼─────────┤
           │ **acosh**(), **acoshf**(), **acoshl**()          │ Thread safety │ MT-Safe │
           └──────────────────────────────────────┴───────────────┴─────────┘
    


## STANDARDS



           C11, POSIX.1-2008.
    


* * *
# twalk

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



           twalk — traverse a binary search tree
    


## SYNOPSIS



           #include <search.h>
    
           void twalk(const void *_root_ ,
               void (*_action_)(const void *, VISIT, int ));
    


## DESCRIPTION



           Refer to tdelete(3p).
    


* * *
# strncat

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



           strncat — concatenate a string with part of another
    


## SYNOPSIS



           #include <string.h>
    
           char *strncat(char *restrict _s1_ , const char *restrict _s2_ , size_t _n_);
    


## 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 _strncat_() function shall append not more than _n_ bytes (a NUL
           character and bytes that follow it are not appended) from the
           array pointed to by _s2_ to the end of the string pointed to by _s1_.
           The initial byte of _s2_ overwrites the NUL character at the end of
           _s1_.  A terminating NUL character is always appended to the result.
           If copying takes place between objects that overlap, the behavior
           is undefined.
    


## RETURN VALUE



           The _strncat_() function shall return _s1_ ; no return value shall be
           reserved to indicate an error.
    


## ERRORS



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


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# gnutls_priority_compression_list

## NAME



           gnutls_priority_compression_list - API function
    


## SYNOPSIS



           **#include <gnutls/compat.h>**
    
           **int gnutls_priority_compression_list(gnutls_priority_t** _pcache_**,**
           **const unsigned int ****_list_**);**
    


## ARGUMENTS



           gnutls_priority_t pcache
                       is a **gnutls_priority_t** type.
    
           const unsigned int ** list
                       will point to an integer list
    


## DESCRIPTION



           Get a list of available compression method in the priority
           structure.
    


## RETURNS



           the number of methods, or an error code.
    


## SINCE



           3.0
    


* * *
# probe::tcpmib.InSegs

## NAME



           probe::tcpmib.InSegs - Count an incoming tcp segment
    


## SYNOPSIS



           tcpmib.InSegs
    


## VALUES



           _sk_
               pointer to the struct sock being acted on
    
           _op_
               value to be added to the counter (default value of 1)
    


## DESCRIPTION



           The packet pointed to by _skb_ is filtered by the function
           **tcpmib_filter_key**(or **ipmib_filter_key** for tcp v4). If the packet
           passes the filter is is counted in the global _InSegs_ (equivalent
           to SNMP's MIB TCP_MIB_INSEGS)
    


* * *
# ibv_unimport_dm

## NAME



           ibv_import_dm - import an DM from a given ibv_context
    
           ibv_unimport_dm - unimport an DM
    


## SYNOPSIS



                  #include <infiniband/verbs.h>
    
                  struct ibv_dm *ibv_import_dm(struct ibv_context *context, uint32_t dm_handle);
                  void ibv_unimport_dm(struct ibv_dm *dm)
    


## DESCRIPTION



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


## RETURN VALUE



           **ibv_import_dm()** returns a pointer to the allocated DM, or NULL if
           the request fails and errno is set.
    


## NOTES



    


* * *
# catgets

## NAME



           catgets - get message from a message catalog
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



           **#include <nl_types.h>**
    
           **char *catgets(nl_catd** _catalog_**, int** _set_number_**, int** _message_number_**,**
                         **const char ***_message_**);**
    


## DESCRIPTION



           **catgets**() reads the message _message_number_ , in set _set_number_ ,
           from the message catalog identified by _catalog_ , where _catalog_ is a
           catalog descriptor returned from an earlier call to catopen(3).
           The fourth argument, _message_ , points to a default message string
           which will be returned by **catgets**() if the identified message
           catalog is not currently available.  The message-text is contained
           in an internal buffer area and should be copied by the application
           if it is to be saved or modified.  The return string is always
           terminated with a null byte ('\0').
    


## RETURN VALUE



           On success, **catgets**() returns a pointer to an internal buffer area
           containing the null-terminated message string.  On failure,
           **catgets**() returns the value _message_.
    


## ATTRIBUTES



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


## STANDARDS



           POSIX.1-2008.
    


* * *
# function::qsq_wait_time

## NAME



           function::qsq_wait_time - Amount of time in queue + service per
           request
    


## SYNOPSIS



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


## ARGUMENTS



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


## DESCRIPTION



           This function returns the average time in microseconds that it
           took for a request to be serviced (**qs_wait** to **qa_done**).
    


* * *
# auparse_flush_feed

## NAME



           auparse_flush_feed - flush any unconsumed feed data through
           parser.
    


## SYNOPSIS



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


## DESCRIPTION



           _auparse_flush_feed_ should be called to signal the end of feed
           input data and flush any pending parse data through the parsing
           system.
    


## RETURN VALUE



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


* * *
# menu_spacing

## NAME



           **set_menu_spacing** , **menu_spacing** - set and get spacing between menu
           items.
    


## SYNOPSIS



           **#include <menu.h>**
    
           **int set_menu_spacing(MENU ***_menu_**,**
                                **int** _spc_description_**,**
                                **int** _spc_rows_**,**
                                **int** _spc_columns_**);**
           **int menu_spacing(const MENU ***_menu_**,**
                            **int***_spc_description_**,**
                            **int***_spc_rows_**,**
                            **int***_spc_columns_**);**
    


## DESCRIPTION



           The function **set_menu_spacing** sets the spacing information for the
           menu.  Its parameter **spc_description** controls the number of spaces
           between an item name and an item description.  It must not be
           larger than **TABSIZE**.  The menu system puts in the middle of this
           spacing area the pad character.  The remaining parts are filled
           with spaces.  The **spc_rows** parameter controls the number of rows
           that are used for an item.  It must not be larger than 3.  The
           menu system inserts the blank lines between item rows, these lines
           will contain the pad character in the appropriate positions.  The
           **spc_columns** parameter controls the number of blanks between
           columns of items.  It must not be larger than **TABSIZE**.  A value of
           0 for all the spacing values resets them to the default, which is
           1 for all of them.
           The function **menu_spacing** passes back the spacing info for the
           menu.  If a pointer is NULL, this specific info is simply not
           returned.
    


## RETURN VALUE



           Both routines return **E_OK** on success.  **set_menu_spacing** may return
           **E_POSTED** if the menu is posted, or **E_BAD_ARGUMENT** if one of the
           spacing values is out of range.
    


## NOTES



           The header file **< menu.h> **automatically includes the header file
           **< curses.h>**.
    


## PORTABILITY



           These routines are specific to ncurses.  They were not supported
           on Version 7, BSD or System V implementations.  It is recommended
           that any code depending on them be conditioned using
           NCURSES_VERSION.
    


* * *
# gnutls_x509_crt_get_tlsfeatures

## NAME



           gnutls_x509_crt_get_tlsfeatures - API function
    


## SYNOPSIS



           **#include <gnutls/x509.h>**
    
           **int gnutls_x509_crt_get_tlsfeatures(gnutls_x509_crt_t** _crt_**,**
           **gnutls_x509_tlsfeatures_t** _features_**, unsigned int** _flags_**, unsigned**
           **int ***_critical_**);**
    


## ARGUMENTS



           gnutls_x509_crt_t crt
                       A X.509 certificate
    
           gnutls_x509_tlsfeatures_t features
                       If the function succeeds, the features will be stored
                       in this variable.
    
           unsigned int flags
                       zero or **GNUTLS_EXT_FLAG_APPEND**
    
           unsigned int * critical
                       the extension status
    


## DESCRIPTION



           This function will get the X.509 TLS features extension structure
           from the certificate. The returned structure needs to be freed
           using **gnutls_x509_tlsfeatures_deinit()**.
    
           When the  _flags_ is set to **GNUTLS_EXT_FLAG_APPEND** , then if the
           _features_ structure is empty this function will behave identically
           as if the flag was not set. Otherwise if there are elements in the
           _features_ structure then they will be merged with.
    
           Note that  _features_ must be initialized prior to calling this
           function.
    


## RETURNS



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


## SINCE



           3.5.1
    


* * *
# end

## NAME



           etext, edata, end - end of program segments
    


## SYNOPSIS



           **extern** _etext_**;**
           **extern** _edata_**;**
           **extern** _end_**;**
    


## DESCRIPTION



           The addresses of these symbols indicate the end of various program
           segments:
    
           _etext_  This is the first address past the end of the text segment
                  (the program code).
    
           _edata_  This is the first address past the end of the initialized
                  data segment.
    
           _end_    This is the first address past the end of the uninitialized
                  data segment (also known as the BSS segment).
    


## STANDARDS



           None.
    


## NOTES



           The program must explicitly declare these symbols; they are not
           defined in any header file.
    
           On some systems the names of these symbols are preceded by
           underscores, thus: __etext_ , __edata_ , and __end_.  These symbols are
           also defined for programs compiled on Linux.
    
           At the start of program execution, the program break will be
           somewhere near _& end_ (perhaps at the start of the following page).
           However, the break will change as memory is allocated via brk(2)
           or malloc(3).  Use sbrk(2) with an argument of zero to find the
           current value of the program break.
    


## EXAMPLES



           When run, the program below produces output such as the following:
    
               $ **./a.out**
               First address past:
                   program text (etext)       0x8048568
                   initialized data (edata)   0x804a01c
                   uninitialized data (end)   0x804a024
    
       **Program source**
    
           #include <stdio.h>
           #include <stdlib.h>
    
           extern char etext, edata, end; /* The symbols must have some type,
                                              or "gcc -Wall" complains */
    
           int
           main(void)
           {
               printf("First address past:\n");
               printf("    program text (etext)      %10p\n", &etext);
               printf("    initialized data (edata)  %10p\n", &edata);
               printf("    uninitialized data (end)  %10p\n", &end);
    
               exit(EXIT_SUCCESS);
           }
    


* * *
# mlx5dv_pp_free

## NAME



           mlx5dv_pp_alloc - Allocates a packet pacing entry
    
           mlx5dv_pp_free - Frees a packet pacing entry
    


## SYNOPSIS



                  #include <infiniband/mlx5dv.h>
    
                  struct mlx5dv_pp *
                  mlx5dv_pp_alloc(struct ibv_context *context,
                          size_t pp_context_sz,
                          const void *pp_context,
                          uint32_t flags);
    
                  void mlx5dv_pp_free(struct mlx5dv_pp *dv_pp);
    


## DESCRIPTION



           Create / free a packet pacing entry which can be used for some
           device commands over the DEVX interface.
    
           The DEVX API enables direct access from the user space area to the
           mlx5 device driver, the packet pacing information is needed for
           few commands where a packet pacing index is needed.
    


## ARGUMENTS



           _context_
                  RDMA device context to work on, need to be opened with DEVX
                  support by using mlx5dv_open_device().
    
           _pp_context_sz_
                  Length of _pp_context_ input buffer.
    
           _pp_context_
                  Packet pacing context according to the device
                  specification.
    
           _flags_  MLX5DV_PP_ALLOC_FLAGS_DEDICATED_INDEX: allocate a dedicated
                  index.
    
       **dv_pp**
                  struct mlx5dv_pp {
                      uint16_t index;
                  };
    
           _index_  The device index to be used.
    


## RETURN VALUE



           Upon success _mlx5dv_pp_alloc_ returns a pointer to the created
           packet pacing object, on error NULL will be returned and errno
           will be set.
    


* * *
# libpfm_arm_ac53

## NAME



           libpfm_arm_ac53 - support for ARM Cortex A53 PMU
    


## SYNOPSIS



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


## DESCRIPTION



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


## MODIFIERS



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


* * *
# fcloseall

## NAME



           fcloseall - close all open streams
    


## LIBRARY



           Standard C library (_libc_ , _-lc_)
    


## SYNOPSIS



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


## DESCRIPTION



           The **fcloseall**() function closes all of the calling process's open
           streams.  Buffered output for each stream is written before it is
           closed (as for fflush(3)); buffered input is discarded.
    
           The standard streams, _stdin_ , _stdout_ , and _stderr_ are also closed.
    


## RETURN VALUE



           This function returns 0 if all files were successfully closed; on
           error, **EOF** is returned.
    


## ATTRIBUTES



           For an explanation of the terms used in this section, see
           attributes(7).
           ┌───────────────────────┬───────────────┬────────────────────────┐
           │ **Interface** │ **Attribute** │ **Value** │
           ├───────────────────────┼───────────────┼────────────────────────┤
           │ **fcloseall**()           │ Thread safety │ MT-Unsafe race:streams │
           └───────────────────────┴───────────────┴────────────────────────┘
    
           The **fcloseall**() function does not lock the streams, so it is not
           thread-safe.
    


## STANDARDS



           GNU.
    


* * *
# wresize

## NAME



           **wresize** - resize a curses window
    


## SYNOPSIS



           **#include <curses.h>**
    
           **int wresize(WINDOW ***_win_**, int** _lines_**, int** _columns_**);**
    


## DESCRIPTION



           This is an extension to the curses library.  It reallocates
           storage for an **ncurses** window to adjust its dimensions to the
           specified values.  If either dimension is larger than the current
           values, the window's data is filled with blanks that have the
           current background rendition (as set by **wbkgdset**) merged into
           them.
    


## RETURN VALUE



           The function returns the integer **ERR** upon failure and **OK** on
           success.  It will fail if either of the dimensions less than or
           equal to zero, or if an error occurs while (re)allocating memory
           for the window.
    


## NOTES



           The only restriction placed on the dimensions is that they be
           greater than zero.  The dimensions are not compared to **curses**
           screen dimensions to simplify the logic of **resizeterm**.  The caller
           must ensure that the window's dimensions fit within the actual
           screen dimensions.
    


## PORTABILITY



           It is not possible to resize windows with SVr4 curses.
    
           This extension of ncurses was introduced in mid-1995.  It was
           adopted in NetBSD curses (2001) and PDCurses (2003).
    


* * *
# memchr

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



           memchr — find byte in memory
    


## SYNOPSIS



           #include <string.h>
    
           void *memchr(const void *_s_ , int _c_ , size_t _n_);
    


## 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 _memchr_() function shall locate the first occurrence of _c_
           (converted to an **unsigned char**) in the initial _n_ bytes (each
           interpreted as **unsigned char**) pointed to by _s_.
    
           Implementations shall behave as if they read the memory byte by
           byte from the beginning of the bytes pointed to by _s_ and stop at
           the first occurrence of _c_ (if it is found in the initial _n_ bytes).
    


## RETURN VALUE



           The _memchr_() function shall return a pointer to the located byte,
           or a null pointer if the byte is not found.
    


## ERRORS



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


## EXAMPLES



           None.
    


## APPLICATION USAGE



           None.
    


## RATIONALE



           None.
    


## FUTURE DIRECTIONS



           None.
    


* * *
# clog

## NAME



           clog, clogf, clogl - natural logarithm of a complex number
    


## LIBRARY



           Math library (_libm_ , _-lm_)
    


## SYNOPSIS



           **#include <complex.h>**
    
           **double complex clog(double complex** _z_**);**
           **float complex clogf(float complex** _z_**);**
           **long double complex clogl(long double complex** _z_**);**
    


## DESCRIPTION



           These functions calculate the complex natural logarithm of _z_ , with
           a branch cut along the negative real axis.
    
           The logarithm **clog**() is the inverse function of the exponential
           cexp(3).  Thus, if _y = clog(z)_ , then _z = cexp(y)_.  The imaginary
           part of _y_ is chosen in the interval [-pi,pi].
    
           One has:
    
               clog(z) = log(cabs(z)) + I * carg(z)
    
           Note that _z_ close to zero will cause an overflow.
    


## ATTRIBUTES



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


## STANDARDS



           C11, POSIX.1-2008.
    


* * *
# curs_getyx

## NAME



           **getyx** , **getparyx** , **getbegyx** , **getmaxyx** - get **curses** cursor and window
           coordinates
    


## SYNOPSIS



           **#include <curses.h>**
    
           **void getyx(WINDOW ***_win_**, int** _y_**, int** _x_**);**
           **void getparyx(WINDOW ***_win_**, int** _y_**, int** _x_**);**
           **void getbegyx(WINDOW ***_win_**, int** _y_**, int** _x_**);**
           **void getmaxyx(WINDOW ***_win_**, int** _y_**, int** _x_**);**
    


## DESCRIPTION



           The **getyx** macro places the current cursor position of the given
           window in the two integer variables _y_ and _x_.
    
           If _win_ is a subwindow, the **getparyx** macro places the beginning
           coordinates of the subwindow relative to the parent window into
           two integer variables _y_ and _x_.  Otherwise, **-1** is placed into _y_ and
           _x_.
    
           Like **getyx** , the **getbegyx** and **getmaxyx** macros store the current
           beginning coordinates and size of the specified window.
    


## RETURN VALUE



           The return values of these macros are undefined (i.e., they should
           not be used as the right-hand side of assignment statements).
    


## NOTES



           All of these interfaces are macros.  A "**&** " is not necessary before
           the variables _y_ and _x_.
    


## PORTABILITY



           The **getyx** , **getparyx** , **getbegyx** and **getmaxyx** macros are described in
           the XSI Curses standard, Issue 4.
    
           This implementation also provides functions **getbegx** , **getbegy** ,
           **getcurx** , **getcury** , **getmaxx** , **getmaxy** , **getparx** and **getpary** for
           compatibility with older versions of curses.
    
           Although X/Open Curses does not address this, many implementations
           provide members of the WINDOW structure containing values
           corresponding to these macros.  For best portability, do not rely
           on using the data in WINDOW, since some implementations make
           WINDOW opaque (do not allow direct use of its members).
    
           Besides the problem of opaque structures, the data stored in like-
           named members may not have like-values in different
           implementations.  For example, the WINDOW._maxx and WINDOW._maxy
           values in ncurses have (at least since release 1.8.1) differed by
           one from some other implementations.  The difference is hidden by
           means of the macro **getmaxyx**.
    


* * *
# io_uring_prep_cmd_discard

## NAME



           io_uring_prep_cmd_discard - prepare a discard command
    


## SYNOPSIS



           **#include <liburing.h>**
    
           **void io_uring_prep_cmd_discard(struct io_uring_sqe ***_sqe_**,**
                                     **int** _fd_**,**
                                     **uint64_t** _offset_**,**
                                     **uint64_t** _nbytes_**);**
    


## DESCRIPTION



           The io_uring_prep_cmd_discard(3) function prepares a discard
           command request. The submission queue entry _sqe_ is setup to use
           the file descriptor _fd_ to start discarding _nbytes_ at the specified
           _offset_.
    
           The command is an asynchronous equivalent of
           **BLOCK_URING_CMD_DISCARD** ioctl with a few differences. It allows
           multiple parallel discards, and it does not exclude concurrent
           writes and reads. As a result, it may lead to races for the data
           on the disk, if the application has IO inflight for the same
           ranges that the discard operates on. It's the user's
           responsibility to account for that.  Furthermore, only best
           efforts are done to invalidate page caches. The user has to make
           sure that no other inflight requests are modifying or reading the
           range(s). If that is the case, it might result in stale page cache
           and data inconsistencies.
    
           Available since 6.12.
    


## RETURN VALUE



           None
    


## ERRORS



           The CQE _res_ field will contain the result of the operation. On
           success, this field will be set to **0 .** On error, a negative error
           value is returned. 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.
    


* * *
# pthread_mutex_consistent

## NAME



           pthread_mutex_consistent - make a robust mutex consistent
    


## LIBRARY



           POSIX threads library (_libpthread_ , _-lpthread_)
    


## SYNOPSIS



           **#include <pthread.h>**
    
           **int pthread_mutex_consistent(pthread_mutex_t ***_mutex_**);**
    
       Feature Test Macro Requirements for glibc (see
       feature_test_macros(7)):
    
           **pthread_mutex_consistent**():
               _POSIX_C_SOURCE >= 200809L
    


## DESCRIPTION



           This function makes a robust mutex consistent if it is in an
           inconsistent state.  A mutex can be left in an inconsistent state
           if its owner terminates while holding the mutex, in which case the
           next owner who acquires the mutex will succeed and be notified by
           a return value of **EOWNERDEAD** from a call to **pthread_mutex_lock**().
    


## RETURN VALUE



           On success, _pthread_mutex_consistent_() returns 0.  Otherwise, it
           returns a positive error number to indicate the error.
    


## ERRORS



           **EINVAL** The mutex is either not robust or is not in an inconsistent
                  state.
    


## STANDARDS



           POSIX.1-2008.
    


## NOTES



           **pthread_mutex_consistent**() simply informs the implementation that
           the state (shared data) guarded by the mutex has been restored to
           a consistent state and that normal operations can now be performed
           with the mutex.  It is the application's responsibility to ensure
           that the shared data has been restored to a consistent state
           before calling **pthread_mutex_consistent**().
    


## EXAMPLES



           See pthread_mutexattr_setrobust(3).
    


* * *
# libpfm_intel_spr_unc_cha

## NAME



           libpfm_intel_spr_unc_cha - support for Intel IcelakeX Server CHA
           uncore PMU
    


## SYNOPSIS



           **#include <perfmon/pfmlib.h>**
    
           **PMU name: spr_unc_cha[0-59]**
           **PMU desc: Intel SapphireRapids CHA uncore PMU**
    


## DESCRIPTION



           The library supports the Intel SapphireRapids CHA (coherency and
           home agent) uncore PMU.  There is one CHA-box PMU per physical
           core. Therefore there are up forty identical CHA PMU instances
           numbered from 0 up to possibly 59. On dual-socket systems, the
           number refers to the CHA PMUs on the socket where the program
           runs.
    
           Each CHA PMU implements 4 generic counters.
    


## MODIFIERS



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


* * *
# gnutls_srp_set_server_fake_salt_seed

## NAME



           gnutls_srp_set_server_fake_salt_seed - API function
    


## SYNOPSIS



           **#include <gnutls/gnutls.h>**
    
           **void**
           **gnutls_srp_set_server_fake_salt_seed(gnutls_srp_server_credentials_t**
           _cred_**, const gnutls_datum_t ***_seed_**, unsigned int** _salt_length_**);**
    


## ARGUMENTS



           gnutls_srp_server_credentials_t cred
                       is a **gnutls_srp_server_credentials_t** type
    
           const gnutls_datum_t * seed
                       is the seed data, only needs to be valid until the
                       function returns; size of the seed must be greater
                       than zero
    
           unsigned int salt_length
                       is the length of the generated fake salts
    


## DESCRIPTION



           This function sets the seed that is used to generate salts for
           invalid (non-existent) usernames.
    
           In order to prevent attackers from guessing valid usernames, when
           a user does not exist gnutls generates a salt and a verifier and
           proceeds with the protocol as usual.  The authentication will
           ultimately fail, but the client cannot tell whether the username
           is valid (exists) or invalid.
    
           If an attacker learns the seed, given a salt (which is part of the
           handshake) which was generated when the seed was in use, it can
           tell whether or not the authentication failed because of an
           unknown username.  This seed cannot be used to reveal application
           data or passwords.
    
            _salt_length_ should represent the salt length your application
           uses.  Generating fake salts longer than 20 bytes is not
           supported.
    
           By default the seed is a random value, different each time a
           **gnutls_srp_server_credentials_t** is allocated and fake salts are 16
           bytes long.
    


## SINCE



           3.3.0
    


* * *
# function::proc_mem_shr

## NAME



           function::proc_mem_shr - Program shared pages (from shared
           mappings)
    


## SYNOPSIS



           1) proc_mem_shr:long()
    
           2) proc_mem_shr:long(pid:long)
    


## ARGUMENTS



           _pid_
               The pid of process to examine
    


## DESCRIPTION



           1) Returns the shared pages (from shared mappings) of the current
           process, or zero when there is no current process or the number of
           pages couldn't be retrieved.
    
           2) Returns the shared pages (from shared mappings) of the given
           process, or zero when the process doesn't exist or the number of
           pages couldn't be retrieved.
    


* * *
# gnutls_hmac_output

## NAME



           gnutls_hmac_output - API function
    


## SYNOPSIS



           **#include <gnutls/crypto.h>**
    
           **void gnutls_hmac_output(gnutls_hmac_hd_t** _handle_**, void ***_digest_**);**
    


## ARGUMENTS



           gnutls_hmac_hd_t handle
                       is a **gnutls_hmac_hd_t** type
    
           void * digest
                       is the output value of the MAC
    


## DESCRIPTION



           This function will output the current MAC value and reset the
           state of the MAC.
    


## SINCE



           2.10.0
    


* * *
# mkstemp

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



           mkstemp — create a unique file
    


## SYNOPSIS



           #include <stdlib.h>
    
           int mkstemp(char *_template_);
    


## DESCRIPTION



           Refer to mkdtemp(3p).
    


* * *
# gnutls_pkcs11_privkey_cpy

## NAME



           gnutls_pkcs11_privkey_cpy - API function
    


## SYNOPSIS



           **#include <gnutls/pkcs11.h>**
    
           **int gnutls_pkcs11_privkey_cpy(gnutls_pkcs11_privkey_t** _dst_**,**
           **gnutls_pkcs11_privkey_t** _src_**);**
    


## ARGUMENTS



           gnutls_pkcs11_privkey_t dst
                       The destination key, which should be initialized.
    
           gnutls_pkcs11_privkey_t src
                       The source key
    


## DESCRIPTION



           This function will copy a private key from source to destination
           key. Destination has to be initialized.
    


## RETURNS



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


## SINCE



           3.4.0
    


* * *
# gnutls_x509_ext_export_name_constraints

## NAME



           gnutls_x509_ext_export_name_constraints - API function
    


## SYNOPSIS



           **#include <gnutls/x509-ext.h>**
    
           **int**
           **gnutls_x509_ext_export_name_constraints(gnutls_x509_name_constraints_t**
           _nc_**, gnutls_datum_t ***_ext_**);**
    


## ARGUMENTS



           gnutls_x509_name_constraints_t nc
                       The nameconstraints
    
           gnutls_datum_t * ext
                       The DER-encoded extension data; must be freed using
                       **gnutls_free()**.
    


## DESCRIPTION



           This function will convert the provided name constraints type to a
           DER-encoded PKIX NameConstraints (2.5.29.30) extension. The output
           data in
            _ext_ will be allocated using **gnutls_malloc()**.
    


## RETURNS



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


## SINCE



           3.3.0
    


* * *
# getfscreatecon

## NAME



           getfscreatecon, setfscreatecon - get or set the SELinux security
           context used for creating a new file system object
    


## SYNOPSIS



           **#include <selinux/selinux.h>**
    
           **int getfscreatecon(char ****_con_**);**
    
           **int getfscreatecon_raw(char ****_con_**);**
    
           **int setfscreatecon(const char ***_context_**);**
    
           **int setfscreatecon_raw(const char ***_context_**);**
    


## DESCRIPTION



           **getfscreatecon**() retrieves the context used for creating a new
           file system object.  This returned context should be freed with
           freecon(3) if non-NULL.  **getfscreatecon**() sets *con to NULL if no
           fscreate context has been explicitly set by the program (i.e.
           using the default policy behavior).
    
           **setfscreatecon**() sets the context used for creating a new file
           system object.  NULL can be passed to **setfscreatecon**() to reset to
           the default policy behavior.  The fscreate context is
           automatically reset after the next execve(2), so a program doesn't
           need to explicitly sanitize it upon startup.
    
           **setfscreatecon**() can be applied prior to library functions that
           internally perform an file creation, in order to set an file
           context on the objects.
    
           **getfscreatecon_raw**() and **setfscreatecon_raw**() behave identically
           to their non-raw counterparts but do not perform context
           translation.
    
           **Note:** Signal handlers that perform a **setfscreatecon**() must take
           care to save, reset, and restore the fscreate context to avoid
           unexpected behavior.
    
           **Note:** Contexts are thread specific.
    


## RETURN VALUE



           On error -1 is returned.  On success 0 is returned.
    


* * *
# probe::nfs.fop.fsync

## NAME



           probe::nfs.fop.fsync - NFS client fsync operation
    


## SYNOPSIS



           nfs.fop.fsync
    


## VALUES



           _ino_
               inode number
    
           _dev_
               device identifier
    
           _ndirty_
               number of dirty pages
    


* * *
# aio_cancel

## NAME



           aio_cancel - cancel an outstanding asynchronous I/O request
    


## LIBRARY



           Real-time library (_librt_ , _-lrt_)
    


## SYNOPSIS



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


## DESCRIPTION



           The **aio_cancel**() function attempts to cancel outstanding
           asynchronous I/O requests for the file descriptor _fd_.  If _aiocbp_
           is NULL, all such requests are canceled.  Otherwise, only the
           request described by the control block pointed to by _aiocbp_ is
           canceled.  (See aio(7) for a description of the _aiocb_ structure.)
    
           Normal asynchronous notification occurs for canceled requests (see
           aio(7) and sigevent(3type)).  The request return status
           (aio_return(3)) is set to -1, and the request error status
           (aio_error(3)) is set to **ECANCELED**.  The control block of requests
           that cannot be canceled is not changed.
    
           If the request could not be canceled, then it will terminate in
           the usual way after performing the I/O operation.  (In this case,
           aio_error(3) will return the status **EINPROGRESSS**.)
    
           If _aiocbp_ is not NULL, and _fd_ differs from the file descriptor
           with which the asynchronous operation was initiated, unspecified
           results occur.
    
           Which operations are cancelable is implementation-defined.
    


## RETURN VALUE



           The **aio_cancel**() function returns one of the following values:
    
           **AIO_CANCELED**
                  All requests were successfully canceled.
    
           **AIO_NOTCANCELED**
                  At least one of the requests specified was not canceled
                  because it was in progress.  In this case, one may check
                  the status of individual requests using aio_error(3).
    
           **AIO_ALLDONE**
                  All requests had already been completed before the call.
    
           -1     An error occurred.  The error can be found by inspecting
                  _errno_.
    


## ERRORS



           **EBADF** _fd_ is not a valid file descriptor.
    
           **ENOSYS aio_cancel**() is not implemented.
    


## ATTRIBUTES



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


## STANDARDS



           POSIX.1-2008.
    


## EXAMPLES



           See aio(7).
    


* * *