summaryrefslogtreecommitdiff
path: root/lib/rnam.c
diff options
context:
space:
mode:
authorPatrick McCarty <patrick.mccarty@linux.intel.com>2013-02-08 13:26:27 -0800
committerPatrick McCarty <patrick.mccarty@linux.intel.com>2013-02-08 13:26:27 -0800
commit9bb81f8a90ecc8b70c955bff72ec59dd3d9e5ae7 (patch)
tree881eebfa461e4f8aa6b6f44b96ac0decd3bc887a /lib/rnam.c
downloadlsof-9bb81f8a90ecc8b70c955bff72ec59dd3d9e5ae7.tar.gz
lsof-9bb81f8a90ecc8b70c955bff72ec59dd3d9e5ae7.tar.bz2
lsof-9bb81f8a90ecc8b70c955bff72ec59dd3d9e5ae7.zip
Imported Upstream version 4.87upstream/4.87
Diffstat (limited to 'lib/rnam.c')
-rw-r--r--lib/rnam.c669
1 files changed, 669 insertions, 0 deletions
diff --git a/lib/rnam.c b/lib/rnam.c
new file mode 100644
index 0000000..c7ed582
--- /dev/null
+++ b/lib/rnam.c
@@ -0,0 +1,669 @@
+/*
+ * rnam.c -- BSD format name cache functions 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(HASNCACHE) && defined(USE_LIB_RNAM)
+
+# if !defined(lint)
+static char copyright[] =
+"@(#) Copyright 1997 Purdue Research Foundation.\nAll rights reserved.\n";
+static char *rcsid = "$Id: rnam.c,v 1.11 2008/10/21 16:13:23 abe Exp $";
+# endif /* !defined(lint) */
+
+#include "../lsof.h"
+
+
+/*
+ * rnam.c - read BSD format (struct namecache or nch) name cache
+ *
+ * This code is effective only when HASNCACHE is defined.
+ */
+
+/*
+ * The caller must:
+ *
+ * #include the relevant header file -- e.g., <sys/namei.h>.
+ *
+ * Define X_NCACHE as the nickname for the kernel cache address.
+ *
+ * Define X_NCSIZE as the nickname for the size of the kernel cache.
+ *
+ * Define NCACHE_NXT if the kernel's name cache is a linked list, starting
+ * at the X_NCACHE address, rather than a table, starting at that address.
+ *
+ * Define NCACHE_NO_ROOT if the calling dialect doesn't support
+ * the locating of the root node of a file system.
+ *
+ * Define the name of the name cache structure -- e.g.,
+ *
+ * #define NCACHE <structure name>
+ *
+ * Define the following casts, if they differ from the defaults:
+ *
+ * NCACHE_SZ_CAST cast for X_NCSIZE (default int)
+ *
+ * e.g.,
+ * #define NCACHE_SZ_CAST unsigned long
+ *
+ * Define the names of these elements of struct NCACHE:
+ *
+ * must #define NCACHE_NM <name>
+ * must #define NCACHE_NMLEN <name length
+ * optional #define NCACHE_NXT <link to next entry>
+ * must #define NCACHE_NODEADDR <node address>
+ * must #define NCACHE_NODEID <node capability ID)
+ * optional #define NCACHE_PARADDR <parent node address>
+ * optional #define NCACHE_PARID <parent node capability ID)
+ *
+ * The caller may need to:
+ *
+ * Define NCHNAMLEN as the length of the name element of NCACHE, if it's
+ * not defined in the header file that defines the NCACHE structure.
+ *
+ * Define this prototype for ncache_load():
+ *
+ * _PROTOTYPE(static void ncache_load,(void));
+ */
+
+
+/*
+ * Local static values
+ */
+
+static int Mch; /* name cache hash mask */
+
+# if !defined(NCACHE_NC_CAST)
+#define NCACHE_SZ_CAST int
+# endif /* !defined(NCACHE_NC_CAST) */
+
+static NCACHE_SZ_CAST Nc = 0; /* size of name cache */
+static int Nch = 0; /* size of name cache hash pointer
+ * table */
+struct l_nch {
+ KA_T na; /* node address */
+
+# if defined(NCACHE_NODEID)
+ unsigned long id; /* capability ID */
+# endif /* defined(NCACHE_NODEID) */
+
+# if defined(NCACHE_PARADDR) && defined(NCACHE_PARID)
+ KA_T pa; /* parent node address */
+ struct l_nch *pla; /* parent local node address */
+ unsigned long did; /* parent capability ID */
+# endif /* defined(NCACHE_PARADDR) && defined(NCACHE_PARID) */
+
+ char nm[NCHNAMLEN+1]; /* name */
+ int nl; /* name length */
+};
+
+static struct l_nch *Ncache = (struct l_nch*)NULL;
+ /* the local name cache */
+static struct l_nch **Nchash = (struct l_nch **)NULL;
+ /* Ncache hash pointers */
+static int Ncfirst = 1; /* first-call status */
+
+# if defined(NCACHE_NODEID)
+#define ncachehash(i,n) Nchash+(((((int)(n)>>2)+((int)(i)))*31415)&Mch)
+_PROTOTYPE(static struct l_nch *ncache_addr,(unsigned long i, KA_T na));
+# else /* !defined(NCACHE_NODEID) */
+#define ncachehash(n) Nchash+((((int)(n)>>2)*31415)&Mch)
+_PROTOTYPE(static struct l_nch *ncache_addr,(KA_T na));
+# endif /* defined(NCACHE_NODEID) */
+
+#define DEFNCACHESZ 1024 /* local size if X_NCSIZE kernel value < 1 */
+#define LNCHINCRSZ 64 /* local size increment */
+
+# if !defined(NCACHE_NO_ROOT)
+_PROTOTYPE(static int ncache_isroot,(KA_T na, char *cp));
+# endif /* !defined(NCACHE_NO_ROOT) */
+
+
+/*
+ * ncache_addr() - look up a node's local ncache address
+ */
+
+static struct l_nch *
+
+# if defined(NCACHE_NODEID)
+ncache_addr(i, na)
+ unsigned long i; /* node's capability ID */
+# else /* !defined(NCACHE_NODEID) */
+ncache_addr(na)
+# endif /* defined(NCACHE_NODEID) */
+
+ KA_T na; /* node's address */
+{
+ struct l_nch **hp;
+
+# if defined(NCACHE_NODEID)
+ for (hp = ncachehash(i, na); *hp; hp++)
+# else /* !defined(NCACHE_NODEID) */
+ for (hp = ncachehash(na); *hp; hp++)
+# endif /* defined(NCACHE_NODEID) */
+
+ {
+
+# if defined(NCACHE_NODEID)
+ if ((*hp)->id == i && (*hp)->na == na)
+# else /* !defined(NCACHE_NODEID) */
+ if ((*hp)->na == na)
+# endif /* defined(NCACHE_NODEID) */
+
+ return(*hp);
+ }
+ return((struct l_nch *)NULL);
+}
+
+
+# if !defined(NCACHE_NO_ROOT)
+/*
+ * ncache_isroot() - is head of name cache path a file system root?
+ */
+
+static int
+ncache_isroot(na, cp)
+ KA_T na; /* kernel node address */
+ char *cp; /* partial path */
+{
+ char buf[MAXPATHLEN];
+ int i;
+ MALLOC_S len;
+ struct mounts *mtp;
+ static int nca = 0;
+ static int ncn = 0;
+ static KA_T *nc = (KA_T *)NULL;
+ struct stat sb;
+ struct vnode v;
+
+ if (!na)
+ return(0);
+/*
+ * Search the root vnode cache.
+ */
+ for (i = 0; i < ncn; i++) {
+ if (na == nc[i])
+ return(1);
+ }
+/*
+ * Read the vnode and see if it's a VDIR node with the VROOT flag set. If
+ * it is, then the path is complete.
+ *
+ * If it isn't, and if the file has an inode number, search the mount table
+ * and see if the file system's inode number is known. If it is, form the
+ * possible full path, safely stat() it, and see if it's inode number matches
+ * the one we have for this file. If it does, then the path is complete.
+ */
+ if (kread((KA_T)na, (char *)&v, sizeof(v))
+ || v.v_type != VDIR || !(v.v_flag & VROOT)) {
+
+ /*
+ * The vnode tests failed. Try the inode tests.
+ */
+ if (Lf->inp_ty != 1 || !Lf->inode
+ || !Lf->fsdir || (len = strlen(Lf->fsdir)) < 1)
+ return(0);
+ if ((len + 1 + strlen(cp) + 1) > sizeof(buf))
+ return(0);
+ for (mtp = readmnt(); mtp; mtp = mtp->next) {
+ if (!mtp->dir || !mtp->inode)
+ continue;
+ if (strcmp(Lf->fsdir, mtp->dir) == 0)
+ break;
+ }
+ if (!mtp)
+ return(0);
+ (void) strcpy(buf, Lf->fsdir);
+ if (buf[len - 1] != '/')
+ buf[len++] = '/';
+ (void) strcpy(&buf[len], cp);
+ if (statsafely(buf, &sb) != 0
+ || (unsigned long)sb.st_ino != Lf->inode)
+ return(0);
+ }
+/*
+ * Add the node address to the root node cache.
+ */
+ if (ncn >= nca) {
+ if (!nca) {
+ len = (MALLOC_S)(10 * sizeof(KA_T));
+ nc = (KA_T *)malloc(len);
+ } else {
+ len = (MALLOC_S)((nca + 10) * sizeof(KA_T));
+ nc = (KA_T *)realloc(nc, len);
+ }
+ if (!nc) {
+ (void) fprintf(stderr, "%s: no space for root node table\n",
+ Pn);
+ Exit(1);
+ }
+ nca += 10;
+ }
+ nc[ncn++] = na;
+ return(1);
+}
+# endif /* !defined(NCACHE_NO_ROOT) */
+
+
+/*
+ * ncache_load() - load the kernel's name cache
+ */
+
+void
+ncache_load()
+{
+ struct l_nch **hp, *lc;
+ int i, len, n;
+ static int iNc = 0;
+ struct NCACHE *kc;
+ static KA_T kp = (KA_T)NULL;
+ KA_T v;
+
+# if defined(NCACHE_NXT)
+ static KA_T kf;
+ struct NCACHE nc;
+# else /* !defined NCACHE_NXT) */
+ static struct NCACHE *kca = (struct NCACHE *)NULL;
+# endif /* defined(NCACHE_NXT) */
+
+ if (!Fncache)
+ return;
+ if (Ncfirst) {
+
+ /*
+ * Do startup (first-time) functions.
+ */
+ Ncfirst = 0;
+ /*
+ * Establish kernel cache size.
+ */
+ v = (KA_T)0;
+ if (get_Nl_value(X_NCSIZE, (struct drive_Nl *)NULL, &v) < 0
+ || !v
+ || kread((KA_T)v, (char *)&Nc, sizeof(Nc)))
+ {
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: WARNING: can't read name cache size: %s\n",
+ Pn, print_kptr(v, (char *)NULL, 0));
+ iNc = Nc = 0;
+ return;
+ }
+ iNc = Nc;
+ if (Nc < 1) {
+ if (!Fwarn) {
+ (void) fprintf(stderr,
+ "%s: WARNING: kernel name cache size: %d\n", Pn, Nc);
+ (void) fprintf(stderr,
+ " Cache size assumed to be: %d\n", DEFNCACHESZ);
+ }
+ iNc = Nc = DEFNCACHESZ;
+ }
+ /*
+ * Establish kernel cache address.
+ */
+ v = (KA_T)0;
+ if (get_Nl_value(X_NCACHE, (struct drive_Nl *)NULL, &v) < 0
+ || !v
+ || kread((KA_T)v, (char *)&kp, sizeof(kp))) {
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: WARNING: can't read name cache address: %s\n",
+ Pn, print_kptr(v, (char *)NULL, 0));
+ iNc = Nc = 0;
+ return;
+ }
+
+# if defined(NCACHE_NXT)
+ kf = kp;
+
+# else /* !defined(NCACHE_NXT) */
+ /*
+ * Allocate space for a local copy of the kernel's cache.
+ */
+ len = Nc * sizeof(struct NCACHE);
+ if (!(kca = (struct NCACHE *)malloc((MALLOC_S)len))) {
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: can't allocate name cache space: %d\n", Pn, len);
+ Exit(1);
+ }
+# endif /* defined(NCACHE_NXT) */
+
+ /*
+ * Allocate space for the local cache.
+ */
+ len = Nc * sizeof(struct l_nch);
+ if (!(Ncache = (struct l_nch *)malloc((MALLOC_S)len))) {
+
+no_local_space:
+
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: no space for %d byte local name cache\n", Pn, len);
+ Exit(1);
+ }
+ } else {
+
+ /*
+ * Do setup for repeat calls.
+ */
+ if ((Nc = iNc) == 0)
+ return;
+ if (Nchash) {
+ (void) free((FREE_P *)Nchash);
+ Nchash = (struct l_nch **)NULL;
+ }
+
+# if defined(NCACHE_NXT)
+ kp = kf;
+# endif /* defined(NCACHE_NXT) */
+
+ }
+
+# if !defined(NCACHE_NXT)
+
+/*
+ * Read the kernel's name cache.
+ */
+ if (kread(kp, (char *)kca, (Nc * sizeof(struct NCACHE)))) {
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: WARNING: can't read kernel's name cache: %s\n",
+ Pn, print_kptr(kp, (char *)NULL, 0));
+ Nc = 0;
+ return;
+ }
+# endif /* !defined(NCACHE_NXT) */
+
+/*
+ * Build a local copy of the kernel name cache.
+ */
+
+# if defined(NCACHE_NXT)
+ for (i = iNc * 16, kc = &nc, lc = Ncache, n = 0; kp; )
+# else /* !defined(NCACHE_NXT) */
+ for (i = n = 0, kc = kca, lc = Ncache; i < Nc; i++, kc++)
+# endif /* defined(NCACHE_NXT) */
+
+ {
+
+# if defined(NCACHE_NXT)
+ if (kread(kp, (char *)kc, sizeof(nc)))
+ break;
+ if ((kp = (KA_T)kc->NCACHE_NXT) == kf)
+ kp = (KA_T)NULL;
+# endif /* defined(NCACHE_NXT) */
+
+ if (!kc->NCACHE_NODEADDR)
+ continue;
+ if ((len = kc->NCACHE_NMLEN) < 1 || len > NCHNAMLEN)
+ continue;
+ if (len < 3 && kc->NCACHE_NM[0] == '.') {
+ if (len == 1 || (len == 2 && kc->NCACHE_NM[1] == '.'))
+ continue;
+ }
+
+# if defined(NCACHE_NXT)
+ if (n >= Nc) {
+ Nc += LNCHINCRSZ;
+ if (!(Ncache = (struct l_nch *)realloc(Ncache,
+ (MALLOC_S)(Nc * sizeof(struct l_nch)))))
+ {
+ (void) fprintf(stderr,
+ "%s: no more space for %d entry local name cache\n",
+ Pn, Nc);
+ Exit(1);
+ }
+ lc = &Ncache[n];
+ }
+# endif /* defined(NCACHE_NXT) */
+
+# if defined(NCACHE_NODEID)
+ lc->na = (KA_T)kc->NCACHE_NODEADDR;
+ lc->id = kc->NCACHE_NODEID;
+# endif /* defined(NCACHE_NODEID) */
+
+# if defined(NCACHE_PARADDR)
+ lc->pa = (KA_T)kc->NCACHE_PARADDR;
+ lc->pla = (struct l_nch *)NULL;
+# endif /* defined(NCACHE_PARADDR) */
+
+# if defined(NCACHE_PARID)
+ lc->did = kc->NCACHE_PARID;
+# endif /* defined(NCACHE_PARID) */
+
+ (void) strncpy(lc->nm, kc->NCACHE_NM, len);
+ lc->nm[len] = '\0';
+ lc->nl = strlen(lc->nm);
+ n++;
+ lc++;
+
+# if defined(NCACHE_NXT)
+ if (n >= i) {
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: WARNING: name cache truncated at %d entries\n",
+ Pn, n);
+ break;
+ }
+# endif /* defined(NCACHE_NXT) */
+
+ }
+/*
+ * Reduce memory usage, as required.
+ */
+
+# if !defined(NCACHE_NXT)
+ if (!RptTm)
+ (void) free((FREE_P *)kca);
+# endif /* !defined(NCACHE_NXT) */
+
+ if (n < 1) {
+ Nc = 0;
+ if (!RptTm) {
+ (void) free((FREE_P *)Ncache);
+ Ncache = (struct l_nch *)NULL;
+ }
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: WARNING: unusable name cache size: %d\n", Pn, n);
+ return;
+ }
+ if (n < Nc) {
+ Nc = n;
+ if (!RptTm) {
+ len = Nc * sizeof(struct l_nch);
+ if (!(Ncache = (struct l_nch *)realloc(Ncache, len)))
+ goto no_local_space;
+ }
+ }
+/*
+ * Build a hash table to locate Ncache entries.
+ */
+ for (Nch = 1; Nch < Nc; Nch <<= 1)
+ ;
+ Nch <<= 1;
+ Mch = Nch - 1;
+ if (!(Nchash = (struct l_nch **)calloc(Nch+Nc, sizeof(struct l_nch *))))
+ {
+ if (!Fwarn)
+ (void) fprintf(stderr,
+ "%s: no space for %d name cache hash pointers\n",
+ Pn, Nch + Nc);
+ Exit(1);
+ }
+ for (i = 0, lc = Ncache; i < Nc; i++, lc++) {
+
+# if defined(NCACHE_NODEID)
+ for (hp = ncachehash(lc->id, lc->na), n = 1; *hp; hp++)
+# else /* defined(NCACHE_NODEID) */
+ for (hp = ncachehash(lc->na), n = 1; *hp; hp++)
+# endif /* defined(NCACHE_NODEID) */
+
+ {
+
+# if defined(NCACHE_NODEID)
+ if ((*hp)->na == lc->na && (*hp)->id == lc->id
+# else /* defined(NCACHE_NODEID) */
+ if ((*hp)->na == lc->na
+# endif /* defined(NCACHE_NODEID) */
+
+ && strcmp((*hp)->nm, lc->nm) == 0
+
+# if defined(NCACHE_PARADDR) && defined(NCACHE_PARID)
+ && (*hp)->pa == lc->pa && (*hp)->did == lc->did
+# endif /* defined(NCACHE_PARADDR) && defined(NCACHE_PARID) */
+
+ ) {
+ n = 0;
+ break;
+ }
+ }
+ if (n)
+ *hp = lc;
+ }
+
+# if defined(NCACHE_PARADDR) && defined(NCACHE_PARID)
+/*
+ * Make a final pass through the local cache and convert parent node
+ * addresses to local name cache pointers.
+ */
+ for (i = 0, lc = Ncache; i < Nc; i++, lc++) {
+ if (!lc->pa)
+ continue;
+ lc->pla = ncache_addr(lc->did, lc->pa);
+ }
+# endif /* defined(NCACHE_PARADDR) && defined(NCACHE_PARID) */
+}
+
+
+/*
+ * ncache_lookup() - look up a node's name in the kernel's name cache
+ */
+
+char *
+ncache_lookup(buf, blen, fp)
+ char *buf; /* receiving name buffer */
+ int blen; /* receiving buffer length */
+ int *fp; /* full path reply */
+{
+ char *cp = buf;
+ struct l_nch *lc;
+ struct mounts *mtp;
+ int nl, rlen;
+
+ *cp = '\0';
+ *fp = 0;
+
+# if defined(HASFSINO)
+/*
+ * If the entry has an inode number that matches the inode number of the
+ * file system mount point, return an empty path reply. That tells the
+ * caller to print the file system mount point name only.
+ */
+ if ((Lf->inp_ty == 1) && Lf->fs_ino && (Lf->inode == Lf->fs_ino))
+ return(cp);
+# endif /* defined(HASFSINO) */
+
+/*
+ * Look up the name cache entry for the node address.
+ */
+
+# if defined(NCACHE_NODEID)
+ if (Nc == 0 || !(lc = ncache_addr(Lf->id, Lf->na)))
+# else /* defined(NCACHE_NODEID) */
+ if (Nc == 0 || !(lc = ncache_addr(Lf->na)))
+# endif /* defined(NCACHE_NODEID) */
+
+
+ {
+
+ /*
+ * If the node has no cache entry, see if it's the mount
+ * point of a known file system.
+ */
+ if (!Lf->fsdir || !Lf->dev_def || Lf->inp_ty != 1)
+ return((char *)NULL);
+ for (mtp = readmnt(); mtp; mtp = mtp->next) {
+ if (!mtp->dir || !mtp->inode)
+ continue;
+ if (Lf->dev == mtp->dev
+ && mtp->inode == Lf->inode
+ && strcmp(mtp->dir, Lf->fsdir) == 0)
+ return(cp);
+ }
+ return((char *)NULL);
+ }
+/*
+ * Start the path assembly.
+ */
+ if ((nl = lc->nl) > (blen - 1))
+ return((char *)NULL);
+ cp = buf + blen - nl - 1;
+ rlen = blen - nl - 1;
+ (void) strcpy(cp, lc->nm);
+
+# if defined(NCACHE_PARADDR) && defined(NCACHE_PARID)
+/*
+ * Look up the name cache entries that are parents of the node address.
+ * Quit when:
+ *
+ * there's no parent;
+ * the name length is too large to fit in the receiving buffer.
+ */
+ for (;;) {
+ if (!lc->pla) {
+
+# if !defined(NCACHE_NO_ROOT)
+ if (ncache_isroot(lc->pa, cp))
+ *fp = 1;
+# endif /* !defined(NCACHE_NO_ROOT) */
+
+ break;
+ }
+ lc = lc->pla;
+ if (((nl = lc->nl) + 1) > rlen)
+ break;
+ *(cp - 1) = '/';
+ cp--;
+ rlen--;
+ (void) strncpy((cp - nl), lc->nm, nl);
+ cp -= nl;
+ rlen -= nl;
+ }
+# endif /* defined(NCACHE_PARADDR) && defined(NCACHE_PARID) */
+ return(cp);
+}
+#else /* !defined(HASNCACHE) || !defined(USE_LIB_RNAM) */
+char rnam_d1[] = "d"; char *rnam_d2 = rnam_d1;
+#endif /* defined(HASNCACHE) && defined(USE_LIB_RNAM) */