开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
hr_disk.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：29k
源码类别：

SNMP编程

开发平台：

Unix_Linux

hr_disk.c：源码内容
  1. /*
  2.  *  Host Resources MIB - disk device group implementation - hr_disk.c
  3.  *
  4.  */
  6. #include <net-snmp/net-snmp-config.h>
  7. #include "host_res.h"
  8. #include "hr_disk.h"
  9. #if HAVE_STRING_H
  10. #include <string.h>
  11. #else
  12. #include <strings.h>
  13. #endif
  15. #include <fcntl.h>
  16. #if HAVE_UNISTD_H
  17. #include <unistd.h>
  18. #endif
  19. #if HAVE_KVM_H
  20. #include <kvm.h>
  21. #endif
  22. #if HAVE_DIRENT_H
  23. #include <dirent.h>
  24. #else
  25. # define dirent direct
  26. # if HAVE_SYS_NDIR_H
  27. #  include <sys/ndir.h>
  28. # endif
  29. # if HAVE_SYS_DIR_H
  30. #  include <sys/dir.h>
  31. # endif
  32. # if HAVE_NDIR_H
  33. #  include <ndir.h>
  34. # endif
  35. #endif
  36. #if HAVE_SYS_IOCTL_H
  37. #include <sys/ioctl.h>
  38. #endif
  40. #if HAVE_SYS_DKIO_H
  41. #include <sys/dkio.h>
  42. #endif
  43. #if HAVE_SYS_DISKIO_H           /* HP-UX only ? */
  44. #include <sys/diskio.h>
  45. #endif
  46. #if HAVE_LINUX_HDREG_H
  47. #include <linux/hdreg.h>
  48. #endif
  49. #if HAVE_SYS_DISKLABEL_H
  50. #define DKTYPENAMES
  51. #include <sys/disklabel.h>
  52. #endif
  53. #if TIME_WITH_SYS_TIME
  54. # include <sys/time.h>
  55. # include <time.h>
  56. #else
  57. # if HAVE_SYS_TIME_H
  58. #  include <sys/time.h>
  59. # else
  60. #  include <time.h>
  61. # endif
  62. #endif
  64. #if HAVE_LIMITS_H
  65. #include <limits.h>
  66. #endif
  68. #ifdef linux
  69. /*
  70.  * define BLKGETSIZE from <linux/fs.h>:
  71.  * Note: cannot include this file completely due to errors with redefinition
  72.  * of structures (at least with older linux versions) --jsf
  73.  */
  74. #define BLKGETSIZE _IO(0x12,96) /* return device size */
  75. #endif
  77. #include <net-snmp/agent/agent_read_config.h>
  78. #include <net-snmp/library/read_config.h>
  80. #define HRD_MONOTONICALLY_INCREASING
  82.         /*********************
  83.  *
  84.  *  Kernel & interface information,
  85.  *   and internal forward declarations
  86.  *
  87.  *********************/
  89. void            Init_HR_Disk(void);
  90. int             Get_Next_HR_Disk(void);
  91. int             Get_Next_HR_Disk_Partition(char *, size_t, int);
  92. static void     Add_HR_Disk_entry(const char *, int, int, int, int,
  93.                                   const char *, int, int);
  94. static void     Save_HR_Disk_General(void);
  95. static void     Save_HR_Disk_Specific(void);
  96. static int      Query_Disk(int, const char *);
  97. static int      Is_It_Writeable(void);
  98. static int      What_Type_Disk(void);
  99. static int      Is_It_Removeable(void);
  100. static const char *describe_disk(int);
  102. int             header_hrdisk(struct variable *, oid *, size_t *, int,
  103.                               size_t *, WriteMethod **);
  105. static int      HRD_type_index;
  106. static int      HRD_index;
  107. static char     HRD_savedModel[40];
  108. static long     HRD_savedCapacity = 1044;
  109. static int      HRD_savedFlags;
  110. static time_t   HRD_history[HRDEV_TYPE_MASK];
  112. #ifdef DIOC_DESCRIBE
  113. static disk_describe_type HRD_info;
  114. static capacity_type HRD_cap;
  116. static int      HRD_savedIntf_type;
  117. static int      HRD_savedDev_type;
  118. #endif
  120. #ifdef DKIOCINFO
  121. static struct dk_cinfo HRD_info;
  122. static struct dk_geom HRD_cap;
  124. static int      HRD_savedCtrl_type;
  125. #endif
  127. #ifdef HAVE_LINUX_HDREG_H
  128. static struct hd_driveid HRD_info;
  129. #endif
  131. #ifdef DIOCGDINFO
  132. static struct disklabel HRD_info;
  133. #endif
  135. static void     parse_disk_config(const char *, char *);
  136. static void     free_disk_config(void);
  138.         /*********************
  139.  *
  140.  *  Initialisation & common implementation functions
  141.  *
  142.  *********************/
  144. #define HRDISK_ACCESS 1
  145. #define HRDISK_MEDIA 2
  146. #define HRDISK_REMOVEABLE 3
  147. #define HRDISK_CAPACITY 4
  149. struct variable4 hrdisk_variables[] = {
  150.     {HRDISK_ACCESS, ASN_INTEGER, RONLY, var_hrdisk, 2, {1, 1}},
  151.     {HRDISK_MEDIA, ASN_INTEGER, RONLY, var_hrdisk, 2, {1, 2}},
  152.     {HRDISK_REMOVEABLE, ASN_INTEGER, RONLY, var_hrdisk, 2, {1, 3}},
  153.     {HRDISK_CAPACITY, ASN_INTEGER, RONLY, var_hrdisk, 2, {1, 4}}
  154. };
  155. oid             hrdisk_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 6 };
  158. void
  159. init_hr_disk(void)
  160. {
  161.     int             i;
  163.     init_device[HRDEV_DISK] = Init_HR_Disk;
  164.     next_device[HRDEV_DISK] = Get_Next_HR_Disk;
  165.     save_device[HRDEV_DISK] = Save_HR_Disk_General;
  166. #ifdef HRD_MONOTONICALLY_INCREASING
  167.     dev_idx_inc[HRDEV_DISK] = 1;
  168. #endif
  170. #if defined(linux)
  171.     Add_HR_Disk_entry("/dev/hd%c%d", -1, -1, 'a', 'l', "/dev/hd%c", 1, 15);
  172.     Add_HR_Disk_entry("/dev/sd%c%d", -1, -1, 'a', 'p', "/dev/sd%c", 1, 15);
  173.     Add_HR_Disk_entry("/dev/md%d", -1, -1, 0, 3, "/dev/md%d", 0, 0);
  174.     Add_HR_Disk_entry("/dev/fd%d", -1, -1, 0, 1, "/dev/fd%d", 0, 0);
  175. #elif defined(hpux)
  176. #if defined(hpux10) || defined(hpux11)
  177.     Add_HR_Disk_entry("/dev/rdsk/c%dt%xd%d", 0, 1, 0, 15,
  178.                       "/dev/rdsk/c%dt%xd0", 0, 4);
  179. #else                           /* hpux9 */
  180.     Add_HR_Disk_entry("/dev/rdsk/c%dd%xs%d", 201, 201, 0, 15,
  181.                       "/dev/rdsk/c%dd%xs0", 0, 4);
  182. #endif
  183. #elif defined(solaris2)
  184.     Add_HR_Disk_entry("/dev/rdsk/c%dt%dd0s%d", 0, 7, 0, 15,
  185.                       "/dev/rdsk/c%dt%dd0s0", 0, 7);
  186.     Add_HR_Disk_entry("/dev/rdsk/c%dd%ds%d", 0, 7, 0, 15,
  187.                       "/dev/rdsk/c%dd%ds0", 0, 7);
  188. #elif defined(freebsd4) || defined(freebsd5)
  189.     Add_HR_Disk_entry("/dev/ad%ds%d%c", 0, 1, 1, 4, "/dev/ad%ds%d", 'a', 'h');
  190.     Add_HR_Disk_entry("/dev/da%ds%d%c", 0, 1, 1, 4, "/dev/da%ds%d", 'a', 'h');
  191. #elif defined(freebsd3)
  192.     Add_HR_Disk_entry("/dev/wd%ds%d%c", 0, 1, 1, 4, "/dev/wd%ds%d", 'a',
  193.                       'h');
  194.     Add_HR_Disk_entry("/dev/sd%ds%d%c", 0, 1, 1, 4, "/dev/sd%ds%d", 'a',
  195.                       'h');
  196. #elif defined(freebsd2)
  197.     Add_HR_Disk_entry("/dev/wd%d%c", -1, -1, 0, 3, "/dev/wd%d", 'a', 'h');
  198.     Add_HR_Disk_entry("/dev/sd%d%c", -1, -1, 0, 3, "/dev/sd%d", 'a', 'h');
  199. #elif defined(netbsd1)
  200.     Add_HR_Disk_entry("/dev/wd%d%c", -1, -1, 0, 3, "/dev/wd%dc", 'a', 'h');
  201.     Add_HR_Disk_entry("/dev/sd%d%c", -1, -1, 0, 3, "/dev/sd%dc", 'a', 'h');
  202. #endif
  204.     device_descr[HRDEV_DISK] = describe_disk;
  205.     HRD_savedModel[0] = '';
  206.     HRD_savedCapacity = 0;
  208.     for (i = 0; i < HRDEV_TYPE_MASK; ++i)
  209.         HRD_history[i] = -1;
  211.     REGISTER_MIB("host/hr_disk", hrdisk_variables, variable4,
  212.                  hrdisk_variables_oid);
  214.     snmpd_register_config_handler("ignoredisk", parse_disk_config,
  215.                                   free_disk_config, "name");
  216. }
  218. #define ITEM_STRING 1
  219. #define ITEM_SET 2
  220. #define ITEM_STAR 3
  221. #define ITEM_ANY 4
  223. typedef unsigned char details_set[32];
  225. typedef struct _conf_disk_item {
  226.     int             item_type;  /* ITEM_STRING, ITEM_SET, ITEM_STAR, ITEM_ANY */
  227.     void           *item_details;       /* content depends upon item_type */
  228.     struct _conf_disk_item *item_next;
  229. } conf_disk_item;
  231. typedef struct _conf_disk_list {
  232.     conf_disk_item *list_item;
  233.     struct _conf_disk_list *list_next;
  234. } conf_disk_list;
  235. static conf_disk_list *conf_list = NULL;
  237. static int      match_disk_config(const char *);
  238. static int      match_disk_config_item(const char *, conf_disk_item *);
  240. static void
  241. parse_disk_config(const char *token, char *cptr)
  242. {
  243.     conf_disk_list *d_new;
  244.     conf_disk_item *di_curr;
  245.     details_set    *d_set;
  246.     char           *name, *p, *d_str, c;
  247.     unsigned int    i, neg, c1, c2;
  248.     char           *st;
  250.     name = strtok_r(cptr, " t", &st);
  251.     if (!name) {
  252.         config_perror("Missing NAME parameter");
  253.         return;
  254.     }
  255.     d_new = (conf_disk_list *) malloc(sizeof(conf_disk_list));
  256.     if (!d_new) {
  257.         config_perror("Out of memory");
  258.         return;
  259.     }
  260.     di_curr = (conf_disk_item *) malloc(sizeof(conf_disk_item));
  261.     if (!di_curr) {
  262.         config_perror("Out of memory");
  263.         return;
  264.     }
  265.     d_new->list_item = di_curr;
  266.     for (;;) {
  267.         if (*name == '?') {
  268.             di_curr->item_type = ITEM_ANY;
  269.             di_curr->item_details = (void *) 0;
  270.             name++;
  271.         } else if (*name == '*') {
  272.             di_curr->item_type = ITEM_STAR;
  273.             di_curr->item_details = (void *) 0;
  274.             name++;
  275.         } else if (*name == '[') {
  276.             d_set = (details_set *) malloc(sizeof(details_set));
  277.             if (!d_set) {
  278.                 config_perror("Out of memory");
  279.                 return;
  280.             }
  281.             for (i = 0; i < sizeof(details_set); i++)
  282.                 (*d_set)[i] = (unsigned char) 0;
  283.             name++;
  284.             if (*name == '^' || *name == '!') {
  285.                 neg = 1;
  286.                 name++;
  287.             } else {
  288.                 neg = 0;
  289.             }
  290.             while (*name && *name != ']') {
  291.                 c1 = ((unsigned int) *name++) & 0xff;
  292.                 if (*name == '-' && *(name + 1) != ']') {
  293.                     name++;
  294.                     c2 = ((unsigned int) *name++) & 0xff;
  295.                 } else {
  296.                     c2 = c1;
  297.                 }
  298.                 for (i = c1; i <= c2; i++)
  299.                     (*d_set)[i / 8] |= (unsigned char) (1 << (i % 8));
  300.             }
  301.             if (*name != ']') {
  302.                 config_perror
  303.                     ("Syntax error in NAME: invalid set specified");
  304.                 return;
  305.             }
  306.             if (neg) {
  307.                 for (i = 0; i < sizeof(details_set); i++)
  308.                     (*d_set)[i] = (*d_set)[i] ^ (unsigned char) 0xff;
  309.             }
  310.             di_curr->item_type = ITEM_SET;
  311.             di_curr->item_details = (void *) d_set;
  312.             name++;
  313.         } else {
  314.             for (p = name;
  315.                  *p != '' && *p != '?' && *p != '*' && *p != '['; p++);
  316.             c = *p;
  317.             *p = '';
  318.             d_str = (char *) malloc(strlen(name) + 1);
  319.             if (!d_str) {
  320.                 config_perror("Out of memory");
  321.                 return;
  322.             }
  323.             strcpy(d_str, name);
  324.             *p = c;
  325.             di_curr->item_type = ITEM_STRING;
  326.             di_curr->item_details = (void *) d_str;
  327.             name = p;
  328.         }
  329.         if (!*name) {
  330.             di_curr->item_next = (conf_disk_item *) 0;
  331.             break;
  332.         }
  333.         di_curr->item_next =
  334.             (conf_disk_item *) malloc(sizeof(conf_disk_item));
  335.         if (!di_curr->item_next) {
  336.             config_perror("Out of memory");
  337.             return;
  338.         }
  339.         di_curr = di_curr->item_next;
  340.     }
  341.     d_new->list_next = conf_list;
  342.     conf_list = d_new;
  343. }
  345. static void
  346. free_disk_config(void)
  347. {
  348.     conf_disk_list *d_ptr = conf_list, *d_next;
  349.     conf_disk_item *di_ptr, *di_next;
  351.     while (d_ptr) {
  352.         d_next = d_ptr->list_next;
  353.         di_ptr = d_ptr->list_item;
  354.         while (di_ptr) {
  355.             di_next = di_ptr->item_next;
  356.             if (di_ptr->item_details)
  357.                 free(di_ptr->item_details);
  358.             free((void *) di_ptr);
  359.             di_ptr = di_next;
  360.         }
  361.         free((void *) d_ptr);
  362.         d_ptr = d_next;
  363.     }
  364.     conf_list = (conf_disk_list *) 0;
  365. }
  367. static int
  368. match_disk_config_item(const char *name, conf_disk_item * di_ptr)
  369. {
  370.     int             result = 0;
  371.     size_t          len;
  372.     details_set    *d_set;
  373.     unsigned int    c;
  375.     if (di_ptr) {
  376.         switch (di_ptr->item_type) {
  377.         case ITEM_STRING:
  378.             len = strlen((const char *) di_ptr->item_details);
  379.             if (!strncmp(name, (const char *) di_ptr->item_details, len))
  380.                 result = match_disk_config_item(name + len,
  381.                                                 di_ptr->item_next);
  382.             break;
  383.         case ITEM_SET:
  384.             if (*name) {
  385.                 d_set = (details_set *) di_ptr->item_details;
  386.                 c = ((unsigned int) *name) & 0xff;
  387.                 if ((*d_set)[c / 8] & (unsigned char) (1 << (c % 8)))
  388.                     result = match_disk_config_item(name + 1,
  389.                                                     di_ptr->item_next);
  390.             }
  391.             break;
  392.         case ITEM_STAR:
  393.             if (di_ptr->item_next) {
  394.                 for (; !result && *name; name++)
  395.                     result = match_disk_config_item(name,
  396.                                                     di_ptr->item_next);
  397.             } else {
  398.                 result = 1;
  399.             }
  400.             break;
  401.         case ITEM_ANY:
  402.             if (*name)
  403.                 result = match_disk_config_item(name + 1,
  404.                                                 di_ptr->item_next);
  405.             break;
  406.         }
  407.     } else {
  408.         if (*name == '')
  409.             result = 1;
  410.     }
  412.     return result;
  413. }
  415. static int
  416. match_disk_config(const char *name)
  417. {
  418.     conf_disk_list *d_ptr = conf_list;
  420.     while (d_ptr) {
  421.         if (match_disk_config_item(name, d_ptr->list_item))
  422.             return 1;           /* match found in ignorelist */
  423.         d_ptr = d_ptr->list_next;
  424.     }
  426.     /*
  427.      * no match in ignorelist 
  428.      */
  429.     return 0;
  430. }
  432. /*
  433.  * header_hrdisk(...
  434.  * Arguments:
  435.  * vp     IN      - pointer to variable entry that points here
  436.  * name    IN/OUT  - IN/name requested, OUT/name found
  437.  * length  IN/OUT  - length of IN/OUT oid's 
  438.  * exact   IN      - TRUE if an exact match was requested
  439.  * var_len OUT     - length of variable or 0 if function returned
  440.  * write_method
  441.  */
  443. int
  444. header_hrdisk(struct variable *vp,
  445.               oid * name,
  446.               size_t * length,
  447.               int exact, size_t * var_len, WriteMethod ** write_method)
  448. {
  449. #define HRDISK_ENTRY_NAME_LENGTH 11
  450.     oid             newname[MAX_OID_LEN];
  451.     int             disk_idx, LowIndex = -1;
  452.     int             result;
  454.     DEBUGMSGTL(("host/hr_disk", "var_hrdisk: "));
  455.     DEBUGMSGOID(("host/hr_disk", name, *length));
  456.     DEBUGMSG(("host/hr_disk", " %dn", exact));
  458.     memcpy((char *) newname, (char *) vp->name,
  459.            (int) vp->namelen * sizeof(oid));
  460.     /*
  461.      * Find "next" disk entry 
  462.      */
  464.     Init_HR_Disk();
  465.     for (;;) {
  466.         disk_idx = Get_Next_HR_Disk();
  467.         if (disk_idx == -1)
  468.             break;
  469.         newname[HRDISK_ENTRY_NAME_LENGTH] = disk_idx;
  470.         result =
  471.             snmp_oid_compare(name, *length, newname,
  472.                              (int) vp->namelen + 1);
  473.         if (exact && (result == 0)) {
  474.             LowIndex = disk_idx;
  475.             Save_HR_Disk_Specific();
  476.             break;
  477.         }
  478.         if ((!exact && (result < 0)) &&
  479.             (LowIndex == -1 || disk_idx < LowIndex)) {
  480.             LowIndex = disk_idx;
  481.             Save_HR_Disk_Specific();
  482. #ifdef HRD_MONOTONICALLY_INCREASING
  483.             break;
  484. #endif
  485.         }
  486.     }
  488.     if (LowIndex == -1) {
  489.         DEBUGMSGTL(("host/hr_disk", "... index out of rangen"));
  490.         return (MATCH_FAILED);
  491.     }
  493.     newname[HRDISK_ENTRY_NAME_LENGTH] = LowIndex;
  494.     memcpy((char *) name, (char *) newname,
  495.            ((int) vp->namelen + 1) * sizeof(oid));
  496.     *length = vp->namelen + 1;
  497.     *write_method = 0;
  498.     *var_len = sizeof(long);    /* default to 'long' results */
  500.     DEBUGMSGTL(("host/hr_disk", "... get disk stats "));
  501.     DEBUGMSGOID(("host/hr_disk", name, *length));
  502.     DEBUGMSG(("host/hr_disk", "n"));
  504.     return LowIndex;
  505. }
  508.         /*********************
  509.  *
  510.  *  System specific implementation functions
  511.  *
  512.  *********************/
  515. u_char         *
  516. var_hrdisk(struct variable * vp,
  517.            oid * name,
  518.            size_t * length,
  519.            int exact, size_t * var_len, WriteMethod ** write_method)
  520. {
  521.     int             disk_idx;
  523.     disk_idx =
  524.         header_hrdisk(vp, name, length, exact, var_len, write_method);
  525.     if (disk_idx == MATCH_FAILED)
  526.         return NULL;
  529.     switch (vp->magic) {
  530.     case HRDISK_ACCESS:
  531.         long_return = Is_It_Writeable();
  532.         return (u_char *) & long_return;
  533.     case HRDISK_MEDIA:
  534.         long_return = What_Type_Disk();
  535.         return (u_char *) & long_return;
  536.     case HRDISK_REMOVEABLE:
  537.         long_return = Is_It_Removeable();
  538.         return (u_char *) & long_return;
  539.     case HRDISK_CAPACITY:
  540.         long_return = HRD_savedCapacity;
  541.         return (u_char *) & long_return;
  542.     default:
  543.         DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrdiskn",
  544.                     vp->magic));
  545.     }
  546.     return NULL;
  547. }
  550.         /*********************
  551.  *
  552.  *  Internal implementation functions
  553.  *
  554.  *********************/
  556. #define MAX_NUMBER_DISK_TYPES 16      /* probably should be a variable */
  557. #define MAX_DISKS_PER_TYPE 15      /* SCSI disks - not a hard limit */
  558. #define HRDISK_TYPE_SHIFT 4       /* log2 (MAX_DISKS_PER_TYPE+1) */
  560. typedef struct {
  561.     const char     *disk_devpart_string;        /* printf() format disk part. name */
  562.     short           disk_controller;    /* controller id or -1 if NA */
  563.     short           disk_device_first;  /* first device id */
  564.     short           disk_device_last;   /* last device id */
  565.     const char     *disk_devfull_string;        /* printf() format full disk name */
  566.     short           disk_partition_first;       /* first partition id */
  567.     short           disk_partition_last;        /* last partition id */
  568. } HRD_disk_t;
  570. static HRD_disk_t disk_devices[MAX_NUMBER_DISK_TYPES];
  571. static int      HR_number_disk_types = 0;
  573. static void
  574. Add_HR_Disk_entry(const char *devpart_string,
  575.                   int first_ctl,
  576.                   int last_ctl,
  577.                   int first_dev,
  578.                   int last_dev,
  579.                   const char *devfull_string,
  580.                   int first_partn, int last_partn)
  581. {
  582.     int lodev, hidev, nbr_created = 0;
  584.     while (first_ctl <= last_ctl) {
  585.       for (lodev = first_dev;
  586.            lodev < last_dev && MAX_NUMBER_DISK_TYPES > HR_number_disk_types;
  587.            lodev += (1+MAX_DISKS_PER_TYPE), HR_number_disk_types++)
  588.       {
  589.         nbr_created++;
  590.         /*
  591.          * Split long runs of disks into separate "types"
  592.          */
  593.         hidev = lodev + MAX_DISKS_PER_TYPE;
  594.         if (last_dev < hidev)
  595.             hidev = last_dev;
  596.         disk_devices[HR_number_disk_types].disk_devpart_string =
  597.             devpart_string;
  598.         disk_devices[HR_number_disk_types].disk_controller = first_ctl;
  599.         disk_devices[HR_number_disk_types].disk_device_first = lodev;
  600.         disk_devices[HR_number_disk_types].disk_device_last = hidev;
  601.         disk_devices[HR_number_disk_types].disk_devfull_string =
  602.             devfull_string;
  603.         disk_devices[HR_number_disk_types].disk_partition_first =
  604.             first_partn;
  605.         disk_devices[HR_number_disk_types].disk_partition_last =
  606.             last_partn;
  607. #if DEBUG_TEST
  608.         DEBUGMSGTL(("host/hr_disk",
  609.                     "Add_HR %02d '%s' first=%d last=%dn",
  610.                     HR_number_disk_types, devpart_string, lodev, hidev));
  611. #endif
  612.       }
  613.       first_ctl++;
  614.     }
  616.     if (nbr_created == 0 || MAX_NUMBER_DISK_TYPES < HR_number_disk_types) {
  617.         HR_number_disk_types = MAX_NUMBER_DISK_TYPES;
  618.         DEBUGMSGTL(("host/hr_disk",
  619.                     "WARNING! Add_HR_Disk_entry '%s' incomplete, %d createdn",
  620.                     devpart_string, nbr_created));
  621.     }
  622. #if DEBUG_TEST
  623.     else
  624.         DEBUGMSGTL(("host/hr_disk",
  625.                     "Add_HR_Disk_entry '%s' completed, %d createdn",
  626.                     devpart_string, nbr_created));
  627. #endif
  628. }
  630. void
  631. Init_HR_Disk(void)
  632. {
  633.     HRD_type_index = 0;
  634.     HRD_index = -1;
  635.     DEBUGMSGTL(("host/hr_disk", "Init_Diskn"));
  636. }
  638. int
  639. Get_Next_HR_Disk(void)
  640. {
  641.     char            string[1024];
  642.     int             fd, result;
  643.     int             iindex;
  644.     int             max_disks;
  645.     time_t          now;
  647.     HRD_index++;
  648.     (void *) time(&now);
  649.     DEBUGMSGTL(("host/hr_disk", "Next_Disk type %d of %dn",
  650.                 HRD_type_index, HR_number_disk_types));
  651.     while (HRD_type_index < HR_number_disk_types) {
  652.         max_disks = disk_devices[HRD_type_index].disk_device_last -
  653.             disk_devices[HRD_type_index].disk_device_first + 1;
  654.         DEBUGMSGTL(("host/hr_disk", "Next_Disk max %d of type %dn",
  655.                     max_disks, HRD_type_index));
  657.         while (HRD_index < max_disks) {
  658.             iindex = (HRD_type_index << HRDISK_TYPE_SHIFT) + HRD_index;
  660.             /*
  661.              * Check to see whether this device
  662.              *   has been probed for 'recently'
  663.              *   and skip if so.
  664.              * This has a *major* impact on run
  665.              *   times (by a factor of 10!)
  666.              */
  667.             if ((HRD_history[iindex] > 0) &&
  668.                 ((now - HRD_history[iindex]) < 60)) {
  669.                 HRD_index++;
  670.                 continue;
  671.             }
  673.             /*
  674.              * Construct the full device name in "string" 
  675.              */
  676.             if (disk_devices[HRD_type_index].disk_controller != -1) {
  677.                 snprintf(string, sizeof(string),
  678.                         disk_devices[HRD_type_index].disk_devfull_string,
  679.                         disk_devices[HRD_type_index].disk_controller,
  680.                         disk_devices[HRD_type_index].disk_device_first +
  681.                         HRD_index);
  682.             } else {
  683.                 snprintf(string, sizeof(string),
  684.                         disk_devices[HRD_type_index].disk_devfull_string,
  685.                         disk_devices[HRD_type_index].disk_device_first +
  686.                         HRD_index);
  687.             }
  688.             string[ sizeof(string)-1 ] = 0;
  690.             DEBUGMSGTL(("host/hr_disk", "Get_Next_HR_Disk: %s (%d/%d)n",
  691.                         string, HRD_type_index, HRD_index));
  693.             if (HRD_history[iindex] == -1) {
  694.                 /*
  695.                  * check whether this device is in the "ignoredisk" list in
  696.                  * the config file. if yes this device will be marked as
  697.                  * invalid for the future, i.e. it won't ever be checked
  698.                  * again.
  699.                  */
  700.                 if (match_disk_config(string)) {
  701.                     /*
  702.                      * device name matches entry in ignoredisk list 
  703.                      */
  704.                     DEBUGMSGTL(("host/hr_disk",
  705.                                 "Get_Next_HR_Disk: %s ignoredn", string));
  706.                     HRD_history[iindex] = LONG_MAX;
  707.                     HRD_index++;
  708.                     continue;
  709.                 }
  710.             }
  712.             /*
  713.              * use O_NDELAY to avoid CDROM spin-up and media detection
  714.              * * (too slow) --okir 
  715.              */
  716.             /*
  717.              * at least with HP-UX 11.0 this doesn't seem to work properly
  718.              * * when accessing an empty CDROM device --jsf 
  719.              */
  720. #ifdef O_NDELAY                 /* I'm sure everything has it, but just in case...  --Wes */
  721.             fd = open(string, O_RDONLY | O_NDELAY);
  722. #else
  723.             fd = open(string, O_RDONLY);
  724. #endif
  725.             if (fd != -1) {
  726.                 result = Query_Disk(fd, string);
  727.                 close(fd);
  728.                 if (result != -1) {
  729.                     HRD_history[iindex] = 0;
  730.                     return ((HRDEV_DISK << HRDEV_TYPE_SHIFT) + iindex);
  731.                 }
  732.             }
  733.             HRD_history[iindex] = now;
  734.             HRD_index++;
  735.         }
  736.         HRD_type_index++;
  737.         HRD_index = 0;
  738.     }
  739.     HRD_index = -1;
  740.     return -1;
  741. }
  743. int
  744. Get_Next_HR_Disk_Partition(char *string, size_t str_len, int HRP_index)
  745. {
  746.     DEBUGMSGTL(("host/hr_disk", "Next_Partition type %d/%d:%dn",
  747.                 HRD_type_index, HRD_index, HRP_index));
  749.     /*
  750.      * no more partition names => return -1 
  751.      */
  752.     if (disk_devices[HRD_type_index].disk_partition_last -
  753.         disk_devices[HRD_type_index].disk_partition_first + 1
  754.         <= HRP_index) {
  755.         return -1;
  756.     }
  758.     /*
  759.      * Construct the partition name in "string" 
  760.      */
  761.     if (disk_devices[HRD_type_index].disk_controller != -1) {
  762.         snprintf(string, str_len,
  763.                 disk_devices[HRD_type_index].disk_devpart_string,
  764.                 disk_devices[HRD_type_index].disk_controller,
  765.                 disk_devices[HRD_type_index].disk_device_first + HRD_index,
  766.                 disk_devices[HRD_type_index].disk_partition_first +
  767.                 HRP_index);
  768.     } else {
  769.         snprintf(string, str_len,
  770.                 disk_devices[HRD_type_index].disk_devpart_string,
  771.                 disk_devices[HRD_type_index].disk_device_first + HRD_index,
  772.                 disk_devices[HRD_type_index].disk_partition_first +
  773.                 HRP_index);
  774.     }
  775.     string[ str_len-1 ] = 0;
  777.     DEBUGMSGTL(("host/hr_disk",
  778.                 "Get_Next_HR_Disk_Partition: %s (%d/%d:%d)n", string,
  779.                 HRD_type_index, HRD_index, HRP_index));
  781.     return 0;
  782. }
  784. static void
  785. Save_HR_Disk_Specific(void)
  786. {
  787. #ifdef DIOC_DESCRIBE
  788.     HRD_savedIntf_type = HRD_info.intf_type;
  789.     HRD_savedDev_type = HRD_info.dev_type;
  790.     HRD_savedFlags = HRD_info.flags;
  791.     HRD_savedCapacity = HRD_cap.lba / 2;
  792. #endif
  793. #ifdef DKIOCINFO
  794.     HRD_savedCtrl_type = HRD_info.dki_ctype;
  795.     HRD_savedFlags = HRD_info.dki_flags;
  796.     HRD_savedCapacity = HRD_cap.dkg_ncyl * HRD_cap.dkg_nhead * HRD_cap.dkg_nsect / 2;   /* ??? */
  797. #endif
  798. #ifdef HAVE_LINUX_HDREG_H
  799.     HRD_savedCapacity = HRD_info.lba_capacity / 2;
  800.     HRD_savedFlags = HRD_info.config;
  801. #endif
  802. #ifdef DIOCGDINFO
  803.     HRD_savedCapacity = HRD_info.d_secperunit / 2;
  804. #endif
  805. }
  807. static void
  808. Save_HR_Disk_General(void)
  809. {
  810. #ifdef DIOC_DESCRIBE
  811.     strncpy(HRD_savedModel, HRD_info.model_num, sizeof(HRD_savedModel)-1);
  812.     HRD_savedModel[ sizeof(HRD_savedModel)-1 ] = 0;
  813. #endif
  814. #ifdef DKIOCINFO
  815.     strncpy(HRD_savedModel, HRD_info.dki_dname, sizeof(HRD_savedModel)-1);
  816.     HRD_savedModel[ sizeof(HRD_savedModel)-1 ] = 0;
  817. #endif
  818. #ifdef HAVE_LINUX_HDREG_H
  819.     strncpy(HRD_savedModel, (const char *) HRD_info.model,
  820.                     sizeof(HRD_savedModel)-1);
  821.     HRD_savedModel[ sizeof(HRD_savedModel)-1 ] = 0;
  822. #endif
  823. #ifdef DIOCGDINFO
  824.     strncpy(HRD_savedModel, dktypenames[HRD_info.d_type],
  825.                     sizeof(HRD_savedModel)-1);
  826.     HRD_savedModel[ sizeof(HRD_savedModel)-1 ] = 0;
  827. #endif
  828. }
  830. static const char *
  831. describe_disk(int idx)
  832. {
  833.     if (HRD_savedModel[0] == '')
  834.         return ("some sort of disk");
  835.     else
  836.         return (HRD_savedModel);
  837. }
  840. static int
  841. Query_Disk(int fd, const char *devfull)
  842. {
  843.     int             result = -1;
  845. #ifdef DIOC_DESCRIBE
  846.     result = ioctl(fd, DIOC_DESCRIBE, &HRD_info);
  847.     if (result != -1)
  848.         result = ioctl(fd, DIOC_CAPACITY, &HRD_cap);
  849. #endif
  851. #ifdef DKIOCINFO
  852.     result = ioctl(fd, DKIOCINFO, &HRD_info);
  853.     if (result != -1)
  854.         result = ioctl(fd, DKIOCGGEOM, &HRD_cap);
  855. #endif
  857. #ifdef HAVE_LINUX_HDREG_H
  858.     if (HRD_type_index == 0)    /* IDE hard disk */
  859.         result = ioctl(fd, HDIO_GET_IDENTITY, &HRD_info);
  860.     else if (HRD_type_index <= 2) {     /* SCSI hard disk and md devices */
  861.         long            h;
  862.         result = ioctl(fd, BLKGETSIZE, &h);
  863.         if (result != -1 && HRD_type_index == 2 && h == 0L)
  864.             result = -1;        /* ignore empty md devices */
  865.         if (result != -1) {
  866.             HRD_info.lba_capacity = h;
  867.             if (HRD_type_index == 1)
  868.                 snprintf( HRD_info.model, sizeof(HRD_info.model)-1,
  869.                          "SCSI disk (%s)", devfull);
  870.             else
  871.                 snprintf( HRD_info.model, sizeof(HRD_info.model)-1,
  872.                         "RAID disk (%s)", devfull);
  873.             HRD_info.model[ sizeof(HRD_info.model)-1 ] = 0;
  874.             HRD_info.config = 0;
  875.         }
  876.     }
  877. #endif
  879. #ifdef DIOCGDINFO
  880.     result = ioctl(fd, DIOCGDINFO, &HRD_info);
  881. #endif
  883.     return (result);
  884. }
  887. static int
  888. Is_It_Writeable(void)
  889. {
  890. #ifdef DIOC_DESCRIBE
  891.     if ((HRD_savedFlags & WRITE_PROTECT_FLAG) ||
  892.         (HRD_savedDev_type == CDROM_DEV_TYPE))
  893.         return (2);             /* read only */
  894. #endif
  896. #ifdef DKIOCINFO
  897.     if (HRD_savedCtrl_type == DKC_CDROM)
  898.         return (2);             /* read only */
  899. #endif
  901.     return (1);                 /* read-write */
  902. }
  904. static int
  905. What_Type_Disk(void)
  906. {
  907. #ifdef DIOC_DESCRIBE
  908.     switch (HRD_savedDev_type) {
  909.     case DISK_DEV_TYPE:
  910.         if (HRD_savedIntf_type == PC_FDC_INTF)
  911.             return (4);         /* Floppy Disk */
  912.         else
  913.             return (3);         /* Hard Disk */
  914.         break;
  915.     case CDROM_DEV_TYPE:
  916.         return (5);             /* Optical RO */
  917.         break;
  918.     case WORM_DEV_TYPE:
  919.         return (6);             /* Optical WORM */
  920.         break;
  921.     case MO_DEV_TYPE:
  922.         return (7);             /* Optical R/W */
  923.         break;
  924.     default:
  925.         return (2);             /* Unknown */
  926.         break;
  927.     }
  928. #endif
  930. #ifdef DKIOCINFO
  931.     switch (HRD_savedCtrl_type) {
  932.     case DKC_WDC2880:
  933.     case DKC_DSD5215:
  934. #ifdef DKC_XY450
  935.     case DKC_XY450:
  936. #endif
  937.     case DKC_ACB4000:
  938.     case DKC_MD21:
  939. #ifdef DKC_XD7053
  940.     case DKC_XD7053:
  941. #endif
  942.     case DKC_SCSI_CCS:
  943. #ifdef DKC_PANTHER
  944.     case DKC_PANTHER:
  945. #endif
  946. #ifdef DKC_CDC_9057
  947.     case DKC_CDC_9057:
  948. #endif
  949. #ifdef DKC_FJ_M1060
  950.     case DKC_FJ_M1060:
  951. #endif
  952.     case DKC_DIRECT:
  953.     case DKC_PCMCIA_ATA:
  954.         return (3);             /* Hard Disk */
  955.         break;
  956.     case DKC_NCRFLOPPY:
  957.     case DKC_SMSFLOPPY:
  958.     case DKC_INTEL82077:
  959.         return (4);             /* Floppy Disk */
  960.         break;
  961.     case DKC_CDROM:
  962.         return (5);             /* Optical RO */
  963.         break;
  964.     case DKC_PCMCIA_MEM:
  965.         return (8);             /* RAM disk */
  966.         break;
  967.     case DKC_MD:               /* "meta-disk" driver */
  968.         return (1);             /* Other */
  969.         break;
  970.     }
  971. #endif
  974.     return (2);                 /* Unknown */
  975. }
  977. static int
  978. Is_It_Removeable(void)
  979. {
  980. #ifdef DIOC_DESCRIBE
  981.     if ((HRD_savedIntf_type == PC_FDC_INTF) ||
  982.         (HRD_savedDev_type == WORM_DEV_TYPE) ||
  983.         (HRD_savedDev_type == MO_DEV_TYPE) ||
  984.         (HRD_savedDev_type == CDROM_DEV_TYPE))
  985.         return (1);             /* true */
  986. #endif
  988. #ifdef DKIOCINFO
  989.     if ((HRD_savedCtrl_type == DKC_CDROM) ||
  990.         (HRD_savedCtrl_type == DKC_NCRFLOPPY) ||
  991.         (HRD_savedCtrl_type == DKC_SMSFLOPPY) ||
  992.         (HRD_savedCtrl_type == DKC_INTEL82077) ||
  993.         (HRD_savedCtrl_type == DKC_PCMCIA_MEM) ||
  994.         (HRD_savedCtrl_type == DKC_PCMCIA_ATA))
  995.         return (1);             /* true */
  996. #endif
  998. #ifdef HAVE_LINUX_HDREG_H
  999.     if (HRD_savedFlags & 0x80)
  1000.         return (1);             /* true */
  1001. #endif
  1003.     return (2);                 /* false */
  1004. }