| /* |
| * rdev.c -- readdev() function for lsof library |
| */ |
| |
| |
| /* |
| * Copyright 1997 Purdue Research Foundation, West Lafayette, Indiana |
| * 47907. All rights reserved. |
| * |
| * Written by Victor A. Abell |
| * |
| * This software is not subject to any license of the American Telephone |
| * and Telegraph Company or the Regents of the University of California. |
| * |
| * Permission is granted to anyone to use this software for any purpose on |
| * any computer system, and to alter it and redistribute it freely, subject |
| * to the following restrictions: |
| * |
| * 1. Neither the authors nor Purdue University are responsible for any |
| * consequences of the use of this software. |
| * |
| * 2. The origin of this software must not be misrepresented, either by |
| * explicit claim or by omission. Credit to the authors and Purdue |
| * University must appear in documentation and sources. |
| * |
| * 3. Altered versions must be plainly marked as such, and must not be |
| * misrepresented as being the original software. |
| * |
| * 4. This notice may not be removed or altered. |
| */ |
| |
| |
| #include "../machine.h" |
| |
| #if defined(USE_LIB_READDEV) |
| |
| # if !defined(lint) |
| static char copyright[] = |
| "@(#) Copyright 1997 Purdue Research Foundation.\nAll rights reserved.\n"; |
| static char *rcsid = "$Id: rdev.c,v 1.12 2008/10/21 16:13:23 abe Exp $"; |
| # endif /* !defined(lint) */ |
| |
| #include "../lsof.h" |
| |
| |
| _PROTOTYPE(static int rmdupdev,(struct l_dev ***dp, int n, char *nm)); |
| |
| |
| /* |
| * To use this source file: |
| * |
| * 1. Define DIRTYPE as: |
| * |
| * #define DIRTYPE direct |
| * or #define DIRTYPE dirent |
| * |
| * 2. Define HASDNAMLEN if struct DIRTYPE has a d_namlen element, giving |
| * the length of d_name. |
| * |
| * 3. Define the RDEV_EXPDEV macro to apply special handling to device |
| * numbers, as required. For example, for EP/IX 2.1.1: |
| * |
| * #define RDEV_EXPDEV(n) expdev(n) |
| * |
| * to use the expdev() function to expand device numbers. If |
| * no RDEV_EXPDEV macro is defined, it defaults to: |
| * |
| * #define RDEV_EXPDEV(n) (n) |
| * |
| * 4. Define HASBLKDEV to request that information on S_IFBLK devices be |
| * recorded in BDevtp[]. |
| * |
| * Define NOWARNBLKDEV to suppress the issuance of a warning when no |
| * block devices are found. |
| * |
| * 5. Define RDEV_STATFN to be a stat function other than stat() or lstat() |
| * -- e.g., |
| * |
| * #define RDEV_STATFN private_stat |
| * |
| * 6. Define HAS_STD_CLONE to request that clone device information be stored |
| * in standard clone structures (defined in lsof.h and addressed via |
| * Clone). If HAS_STD_CLONE is defined, these must also be defined: |
| * |
| * a. Define CLONEMAJ to be the name of the constant or |
| * variable that defines the clone major device -- e.g., |
| * |
| * #define CLONEMAJ CloneMaj |
| * |
| * b. Define HAVECLONEMAJ to be the name of the variable that |
| * contains the status of the clone major device -- e.g., |
| * |
| * #define HAVECLONEMAJ HaveCloneMaj |
| * |
| * Define HAS_STD_CLONE to be 1 if readdev() is expected to build the |
| * clone table, the clone table is cached (if HASDCACHE is defined), and |
| * there is a function to clear the cache table when the device table must |
| * be reloaded. (See dvch.c for naming the clone cache build and clear |
| * functions.) |
| */ |
| |
| |
| # if !defined(RDEV_EXPDEV) |
| #define RDEV_EXPDEV(n) (n) |
| # endif /* !defined(RDEV_EXPDEV) */ |
| |
| # if !defined(RDEV_STATFN) |
| # if defined(USE_STAT) |
| #define RDEV_STATFN stat |
| # else /* !defined(USE_STAT) */ |
| #define RDEV_STATFN lstat |
| # endif /* defined(USE_STAT) */ |
| # endif /* !defined(RDEV_STATFN) */ |
| |
| |
| /* |
| * readdev() - read device names, modes and types |
| */ |
| |
| void |
| readdev(skip) |
| int skip; /* skip device cache read if 1 */ |
| { |
| |
| # if defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 |
| struct clone *c; |
| # endif /* defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 */ |
| |
| # if defined(HASDCACHE) |
| int dcrd; |
| # endif /* defined(HASDCACHE) */ |
| |
| DIR *dfp; |
| int dnamlen; |
| struct DIRTYPE *dp; |
| char *fp = (char *)NULL; |
| int i = 0; |
| |
| # if defined(HASBLKDEV) |
| int j = 0; |
| # endif /* defined(HASBLKDEV) */ |
| |
| char *path = (char *)NULL; |
| MALLOC_S pl; |
| struct stat sb; |
| |
| if (Sdev) |
| return; |
| |
| # if defined(HASDCACHE) |
| /* |
| * Read device cache, as directed. |
| */ |
| if (!skip) { |
| if (DCstate == 2 || DCstate == 3) { |
| if ((dcrd = read_dcache()) == 0) |
| return; |
| } |
| } else |
| dcrd = 1; |
| # endif /* defined(HASDCACHE) */ |
| |
| Dstkn = Dstkx = 0; |
| Dstk = (char **)NULL; |
| (void) stkdir("/dev"); |
| /* |
| * Unstack the next /dev or /dev/<subdirectory> directory. |
| */ |
| while (--Dstkx >= 0) { |
| if (!(dfp = OpenDir(Dstk[Dstkx]))) { |
| |
| # if defined(WARNDEVACCESS) |
| if (!Fwarn) { |
| (void) fprintf(stderr, "%s: WARNING: can't open: ", Pn); |
| safestrprt(Dstk[Dstkx], stderr, 1); |
| } |
| # endif /* defined(WARNDEVACCESS) */ |
| |
| (void) free((FREE_P *)Dstk[Dstkx]); |
| Dstk[Dstkx] = (char *)NULL; |
| continue; |
| } |
| if (path) { |
| (void) free((FREE_P *)path); |
| path = (char *)NULL; |
| } |
| if (!(path = mkstrcat(Dstk[Dstkx], -1, "/", 1, (char *)NULL, -1, |
| &pl))) |
| { |
| (void) fprintf(stderr, "%s: no space for: ", Pn); |
| safestrprt(Dstk[Dstkx], stderr, 1); |
| Exit(1); |
| } |
| (void) free((FREE_P *)Dstk[Dstkx]); |
| Dstk[Dstkx] = (char *)NULL; |
| /* |
| * Scan the directory. |
| */ |
| for (dp = ReadDir(dfp); dp; dp = ReadDir(dfp)) { |
| if (dp->d_ino == 0 || dp->d_name[0] == '.') |
| continue; |
| /* |
| * Form the full path name and get its status. |
| */ |
| |
| # if defined(HASDNAMLEN) |
| dnamlen = (int)dp->d_namlen; |
| # else /* !defined(HASDNAMLEN) */ |
| dnamlen = (int)strlen(dp->d_name); |
| # endif /* defined(HASDNAMLEN) */ |
| |
| if (fp) { |
| (void) free((FREE_P *)fp); |
| fp = (char *)NULL; |
| } |
| if (!(fp = mkstrcat(path, pl, dp->d_name, dnamlen, |
| (char *)NULL, -1, (MALLOC_S *)NULL))) |
| { |
| (void) fprintf(stderr, "%s: no space for: ", Pn); |
| safestrprt(path, stderr, 0); |
| safestrprtn(dp->d_name, dnamlen, stderr, 1); |
| Exit(1); |
| } |
| if (RDEV_STATFN(fp, &sb) != 0) { |
| if (errno == ENOENT) /* a sym link to nowhere? */ |
| continue; |
| |
| # if defined(WARNDEVACCESS) |
| if (!Fwarn) { |
| int errno_save = errno; |
| |
| (void) fprintf(stderr, "%s: can't stat ", Pn); |
| safestrprt(fp, stderr, 0); |
| (void) fprintf(stderr, ": %s\n", strerror(errno_save)); |
| } |
| # endif /* defined(WARNDEVACCESS) */ |
| |
| continue; |
| } |
| /* |
| * If it's a subdirectory, stack its name for later |
| * processing. |
| */ |
| if ((sb.st_mode & S_IFMT) == S_IFDIR) { |
| (void) stkdir(fp); |
| continue; |
| } |
| if ((sb.st_mode & S_IFMT) == S_IFCHR) { |
| |
| /* |
| * Save character device information in Devtp[]. |
| */ |
| if (i >= Ndev) { |
| Ndev += DEVINCR; |
| if (!Devtp) |
| Devtp = (struct l_dev *)malloc( |
| (MALLOC_S)(sizeof(struct l_dev)*Ndev)); |
| else |
| Devtp = (struct l_dev *)realloc((MALLOC_P *)Devtp, |
| (MALLOC_S)(sizeof(struct l_dev)*Ndev)); |
| if (!Devtp) { |
| (void) fprintf(stderr, |
| "%s: no space for character device\n", Pn); |
| Exit(1); |
| } |
| } |
| Devtp[i].rdev = RDEV_EXPDEV(sb.st_rdev); |
| Devtp[i].inode = (INODETYPE)sb.st_ino; |
| if (!(Devtp[i].name = mkstrcpy(fp, (MALLOC_S *)NULL))) { |
| (void) fprintf(stderr, |
| "%s: no space for device name: ", Pn); |
| safestrprt(fp, stderr, 1); |
| Exit(1); |
| } |
| Devtp[i].v = 0; |
| |
| # if defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 |
| if (HAVECLONEMAJ && GET_MAJ_DEV(Devtp[i].rdev) == CLONEMAJ) |
| { |
| |
| /* |
| * Record clone device information. |
| */ |
| if (!(c = (struct clone *)malloc(sizeof(struct clone)))) |
| { |
| (void) fprintf(stderr, |
| "%s: no space for clone device: ", Pn); |
| safestrprt(fp, stderr, 1); |
| Exit(1); |
| } |
| c->dx = i; |
| c->next = Clone; |
| Clone = c; |
| } |
| # endif /* defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 */ |
| |
| i++; |
| } |
| |
| # if defined(HASBLKDEV) |
| if ((sb.st_mode & S_IFMT) == S_IFBLK) { |
| |
| /* |
| * Save block device information in BDevtp[]. |
| */ |
| if (j >= BNdev) { |
| BNdev += DEVINCR; |
| if (!BDevtp) |
| BDevtp = (struct l_dev *)malloc( |
| (MALLOC_S)(sizeof(struct l_dev)*BNdev)); |
| else |
| BDevtp = (struct l_dev *)realloc((MALLOC_P *)BDevtp, |
| (MALLOC_S)(sizeof(struct l_dev)*BNdev)); |
| if (!BDevtp) { |
| (void) fprintf(stderr, |
| "%s: no space for block device\n", Pn); |
| Exit(1); |
| } |
| } |
| BDevtp[j].name = fp; |
| fp = (char *)NULL; |
| BDevtp[j].inode = (INODETYPE)sb.st_ino; |
| BDevtp[j].rdev = RDEV_EXPDEV(sb.st_rdev); |
| BDevtp[j].v = 0; |
| j++; |
| } |
| # endif /* defined(HASBLKDEV) */ |
| |
| } |
| (void) CloseDir(dfp); |
| } |
| /* |
| * Free any allocated space. |
| */ |
| if (!Dstk) { |
| (void) free((FREE_P *)Dstk); |
| Dstk = (char **)NULL; |
| } |
| if (fp) |
| (void) free((FREE_P *)fp); |
| if (path) |
| (void) free((FREE_P *)path); |
| |
| # if defined(HASBLKDEV) |
| /* |
| * Reduce the BDevtp[] (optional) and Devtp[] tables to their minimum |
| * sizes; allocate and build sort pointer lists; and sort the tables by |
| * device number. |
| */ |
| if (BNdev) { |
| if (BNdev > j) { |
| BNdev = j; |
| BDevtp = (struct l_dev *)realloc((MALLOC_P *)BDevtp, |
| (MALLOC_S)(sizeof(struct l_dev) * BNdev)); |
| } |
| if (!(BSdev = (struct l_dev **)malloc( |
| (MALLOC_S)(sizeof(struct l_dev *) * BNdev)))) |
| { |
| (void) fprintf(stderr, |
| "%s: no space for block device sort pointers\n", Pn); |
| Exit(1); |
| } |
| for (j = 0; j < BNdev; j++) { |
| BSdev[j] = &BDevtp[j]; |
| } |
| (void) qsort((QSORT_P *)BSdev, (size_t)BNdev, |
| (size_t)sizeof(struct l_dev *), compdev); |
| BNdev = rmdupdev(&BSdev, BNdev, "block"); |
| } |
| |
| # if !defined(NOWARNBLKDEV) |
| else { |
| if (!Fwarn) |
| (void) fprintf(stderr, |
| "%s: WARNING: no block devices found\n", Pn); |
| } |
| # endif /* !defined(NOWARNBLKDEV) */ |
| # endif /* defined(HASBLKDEV) */ |
| |
| if (Ndev) { |
| if (Ndev > i) { |
| Ndev = i; |
| Devtp = (struct l_dev *)realloc((MALLOC_P *)Devtp, |
| (MALLOC_S)(sizeof(struct l_dev) * Ndev)); |
| } |
| if (!(Sdev = (struct l_dev **)malloc( |
| (MALLOC_S)(sizeof(struct l_dev *) * Ndev)))) |
| { |
| (void) fprintf(stderr, |
| "%s: no space for character device sort pointers\n", Pn); |
| Exit(1); |
| } |
| for (i = 0; i < Ndev; i++) { |
| Sdev[i] = &Devtp[i]; |
| } |
| (void) qsort((QSORT_P *)Sdev, (size_t)Ndev, |
| (size_t)sizeof(struct l_dev *), compdev); |
| Ndev = rmdupdev(&Sdev, Ndev, "char"); |
| } else { |
| (void) fprintf(stderr, "%s: no character devices found\n", Pn); |
| Exit(1); |
| } |
| |
| # if defined(HASDCACHE) |
| /* |
| * Write device cache file, as required. |
| */ |
| if (DCstate == 1 || (DCstate == 3 && dcrd)) |
| write_dcache(); |
| # endif /* defined(HASDCACHE) */ |
| |
| } |
| |
| |
| # if defined(HASDCACHE) |
| /* |
| * rereaddev() - reread device names, modes and types |
| */ |
| |
| void |
| rereaddev() |
| { |
| (void) clr_devtab(); |
| |
| # if defined(DCACHE_CLR) |
| (void) DCACHE_CLR(); |
| # endif /* defined(DCACHE_CLR) */ |
| |
| readdev(1); |
| DCunsafe = 0; |
| } |
| #endif /* defined(HASDCACHE) */ |
| |
| |
| /* |
| * rmdupdev() - remove duplicate (major/minor/inode) devices |
| */ |
| |
| static int |
| rmdupdev(dp, n, nm) |
| struct l_dev ***dp; /* device table pointers address */ |
| int n; /* number of pointers */ |
| char *nm; /* device table name for error message */ |
| { |
| |
| # if defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 |
| struct clone *c, *cp; |
| # endif /* defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 */ |
| |
| int i, j, k; |
| struct l_dev **p; |
| |
| for (i = j = 0, p = *dp; i < n ;) { |
| for (k = i + 1; k < n; k++) { |
| if (p[i]->rdev != p[k]->rdev || p[i]->inode != p[k]->inode) |
| break; |
| |
| # if defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 |
| /* |
| * See if we're deleting a duplicate clone device. If so, |
| * delete its clone table entry. |
| */ |
| for (c = Clone, cp = (struct clone *)NULL; |
| c; |
| cp = c, c = c->next) |
| { |
| if (&Devtp[c->dx] != p[k]) |
| continue; |
| if (!cp) |
| Clone = c->next; |
| else |
| cp->next = c->next; |
| (void) free((FREE_P *)c); |
| break; |
| } |
| # endif /* defined(HAS_STD_CLONE) && HAS_STD_CLONE==1 */ |
| |
| } |
| if (i != j) |
| p[j] = p[i]; |
| j++; |
| i = k; |
| } |
| if (n == j) |
| return(n); |
| if (!(*dp = (struct l_dev **)realloc((MALLOC_P *)*dp, |
| (MALLOC_S)(j * sizeof(struct l_dev *))))) |
| { |
| (void) fprintf(stderr, "%s: can't realloc %s device pointers\n", |
| Pn, nm); |
| Exit(1); |
| } |
| return(j); |
| } |
| |
| |
| # if defined(HASDCACHE) |
| /* |
| * vfy_dev() - verify a device table entry (usually when DCunsafe == 1) |
| * |
| * Note: rereads entire device table when an entry can't be verified. |
| */ |
| |
| int |
| vfy_dev(dp) |
| struct l_dev *dp; /* device table pointer */ |
| { |
| struct stat sb; |
| |
| if (!DCunsafe || dp->v) |
| return(1); |
| if (RDEV_STATFN(dp->name, &sb) != 0 |
| || dp->rdev != RDEV_EXPDEV(sb.st_rdev) |
| || dp->inode != sb.st_ino) { |
| (void) rereaddev(); |
| return(0); |
| } |
| dp->v = 1; |
| return(1); |
| } |
| # endif /* defined(HASDCACHE) */ |
| #else /* !defined(USE_LIB_READDEV) */ |
| char rdev_d1[] = "d"; char *rdev_d2 = rdev_d1; |
| #endif /* defined(USE_LIB_READDEV) */ |