operatingsystem_vms.cpp

来自「Pegasus is an open-source implementation」· C++ 代码 · 共 2,080 行 · 第 1/4 页

  itmlst3[1].pbuffer = NULL;
  itmlst3[1].pretlen = NULL;

  status = sys$getsyiw(0, 0, 0, itmlst3, 0, 0, 0);

  // Pagesize in KB
  pagesize = pagesize/1024;

  struct k1_arglist
  {				// kernel call arguments

    long lCount;		// number of arguments

    long *pFreeMem;
  }
  getfreememkargs =
  {
    1
  };				// init 1 argument

  getfreememkargs.pFreeMem = &lFreeMem;

  status = sys$cmkrnl(GetFreeMem, &getfreememkargs);
  if ($VMS_STATUS_SUCCESS(status))
  {
    total = lFreeMem;
    total = total * pagesize;
    return true;
  }
  else
  {
    return false;
  }
}

//
// ================================================================================
// NAME              : getTotalVisibleMemorySize
// DESCRIPTION       : Number of Kbytes of physical memory.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

// Added calculation of pagesize using sys$getsyi() -PTR 73-51-22
Boolean OperatingSystem::getTotalVisibleMemorySize(Uint64 & memory)
{
  long status,
    physmem;
  __int64 membytes;
  int pagesize;
  typedef struct
  {
    unsigned short wlength;
    unsigned short wcode;
    void *pbuffer;
    void *pretlen;
  }
  item_list;

  item_list itmlst3[3];

  itmlst3[0].wlength = 4;
  itmlst3[0].wcode = SYI$_MEMSIZE;
  itmlst3[0].pbuffer = &physmem;
  itmlst3[0].pretlen = NULL;
  itmlst3[1].wlength = 4;
  itmlst3[1].wcode = SYI$_PAGE_SIZE;
  itmlst3[1].pbuffer = &pagesize;
  itmlst3[1].pretlen = NULL;
  itmlst3[2].wlength = 0;
  itmlst3[2].wcode = 0;
  itmlst3[2].pbuffer = NULL;
  itmlst3[2].pretlen = NULL;


  status = sys$getsyiw(0, 0, 0, itmlst3, 0, 0, 0);
  
  // Pagesize in KB
  pagesize = pagesize/1024;

  if ($VMS_STATUS_SUCCESS(status))
  {
    membytes = physmem;
    memory = membytes * pagesize;
    return true;
  }
  else
  {
    return false;
  }
}

//
// ================================================================================
// NAME              : getSizeStoredInPagingFiles
// DESCRIPTION       : Number of Kbytes that can be stored in the OS's paging
//                      files.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

// Added calculation of pagesize using sys$getsyi() -PTR 73-51-22
Boolean OperatingSystem::getSizeStoredInPagingFiles(Uint64 & total)
{
  int status,
    pagesize;
 
  int pgsize;
  typedef struct
  {
    unsigned short wlength;
    unsigned short wcode;
    void *pbuffer;
    void *pretlen;
  }
  item_list;

  item_list itmlst3[3];

  itmlst3[0].wlength = 4;
  itmlst3[0].wcode = SYI$_PAGEFILE_PAGE;
  itmlst3[0].pbuffer = &pagesize;
  itmlst3[0].pretlen = NULL;
  itmlst3[1].wlength = 4;
  itmlst3[1].wcode = SYI$_PAGE_SIZE;
  itmlst3[1].pbuffer = &pgsize;
  itmlst3[1].pretlen = NULL;
  itmlst3[2].wlength = 0;
  itmlst3[2].wcode = 0;
  itmlst3[2].pbuffer = NULL;
  itmlst3[2].pretlen = NULL;

  status = sys$getsyiw(0, 0, 0, itmlst3, 0, 0, 0);
  
  // Pagesize in KB
  pgsize = pgsize/1024;

  if ($VMS_STATUS_SUCCESS(status))
  {
    total = pagesize * pgsize;
    return true;
  }
  else
  {
    return false;
  }
}

//
// ================================================================================
// NAME              : getFreeSpaceInPagingFiles
// DESCRIPTION       : Number of Kbytes that can be mapped into the OS's paging
//                      files without causing other pages to be swapped out.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

// Added calculation of pagesize using sys$getsyi() -PTR 73-51-22
Boolean OperatingSystem::getFreeSpaceInPagingFiles(Uint64 & freeSpaceInPagingFiles)
{
  int status,
    pagefree;                                   
  int pagesize;

  typedef struct
  {
    unsigned short wlength;
    unsigned short wcode;
    void *pbuffer;
    void *pretlen;
  }
  item_list;

  item_list itmlst3[3];

  itmlst3[0].wlength = 4;
  itmlst3[0].wcode = SYI$_PAGEFILE_FREE;
  itmlst3[0].pbuffer = &pagefree;
  itmlst3[0].pretlen = NULL;
  itmlst3[1].wlength = 4;
  itmlst3[1].wcode = SYI$_PAGE_SIZE;
  itmlst3[1].pbuffer = &pagesize;
  itmlst3[1].pretlen = NULL;
  itmlst3[2].wlength = 0;
  itmlst3[2].wcode = 0;
  itmlst3[2].pbuffer = NULL;
  itmlst3[2].pretlen = NULL;

  status = sys$getsyiw(0, 0, 0, itmlst3, 0, 0, 0);
  
  // Pagesize in KB
  pagesize = pagesize/1024;

  if ($VMS_STATUS_SUCCESS(status))
  {
    freeSpaceInPagingFiles = pagefree * pagesize;
    return true;
  }
  else
  {
    return false;
  }
}

//
// ================================================================================
// NAME              : getMaxProcessMemorySize
// DESCRIPTION       : Maximum amount of Kbytes of memory that can be allocated to
//                      this process.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

Boolean OperatingSystem::getMaxProcessMemorySize(Uint64 & maxProcessMemorySize)
{
  int status;
  __int64 maxprocmem;
  typedef struct
  {
    unsigned short wlength;
    unsigned short wcode;
    void *pbuffer;
    void *pretlen;
  }
  item_list;

  item_list itmlst3[2];

  itmlst3[0].wlength = sizeof (maxprocmem);
  itmlst3[0].wcode = SYI$_WSMAX;
  itmlst3[0].pbuffer = &maxprocmem;
  itmlst3[0].pretlen = NULL;
  itmlst3[1].wlength = 0;
  itmlst3[1].wcode = 0;
  itmlst3[1].pbuffer = NULL;
  itmlst3[1].pretlen = NULL;

  status = sys$getsyiw(0, 0, 0, itmlst3, 0, 0, 0);
  if ($VMS_STATUS_SUCCESS(status))
  {
    maxProcessMemorySize = (maxprocmem * 512) / 1024;
    return true;
  }
  else
  {
    return false;
  }
}

//
// ================================================================================
// NAME              : getDistributed
// DESCRIPTION       : Determine whether the OS is distributed across several
//                      nodes. If the system is a cluster member, it is
//                      distributed.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

Boolean OperatingSystem::getDistributed(Boolean & distributed)
{
  int status,
    clumem;
  typedef struct
  {
    unsigned short wlength;
    unsigned short wcode;
    void *pbuffer;
    void *pretlen;
  }
  item_list;

  item_list itmlst3[2];

  itmlst3[0].wlength = 4;
  itmlst3[0].wcode = SYI$_CLUSTER_MEMBER;
  itmlst3[0].pbuffer = &clumem;
  itmlst3[0].pretlen = NULL;
  itmlst3[1].wlength = 0;
  itmlst3[1].wcode = 0;
  itmlst3[1].pbuffer = NULL;
  itmlst3[1].pretlen = NULL;

  status = sys$getsyiw(0, 0, 0, itmlst3, 0, 0, 0);
  if ($VMS_STATUS_SUCCESS(status))
  {
    distributed = clumem;
    return true;
  }
  else
  {
    return false;
  }
}

//
// ================================================================================
// NAME              : getMaxProcsPerUser
// DESCRIPTION       : Maximum number of procs this user can have.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

Boolean OperatingSystem::getMaxProcsPerUser(Uint32 & maxProcsPerUser)
{
  int status,
    maxprocount;
  typedef struct
  {
    unsigned short wlength;
    unsigned short wcode;
    void *pbuffer;
    void *pretlen;
  }
  item_list;

  item_list itmlst3[2];

  itmlst3[0].wlength = sizeof (maxprocount);
  itmlst3[0].wcode = SYI$_MAXPROCESSCNT;
  itmlst3[0].pbuffer = &maxprocount;
  itmlst3[0].pretlen = NULL;
  itmlst3[1].wlength = 0;
  itmlst3[1].wcode = 0;
  itmlst3[1].pbuffer = NULL;
  itmlst3[1].pretlen = NULL;

  status = sys$getsyiw(0, 0, 0, itmlst3, 0, 0, 0);
  if ($VMS_STATUS_SUCCESS(status))
  {
    maxProcsPerUser = maxprocount;
    return true;
  }
  else
  {
    return false;
  }
}

//
// ================================================================================
// NAME              : getSystemUpTime
// DESCRIPTION       : Elapsed time since the OS was booted, in seconds.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

Boolean OperatingSystem::getSystemUpTime(Uint64 & mUpTime)
{
  long status,
    item = SYI$_BOOTTIME,
    dst_desc[2];
  char t_string[24] = "";
  char cimtime[80] = "";
  char log_string[] = "SYS$TIMEZONE_DAYLIGHT_SAVING";
  char libdst;
  time_t tme = 0,
    tme1 = 0;
  unsigned __int64 bintime = 0;
  unsigned short int timbuf[7],
    val = 0;
  unsigned long libop,
    libdayweek,
    libdayear;
  unsigned int retlen;
  struct tm timetm;
  struct tm *ptimetm = &timetm;
  struct dsc$descriptor_s sysinfo;
  static $DESCRIPTOR(lnm_tbl, "LNM$SYSTEM");
  struct
  {
    unsigned short wLength;
    unsigned short wCode;
    void *pBuffer;
    unsigned int *pRetLen;
    int term;
  }
  item_list;

  sysinfo.dsc$b_dtype = DSC$K_DTYPE_T;
  sysinfo.dsc$b_class = DSC$K_CLASS_S;
  sysinfo.dsc$w_length = sizeof (t_string);
  sysinfo.dsc$a_pointer = t_string;

  status = lib$getsyi(&item, 0, &sysinfo, &val, 0, 0);
  if (!$VMS_STATUS_SUCCESS(status))
  {
    return false;
  }

  status = sys$bintim(&sysinfo, &bintime);
  if (!$VMS_STATUS_SUCCESS(status))
  {
    return false;
  }

  libop = LIB$K_DAY_OF_WEEK;
  status = lib$cvt_from_internal_time(&libop, &libdayweek, &bintime);
  if (!$VMS_STATUS_SUCCESS(status))
  {
    return false;
  }

  libop = LIB$K_DAY_OF_YEAR;
  status = lib$cvt_from_internal_time(&libop, &libdayear, &bintime);
  if (!$VMS_STATUS_SUCCESS(status))
  {
    return false;
  }

  dst_desc[0] = strlen(log_string);
  dst_desc[1] = (long) log_string;
  item_list.wLength = 1;
  item_list.wCode = LNM$_STRING;
  item_list.pBuffer = &libdst;
  item_list.pRetLen = &retlen;
  item_list.term = 0;

  status = sys$trnlnm(0, &lnm_tbl, &dst_desc, 0, &item_list);
  if (!$VMS_STATUS_SUCCESS(status))
  {
    return false;
  }

  status = sys$numtim(timbuf, &bintime);
  if (!$VMS_STATUS_SUCCESS(status))
  {
    return false;
  }

  timetm.tm_sec = timbuf[5];
  timetm.tm_min = timbuf[4];
  timetm.tm_hour = timbuf[3];
  timetm.tm_mday = timbuf[2];
  timetm.tm_mon = timbuf[1] - 1;
  timetm.tm_year = timbuf[0] - 1900;
  timetm.tm_wday = libdayweek - 1;
  timetm.tm_yday = libdayear - 1;
  timetm.tm_isdst = 0;
  if (libdst != 48)
  {
    timetm.tm_isdst = 1;
  }

  time(&tme);
  tme1 = mktime(ptimetm);
  mUpTime = tme - tme1;
  return true;
}

//
// ================================================================================
// NAME              : getOperatingSystemCapability
// DESCRIPTION       : The OS capability.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

Boolean OperatingSystem::getOperatingSystemCapability(String & scapability)
{
  scapability.assign("64 bit");
  return true;
}

//
// ================================================================================
// NAME              : _reboot
// DESCRIPTION       : Method to reboot the system.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

Uint32 OperatingSystem::_reboot()
{
  return false;
}

//
// ================================================================================
// NAME              : _shutdown
// DESCRIPTION       : Method to shutdown system.
// ASSUMPTIONS       : None
// PRE-CONDITIONS    :
// POST-CONDITIONS   :
// NOTES             :
// ================================================================================
//

Uint32 OperatingSystem::_shutdown()
{
  return false;
}