lib/lkud.c

   1 /*
   2  * lkud.c -- device lookup functions for lsof library
   3  */
   4
   5
   6 /*
   7  * Copyright 1997 Purdue Research Foundation, West Lafayette, Indiana
   8  * 47907.  All rights reserved.
   9  *
  10  * Written by Victor A. Abell
  11  *
  12  * This software is not subject to any license of the American Telephone
  13  * and Telegraph Company or the Regents of the University of California.
  14  *
  15  * Permission is granted to anyone to use this software for any purpose on
  16  * any computer system, and to alter it and redistribute it freely, subject
  17  * to the following restrictions:
  18  *
  19  * 1. Neither the authors nor Purdue University are responsible for any
  20  *    consequences of the use of this software.
  21  *
  22  * 2. The origin of this software must not be misrepresented, either by
  23  *    explicit claim or by omission.  Credit to the authors and Purdue
  24  *    University must appear in documentation and sources.
  25  *
  26  * 3. Altered versions must be plainly marked as such, and must not be
  27  *    misrepresented as being the original software.
  28  *
  29  * 4. This notice may not be removed or altered.
  30  */
  31
  32
  33 /*
  34  * lkud.c -- lookup device
  35  *
  36  * The caller may define:
  37  *
  38  *      HASBLKDEV       to activate block device lookup
  39  */
  40
  41
  42 #include "../machine.h"
  43
  44 #if     defined(HASBLKDEV) || defined(USE_LIB_LKUPDEV)
  45
  46 # if    !defined(lint)
  47 static char copyright[] =
  48 "@(#) Copyright 1997 Purdue Research Foundation.\nAll rights reserved.\n";
  49 static char *rcsid = "$Id: lkud.c,v 1.7 2008/10/21 16:12:36 abe Exp $";
  50 # endif /* !defined(lint) */
  51
  52 #include "../lsof.h"
  53
  54 #else   /* !defined(HASBLKDEV) && !defined(USE_LIB_LKUPDEV) */
  55 char lkud_d1[] = "d"; char *lkud_d2 = lkud_d1;
  56 #endif  /* defined(HASBLKDEV) || defined(USE_LIB_LKUPDEV) */
  57
  58
  59
  60 #if     defined(HASBLKDEV)
  61 /*
  62  * lkupbdev() - look up a block device
  63  */
  64
  65 struct l_dev *
  66 lkupbdev(dev, rdev, i, r)
  67         dev_t *dev;                     /* pointer to device number */
  68         dev_t *rdev;                    /* pointer to raw device number */
  69         int i;                          /* inode match status */
  70         int r;                          /* if 1, rebuild the device cache with
  71                                          * rereaddev() when no match is found
  72                                          * and HASDCACHE is defined and
  73                                          * DCunsafe is one */
  74 {
  75         INODETYPE inode = (INODETYPE)0;
  76         int low, hi, mid;
  77         struct l_dev *dp;
  78         int ty = 0;
  79
  80         if (*dev != DevDev)
  81             return((struct l_dev *)NULL);
  82         readdev(0);
  83         if (i) {
  84             inode = Lf->inode;
  85             ty = Lf->inp_ty;
  86         }
  87 /*
  88  * Search block device table for match.
  89  */
  90
  91 # if    defined(HASDCACHE)
  92
  93 lkupbdev_again:
  94
  95 # endif /* defined(HASDCACHE) */
  96
  97         low = mid = 0;
  98         hi = BNdev - 1;
  99         while (low <= hi) {
 100             mid = (low + hi) / 2;
 101             dp = BSdev[mid];
 102             if (*rdev < dp->rdev)
 103                 hi = mid - 1;
 104             else if (*rdev > dp->rdev)
 105                 low = mid + 1;
 106             else {
 107                 if ((i == 0) || (ty != 1) || (inode == dp->inode)) {
 108
 109 # if    defined(HASDCACHE)
 110                     if (DCunsafe && !dp->v && !vfy_dev(dp))
 111                         goto lkupbdev_again;
 112 # endif /* defined(HASDCACHE) */
 113
 114                     return(dp);
 115                 }
 116                 if (inode < dp->inode)
 117                     hi = mid - 1;
 118                 else
 119                     low = mid + 1;
 120             }
 121         }
 122
 123 # if    defined(HASDCACHE)
 124         if (DCunsafe && r) {
 125             (void) rereaddev();
 126             goto lkupbdev_again;
 127         }
 128 # endif /* defined(HASDCACHE) */
 129
 130         return((struct l_dev *)NULL);
 131 }
 132 #endif  /* defined(HASBLKDEV) */
 133
 134
 135 #if     defined(USE_LIB_LKUPDEV)
 136 /*
 137  * lkupdev() - look up a character device
 138  */
 139
 140 struct l_dev *
 141 lkupdev(dev, rdev, i, r)
 142         dev_t *dev;                     /* pointer to device number */
 143         dev_t *rdev;                    /* pointer to raw device number */
 144         int i;                          /* inode match status */
 145         int r;                          /* if 1, rebuild the device cache with
 146                                          * rereaddev() when no match is found
 147                                          * and HASDCACHE is defined and
 148                                          * DCunsafe is one */
 149 {
 150         INODETYPE inode = (INODETYPE)0;
 151         int low, hi, mid;
 152         struct l_dev *dp;
 153         int ty = 0;
 154
 155         if (*dev != DevDev)
 156             return((struct l_dev *)NULL);
 157         readdev(0);
 158         if (i) {
 159             inode = Lf->inode;
 160             ty = Lf->inp_ty;
 161         }
 162 /*
 163  * Search device table for match.
 164  */
 165
 166 # if    defined(HASDCACHE)
 167
 168 lkupdev_again:
 169
 170 # endif /* defined(HASDCACHE) */
 171
 172         low = mid = 0;
 173         hi = Ndev - 1;
 174         while (low <= hi) {
 175             mid = (low + hi) / 2;
 176             dp = Sdev[mid];
 177             if (*rdev < dp->rdev)
 178                 hi = mid - 1;
 179             else if (*rdev > dp->rdev)
 180                 low = mid + 1;
 181             else {
 182                 if ((i == 0) || (ty != 1) || (inode == dp->inode)) {
 183
 184 # if    defined(HASDCACHE)
 185                     if (DCunsafe && !dp->v && !vfy_dev(dp))
 186                         goto lkupdev_again;
 187 # endif /* defined(HASDCACHE) */
 188
 189                     return(dp);
 190                 }
 191                 if (inode < dp->inode)
 192                     hi = mid - 1;
 193                 else
 194                     low = mid + 1;
 195             }
 196         }
 197
 198 # if    defined(HASDCACHE)
 199         if (DCunsafe && r) {
 200             (void) rereaddev();
 201             goto lkupdev_again;
 202         }
 203 # endif /* defined(HASDCACHE) */
 204
 205         return((struct l_dev *)NULL);
 206 }
 207 #endif  /* defined(USE_LIB_LKUPDEV) */