zos-base.h

Go to the documentation of this file.

 
// Licensed Materials - Property of IBM
// ZOSLIB
// (C) Copyright IBM Corp. 2020. All Rights Reserved.
// US Government Users Restricted Rights - Use, duplication
// or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
 
#ifndef ZOS_BASE_H_
#define ZOS_BASE_H_
 
#undef __ZOS_EXT
#define __ZOS_EXT__ 1
 
#if ' ' != 0x20
#error EBCDIC codeset detected. ZOSLIB is compatible with the ASCII codeset only.
#endif
 
#include <_Nascii.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <sys/__getipc.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>
 
#define __ZOS_CC
 
#include "zos-macros.h"
#include "zos-bpx.h"
#include "zos-char-util.h"
#include "zos-io.h"
#include "zos-savstack.h"
#include "zos-sys-info.h"
#include "zos-tls.h"
#include "zos-getentropy.h"
 
#define IPC_CLEANUP_ENVAR_DEFAULT "__IPC_CLEANUP"
#define RUNTIME_LIMIT_ENVAR_DEFAULT "__RUNTIMELIMIT"
#define CCSID_GUESS_BUF_SIZE_DEFAULT "__CCSIDGUESSBUFSIZE"
#define UNTAGGED_READ_MODE_DEFAULT "__UNTAGGED_READ_MODE"
#define UNTAGGED_READ_MODE_CCSID1047_DEFAULT "__UNTAGGED_READ_MODE_CCSID1047"
#define MEMORY_USAGE_LOG_FILE_ENVAR_DEFAULT "__MEMORY_USAGE_LOG_FILE"
#define MEMORY_USAGE_LOG_LEVEL_ENVAR_DEFAULT "__MEMORY_USAGE_LOG_LEVEL"
 
typedef enum {
  __NO_TAG_READ_DEFAULT = 0,
  __NO_TAG_READ_DEFAULT_WITHWARNING = 1,
  __NO_TAG_READ_V6 = 2,
  __NO_TAG_READ_STRICT = 3
} notagread_t;
 
struct timespec;
 
extern const char *__zoslib_version;
 
typedef struct __stack_info {
  void *prev_dsa;
  void *entry_point;
  char entry_name[256];
  int *return_addr;
  int *entry_addr;
  int *stack_addr;
} __stack_info;
 
#ifdef __cplusplus
#include <bitset>
extern "C" {
#endif
 
__Z_EXPORT char **__get_environ_np(void);
 
__Z_EXPORT void __xfer_env(void);
 
__Z_EXPORT void __cleanupipc(int others);
 
__Z_EXPORT const char *getIFAUsageErrorString(unsigned long rc);
 
__Z_EXPORT unsigned long long __registerProduct(const char *major_version,
                                                const char *product_owner,
                                                const char *feature_name,
                                                const char *product_name,
                                                const char *pid);
 
__Z_EXPORT int gettid();
 
__Z_EXPORT int __getMainThreadId();
 
__Z_EXPORT pthread_t __getMainThreadSelf();
 
__Z_EXPORT void __display_backtrace(int fd);
 
__Z_EXPORT void __set_backtrace_on_abort(bool flag);
 
__Z_EXPORT int backtrace(void **buffer, int size);
 
__Z_EXPORT char **backtrace_symbols(void *const *buffer, int size);
 
__Z_EXPORT void backtrace_symbols_fd(void *const *buffer, int size, int fd);
 
__Z_EXPORT void __abend(int comp_code, unsigned reason_code, int flat_byte,
                        void *plist);
 
__Z_EXPORT int strncasecmp_ignorecp(const char *a, const char *b, size_t n);
 
__Z_EXPORT int strcasecmp_ignorecp(const char *a, const char *b);
 
__Z_EXPORT int __getargcv(int *argc, char ***argv, pid_t pid);
 
__Z_EXPORT int __getexepath(char *path, int pathlen, pid_t pid);
 
__Z_EXPORT char **__getargv(void);
 
__Z_EXPORT int __getargc(void);
 
__Z_EXPORT int *__get_stack_start();
 
__Z_EXPORT void *__iterate_stack_and_get(void *dsaptr, __stack_info *si);
 
__Z_EXPORT void *__dlcb_next(void *last);
 
__Z_EXPORT int __dlcb_entry_name(char *buf, int size, void *dlcb);
 
__Z_EXPORT void *__dlcb_entry_addr(void *dlcb);
 
__Z_EXPORT int __dlcb_iterate(int (*cb)(char* name, void* addr, void* data),
                              void *data);
 
__Z_EXPORT unsigned long __mach_absolute_time(void);
 
__Z_EXPORT void *__zalloc(size_t len, size_t alignment);
 
__Z_EXPORT void *anon_mmap(void *_, size_t len);
 
__Z_EXPORT void *__zalloc_for_fd(size_t len, const char *filename, int fd,
                                 off_t offset);
 
__Z_EXPORT void *roanon_mmap(void *_, size_t len, int prot, int flags,
                  const char *filename, int fd, off_t offset);
__Z_EXPORT int __zfree(void *addr, int len);
 
__Z_EXPORT int anon_munmap(void *addr, size_t len);
 
int __check_le_func(void *addr, char *funcname, size_t len);
 
__Z_EXPORT int __cond_timed_wait(unsigned int secs, unsigned int nsecs,
                      unsigned int event_list, unsigned int *secs_rem,
                      unsigned int *nsecs_rem);
 
enum COND_TIME_WAIT_CONSTANTS { CW_INTRPT = 1, CW_CONDVAR = 32 };
 
__Z_EXPORT int __getentropy(void *buffer, size_t length);
 
__Z_EXPORT char* __get_le_version(void);
 
__Z_EXPORT void __build_version(void);
 
__Z_EXPORT void __tcp_clear_to_close(int socket, unsigned int secs);
 
__Z_EXPORT int get_ipcs_overview(IPCQPROC *info);
 
__Z_EXPORT int __print_zoslib_help(FILE *fp, const char *title);
 
typedef struct __cpu_relax_workarea {
  void *sfaddr;
  unsigned long t0;
} __crwa_t;
 
__Z_EXPORT void __cpu_relax(__crwa_t *);
 
__Z_EXPORT int __testread(const void *location);
__Z_EXPORT void __tb(void);
 
__Z_EXPORT notagread_t __get_no_tag_read_behaviour();
__Z_EXPORT int __get_no_tag_ignore_ccsid1047();
 
#ifdef __cplusplus
typedef struct __Z_EXPORT zoslib_config {
  const char *IPC_CLEANUP_ENVAR = IPC_CLEANUP_ENVAR_DEFAULT;
  const char *RUNTIME_LIMIT_ENVAR = RUNTIME_LIMIT_ENVAR_DEFAULT;
  const char *CCSID_GUESS_BUF_SIZE_ENVAR = CCSID_GUESS_BUF_SIZE_DEFAULT;
  const char *UNTAGGED_READ_MODE_ENVAR = UNTAGGED_READ_MODE_DEFAULT;
  const char *UNTAGGED_READ_MODE_CCSID1047_ENVAR =
      UNTAGGED_READ_MODE_CCSID1047_DEFAULT;
  const char *MEMORY_USAGE_LOG_FILE_ENVAR = MEMORY_USAGE_LOG_FILE_ENVAR_DEFAULT;
  const char *MEMORY_USAGE_LOG_LEVEL_ENVAR =
              MEMORY_USAGE_LOG_LEVEL_ENVAR_DEFAULT;
} zoslib_config_t;
 
__Z_EXPORT void init_zoslib(const zoslib_config_t config = {});
 
#else
typedef struct __Z_EXPORT zoslib_config {
  const char *IPC_CLEANUP_ENVAR;
  const char *RUNTIME_LIMIT_ENVAR;
  const char *CCSID_GUESS_BUF_SIZE_ENVAR;
  const char *UNTAGGED_READ_MODE_ENVAR;
  const char *UNTAGGED_READ_MODE_CCSID1047_ENVAR;
  const char *MEMORY_USAGE_LOG_FILE_ENVAR;
  const char *MEMORY_USAGE_LOG_LEVEL_ENVAR;
} zoslib_config_t;
 
__Z_EXPORT void init_zoslib(const zoslib_config_t config);
 
#endif // __cplusplus
 
__Z_EXPORT void init_zoslib_config(zoslib_config_t *const config);
 
__Z_EXPORT int __update_envar_settings(const char *envar);
 
unsigned long __get_libvec_base(void);
 
__Z_EXPORT int __update_envar_names(zoslib_config_t *const config);
 
__Z_EXPORT bool __doLogMemoryUsage();
 
__Z_EXPORT char *__getMemoryUsageLogFile();
 
__Z_EXPORT bool __doLogMemoryAll();
 
__Z_EXPORT bool __doLogMemoryWarning();
 
__Z_EXPORT void __mainTerminating();
 
#ifdef __cplusplus
}
#endif
 
#ifdef __cplusplus
__Z_EXPORT void init_zoslib_config(zoslib_config_t &config);
 
#include <exception>
#include <map>
#include <string>
#include <unordered_map>
 
inline bool operator==(const pthread_t &_a, const pthread_t &_b) {
  return _a.__ == _b.__;
}
inline bool operator!=(const pthread_t &_a, const pthread_t &_b) {
  return _a.__ != _b.__;
}
inline bool operator<=(const pthread_t &_a, const pthread_t &_b) {
  return _a.__ <= _b.__;
}
inline bool operator>=(const pthread_t &_a, const pthread_t &_b) {
  return _a.__ >= _b.__;
}
inline bool operator<(const pthread_t &_a, const pthread_t &_b) {
  return _a.__ < _b.__;
}
inline bool operator>(const pthread_t &_a, const pthread_t &_b) {
  return _a.__ > _b.__;
}
inline bool operator==(const pthread_t &_a, const int _b) {
  return _a.__ == static_cast<unsigned long long>(_b);
}
inline bool operator!=(const pthread_t &_a, const int _b) {
  return _a.__ != static_cast<unsigned long long>(_b);
}
 
struct zoslibEnvar {
  std::string envarName;
  std::string envarValue;
 
  zoslibEnvar(std::string name, std::string value)
      : envarName(name), envarValue(value) {}
 
  bool operator<(const zoslibEnvar &t) const {
    return std::tie(envarName, envarValue) <
           std::tie(t.envarName, t.envarValue);
  }
};
 
class __zinit {
  int mode;
  int cvstate;
  std::terminate_handler _th;
 
public:
  zoslib_config_t config;
  std::map<zoslibEnvar, std::string> envarHelpMap;
 
public:
  __zinit();
  ~__zinit();
 
  int initialize(const zoslib_config_t &config);
  bool isValidZOSLIBEnvar(std::string envar);
  int setEnvarHelpMap(void);
  void populateLEFunctionPointers(void);
 
  void __abort() { _th(); }
 
private:
  void del_instance();
};
 
struct __Z_EXPORT __init_zoslib {
  __init_zoslib(const zoslib_config_t &config = {});
};
 
template <std::size_t N> __Z_EXPORT std::bitset<N>
                                    __subtractOne(std::bitset<N> bs) {
  // Flip bits from rightmost bit till and including the first 1:
  for (int i=0; i<bs.size(); i++) {
    if (bs[i]) {
      bs[i] = 0b0;
      break;
    } else {
      bs[i] = 0b1;
    }
  }
  return bs;
}
 
template <std::size_t N> __Z_EXPORT std::bitset<N>
                                    __addOne(std::bitset<N> bs) {
  // Flip bits from rightmost bit till and including the first 0:
  for (int i=0; i<bs.size(); i++) {
    if (!bs[i]) {
      bs[i] = 0b1;
      break;
    } else {
      bs[i] = 0b0;
    }
  }
  return bs;
}
 
__zinit* __get_instance();
 
#endif // __cplusplus
#endif // ZOS_BASE_H_