int sigar_file_system_list_get(sigar_t *sigar,
sigar_file_system_list_t *fslist)
{
struct mnttab ent;
sigar_file_system_t *fsp;
FILE *fp = fopen(MNTTAB, "r");
if (!fp) {
return errno;
}
sigar_file_system_list_create(fslist);
while (getmntent(fp, &ent) == 0) {
if (strstr(ent.mnt_mntopts, "ignore")) {
continue; /* e.g. vold */
}
SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
fsp = &fslist->data[fslist->number++];
SIGAR_SSTRCPY(fsp->dir_name, ent.mnt_mountp);
SIGAR_SSTRCPY(fsp->dev_name, ent.mnt_special);
SIGAR_SSTRCPY(fsp->sys_type_name, ent.mnt_fstype);
SIGAR_SSTRCPY(fsp->options, ent.mnt_mntopts);
sigar_fs_type_init(fsp);
}
fclose(fp);
return SIGAR_OK;
}
int sigar_cpu_info_list_get(sigar_t *sigar,
sigar_cpu_info_list_t *cpu_infos)
{
sigar_cpu_info_t *info;
sigar_cpu_info_list_create(cpu_infos);
info = &cpu_infos->data[cpu_infos->number++];
SIGAR_SSTRCPY(info->vendor, "vendor");
SIGAR_SSTRCPY(info->model, "model");
info->mhz = -1;
info->cache_size = -1;
return SIGAR_OK;
}
int sigar_os_sys_info_get(sigar_t *sigar,
sigar_sys_info_t *sysinfo)
{
char *vendor_version, *arch;
long cpu = sysconf(_SC_CPU_VERSION);
switch (cpu) {
case CPU_PA_RISC1_0:
arch = "PA_RISC1.0";
break;
case CPU_PA_RISC1_1:
arch = "PA_RISC1.1";
break;
case CPU_PA_RISC2_0:
arch = "PA_RISC2.0";
break;
#ifdef CPU_IA64_ARCHREV_0
case CPU_IA64_ARCHREV_0:
arch = "ia64";
break;
#endif
default:
arch = "unknown";
break;
}
SIGAR_SSTRCPY(sysinfo->arch, arch);
SIGAR_SSTRCPY(sysinfo->name, "HPUX");
SIGAR_SSTRCPY(sysinfo->vendor, "Hewlett-Packard");
if (strstr(sysinfo->version, ".11.")) {
vendor_version = "11";
}
else {
vendor_version = sysinfo->version;
}
SIGAR_SSTRCPY(sysinfo->vendor_version, vendor_version);
snprintf(sysinfo->description,
sizeof(sysinfo->description),
"%s %s",
sysinfo->vendor_name, sysinfo->vendor_version);
return SIGAR_OK;
}
int sigar_cpu_info_list_get(sigar_t *sigar,
sigar_cpu_info_list_t *cpu_infos)
{
int i;
struct pst_dynamic stats;
pstat_getdynamic(&stats, sizeof(stats), 1, 0);
sigar->ncpu = stats.psd_proc_cnt;
sigar_cpu_info_list_create(cpu_infos);
for (i=0; i<sigar->ncpu; i++) {
sigar_cpu_info_t *info;
struct pst_processor proc;
if (pstat_getprocessor(&proc, sizeof(proc), 1, i) < 0) {
perror("pstat_getprocessor");
continue;
}
SIGAR_CPU_INFO_LIST_GROW(cpu_infos);
info = &cpu_infos->data[cpu_infos->number++];
info->total_cores = sigar->ncpu;
info->cores_per_socket = 1; /*XXX*/
info->total_sockets = sigar->ncpu; /*XXX*/
#ifdef __ia64__
SIGAR_SSTRCPY(info->vendor, "Intel"); /*XXX*/
SIGAR_SSTRCPY(info->model, "Itanium"); /*XXX*/
#else
SIGAR_SSTRCPY(info->vendor, "HP"); /*XXX*/
SIGAR_SSTRCPY(info->model, "PA RISC"); /*XXX*/
#endif
info->mhz = sigar->ticks * proc.psp_iticksperclktick / 1000000;
info->cache_size = SIGAR_FIELD_NOTIMPL; /*XXX*/
}
return SIGAR_OK;
}
int sigar_file_system_list_get(sigar_t *sigar,
sigar_file_system_list_t *fslist)
{
struct mntent *ent;
FILE *fp;
sigar_file_system_t *fsp;
if (!(fp = setmntent(MNT_CHECKLIST, "r"))) {
return errno;
}
sigar_file_system_list_create(fslist);
while ((ent = getmntent(fp))) {
if ((*(ent->mnt_type) == 's') &&
strEQ(ent->mnt_type, "swap"))
{
/*
* in this case, devname == "...", for
* which statfs chokes on. so skip it.
* also notice hpux df command has no swap info.
*/
continue;
}
SIGAR_FILE_SYSTEM_LIST_GROW(fslist);
fsp = &fslist->data[fslist->number++];
SIGAR_SSTRCPY(fsp->dir_name, ent->mnt_dir);
SIGAR_SSTRCPY(fsp->dev_name, ent->mnt_fsname);
SIGAR_SSTRCPY(fsp->sys_type_name, ent->mnt_type);
SIGAR_SSTRCPY(fsp->options, ent->mnt_opts);
sigar_fs_type_init(fsp);
}
endmntent(fp);
return SIGAR_OK;
}
int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_state_t *procstate)
{
SIGAR_SSTRCPY(procstate->name, "java");
procstate->ppid = -1;
procstate->priority = -1;
procstate->nice = -1;
procstate->tty = -1;
procstate->state = 'R';
procstate->threads = -1;
procstate->processor = -1;
return SIGAR_OK;
}
int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_state_t *procstate)
{
int status = sigar_pstat_getproc(sigar, pid);
struct pst_status *pinfo = sigar->pinfo;
if (status != SIGAR_OK) {
return status;
}
SIGAR_SSTRCPY(procstate->name, pinfo->pst_ucomm);
procstate->ppid = pinfo->pst_ppid;
procstate->tty = makedev(pinfo->pst_term.psd_major,
pinfo->pst_term.psd_minor);
procstate->priority = pinfo->pst_pri;
procstate->nice = pinfo->pst_nice;
procstate->threads = pinfo->pst_nlwps;
procstate->processor = pinfo->pst_procnum;
/* cast to prevent compiler warning: */
/* Case label too big for the type of the switch expression */
switch ((int32_t)pinfo->pst_stat) {
case PS_SLEEP:
procstate->state = 'S';
break;
case PS_RUN:
procstate->state = 'R';
break;
case PS_STOP:
procstate->state = 'T';
break;
case PS_ZOMBIE:
procstate->state = 'Z';
break;
case PS_IDLE:
procstate->state = 'D';
break;
}
return SIGAR_OK;
}
static void hwaddr_libdlpi_lookup(sigar_t *sigar, sigar_net_interface_config_t *ifconfig)
{
dlpi_handle_t handle;
dlpi_info_t linkinfo;
uchar_t addr[DLPI_PHYSADDR_MAX];
uint_t alen = sizeof(addr);
if (dlpi_open(ifconfig->name, &handle, 0) != DLPI_SUCCESS) {
return;
}
if (dlpi_get_physaddr(handle, DL_CURR_PHYS_ADDR, addr, &alen) == DLPI_SUCCESS &&
dlpi_info(handle, &linkinfo, 0) == DLPI_SUCCESS) {
if (alen < sizeof(ifconfig->hwaddr.addr.mac)) {
sigar_net_address_mac_set(ifconfig->hwaddr, addr, alen);
SIGAR_SSTRCPY(ifconfig->type, dlpi_mactype(linkinfo.di_mactype));
}
}
dlpi_close(handle);
}
int sigar_proc_state_get(sigar_t *sigar, sigar_pid_t pid,
sigar_proc_state_t *procstate)
{
int status = sigar_proc_psinfo_get(sigar, pid);
psinfo_t *pinfo = sigar->pinfo;
if (status != SIGAR_OK) {
return status;
}
SIGAR_SSTRCPY(procstate->name, pinfo->pr_fname);
procstate->ppid = pinfo->pr_ppid;
procstate->tty = pinfo->pr_ttydev;
procstate->priority = pinfo->pr_lwp.pr_pri;
procstate->nice = pinfo->pr_lwp.pr_nice - NZERO;
procstate->threads = pinfo->pr_nlwp;
procstate->processor = pinfo->pr_lwp.pr_onpro;
switch (pinfo->pr_lwp.pr_state) {
case SONPROC:
case SRUN:
procstate->state = 'R';
break;
case SZOMB:
procstate->state = 'Z';
break;
case SSLEEP:
procstate->state = 'S';
break;
case SSTOP:
procstate->state = 'T';
break;
case SIDL:
procstate->state = 'D';
break;
}
return SIGAR_OK;
}
int sigar_net_interface_ipv6_config_get(sigar_t *sigar, const char *name,
sigar_net_interface_config_t *ifconfig)
{
int sock;
struct lifreq lifr;
if ((sock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
return errno;
}
SIGAR_SSTRCPY(lifr.lifr_name, name);
if (ioctl(sock, SIOCGLIFADDR, &lifr) == 0) {
struct in6_addr *addr = SIGAR_SIN6_ADDR(&lifr.lifr_addr);
sigar_net_address6_set(ifconfig->address6, addr);
sigar_net_interface_scope6_set(ifconfig, addr);
ifconfig->prefix6_length = lifr.lifr_addrlen;
}
close(sock);
return SIGAR_OK;
}
void sigar_strerror_set(sigar_t *sigar, char *msg)
{
SIGAR_SSTRCPY(sigar->errbuf, msg);
}
int sigar_net_interface_config_get(sigar_t *sigar, const char *name,
sigar_net_interface_config_t *ifconfig)
{
int sock;
struct ifreq ifr;
if (!name) {
return sigar_net_interface_config_primary_get(sigar, ifconfig);
}
SIGAR_ZERO(ifconfig);
if ((sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
return errno;
}
SIGAR_SSTRCPY(ifconfig->name, name);
SIGAR_SSTRCPY(ifr.ifr_name, name);
#define ifr_s_addr(ifr) \
((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr
if (!ioctl(sock, SIOCGIFADDR, &ifr)) {
sigar_net_address_set(ifconfig->address,
ifr_s_addr(ifr));
}
if (!ioctl(sock, SIOCGIFNETMASK, &ifr)) {
sigar_net_address_set(ifconfig->netmask,
ifr_s_addr(ifr));
}
if (!ioctl(sock, SIOCGIFFLAGS, &ifr)) {
sigar_uint64_t flags = ifr.ifr_flags;
#ifdef __linux__
# ifndef IFF_DYNAMIC
# define IFF_DYNAMIC 0x8000 /* not in 2.2 kernel */
# endif /* IFF_DYNAMIC */
int is_mcast = flags & IFF_MULTICAST;
int is_slave = flags & IFF_SLAVE;
int is_master = flags & IFF_MASTER;
int is_dynamic = flags & IFF_DYNAMIC;
/*
* XXX: should just define SIGAR_IFF_*
* and test IFF_* bits on given platform.
* this is the only diff between solaris/hpux/linux
* for the flags we care about.
*
*/
flags &= ~(IFF_MULTICAST|IFF_SLAVE|IFF_MASTER);
if (is_mcast) {
flags |= SIGAR_IFF_MULTICAST;
}
if (is_slave) {
flags |= SIGAR_IFF_SLAVE;
}
if (is_master) {
flags |= SIGAR_IFF_MASTER;
}
if (is_dynamic) {
flags |= SIGAR_IFF_DYNAMIC;
}
#endif
ifconfig->flags = flags;
}
else {
/* should always be able to get flags for existing device */
/* other ioctls may fail if device is not enabled: ok */
close(sock);
return errno;
}
if (ifconfig->flags & IFF_LOOPBACK) {
sigar_net_address_set(ifconfig->destination,
ifconfig->address.addr.in);
sigar_net_address_set(ifconfig->broadcast, 0);
sigar_hwaddr_set_null(ifconfig);
SIGAR_SSTRCPY(ifconfig->type,
SIGAR_NIC_LOOPBACK);
}
else {
if (!ioctl(sock, SIOCGIFDSTADDR, &ifr)) {
sigar_net_address_set(ifconfig->destination,
ifr_s_addr(ifr));
}
if (!ioctl(sock, SIOCGIFBRDADDR, &ifr)) {
sigar_net_address_set(ifconfig->broadcast,
ifr_s_addr(ifr));
}
#if defined(HAVE_LIBDLPI_H)
hwaddr_libdlpi_lookup(sigar, ifconfig);
#elif defined(SIOCGIFHWADDR)
if (!ioctl(sock, SIOCGIFHWADDR, &ifr)) {
get_interface_type(ifconfig,
ifr.ifr_hwaddr.sa_family);
sigar_net_address_mac_set(ifconfig->hwaddr,
ifr.ifr_hwaddr.sa_data,
IFHWADDRLEN);
}
#elif defined(_AIX) || defined(__osf__)
hwaddr_aix_lookup(sigar, ifconfig);
SIGAR_SSTRCPY(ifconfig->type,
SIGAR_NIC_ETHERNET);
#else
hwaddr_arp_lookup(ifconfig, sock);
SIGAR_SSTRCPY(ifconfig->type,
SIGAR_NIC_ETHERNET);
#endif
}
#if defined(SIOCGLIFMTU) && !defined(__hpux)
{
struct lifreq lifr;
SIGAR_SSTRCPY(lifr.lifr_name, name);
if(!ioctl(sock, SIOCGLIFMTU, &lifr)) {
ifconfig->mtu = lifr.lifr_mtu;
}
}
#elif defined(SIOCGIFMTU)
if (!ioctl(sock, SIOCGIFMTU, &ifr)) {
# if defined(__hpux)
ifconfig->mtu = ifr.ifr_metric;
# else
ifconfig->mtu = ifr.ifr_mtu;
#endif
}
#else
ifconfig->mtu = 0; /*XXX*/
#endif
if (!ioctl(sock, SIOCGIFMETRIC, &ifr)) {
ifconfig->metric = ifr.ifr_metric ? ifr.ifr_metric : 1;
}
#if defined(SIOCGIFTXQLEN)
if (!ioctl(sock, SIOCGIFTXQLEN, &ifr)) {
ifconfig->tx_queue_len = ifr.ifr_qlen;
}
else {
ifconfig->tx_queue_len = -1; /* net-tools behaviour */
}
#else
ifconfig->tx_queue_len = -1;
#endif
close(sock);
/* XXX can we get a better description like win32? */
SIGAR_SSTRCPY(ifconfig->description,
ifconfig->name);
sigar_net_interface_ipv6_config_init(ifconfig);
sigar_net_interface_ipv6_config_get(sigar, name, ifconfig);
return SIGAR_OK;
}
static void get_interface_type(sigar_net_interface_config_t *ifconfig,
int family)
{
char *type;
switch (family) {
case ARPHRD_SLIP:
type = SIGAR_NIC_SLIP;
break;
case ARPHRD_CSLIP:
type = SIGAR_NIC_CSLIP;
break;
case ARPHRD_SLIP6:
type = SIGAR_NIC_SLIP6;
break;
case ARPHRD_CSLIP6:
type = SIGAR_NIC_CSLIP6;
break;
case ARPHRD_ADAPT:
type = SIGAR_NIC_ADAPTIVE;
break;
case ARPHRD_ETHER:
type = SIGAR_NIC_ETHERNET;
break;
case ARPHRD_ASH:
type = SIGAR_NIC_ASH;
break;
case ARPHRD_FDDI:
type = SIGAR_NIC_FDDI;
break;
case ARPHRD_HIPPI:
type = SIGAR_NIC_HIPPI;
break;
case ARPHRD_AX25:
type = SIGAR_NIC_AX25;
break;
case ARPHRD_ROSE:
type = SIGAR_NIC_ROSE;
break;
case ARPHRD_NETROM:
type = SIGAR_NIC_NETROM;
break;
case ARPHRD_X25:
type = SIGAR_NIC_X25;
break;
case ARPHRD_TUNNEL:
type = SIGAR_NIC_TUNNEL;
break;
case ARPHRD_PPP:
type = SIGAR_NIC_PPP;
break;
case ARPHRD_CISCO:
type = SIGAR_NIC_HDLC;
break;
case ARPHRD_LAPB:
type = SIGAR_NIC_LAPB;
break;
case ARPHRD_ARCNET:
type = SIGAR_NIC_ARCNET;
break;
case ARPHRD_DLCI:
type = SIGAR_NIC_DLCI;
break;
case ARPHRD_FRAD:
type = SIGAR_NIC_FRAD;
break;
case ARPHRD_SIT:
type = SIGAR_NIC_SIT;
break;
case ARPHRD_IRDA:
type = SIGAR_NIC_IRDA;
break;
case ARPHRD_ECONET:
type = SIGAR_NIC_EC;
break;
default:
type = SIGAR_NIC_UNSPEC;
break;
}
SIGAR_SSTRCPY(ifconfig->type, type);
}
