| /* |
| * isfn.c -- is_file_named() 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. |
| */ |
| |
| |
| /* |
| * To use this source file: |
| * |
| * 1. Define USE_LIB_IS_FILE_NAMED. |
| * |
| * 2. If clone support is required: |
| * |
| * a. Define HAVECLONEMAJ to be the name of the variable that |
| * contains the status of the clone major device -- e.g., |
| * |
| * #define HAVECLONEMAJ HaveCloneMaj |
| * |
| * b. Define CLONEMAJ to be the name of the constant or |
| * variable that defines the clone major device -- e.g., |
| * |
| * #define CLONEMAJ CloneMaj |
| * |
| * c. Make sure that clone devices are identified by an lfile |
| * element is_stream value of 1. |
| * |
| * d. Accept clone searching by device number only. |
| */ |
| |
| |
| #include "../machine.h" |
| |
| #if defined(USE_LIB_IS_FILE_NAMED) |
| |
| # if !defined(lint) |
| static char copyright[] = |
| "@(#) Copyright 1997 Purdue Research Foundation.\nAll rights reserved.\n"; |
| static char *rcsid = "$Id: isfn.c,v 1.10 2008/10/21 16:12:36 abe Exp $"; |
| # endif /* !defined(lint) */ |
| |
| #include "../lsof.h" |
| |
| |
| /* |
| * Local structures |
| */ |
| |
| struct hsfile { |
| struct sfile *s; /* the Sfile table address */ |
| struct hsfile *next; /* the next hash bucket entry */ |
| }; |
| |
| /* |
| * Local static variables |
| */ |
| |
| # if defined(HAVECLONEMAJ) |
| static struct hsfile *HbyCd = /* hash by clone buckets */ |
| (struct hsfile *)NULL; |
| static int HbyCdCt = 0; /* HbyCd entry count */ |
| # endif /* defined(HAVECLONEMAJ) */ |
| |
| static struct hsfile *HbyFdi = /* hash by file (dev,ino) buckets */ |
| (struct hsfile *)NULL; |
| static int HbyFdiCt = 0; /* HbyFdi entry count */ |
| static struct hsfile *HbyFrd = /* hash by file raw device buckets */ |
| (struct hsfile *)NULL; |
| static int HbyFrdCt = 0; /* HbyFrd entry count */ |
| static struct hsfile *HbyFsd = /* hash by file system buckets */ |
| (struct hsfile *)NULL; |
| static int HbyFsdCt = 0; /* HbyFsd entry count */ |
| static struct hsfile *HbyNm = /* hash by name buckets */ |
| (struct hsfile *)NULL; |
| static int HbyNmCt = 0; /* HbyNm entry count */ |
| |
| |
| /* |
| * Local definitions |
| */ |
| |
| # if defined(HAVECLONEMAJ) |
| #define SFCDHASH 1024 /* Sfile hash by clone device (power |
| * of 2!) */ |
| # endif /* defined(HAVECLONEMAJ) */ |
| |
| #define SFDIHASH 4094 /* Sfile hash by (device,inode) number |
| * pair bucket count (power of 2!) */ |
| #define SFFSHASH 1024 /* Sfile hash by file system device |
| * number bucket count (power of 2!) */ |
| #define SFHASHDEVINO(maj, min, ino, mod) ((int)(((int)((((int)(maj+1))*((int)((min+1))))+ino)*31415)&(mod-1))) |
| /* hash for Sfile by major device, |
| * minor device, and inode, modulo mod |
| * (mod must be a power of 2) */ |
| #define SFRDHASH 1024 /* Sfile hash by raw device number |
| * bucket count (power of 2!) */ |
| #define SFHASHRDEVI(maj, min, rmaj, rmin, ino, mod) ((int)(((int)((((int)(maj+1))*((int)((min+1))))+((int)(rmaj+1)*(int)(rmin+1))+ino)*31415)&(mod-1))) |
| /* hash for Sfile by major device, |
| * minor device, major raw device, |
| * minor raw device, and inode, modulo |
| * mod (mod must be a power of 2) */ |
| #define SFNMHASH 4096 /* Sfile hash by name bucket count |
| * (must be a power of 2!) */ |
| |
| |
| |
| /* |
| * hashSfile() - hash Sfile entries for use in is_file_named() searches |
| */ |
| |
| void |
| hashSfile() |
| { |
| static int hs = 0; |
| int i; |
| int sfplm = 3; |
| struct sfile *s; |
| struct hsfile *sh, *sn; |
| /* |
| * Do nothing if there are no file search arguments cached or if the |
| * hashes have already been constructed. |
| */ |
| if (!Sfile || hs) |
| return; |
| /* |
| * Allocate hash buckets by (device,inode), file system device, and file name. |
| */ |
| |
| # if defined(HAVECLONEMAJ) |
| if (HAVECLONEMAJ) { |
| if (!(HbyCd = (struct hsfile *)calloc((MALLOC_S)SFCDHASH, |
| sizeof(struct hsfile)))) |
| { |
| (void) fprintf(stderr, |
| "%s: can't allocate space for %d clone hash buckets\n", |
| Pn, SFCDHASH); |
| Exit(1); |
| } |
| sfplm++; |
| } |
| # endif /* defined(HAVECLONEMAJ) */ |
| |
| if (!(HbyFdi = (struct hsfile *)calloc((MALLOC_S)SFDIHASH, |
| sizeof(struct hsfile)))) |
| { |
| (void) fprintf(stderr, |
| "%s: can't allocate space for %d (dev,ino) hash buckets\n", |
| Pn, SFDIHASH); |
| Exit(1); |
| } |
| if (!(HbyFrd = (struct hsfile *)calloc((MALLOC_S)SFRDHASH, |
| sizeof(struct hsfile)))) |
| { |
| (void) fprintf(stderr, |
| "%s: can't allocate space for %d rdev hash buckets\n", |
| Pn, SFRDHASH); |
| Exit(1); |
| } |
| if (!(HbyFsd = (struct hsfile *)calloc((MALLOC_S)SFFSHASH, |
| sizeof(struct hsfile)))) |
| { |
| (void) fprintf(stderr, |
| "%s: can't allocate space for %d file sys hash buckets\n", |
| Pn, SFFSHASH); |
| Exit(1); |
| } |
| if (!(HbyNm = (struct hsfile *)calloc((MALLOC_S)SFNMHASH, |
| sizeof(struct hsfile)))) |
| { |
| (void) fprintf(stderr, |
| "%s: can't allocate space for %d name hash buckets\n", |
| Pn, SFNMHASH); |
| Exit(1); |
| } |
| hs++; |
| /* |
| * Scan the Sfile chain, building file, file system, raw device, and file |
| * name hash bucket chains. |
| */ |
| for (s = Sfile; s; s = s->next) { |
| for (i = 0; i < sfplm; i++) { |
| if (i == 0) { |
| if (!s->aname) |
| continue; |
| sh = &HbyNm[hashbyname(s->aname, SFNMHASH)]; |
| HbyNmCt++; |
| } else if (i == 1) { |
| if (s->type) { |
| sh = &HbyFdi[SFHASHDEVINO(GET_MAJ_DEV(s->dev), |
| GET_MIN_DEV(s->dev), s->i, |
| SFDIHASH)]; |
| HbyFdiCt++; |
| } else { |
| sh = &HbyFsd[SFHASHDEVINO(GET_MAJ_DEV(s->dev), |
| GET_MIN_DEV(s->dev), |
| 0, |
| SFFSHASH)]; |
| HbyFsdCt++; |
| } |
| } else if (i == 2) { |
| if ((s->mode == S_IFCHR) || (s->mode == S_IFBLK)) { |
| sh = &HbyFrd[SFHASHRDEVI(GET_MAJ_DEV(s->dev), |
| GET_MIN_DEV(s->dev), |
| GET_MAJ_DEV(s->rdev), |
| GET_MIN_DEV(s->rdev), |
| s->i, |
| SFRDHASH)]; |
| HbyFrdCt++; |
| } else |
| continue; |
| } |
| |
| # if defined(HAVECLONEMAJ) |
| else { |
| if (!HAVECLONEMAJ || (GET_MAJ_DEV(s->rdev) != CLONEMAJ)) |
| continue; |
| sh = &HbyCd[SFHASHDEVINO(0, GET_MIN_DEV(s->rdev), 0, |
| SFCDHASH)]; |
| HbyCdCt++; |
| } |
| # else /* ! defined(HAVECLONEMAJ) */ |
| else |
| continue; |
| # endif /* defined(HAVECLONEMAJ) */ |
| |
| if (!sh->s) { |
| sh->s = s; |
| sh->next = (struct hsfile *)NULL; |
| continue; |
| } else { |
| if (!(sn = (struct hsfile *)malloc( |
| (MALLOC_S)sizeof(struct hsfile)))) |
| { |
| (void) fprintf(stderr, |
| "%s: can't allocate hsfile bucket for: %s\n", |
| Pn, s->aname); |
| Exit(1); |
| } |
| sn->s = s; |
| sn->next = sh->next; |
| sh->next = sn; |
| } |
| } |
| } |
| } |
| |
| |
| /* |
| * is_file_named() - is this file named? |
| */ |
| |
| int |
| is_file_named(p, cd) |
| char *p; /* path name; NULL = search by device |
| * and inode (from *Lf) */ |
| int cd; /* character or block type file -- |
| * VCHR or VBLK vnode, or S_IFCHR |
| * or S_IFBLK inode */ |
| { |
| char *ep; |
| int f = 0; |
| struct sfile *s = (struct sfile *)NULL; |
| struct hsfile *sh; |
| size_t sz; |
| /* |
| * Check for a path name match, as requested. |
| */ |
| if (p && HbyNmCt) { |
| for (sh = &HbyNm[hashbyname(p, SFNMHASH)]; sh; sh = sh->next) { |
| if ((s = sh->s) && strcmp(p, s->aname) == 0) { |
| f = 2; |
| break; |
| } |
| } |
| } |
| |
| # if defined(HAVECLONEMAJ) |
| /* |
| * If this is a stream, check for a clone device match. |
| */ |
| if (!f && HbyCdCt && Lf->is_stream && Lf->dev_def && Lf->rdev_def |
| && (Lf->dev == DevDev)) |
| { |
| for (sh = &HbyCd[SFHASHDEVINO(0, GET_MAJ_DEV(Lf->rdev), 0, |
| SFCDHASH)]; |
| sh; |
| sh = sh->next) |
| { |
| if ((s = sh->s) && (GET_MAJ_DEV(Lf->rdev) |
| == GET_MIN_DEV(s->rdev))) { |
| f = 3; |
| break; |
| } |
| } |
| } |
| # endif /* defined(HAVECLONEMAJ) */ |
| |
| /* |
| * Check for a regular file. |
| */ |
| if (!f && HbyFdiCt && Lf->dev_def |
| && (Lf->inp_ty == 1 || Lf->inp_ty == 3)) |
| { |
| for (sh = &HbyFdi[SFHASHDEVINO(GET_MAJ_DEV(Lf->dev), |
| GET_MIN_DEV(Lf->dev), |
| Lf->inode, |
| SFDIHASH)]; |
| sh; |
| sh = sh->next) |
| { |
| if ((s = sh->s) && (Lf->dev == s->dev) |
| && (Lf->inode == s->i)) { |
| f = 1; |
| break; |
| } |
| } |
| } |
| /* |
| * Check for a file system match. |
| */ |
| if (!f && HbyFsdCt && Lf->dev_def) { |
| for (sh = &HbyFsd[SFHASHDEVINO(GET_MAJ_DEV(Lf->dev), |
| GET_MIN_DEV(Lf->dev), 0, |
| SFFSHASH)]; |
| sh; |
| sh = sh->next) |
| { |
| if ((s = sh->s) && (s->dev == Lf->dev)) { |
| f = 1; |
| break; |
| } |
| } |
| } |
| /* |
| * Check for a character or block device match. |
| */ |
| if (!f && HbyFrdCt && cd |
| && Lf->dev_def && (Lf->dev == DevDev) |
| && Lf->rdev_def |
| && (Lf->inp_ty == 1 || Lf->inp_ty == 3)) |
| { |
| for (sh = &HbyFrd[SFHASHRDEVI(GET_MAJ_DEV(Lf->dev), |
| GET_MIN_DEV(Lf->dev), |
| GET_MAJ_DEV(Lf->rdev), |
| GET_MIN_DEV(Lf->rdev), |
| Lf->inode, SFRDHASH)]; |
| sh; |
| sh = sh->next) |
| { |
| if ((s = sh->s) && (s->dev == Lf->dev) |
| && (s->rdev == Lf->rdev) && (s->i == Lf->inode)) |
| { |
| f = 1; |
| break; |
| } |
| } |
| } |
| /* |
| * Convert the name if a match occurred. |
| */ |
| switch (f) { |
| case 0: |
| return(0); |
| case 1: |
| if (s->type) { |
| |
| /* |
| * If the search argument isn't a file system, propagate it |
| * to Namech[]; otherwise, let printname() compose the name. |
| */ |
| (void) snpf(Namech, Namechl, "%s", s->name); |
| if (s->devnm) { |
| ep = endnm(&sz); |
| (void) snpf(ep, sz, " (%s)", s->devnm); |
| } |
| } |
| break; |
| case 2: |
| (void) strcpy(Namech, p); |
| break; |
| |
| # if defined(HAVECLONEMAJ) |
| /* case 3: do nothing for stream clone matches */ |
| # endif /* defined(HAVECLONEMAJ) */ |
| |
| } |
| if (s) |
| s->f = 1; |
| return(1); |
| } |
| #else /* !defined(USE_LIB_IS_FILE_NAMED) */ |
| char isfn_d1[] = "d"; char *isfn_d2 = isfn_d1; |
| #endif /* defined(USE_LIB_IS_FILE_NAMED) */ |