tdebase/kcontrol/info/info_aix.cpp

/* 
 * info_aix.cpp
 *
 * Reza Arbab <arbab@austin.ibm.com>
 *
 * GetInfo_Partitions() and its helpers (get_fs_usage, fs_adjust_blocks)
 * taken from info_hpux.cpp.  
 *
 */

#include <cf.h>
#define class _class
#include <odmi.h>
#include <sys/cfgodm.h>
#include <sys/cfgdb.h>
#undef class
#include <nl_types.h>
#include <string.h>
#include <kdebug.h>
#include <stdlib.h>

#define INFO_DEVICES_AVAILABLE
#define INFO_SCSI_AVAILABLE
#define INFO_PCI_AVAILABLE

#include <sys/statfs.h>
#include <sys/statvfs.h>
#include <sys/types.h>
#include <unistd.h>
#include <fstab.h>

#define INFO_PARTITIONS_AVAILABLE

#include <errno.h>
#include <sys/utsname.h>

#define INFO_CPU_AVAILABLE

#define INFO_IRQ_AVAILABLE
#define INFO_DMA_AVAILABLE
#define INFO_IOPORTS_AVAILABLE
#define INFO_SOUND_AVAILABLE
#define INFO_XSERVER_AVAILABLE

char *
device_description(struct CuDv *cudv)
{
  char *desc = NULL;
  struct PdDv *pddv = cudv->PdDvLn;  /* link to Predefined Devices database */
  nl_catd cat;

  cat = catopen("/usr/lib/methods/devices.cat", NL_CAT_LOCALE);
  if ((int)cat == -1)
    return NULL;

  desc = strdup( catgets(cat, pddv->setno, pddv->msgno, "N/A") );
  catclose(cat);

  return desc;
}

bool
list_devices(TQListView *lBox, char *criteria)
{
  struct CuDv *cudv;    /* Customized Devices */
  struct listinfo info;
  int i;
  char *cudv_desc;
  TQString cudv_status;
  TQListViewItem *lastitem = NULL;

  lBox->addColumn(i18n("Name"));
  lBox->addColumn(i18n("Status"));
  lBox->addColumn(i18n("Location"));
  lBox->addColumn(i18n("Description"));

  if (odm_initialize() == -1)
    {
      kdError(0) << "odm_initialize() failed: odmerrno = " << odmerrno << endl;
      return(false);         
    }

  cudv = (struct CuDv *) odm_get_list(CuDv_CLASS, criteria, &info, 100, 2);

  if ((int)cudv == -1)
    {
      odm_terminate();
      kdError(0) << "odm_get_list() failed: odmerrno = " << odmerrno << endl;
      return(false);
    }
    else if (!cudv)  /* empty list */
    {
      odm_terminate();
      return(true);
    }

  for (i=0; i<info.num; i++)
    {
      switch(cudv[i].status)
        {
          case DEFINED:    cudv_status = TQString("Defined");    break;
          case AVAILABLE:  cudv_status = TQString("Available");  break;
          case STOPPED:    cudv_status = TQString("Stopped");    break;
          default:         cudv_status = TQString("Unknown");
        }
      cudv_desc = device_description(&cudv[i]);

      lastitem = new TQListViewItem(lBox, lastitem,
                                   TQString(cudv[i].name),
                                   cudv_status,
                                   TQString(cudv[i].location),
                                   TQString(cudv_desc ? cudv_desc : "N/A") );

      if (cudv_desc) free(cudv_desc);
    }

  if (odm_free_list(cudv, &info) == -1)
    {
      odm_terminate();
      kdError(0) << "odm_free_list() failed: odmerrno = " << odmerrno << endl;
      return(false);
    }
    
  odm_terminate();
  return true;
}

enum CHIP 
{
   P2SC, Power, Power2, Power3, Power3_II, PowerPC, 
   PowerPC_604e, PowerPersonal, RD64_II, RS_III, RS64, RS64_II, 
   RS64_III, RS64_IV, RSC, ThinkPad, unknown, 
   NUM_CHIPS
};
static const char chip_name[NUM_CHIPS][16] = 
{
   "P2SC", "Power", "Power2", "Power3", "Power3-II", "PowerPC", 
   "PowerPC 604e", "PowerPersonal", "RD64-II", "RS-III", "RS64", "RS64-II",
   "RS64-III", "RS64-IV", "RSC", "ThinkPad", "unknown"
};

struct model 
{
  char model_ID[21];
  char machine_type[21];
  char processor_speed[21];
  unsigned short architecture; /* enum CHIP */
}; 

struct model _models[] = 
{
  { "02",	"7015-930",		"25",		Power		},
  { "10",	"7013-530",		"25",		Power		},
  { "10",	"7016-730",		"25",		Power		},
  { "11",	"7013-540",		"30",		Power		},
  { "14",	"7013-540",		"30",		Power		},
  { "18",	"7013-53H",		"33",		Power		},
  { "1C",	"7013-550",		"41.6",		Power		},
  { "20",	"7015-930",		"25",		Power		},
  { "2E",	"7015-950",		"41",		Power		},
  { "30",	"7013-520",		"20",		Power		},
  { "31",	"7012-320",		"20",		Power		},
  { "34",	"7013-52H",		"25",		Power		},
  { "35",	"7012-32H",		"25",		Power		},
  { "37",	"7012-340",		"33",		Power		},
  { "38",	"7012-350",		"41",		Power		},
  { "41",	"7011-20",		"33",		PowerPC		},
  { "45",	"7011-220",		"33",		PowerPC		},
  { "42",	"7006-41T/41W",		"80",		PowerPC		},
  { "43",	"7008-M20",		"33",		Power		},
  { "43",	"7008-M2A",		"33",		Power		},
  { "46",	"7011-250",		"66",		PowerPC		},
  { "47",	"7011-230",		"45",		RSC		},
  { "48",	"7009-C10",		"80",		PowerPC		},
/* 4C models use a different table -- see below */
  { "4C",	"70XX",			"(unknown)",	unknown		}, 
  { "57",	"7012-390",		"67",		Power2		},
  { "57",	"7030-3BT",		"67",		Power2		},
  { "57",	"9076-SP2 Thin",	"67",		Power2		},
  { "58",	"7012-380",		"59",		Power2		},
  { "58",	"7030-3AT",		"59",		Power2		},
  { "59",	"7012-39H",		"67",		Power2		},
  { "59",	"9076-SP2 Thin w/L2",	"67",		Power2		},
  { "5C",	"7013-560",		"50",		Power		},
  { "63",	"7015-970",		"50",		Power		},
  { "63",	"7015-97B",		"50",		Power		},
  { "64",	"7015-980",		"62.5",		Power		},
  { "64",	"7015-98B",		"62.5",		Power		},
  { "66",	"7013-580",		"62.5",		Power		},
  { "67",	"7013-570",		"50",		Power		},
  { "67",	"7015-R10",		"50",		Power		},
  { "70",	"7013-590",		"66",		Power2		},
  { "70",	"9076-SP2 Wide",	"66",		Power2		},
  { "71",	"7013-58H",		"55",		Power2		},
  { "72",	"7013-59H",		"66",		Power2		},
  { "72",	"7015-R20",		"66",		Power2		},
  { "72",	"9076-SP2 Wide",	"66",		Power2		},
  { "75",	"7012-370",		"62",		Power		},
  { "75",	"7012-375",		"62",		Power		},
  { "75",	"9076-SP1 Thin",	"62",		Power		},
  { "76",	"7012-360",		"50",		Power		},
  { "76",	"7012-365",		"50",		Power		},
  { "77",	"7012-350",		"41",		Power		},
  { "77",	"7012-355",		"41",		Power		},
  { "77",	"7013-55L",		"41.6",		Power		},
  { "79",	"7013-591",		"77",		Power2		},
  { "79",	"9076-SP2 Wide",	"77",		Power2		},
  { "80",	"7015-990",		"71.5",		Power2		},
  { "81",	"7015-R24",		"71.5",		P2SC		},
  { "89",	"7013-595",		"135",		P2SC		},
  { "89",	"9076-SP2 Wide",	"135",		P2SC		},
  { "90",	"7009-C20",		"120",		PowerPC		},
  { "91",	"7006-42W/42T",		"120",		PowerPC		},
  { "94",	"7012-397",		"160",		P2SC		},
  { "94",	"9076-SP2 Thin",	"160",		P2SC		},
  { "A0",	"7013-J30",		"75",		PowerPC		},
  { "A1",	"7013-J40",		"112",		PowerPC		},
  { "A3",	"7015-R30",		"(unknown)",	PowerPC		},
  { "A4",	"7015-R40",		"(unknown)",	PowerPC		},
  { "A4",	"7015-R50",		"(unknown)",	PowerPC		},
  { "A4",	"9076-SP2 High",	"(unknown)",	PowerPC		},
  { "A6",	"7012-G30",		"(unknown)",	PowerPC		},
  { "A7",	"7012-G40",		"(unknown)",	PowerPC		},
  { "C0",	"7024-E20",		"(unknown)",	PowerPC		},
  { "C0",	"7024-E30",		"(unknown)",	PowerPC		},
  { "C4",	"7025-F30",		"(unknown)",	PowerPC		},
  { "F0",	"7007-N40",		"50",		ThinkPad	},
  { "",		"",			"0",		0		}
};

struct model _4C_models[] = 
{
  { "IBM,7017-S70",	"7017-S70",	"125",		RS64		},
  { "IBM,7017-S7A",	"7017-S7A",	"262",		RD64_II		},
  { "IBM,7017-S80",	"7017-S80",	"450",		RS_III		},
  { "IBM,7017-S85",	"pSeries 680",	"600",		RS64_IV		},
  { "IBM,7025-F40",	"7025-F40",	"166/233",	PowerPC_604e	},
  { "IBM,7025-F50",	"7025-F50",	"(unknown)",	PowerPC_604e	},
  { "IBM,7025-F80",	"7025-F80",	"(unknown)",	RS64_III	},
  { "IBM,7026-H10",	"7025-H10",	"166/233",	PowerPC_604e	},
  { "IBM,7026-H50",	"7025-H50",	"(unknown)",	PowerPC_604e	},
  { "IBM,7026-H80",	"7025-H80",	"(unknown)",	RS64_III	},
  { "IBM,7026-M80",	"7026-M80",	"500",		RS64_III	},
  { "IBM,7025-F40",	"7025-F40",	"166/233",	PowerPC		},
  { "IBM,7025-F50",	"7025-F50",	"(unknown)",	PowerPC		},
  { "IBM,7025-F80",	"7025-F80",	"450",		PowerPC		},
  { "IBM,7026-B80",	"pSeries 640",	"375",		Power3_II	},
  { "IBM,7026-H10",	"7026-H10",	"166/233",	PowerPC		},
  { "IBM,7026-H50",	"7026-H50",	"(unknown)",	PowerPC		},
  { "IBM,7026-H70",	"7026-H70",	"340",		RS64_II		},
  { "IBM,7026-H80",	"7026-H80",	"450",		PowerPC		},
  { "IBM,7026-M80",	"7026-M80",	"500",		PowerPC		},
  { "IBM,7042-140",	"7043-140",	"166/200/233/332",	PowerPC	},
  { "IBM,7042-150",	"7043-150",	"375",		PowerPC		},
  { "IBM,7042-240",	"7043-240",	"166/233",	PowerPC		},
  { "IBM,7043-140",	"7043-140",	"166/200/233/332",	PowerPC	},
  { "IBM,7043-150",	"7043-150",	"375",		PowerPC		},
  { "IBM,7043-240",	"7043-240",	"166/233",	PowerPC		},
  { "IBM,7043-260",	"7043-260",	"200",		Power3		},
  { "IBM,7248",		"7248-100",	"100",		PowerPersonal	},
  { "IBM,7248",		"7248-120",	"120",		PowerPersonal	},
  { "IBM,7248",		"7248-132",	"132",		PowerPersonal	},
  { "IBM,9076-270",	"9076-SP Silver Node",	"(unknown)",	PowerPC		},
  { "",			"",		"",		0		},
};


/*  all GetInfo_ functions should return TRUE, when the Information 
    was filled into the lBox-Widget.
    returning false indicates, that information was not available.
*/

bool 
GetInfo_XServer_and_Video( TQListView *lBox )
{
	return GetInfo_XServer_Generic( lBox );
}

/* 
 * Written using information from:
 *
 * http://service.software.ibm.com/cgi-bin/support/rs6000.support/techbrowse/tbgaus?gaus_mode=8&documents=B93576892313352&database=task
 *
 * Not fully implemented.  In particular there are ways to resolve the 
 * "(unknown)" clock speeds of many of these models.  See page for details.
 * 
 */
bool 
GetInfo_CPU( TQListView *lBox )
{
  struct utsname info;
  struct model *table = _models;  /* table of model information */
  char model_ID[21] = "";  /* information for table lookup */
  char cpu_ID[7] = "";    /* unique CPU ID */
  int i;
  TQListViewItem *lastitem = NULL;

  lBox->addColumn(i18n("Information"));
  lBox->addColumn(i18n("Value"));

  if (uname(&info) == -1)
    {
      kdError(0) << "uname() failed: errno = " << errno << endl;
      return false;
    }

  strncat(model_ID, info.machine+8, 2);  /* we want the ninth and tenth digits */
  strncat(cpu_ID, info.machine+2, 6);

  if (strcmp(model_ID, "4C") == 0)  /* need to use a different model_ID and model table */
    {
      if (odm_initialize() == -1)
        kdError(0) << "odm_initialize() failed: odmerrno = " << odmerrno << endl;
      else 
        {
          struct CuAt cuat;  /* Customized Device attribute */

          /* equivalent to uname -M */
          if ( odm_get_first(CuAt_CLASS, (char *)"name='sys0' and attribute='modelname'", &cuat) )
            {
              strcpy(model_ID, cuat.value);
              table = _4C_models;
            }

          odm_terminate();
        }
    }

  lastitem = new TQListViewItem(lBox, lastitem, TQString("CPU ID"), TQString(cpu_ID));
  lastitem = new TQListViewItem(lBox, lastitem, TQString("Node"), TQString(info.nodename));
  lastitem = new TQListViewItem(lBox, lastitem, TQString("OS"), TQString(info.sysname) + 
             TQString(" ") + TQString(info.version) + TQString(".") + TQString(info.release));

  for (i=0; *(table[i].model_ID); i++)
    if (strcmp(model_ID, table[i].model_ID) == 0)
      {
        lastitem = new TQListViewItem(lBox, lastitem, TQString("Machine Type"), TQString(table[i].machine_type));
        lastitem = new TQListViewItem(lBox, lastitem, TQString("Architecture"), TQString(chip_name[table[i].architecture]));
        lastitem = new TQListViewItem(lBox, lastitem, TQString("Speed"), TQString(table[i].processor_speed) + TQString(" Mhz"));
        break;
      }
         
  return(true);
}

bool GetInfo_IRQ( TQListView * )
{
	return false;
}

bool GetInfo_DMA( TQListView * )
{
	return false;
}

bool 
GetInfo_PCI( TQListView *lBox )
{
  return list_devices(lBox, (char *)"PdDvLn like '*/pci/*'");
}

bool GetInfo_IO_Ports( TQListView * )
{
	return false;
}

bool GetInfo_Sound( TQListView * )
{
	return false;
}

bool 
GetInfo_Devices( TQListView *lBox )
{
  return list_devices(lBox, (char *)"PdDvLn like '*'");
}

bool 
GetInfo_SCSI( TQListView *lBox )
{
  return list_devices(lBox, (char *)"PdDvLn like '*/scsi/*'");
}

/* Parts taken from fsusage.c from the Midnight Commander (mc)

   Copyright (C) 1991, 1992 Free Software Foundation, In

   Return the number of TOSIZE-byte blocks used by
   BLOCKS FROMSIZE-byte blocks, rounding away from zero.
   TOSIZE must be positive.  Return -1 if FROMSIZE is not positive.  */

static long fs_adjust_blocks(long blocks, int fromsize, int tosize)
{
    if (tosize <= 0)
	abort ();
    if (fromsize <= 0)
	return -1;

    if (fromsize == tosize)	/* E.g., from 512 to 512.  */
	return blocks;
    else if (fromsize > tosize)	/* E.g., from 2048 to 512.  */
	return blocks * (fromsize / tosize);
    else			/* E.g., from 256 to 512.  */
	return (blocks + (blocks < 0 ? -1 : 1)) / (tosize / fromsize);
}

/* Fill in the fields of FSP with information about space usage for
   the filesystem on which PATH resides.
   Return 0 if successful, -1 if not. */

#define CONVERT_BLOCKS(b) fs_adjust_blocks ((b), fsd.f_bsize, 512)

static int get_fs_usage (char *path, long *l_total, long *l_avail)
{   struct statfs fsd;    /* 4.3BSD, SunOS 4, HP-UX, AIX.  */
    unsigned long fsu_blocks,fsu_bfree,fsu_bavail;

   *l_total = *l_avail = 0;
    if (statfs (path, &fsd) < 0)
	return -1;

    fsu_blocks = CONVERT_BLOCKS (fsd.f_blocks);
    fsu_bfree = CONVERT_BLOCKS (fsd.f_bfree);
    fsu_bavail = CONVERT_BLOCKS (fsd.f_bavail);

    *l_avail = getuid () ? fsu_bavail/2 : fsu_bfree/2;
    *l_total = fsu_blocks/2;

    return 0;
}


// Some Ideas taken from garbazo from his source in info_fbsd.cpp

bool 
GetInfo_Partitions ( TQListView *lbox )
{
	#define NUMCOLS 5
	TQString Title[NUMCOLS];
	int n;
	
	struct fstab *fstab_ent;
	struct statvfs svfs;
	long total,avail;
	TQString str;
	TQString MB(i18n("MB")+ "  ");	// International Text for MB=Mega-Byte

	if (setfsent() != 1) // Try to open fstab 
	    return false;

	Title[0] = i18n("Device");
	Title[1] = i18n("Mount Point");
	Title[2] = i18n("FS Type");
	Title[3] = i18n("Total Size");
	Title[4] = i18n("Free Size");

	for (n=0; n<NUMCOLS; ++n) {
        lbox->addColumn(Title[n] );
	}

	while ((fstab_ent=getfsent())!=NULL) {
		/* fstab_ent->fs_type holds only "rw","xx","ro"... */
		memset(&svfs,0,sizeof(svfs)); 
		statvfs(fstab_ent->fs_file,&svfs);
		get_fs_usage(fstab_ent->fs_file, &total, &avail);
		
		if (!strcmp(fstab_ent->fs_type,FSTAB_XX))  // valid drive ?
			svfs.f_basetype[0] = 0;

        if(svfs.f_basetype[0]) {
            new TQListViewItem(lbox, TQString(fstab_ent->fs_spec),
                              TQString(fstab_ent->fs_file) + TQString("  "),
                              (svfs.f_basetype[0] ? TQString(svfs.f_basetype) : i18n("n/a")),
                              Value((total+512)/1024,6) + MB,
                              Value((avail+512)/1024,6) + MB);
        }
        else {
            new TQListViewItem(lbox, TQString(fstab_ent->fs_spec),
                              TQString(fstab_ent->fs_file) + TQString("  "),
                              (svfs.f_basetype[0] ? TQString(svfs.f_basetype) : i18n("n/a")));
        }

	}
	endfsent(); 
	    
	return true;
}