/* * Host Resources MIB - partition device group implementation - hr_partition.c * */ /* Portions of this file are subject to the following copyright(s). See * the Net-SNMP's COPYING file for more details and other copyrights * that may apply: */ /* * Portions of this file are copyrighted by: * Copyright (C) 2007 Apple, Inc. All rights reserved. * Use is subject to license terms specified in the COPYING file * distributed with the Net-SNMP package. */ #include #include #ifdef HAVE_STRING_H #include #else #include #endif #ifdef HAVE_UNISTD_H #include #endif #include #include "host_res.h" #include "hr_partition.h" #include "hr_filesys.h" #include "hr_disk.h" #include #define HRP_MONOTONICALLY_INCREASING /********************* * * Kernel & interface information, * and internal forward declarations * *********************/ static int HRP_savedDiskIndex; static int HRP_savedPartIndex; static char HRP_savedName[1024]; #ifdef NETSNMP_CAN_GET_DISK_LABEL static char HRP_savedLabel[1024]; #endif #ifdef darwin extern int Get_HR_Disk_Label(char *string, size_t str_len, const char *devfull); #endif static int HRP_DiskIndex; static void Save_HR_Partition(int, int); /********************* * * Initialisation & common implementation functions * *********************/ static void Init_HR_Partition(void); static int Get_Next_HR_Partition(void); #define HRPART_INDEX 1 #define HRPART_LABEL 2 #define HRPART_ID 3 #define HRPART_SIZE 4 #define HRPART_FSIDX 5 struct variable4 hrpartition_variables[] = { {HRPART_INDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, var_hrpartition, 2, {1, 1}}, {HRPART_LABEL, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, var_hrpartition, 2, {1, 2}}, {HRPART_ID, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, var_hrpartition, 2, {1, 3}}, {HRPART_SIZE, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, var_hrpartition, 2, {1, 4}}, {HRPART_FSIDX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, var_hrpartition, 2, {1, 5}} }; oid hrpartition_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 7 }; void init_hr_partition(void) { REGISTER_MIB("host/hr_partition", hrpartition_variables, variable4, hrpartition_variables_oid); } /* * header_hrpartition(... * Arguments: * vp IN - pointer to variable entry that points here * name IN/OUT - IN/name requested, OUT/name found * length IN/OUT - length of IN/OUT oid's * exact IN - TRUE if an exact match was requested * var_len OUT - length of variable or 0 if function returned * write_method * */ int header_hrpartition(struct variable *vp, oid * name, size_t * length, int exact, size_t * var_len, WriteMethod ** write_method) { #define HRPART_DISK_NAME_LENGTH 11 #define HRPART_ENTRY_NAME_LENGTH 12 oid newname[MAX_OID_LEN]; int part_idx, LowDiskIndex = -1, LowPartIndex = -1; int result; DEBUGMSGTL(("host/hr_partition", "var_hrpartition: ")); DEBUGMSGOID(("host/hr_partition", name, *length)); DEBUGMSG(("host/hr_partition", " %d\n", exact)); memcpy((char *) newname, (char *) vp->name, (int) vp->namelen * sizeof(oid)); /* * Find "next" partition entry */ Init_HR_Disk(); Init_HR_Partition(); /* * Find the "next" disk and partition entries. * If we're in the middle of the table, then there's * no point in examining earlier disks, so set the * starting disk to that of the variable being queried. * * If we've moved from one column of the table to another, * then we need to start at the beginning again. * (i.e. the 'compare' fails to match) * Similarly if we're at the start of the table * (i.e. *length is too short to be a full instance) */ if ((snmp_oid_compare(vp->name, vp->namelen, name, vp->namelen) == 0) && (*length > HRPART_DISK_NAME_LENGTH)) { LowDiskIndex = (name[HRPART_DISK_NAME_LENGTH] & ((1 << HRDEV_TYPE_SHIFT) - 1)); DEBUGMSGTL(("host/hr_partition", "... low index %d\n", LowDiskIndex)); while (HRP_DiskIndex < LowDiskIndex) { Init_HR_Partition(); /* moves to next disk */ if (HRP_DiskIndex == -1) return (MATCH_FAILED); } } for (;;) { part_idx = Get_Next_HR_Partition(); DEBUGMSGTL(("host/hr_partition", "... part index %d\n", part_idx)); if (part_idx == 0) break; newname[HRPART_DISK_NAME_LENGTH] = (HRDEV_DISK << HRDEV_TYPE_SHIFT) + HRP_DiskIndex; newname[HRPART_ENTRY_NAME_LENGTH] = part_idx; result = snmp_oid_compare(name, *length, newname, vp->namelen + 2); if (exact && (result == 0)) { Save_HR_Partition(HRP_DiskIndex, part_idx); LowDiskIndex = HRP_DiskIndex; LowPartIndex = part_idx; break; } if (!exact && (result < 0)) { if (LowPartIndex == -1) { Save_HR_Partition(HRP_DiskIndex, part_idx); LowDiskIndex = HRP_DiskIndex; LowPartIndex = part_idx; } else if (LowDiskIndex < HRP_DiskIndex) break; else if (part_idx < LowPartIndex) { Save_HR_Partition(HRP_DiskIndex, part_idx); LowDiskIndex = HRP_DiskIndex; LowPartIndex = part_idx; } #ifdef HRP_MONOTONICALLY_INCREASING break; #endif } } if (LowPartIndex == -1) { DEBUGMSGTL(("host/hr_partition", "... index out of range\n")); return (MATCH_FAILED); } newname[HRPART_DISK_NAME_LENGTH] = (HRDEV_DISK << HRDEV_TYPE_SHIFT) + LowDiskIndex; newname[HRPART_ENTRY_NAME_LENGTH] = LowPartIndex; memcpy((char *) name, (char *) newname, ((int) vp->namelen + 2) * sizeof(oid)); *length = vp->namelen + 2; *write_method = (WriteMethod*)0; *var_len = sizeof(long); /* default to 'long' results */ DEBUGMSGTL(("host/hr_partition", "... get partition stats ")); DEBUGMSGOID(("host/hr_partition", name, *length)); DEBUGMSG(("host/hr_partition", "\n")); return LowPartIndex; } /********************* * * System specific implementation functions * *********************/ u_char * var_hrpartition(struct variable * vp, oid * name, size_t * length, int exact, size_t * var_len, WriteMethod ** write_method) { int part_idx; static char string[1024]; struct stat stat_buf; part_idx = header_hrpartition(vp, name, length, exact, var_len, write_method); if (part_idx == MATCH_FAILED) return NULL; if (stat(HRP_savedName, &stat_buf) == -1) return NULL; switch (vp->magic) { case HRPART_INDEX: long_return = part_idx; return (u_char *) & long_return; case HRPART_LABEL: #ifdef NETSNMP_CAN_GET_DISK_LABEL *var_len = strlen(HRP_savedLabel); return (u_char *) HRP_savedLabel; #else *var_len = strlen(HRP_savedName); return (u_char *) HRP_savedName; #endif case HRPART_ID: /* Use the device number */ sprintf(string, "0x%x", (int) stat_buf.st_rdev); *var_len = strlen(string); return (u_char *) string; case HRPART_SIZE: /* * XXX - based on single partition assumption */ long_return = Get_FSSize(HRP_savedName); return (u_char *) & long_return; case HRPART_FSIDX: long_return = Get_FSIndex(HRP_savedName); return (u_char *) & long_return; default: DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrpartition\n", vp->magic)); } return NULL; } /********************* * * Internal implementation functions * *********************/ static int HRP_index; static void Init_HR_Partition(void) { DEBUGMSGTL(("host/hr_partition", "Init_HR_Partition\n")); HRP_DiskIndex = Get_Next_HR_Disk(); if (HRP_DiskIndex != -1) HRP_DiskIndex &= ((1 << HRDEV_TYPE_SHIFT) - 1); DEBUGMSGTL(("host/hr_partition", "... %d\n",HRP_DiskIndex)); HRP_index = -1; } static int Get_Next_HR_Partition(void) { char string[1024]; int fd; DEBUGMSGTL(("host/hr_partition", "Get_Next_HR_Partition %d\n",HRP_DiskIndex)); if (HRP_DiskIndex == -1) { return 0; } HRP_index++; while (Get_Next_HR_Disk_Partition(string, sizeof(string), HRP_index) != -1) { DEBUGMSGTL(("host/hr_partition", "Get_Next_HR_Partition: %s (:%d)\n", string, HRP_index)); #ifdef O_NDELAY fd = open(string, O_RDONLY|O_NDELAY); #else fd = open(string, O_RDONLY); #endif if (fd != -1) { close(fd); return HRP_index + 1; } else if (errno == EBUSY) { return HRP_index + 1; } HRP_index++; } /* * Finished with this disk, try the next */ Init_HR_Partition(); return (Get_Next_HR_Partition()); } static void Save_HR_Partition(int disk_idx, int part_idx) { HRP_savedDiskIndex = disk_idx; HRP_savedPartIndex = part_idx; (void) Get_Next_HR_Disk_Partition(HRP_savedName, sizeof(HRP_savedName), HRP_index); #ifdef NETSNMP_CAN_GET_DISK_LABEL (void) Get_HR_Disk_Label(HRP_savedLabel, sizeof(HRP_savedLabel), HRP_savedName); #endif }