source: trunk/third/sysinfo/os-aix.c @ 12269

/*
 * Copyright (c) 1992-1998 Michael A. Cooper.
 * This software may be freely used and distributed provided it is not
 * sold for profit or used in part or in whole for commercial gain
 * without prior written agreement, and the author is credited
 * appropriately.
 */

#ifndef lint
static char *RCSid = "$Revision: 1.1.1.3 $";
#endif

/*
 * AIX specific functions
 */

#include "defs.h"
#include <nl_types.h>
#include <locale.h>

/*
 * Platform Specific Interfaces
 */
extern char                            *GetKernArchCfg();
PSI_t GetKernArchPSI[] = {              /* Get Kernel Architecture */
    { GetKernArchCfg },
    { GetKernArchSysinfo },
    { GetKernArchDef },
    { GetAppArch },
    { NULL },
};
PSI_t GetAppArchPSI[] = {               /* Get Application Architecture */
    { GetAppArchSysinfo },
    { GetAppArchDef },
    { NULL },
};
PSI_t GetCpuTypePSI[] = {               /* Get CPU Type */
    { GetCpuTypeSysinfo },
    { GetCpuTypeDef },
    { NULL },
};
PSI_t GetNumCpuPSI[] = {                /* Get Number of CPU's */
    { GetNumCpuSysconf },
    { NULL },
};
PSI_t GetKernVerPSI[] = {               /* Get Kernel Version */
    { NULL },
};
PSI_t GetOSNamePSI[] = {                /* Get OS Name */
    { GetOSNameSysinfo },
    { GetOSNameUname },
    { NULL },
};
PSI_t GetOSDistPSI[] = {                /* Get OS Release */
    { NULL },
};
extern char                    *GetOSVerFiles();
PSI_t GetOSVerPSI[] = {                 /* Get OS Version */
    { GetOSVerFiles },
    { GetOSVerSysinfo },
    { GetOSVerUname },
    { NULL },
};
char                           *GetModelODM();
PSI_t GetModelPSI[] = {                 /* Get system Model */
    { GetModelFile },
    { GetModelODM },
    { NULL },
};
PSI_t GetSerialPSI[] = {                /* Get Serial Number */
    { NULL },
};
PSI_t GetRomVerPSI[] = {                /* Get ROM Version */
    { NULL },
};
PSI_t GetManShortPSI[] = {              /* Get Short Man Name */
    { GetManShortSysinfo },
    { GetManShortDef },
    { NULL },
};
PSI_t GetManLongPSI[] = {               /* Get Long Man Name */
    { GetManLongSysinfo },
    { GetManLongDef },
    { NULL },
};
extern char                    *GetMemoryODM();
PSI_t GetMemoryPSI[] = {                /* Get amount of memory */
    { GetMemoryODM },
    { NULL },
};
extern char                    *GetVirtMemODM();
PSI_t GetVirtMemPSI[] = {               /* Get amount of virtual memory */
    { GetVirtMemODM },
    { NULL },
};
PSI_t GetBootTimePSI[] = {              /* Get System Boot Time */
    { GetBootTimeUtmp },
    { NULL },
};

/*
 * Get ODM Error string.
 */
static char *odmerror()
{
    static char odmerrstr[256];

    if (odm_err_msg(odmerrno, (char **) &odmerrstr))
        (void) snprintf(odmerrstr, sizeof(odmerrstr),
                        "unknown ODM error %d", odmerrno);

    return(odmerrstr);
}

/*
 * Get the value of attribute 'Attr' with name 'Name' 
 * from the Custom Attribute ODM.
 */
static char *GetAttrVal(Name, Attr)
    char                       *Name;
    char                       *Attr;
{
    static struct CuAt          CuAt;
    static char                 Query[128];
    char                       *errstr = NULL;
    int                         ret;

    if (odm_initialize() == -1) {
        SImsg(SIM_GERR, "ODM initialize failed: %s", odmerror());
        return((char *) NULL);
    }

    (void) snprintf(Query, sizeof(Query), "attribute = '%s' and name = '%s'", 
                    Attr, Name);

    ret = (int) odm_get_obj(CuAt_CLASS, Query, &CuAt, ODM_FIRST);
    if (ret == -1)
        errstr = odmerror();
    else if (ret == 0)
        errstr = "No entry found";

    if (errstr) {
        SImsg(SIM_GERR, "ODM get \"%s\" from \"%s\" failed: %s",
                         Query, CuAt_CLASS[0].classname, errstr);
        return((char *) NULL);
    }

    return((CuAt.value[0]) ? CuAt.value : (char *) NULL);
}

/*
 * Get the PvDv ODM entry with the criteria 'Criteria'.
 */
static struct PdDv *GetPdDv(Criteria)
    char                       *Criteria;
{
    static struct PdDv          PdDv;
    char                       *errstr = NULL;
    int                         ret;

    if (odm_initialize() == -1) {
        SImsg(SIM_GERR, "ODM initialize failed: %s", odmerror());
        return((struct PdDv *) NULL);
    }

    ret = (int) odm_get_obj(PdDv_CLASS, Criteria, &PdDv, ODM_FIRST);
    if (ret == -1)
        errstr = odmerror();
    else if (ret == 0)
        errstr = "No entry found";

    if (errstr) {
        SImsg(SIM_GERR, "ODM get \"%s\" from \"%s\" failed: %s",
                         Criteria, PdDv_CLASS[0].classname, errstr);
        return((struct PdDv *) NULL);
    }

    return(&PdDv);
}

/* 
 * Clean up a VPD string.  Remove initial non alpha-numeric characters
 * as well as any trailing white space.
 */
static char *CleanVPD(string)
    char                       *string;
{
    register char              *cp, *end;

    while (string && *string && !isalnum(*string))
        ++string;

    cp = end = &string[strlen(string) - 1];

    while (cp && *cp && isspace(*cp))
        --cp;

    if (cp != end)
        *(cp+1) = CNULL;

    return(string);
}

/*
 * Find the VPD info entry for "String".  Return a vpdinfo_t
 * entry for the matching entry and set it's "value" correctly.
 */
static VPDinfo_t *GetVPDinfo(String)
    char                       *String;
{
    static char                 Buff[BUFSIZ];
    static char                 Code[3];
    static VPDinfo_t            VPDinfo;

    (void) strncpy(Code, String, 2);    /* XXX Assume codes are only 2 bytes */
    Code[2] = CNULL;

    VPDinfo.Code = Code;
    /*
     * The "value" portion of "String" starts after the "code" portion.
     * CleanVPD() is harmful, so we need to pass it a private copy.
     */
    (void) snprintf(Buff, sizeof(Buff), "%s", String + strlen(VPDinfo.Code));
    VPDinfo.Value = CleanVPD(Buff);

    return(&VPDinfo);
}

/*
 * Given a VPD string "vpdstr", decode it into a list of strings.
 */
static int DecodeVPD(DevInfo, VPDstr)
    DevInfo_t                  *DevInfo;
    char                       *VPDstr;
{
    char                       *myVPDstr;
    register char              *cp;
    Define_t                   *Def;
    VPDinfo_t                  *VPDinfo;

    if (!VPDstr)
        return(-1);

    /* strtok() is destructive */
    myVPDstr = strdup(VPDstr);

    /*
     * Each field in "VPDstr" is seperated by a "*", followed by
     * the code for the field and it's value.  Looks something like:
     *
     *          *TM 19445*MF IBM
     */
    for (cp = strtok(myVPDstr, "*"); cp; cp = strtok((char *)NULL, "*")) {
        if (!(VPDinfo = GetVPDinfo(cp)))
            continue;

        if (EQ(VPDinfo->Code, "MF"))
            DevInfo->Vendor = strdup(VPDinfo->Value);
        else if (EQ(VPDinfo->Code, "TM"))
            DevInfo->Model = strdup(VPDinfo->Value);
        else if (EQ(VPDinfo->Code, "DS"))
            DevInfo->ModelDesc = strdup(VPDinfo->Value);
        else if (EQ(VPDinfo->Code, "SN"))
            DevInfo->Serial = strdup(VPDinfo->Value);
        else {
            if (Def = DefGet(DL_VPD, VPDinfo->Code, -1, 0))
                AddDevDesc(DevInfo, VPDinfo->Value, Def->ValStr1, DA_APPEND);
            else
                SImsg(SIM_UNKN, "Unknown VPD code=`%s' value=`%s'.", 
                      VPDinfo->Code, VPDinfo->Value);
        }
    }

    if (myVPDstr)
        (void) free(myVPDstr);

    return(0);
}

/*
 * Get and decode the Vital Product Data informatin for device "Name".
 */
static int GetVPD(DevInfo)
    DevInfo_t                  *DevInfo;
{
    static struct CuVPD         cuvpd;
    static char                 Query[128];
    int                         ret;

    if (odm_initialize() == -1) {
        SImsg(SIM_GERR, "ODM initialize failed: %s", odmerror());
        return(-1);
    }

    (void) snprintf(Query, sizeof(Query),  "name=%s", DevInfo->Name);
    ret = (int) odm_get_obj(CuVPD_CLASS, Query, &cuvpd, ODM_FIRST);
    if (ret == -1) {
        SImsg(SIM_GERR, "ODM get VPD object for \"%s\" failed: %s", 
                  DevInfo->Name, odmerror());
        return(-1);
    } else if (ret == 0) {
        return(-1);
    }

    SImsg(SIM_DBG, "VPD: name = '%s' type = %d VPD = '%s'", 
               cuvpd.name, cuvpd.vpd_type, cuvpd.vpd);

    return(DecodeVPD(DevInfo, cuvpd.vpd));
}

/*
 * Get the system model name.
 */
extern char *GetModelODM()
{
    Define_t                   *Model;
    register char              *val, *cp;
    register int                i, SysType;

    if ((val = GetAttrVal(NN_SYS0, AT_MODELCODE)) == NULL) {
        SImsg(SIM_GERR, "Cannot get \"%s\" for \"%s\" from ODM.",
                         AT_MODELCODE, NN_SYS0);
        return((char *) NULL);
    }

    SysType = (int) strtol(val, NULL, 0);

    SImsg(SIM_DBG, "System type = 0x%x (%s)", SysType, val);

    Model = DefGet(DL_SYSMODEL, NULL, (long) SysType, 0);
    if (Model && Model->ValStr1)
        return(Model->ValStr1);

    SImsg(SIM_UNKN, "system model/type 0x%x is unknown.", SysType);

    return((char *) NULL);
}

/*
 * Use the kernels _system_configuration structure to determine
 * our kernel architecture.
 * 
 * XXX This isn't working right now
 */
#include <sys/systemcfg.h>
static char                     SysCfgSYM[] = "_system_configuration";
extern char *GetKernArchCfg()
{
#ifdef notdef /* XXX */
    struct nlist               *NLPtr;
    kvm_t                      *kd;
    Define_t                   *Define;

    /*
     * Get _system_configuration
     */
    if (!(kd = KVMopen()))
        return((char *) NULL);
    if ((NLPtr = KVMnlist(kd, SysCfgSYM, (struct nlist *)NULL, 0)) == NULL)
        return((char *) NULL);
    if (CheckNlist(NLPtr))
        return((char *) NULL);
    if (KVMget(kd, NLPtr->n_value, (char *) &_system_configuration, 
               sizeof(_system_configuration), KDT_DATA)) {
        SImsg(SIM_GERR, "Cannot read `%s' from kernel.", SysCfgSYM);
        return((char *) NULL);
    }
    KVMclose(kd);

    Define = DefGet(DL_CPU, NULL, _system_configuration.implementation, 0);
    if (Define && Define->ValStr1)
        return(Define->ValStr1);
#endif  /* notdef */
    return((char *) NULL);
}

/*
 * Get amount of physical memory from the ODM CuAt data.
 */
extern char *GetMemoryODM()
{
    register char              *val;
    Large_t                     amtval;
    static char                 Buff[64];

    if ((val = GetAttrVal(NN_SYS0, AT_REALMEM)) == NULL) {
        SImsg(SIM_GERR, "Cannot get \"%s\" for \"%s\" from ODM.",
              AT_REALMEM, NN_SYS0);
        return((char *) NULL);
    }

    amtval = (Large_t) strtol(val, NULL, 0);
    (void) snprintf(Buff, sizeof(Buff), "%d MB", 
                    DivRndUp(amtval, (Large_t)KBYTES));

    return(Buff);
}

/*
 * Get version of OS
 *
 * The following is based on what the /bin/oslevel script does.
 * There are several files that contain the full OS version/revision
 * level.  The first line of these files contains the version number.
 * The line either looks like '3.2.5' or '3250'.
 */
static char *OSVfiles[] = {
    OSV_OPP, OSV_MAINT, (char *)0
};

extern char *GetOSVerFiles()
{
    register char              *Ptr;
    register char              *Ptr2;
    register char             **PtrPtr;
    FILE                       *FilePtr;
    static char                 Buff[100];
    static char                 Version[100];
    int                         Len;

    Version[0] = CNULL;
    for (PtrPtr = OSVfiles; PtrPtr && *PtrPtr; ++PtrPtr) {
        FilePtr = fopen(*PtrPtr, "r");
        if (!FilePtr) {
            SImsg(SIM_GERR, "Open %s failed: %s.", *PtrPtr, SYSERR);
            continue;
        }
        if (fgets(Buff, sizeof(Buff), FilePtr) && isdigit(Buff[0])) {
            Len = strlen(Buff);
            if (Buff[Len-1] == '\n')
                Buff[Len-1] = CNULL;
            if (strchr(Buff, '.'))
                (void) strcpy(Version, Buff);
            else
                for (Ptr = Buff, Ptr2 = Version; Ptr && *Ptr; ++Ptr, ++Ptr2) {
                    /* If the line ends in 0, don't add it */
                    if (!(*Ptr == '0' && *(Ptr+1) == CNULL))
                        *Ptr2 = *Ptr;
                    if (*(Ptr + 1))
                        *++Ptr2 = '.';
                }
            /* Zap trailing '.' if present */
            Len = strlen(Version);
            if (Version[Len-1] == '.')
                Version[Len-1] = CNULL;
        }
        (void) fclose(FilePtr);
        if (Version[0])
            return(Version);
    }

    return((char *) NULL);
}

/*
 * Take a device name, remove and then return the unit number.
 * e.g. Take "hdisk0", remove "0", and then return 0.
 */
static int GetUnit(Name)
    char                       *Name;
{
    int                         unit;
    register char              *cp;

    for (cp = Name; cp && *cp; ++cp)
        if (isdigit(*cp)) {
            unit = (int) atoi(cp);
            *cp = CNULL;
            return(unit);
        }

    return(-1);
}

/*
 * Get the location information from CuDvPtr.
 */
static char *GetLocation(CuDvPtr)
    struct CuDv                *CuDvPtr;
{
    if (CuDvPtr->location[0])
        return(CuDvPtr->location);

    return((char *) NULL);
}

/*
 * Get Class information.
 */
static char *GetClassInfo(CuDvPtr)
    struct CuDv                *CuDvPtr;
{
    if (CuDvPtr->PdDvLn_Lvalue[0])
        return(CuDvPtr->PdDvLn_Lvalue);

    return((char *) NULL);
}

/*
 * Set the description informatin for DevInfo.
 */
static void SetDescript(DevInfo, CuDvPtr)
    DevInfo_t                  *DevInfo;
    struct CuDv                *CuDvPtr;
{
    AddDevDesc(DevInfo, GetLocation(CuDvPtr), "Location", DA_APPEND);
    AddDevDesc(DevInfo, GetClassInfo(CuDvPtr), "Class/SubClass/Type", 
               DA_APPEND);
    GetVPD(DevInfo);
}

/*
 * Special routine to get memory information.
 */
extern DevInfo_t *ProbeMemory(ProbeData, CuDvPtr, PdDvPtr)
     ProbeData_t               *ProbeData;
     struct CuDv               *CuDvPtr;
     struct PdDv               *PdDvPtr;
{
    DevInfo_t                  *DevInfo;
    char                       *cp;
    char                        Buff[64];
    char                       *Name;
    DevData_t                  *DevData;

    if (!ProbeData)
        return((DevInfo_t *) NULL);
    Name = ProbeData->DevName;
    DevData = ProbeData->DevData;
    
    if ((cp = GetAttrVal(Name, AT_SIZE)) == NULL)
        return((DevInfo_t *) NULL);

    DevInfo = NewDevInfo((DevInfo_t *) NULL);

    (void) snprintf(Buff, sizeof(Buff),  "%s MB Memory Card", cp);
    DevInfo->Model = strdup(Buff);

    DevInfo->Name = Name;
    DevInfo->Unit = DevData->DevUnit;
    DevInfo->Master = MkMasterFromDevData(DevData);
    DevInfo->Type = DT_MEMORY;
    SetDescript(DevInfo, CuDvPtr);

    return(DevInfo);
}

/*
 * Get description information
 */
static char *GetDescript(CuDvPtr, PdDvPtr)
    struct CuDv                *CuDvPtr;
    struct PdDv                *PdDvPtr;
{
    static char                 Buff[BUFSIZ];
    static char                 lastcat[BUFSIZ];
    static nl_catd              catd;
    char                       *msg = NULL;
    char                       *cp;

    if (!PdDvPtr->catalog[0])
        return((char *) NULL);

    /* 
     * Reuse open catalog if it's the same as the last time 
     */
    if ((int) catd <= 0 || !lastcat[0] || strcmp(PdDvPtr->catalog, lastcat)) {
        if ((int) catd > 0)
            (void) catclose(catd);

        if ((int) catd == 0) {
            /*
             * First time stuff.
             */

            if (putenv(ENV_NLSPATH) != 0)
                SImsg(SIM_GERR, "Cannot set environment $NLSPATH.");

            /*
             * If our LANG is "C", then set to our default in order to
             * avoid a bug in AIX that fails to find any catalogs in 
             * this case.
             */
            cp = (char *) getenv("LANG");
            if (!cp || (cp && EQ(cp, "C"))) {
                (void) snprintf(Buff, sizeof(Buff),  "LANG=%s", DEFAULT_LANG);
                if (putenv(strdup(Buff)) != 0)
                    SImsg(SIM_GERR, "Cannot set environment %s.", Buff);
                Buff[0] = CNULL;
            }
            (void) setlocale(LC_ALL, "");
        }

        catd = catopen(PdDvPtr->catalog, 0);
        if ((int) catd <= 0)
            SImsg(SIM_GERR, "Catalog open of \"%s\" failed: %s.",
                             PdDvPtr->catalog, SYSERR);
    }

    /*
     * Retrieve the message from the catalog
     */
    if ((int) catd > 0) {
        msg = catgets(catd, PdDvPtr->setno, PdDvPtr->msgno, Buff);
        /* Save catalog name */
        (void) strcpy(lastcat, PdDvPtr->catalog);
    }

    return((msg && *msg) ? msg : (char *) NULL);
}

/*
 * General routine to get device information from ODM.
 */
extern DevInfo_t *ProbeODM(DevData, TreePtr, CuDvPtr)
    /*ARGSUSED*/
    DevData_t                  *DevData;
    DevInfo_t                 **TreePtr;
    struct CuDv                *CuDvPtr;
{
    DevDefine_t                *DevDefine;
    DevInfo_t                  *DevInfo;
    DevInfo_t                  *Master;
    char                       *MasterName;
    char                       *DevName;
    char                       *desc;
    char                       *cp;
    static char                 Query[128];
    struct PdDv                *PdDvPtr;
    static ProbeData_t          ProbeData;
    static DevFind_t            Find;

    DevName = MkDevName(DevData->DevName, DevData->DevUnit, 0, 0);
    (void) memset(&Find, 0, sizeof(Find));
    Find.Tree = *TreePtr;
    Find.NodeName = DevName;
    DevInfo = DevFind(&Find);

    if (CuDvPtr->PdDvLn_Lvalue[0]) {
        (void) snprintf(Query, sizeof(Query), "uniquetype='%s'", 
                        CuDvPtr->PdDvLn_Lvalue);
        PdDvPtr = GetPdDv(Query);
    } else {
        SImsg(SIM_GERR, "No PdDv link value for '%s'.", DevName);
        return((DevInfo_t *) NULL);
    }

    /*
     * If we can't get the description for this device, then
     * use the device specific probe routine if one is defined.
     */
    if ((desc = GetDescript(CuDvPtr, PdDvPtr)) == (char *) NULL) {
        if ((DevDefine = DevDefGet(DL_VPD, DevData->DevName, 0)) && 
            DevDefine->Probe) {
            (void) memset(&ProbeData, CNULL, sizeof(ProbeData));
            ProbeData.DevName = DevName;
            ProbeData.DevData = DevData;
            ProbeData.DevDefine = DevDefine;
            return((*DevDefine->Probe)(&ProbeData, CuDvPtr, PdDvPtr));
        } else {
            if (Debug) 
                SImsg(SIM_GERR, "No description found for '%s'.", DevName);
            return((DevInfo_t *) NULL);
        }
    }

    if (!DevInfo)
        DevInfo = NewDevInfo((DevInfo_t *) NULL);

    DevInfo->Name = DevName;
    DevInfo->Unit = DevData->DevUnit;
    DevInfo->Type = DT_GENERIC;
    DevInfo->ModelDesc = strdup(desc);
    SetDescript(DevInfo, CuDvPtr);
    if (!DevInfo->MasterName)
        DevInfo->MasterName = MkMasterName(DevData);
    if (!DevInfo->Master) {
        (void) memset(&Find, 0, sizeof(Find));
        Find.Tree = *TreePtr;
        Find.NodeName = DevInfo->MasterName;
        if (Master = DevFind(&Find))
            DevInfo->Master = Master;
        else {
            DevInfo->Master = MkMasterFromDevData(DevData);
            if (DevInfo->Master)
                DevInfo->MasterName = DevInfo->Master->Name;
        }
    }

    return(DevInfo);
}

/*
 * Build device tree by looking at the Object Database Manager (ODM)
 */
static int BuildODM(TreePtr, Names)
    DevInfo_t                 **TreePtr;
    char                      **Names;
{
    static struct CuDv          CuDv;
    extern struct Class         CuDv_CLASS[];
    static DevData_t            DevData;
    DevInfo_t                  *DevInfo;
    int                         op, ret;

    if (odm_initialize() == -1) {
        SImsg(SIM_GERR, "ODM initialize failed: %s", odmerror());
        return(-1);
    }

    for (op = ODM_FIRST; ; op = ODM_NEXT) {
        /*
         * Retrieve the object from ODM.
         */
        ret = (int) odm_get_obj(CuDv_CLASS, (char *)NULL, &CuDv, op);
        if (ret == -1) {
            SImsg(SIM_GERR, "ODM get object \"%s\" failed: %s", 
                             CuDv_CLASS[0].classname, odmerror());
            return(-1);
        } else if (ret == 0)
            /*
             * We're done
             */
            break;

        if (CuDv.status != AVAILABLE) {
            SImsg(SIM_GERR, "Device \"%s\" is not available.", CuDv.name);
            continue;
        }

        /*
         * This should never happen
         */
        if (CuDv.name[0] == CNULL)
            continue;

        /* Make sure devdata is clean */
        bzero(&DevData, sizeof(DevData_t));

        /* Set what we know */
        DevData.DevName = strdup(CuDv.name);
        DevData.DevUnit = GetUnit(DevData.DevName);
        if (CuDv.parent[0]) {
            DevData.CtlrName = strdup(CuDv.parent);
            DevData.CtlrUnit = GetUnit(DevData.CtlrName);
        }
        DevData.Flags |= DD_IS_ALIVE;

        SImsg(SIM_DBG, "ODM: Found '%s' parent '%s' location '%s' uniq = '%s'",
              CuDv.name, CuDv.parent, CuDv.location, CuDv.PdDvLn_Lvalue);

        /* Probe and add device */
        if (DevInfo = ProbeODM(&DevData, TreePtr, &CuDv))
            AddDevice(DevInfo, TreePtr, Names);
    }

    if (odm_terminate() != 0)
        SImsg(SIM_WARN, "ODM Terminate did not succeed.");

    return(0);
}

/*
 * Build device tree using TreePtr.
 * Calls bus and method specific functions to
 * search for devices.
 */
extern int BuildDevices(TreePtr, Names)
    DevInfo_t                  **TreePtr;
    char                       **Names;
{
    int                          Found = 1;

    if (BuildODM(TreePtr, Names) == 0)
        Found = 0;

    return(Found);
}

#include <sys/vminfo.h>

static char                     QueryStr[] = 
    "value = 'paging' and attribute = 'type'";

extern char *GetVirtMemODM()
{
    struct CuAt                *CuAtPtr;
    struct objlistinfo          ObjListInfo;
    register int                i;
    static char                 DevName[MAXPATHLEN];
    static struct pginfo        pginfo;
    Large_t                     Amount = 0;
    static char                 Buff[100];

    odm_initialize();
    odm_set_path(_PATH_ODM);

    CuAtPtr = get_CuAt_list(CuAt_CLASS, QueryStr, &ObjListInfo, 20, 1);
    if ((int)CuAtPtr == -1) {
        SImsg(SIM_GERR, "get_CuAt_list paging info failed: %s.", SYSERR);
        odm_terminate();
        return((char *)NULL);
    }

    for (i = 0; i < ObjListInfo.num; ++i, ++CuAtPtr) {
        (void) snprintf(DevName, sizeof(DevName),  "/dev/%s", CuAtPtr->name);

        if (swapqry(DevName, &pginfo) == -1) {
            SImsg(SIM_GERR, "swapqry %s failed: %s.", DevName, SYSERR);
            continue;
        }

        Amount += (Large_t) ( (pginfo.size * getpagesize() ) / KBYTES );
    }

    odm_terminate();
    (void) snprintf(Buff, sizeof(Buff), "%d MB", 
                    DivRndUp(Amount, (Large_t)KBYTES));

    return(Buff);
}

/*
 * Initialize the OS specific parts of the Device Types table
 */
void DevTypesInit()
{
    register int                i;

    for (i = 0; DevTypes[i].Name; ++i)
        switch (DevTypes[i].Type) {
        case DT_MEMORY:         DevTypes[i].Probe = ProbeMemory;        break;
        }
}