[linux] implemented Linux dialect resource cleanup with lsof_dialect_destroy()

- Added `lsof_dialect_destroy()` function for Linux dialect resource cleanup.
- Implemented cleanup for lock hash table, pipe/PTY/message queue/eventfd endpoint hashes, field pointers, and lock stream buffer.
- Moved static variables and type definitions from dnode.c to dlsof.h for improved modularity.
- Added context field access macros (LckH, Pinfo, PtyInfo, PSXMQinfo, EvtFDinfo, Fp, Fpa, Vbuf, Vsz) for dialect state management.
- Replaced manual array reallocation with `grow_array()` helper function in dnode.c.
- Updated build files to include new dlsof.c source file in Linux dialect compilation.

Author: jiegec

.gitignore

@@ -168,3 +168,6 @@ autom4te.cache
 
 # Doxygen
 /output
+
+compile_commands.json
+.cache

Makefile.am

@@ -16,6 +16,7 @@ LIBLSOF_SOURCES += lib/dialects/linux/dfile.c \
 		lib/dialects/linux/dproc.c \
 		lib/dialects/linux/dsock.c \
 		lib/dialects/linux/dstore.c \
+		lib/dialects/linux/dlsof.c \
 		lib/dialects/linux/dlsof.h \
 		lib/dialects/linux/dproto.h \
 		lib/dialects/linux/machine.h

lib/dialects/linux/Makefile

@@ -24,11 +24,11 @@ GRP=
 
 HDR=	lib/common.h include/lsof_fields.h dlsof.h machine.h lib/proto.h dproto.h
 
-SRC=    dfile.c dmnt.c dnode.c dprint.c dproc.c dsock.c dstore.c \
+SRC=    dfile.c dmnt.c dnode.c dprint.c dproc.c dsock.c dstore.c dlsof.c \
 	arg.c main.c print.c store.c usage.c \
 	util.c
 
-OBJ=	dfile.o dmnt.o dnode.o dprint.o dproc.o dsock.o dstore.o \
+OBJ=	dfile.o dmnt.o dnode.o dprint.o dproc.o dsock.o dstore.o dlsof.o \
 	arg.o main.o print.o store.o usage.o \
 	util.o
 

lib/dialects/linux/Mksrc

@@ -22,7 +22,7 @@ mksrc() {
 }
 
 D=lib/dialects/linux
-L="dfile.c dlsof.h dmnt.c dnode.c dproc.c dproto.h dsock.c dstore.c machine.h"
+L="dfile.c dlsof.h dmnt.c dnode.c dproc.c dproto.h dsock.c dstore.c dlsof.c machine.h"
 
 mksrc
 

lib/dialects/linux/dlsof.c

@@ -0,0 +1,94 @@
+/*
+ * dlsof.c - Linux dialect-specific implementations
+ */
+
+#include "common.h"
+#include "dlsof.h"
+
+/*
+ * lsof_dialect_destroy() - clean up dialect-specific resources
+ */
+
+void lsof_dialect_destroy(struct lsof_context *ctx) {
+    int i;
+    struct llock *lp, *np;
+#if defined(HASEPTOPTS)
+    pxinfo_t *pp, *pnp;
+#endif
+
+    /* Free lock hash table */
+    if (LckH) {
+        for (i = 0; i < PIDBUCKS; i++) {
+            for (lp = LckH[i]; lp; lp = np) {
+                np = lp->next;
+                (void)free((FREE_P *)lp);
+            }
+            LckH[i] = (struct llock *)NULL;
+        }
+        CLEAN(LckH);
+    }
+
+#if defined(HASEPTOPTS)
+    /* Free pipe endpoint hash */
+    if (Pinfo) {
+        for (i = 0; i < PINFOBUCKS; i++) {
+            for (pp = Pinfo[i]; pp; pp = pnp) {
+                pnp = pp->next;
+                (void)free((FREE_P *)pp);
+            }
+            Pinfo[i] = (pxinfo_t *)NULL;
+        }
+        CLEAN(Pinfo);
+    }
+
+#    if defined(HASPTYEPT)
+    /* Free PTY endpoint hash */
+    if (PtyInfo) {
+        for (i = 0; i < PINFOBUCKS; i++) {
+            for (pp = PtyInfo[i]; pp; pp = pnp) {
+                pnp = pp->next;
+                (void)free((FREE_P *)pp);
+            }
+            PtyInfo[i] = (pxinfo_t *)NULL;
+        }
+        CLEAN(PtyInfo);
+    }
+#    endif
+
+    /* Free message queue endpoint hash */
+    if (PSXMQinfo) {
+        for (i = 0; i < PINFOBUCKS; i++) {
+            for (pp = PSXMQinfo[i]; pp; pp = pnp) {
+                pnp = pp->next;
+                (void)free((FREE_P *)pp);
+            }
+            PSXMQinfo[i] = (pxinfo_t *)NULL;
+        }
+        CLEAN(PSXMQinfo);
+    }
+
+    /* Free eventfd endpoint hash */
+    if (EvtFDinfo) {
+        for (i = 0; i < PINFOBUCKS; i++) {
+            for (pp = EvtFDinfo[i]; pp; pp = pnp) {
+                pnp = pp->next;
+                (void)free((FREE_P *)pp);
+            }
+            EvtFDinfo[i] = (pxinfo_t *)NULL;
+        }
+        CLEAN(EvtFDinfo);
+    }
+#endif /* defined(HASEPTOPTS) */
+
+    /* Free field pointers */
+    if (Fp) {
+        CLEAN(Fp);
+        Fpa = 0;
+    }
+
+    /* Free lock stream buffer */
+    if (Vbuf) {
+        CLEAN(Vbuf);
+        Vsz = 0;
+    }
+}

lib/dialects/linux/dlsof.h

@@ -198,6 +198,56 @@ extern dev_t MqueueDev;
 #    define OFFSET_FDINFO 2
 extern int OffType;
 
-struct lsof_context_dialect {};
+#    define PIDBUCKS 64    /* PID hash buckets */
+#    define PINFOBUCKS 512 /* pipe info hash buckets */
+
+struct llock {
+    int pid;
+    dev_t dev;
+    INODETYPE inode;
+    enum lsof_lock_mode type;
+    struct llock *next;
+};
+
+struct lsof_context_dialect {
+    /* dnode.c - lock hash table */
+    struct llock **lock_hash;
+#    if defined(HASEPTOPTS)
+    pxinfo_t **pipe_ep_hash;
+#        if defined(HASPTYEPT)
+    pxinfo_t **pty_ep_hash;
+#        endif
+    pxinfo_t **mqueue_ep_hash;
+    pxinfo_t **eventfd_ep_hash;
+#    endif
+    /* dnode.c - field parser state */
+    char **field_ptrs;
+    int field_ptrs_alloc;
+    /* dnode.c - lock stream buffer */
+    char *lock_stream_buf;
+    size_t lock_stream_buf_sz;
+};
+
+/* Dialect-specific cleanup function */
+void lsof_dialect_destroy(struct lsof_context *ctx);
+
+/* Context field access macros */
+#    define LckH (ctx->dialect.lock_hash)
+#    if defined(HASEPTOPTS)
+#        define Pinfo (ctx->dialect.pipe_ep_hash)
+#        if defined(HASPTYEPT)
+#            define PtyInfo (ctx->dialect.pty_ep_hash)
+#        endif
+#        define PSXMQinfo (ctx->dialect.mqueue_ep_hash)
+#        define EvtFDinfo (ctx->dialect.eventfd_ep_hash)
+#    endif
+
+/* Field parser macros */
+#    define Fp (ctx->dialect.field_ptrs)
+#    define Fpa (ctx->dialect.field_ptrs_alloc)
+
+/* Lock stream buffer macros */
+#    define Vbuf (ctx->dialect.lock_stream_buf)
+#    define Vsz (ctx->dialect.lock_stream_buf_sz)
 
 #endif /* LINUX_LSOF_H	*/

lib/dialects/linux/dmnt.c

@@ -70,8 +70,8 @@ typedef struct mntsup {
  * Local static definitions
  */
 
-static mntsup_t **MSHash = (mntsup_t **)NULL;      /* mount supplement
-                                                    * hash buckets */
+static mntsup_t **MSHash = (mntsup_t **)NULL; /* mount supplement
+                                               * hash buckets */
 
 /*
  * convert_octal_escaped() -- convert octal-escaped characters in string

lib/dialects/linux/dnode.c

@@ -29,6 +29,8 @@
  */
 
 #include "common.h"
+#include "dlsof.h"
+#include "proto.h"
 
 #if defined(HASEPTOPTS) && defined(HASPTYEPT)
 #    include <linux/major.h>
@@ -42,29 +44,13 @@
     ((off_t)0x7fffffff) /* this is defined in                                  \
                          * .../src/fs/locks.c and not                          \
                          * in a header file */
-#define PIDBUCKS 64     /* PID hash buckets */
-#define PINFOBUCKS 512  /* pipe info hash buckets */
 #define HASHPID(pid) (((int)((pid * 31415) >> 3)) & (PIDBUCKS - 1))
 #define HASHPINFO(ino) (((int)((ino * 31415) >> 3)) & (PINFOBUCKS - 1))
 
 /*
  * Local structure definitions
  */
 
-struct llock {
-    int pid;
-    dev_t dev;
-    INODETYPE inode;
-    enum lsof_lock_mode type;
-    struct llock *next;
-};
-
-/*
- * Local definitions
- */
-
-struct llock **LckH = (struct llock **)NULL; /* PID-hashed locks */
-
 /*
  * Local function prototypes
  */
@@ -75,22 +61,6 @@ static void check_lock(struct lsof_context *ctx);
 static void enter_pinfo(struct lsof_context *ctx);
 #endif /* defined(HASEPTOPTS) */
 
-/*
- * Local storage
- */
-
-#if defined(HASEPTOPTS)
-static pxinfo_t **Pinfo = (pxinfo_t **)NULL; /* pipe endpoint hash buckets */
-#    if defined(HASPTYEPT)
-static pxinfo_t **PtyInfo = (pxinfo_t **)NULL; /* pseudoterminal endpoint hash
-                                                * buckets */
-#    endif                                     /* defined(HASPTYEPT) */
-static pxinfo_t **PSXMQinfo =
-    (pxinfo_t **)NULL; /* posix msg queue endpoint hash buckets */
-static pxinfo_t **EvtFDinfo =
-    (pxinfo_t **)NULL; /* envetfd endpoint hash buckets */
-#endif                 /* defined(HASEPTOPTS) */
-
 /*
  * check_lock() - check lock for file *Lf, process *Lp
  */
@@ -469,9 +439,6 @@ int get_fields(struct lsof_context *ctx, /* context */
 {
     char *bp, *cp, *sp;
     int i, j, n;
-    MALLOC_S len;
-    static char **fp = (char **)NULL;
-    static int nfpa = 0;
 
     for (cp = ln, n = 0; cp && *cp;) {
         for (bp = cp; *bp && (*bp == ' ' || *bp == '\t'); bp++)
@@ -535,23 +502,16 @@ int get_fields(struct lsof_context *ctx, /* context */
         }
         if (*cp)
             *cp++ = '\0';
-        if (n >= nfpa) {
-            nfpa += 32;
-            len = (MALLOC_S)(nfpa * sizeof(char *));
-            if (fp)
-                fp = (char **)realloc((MALLOC_P *)fp, len);
-            else
-                fp = (char **)malloc(len);
-            if (!fp) {
-                (void)fprintf(
-                    stderr, "%s: can't allocate %d bytes for field pointers.\n",
-                    Pn, (int)len);
+        if (n >= Fpa) {
+            if (grow_array((void **)&Fp, &Fpa, sizeof(char *), 32)) {
+                (void)fprintf(stderr,
+                              "%s: can't allocate for field pointers.\n", Pn);
                 Error(ctx);
             }
         }
-        fp[n++] = bp;
+        Fp[n++] = bp;
     }
-    *fr = fp;
+    *fr = Fp;
     return (n);
 }
 
@@ -571,8 +531,7 @@ void get_locks(struct lsof_context *ctx, /* context */
     FILE *ls;
     long maj, min;
     enum lsof_lock_mode type;
-    static char *vbuf = (char *)NULL;
-    static size_t vsz = (size_t)0;
+
     /*
      * Destroy previous lock information.
      */
@@ -601,7 +560,7 @@ void get_locks(struct lsof_context *ctx, /* context */
      * Open the /proc lock file, assign a page size buffer to its stream,
      * and read it.
      */
-    if (!(ls = open_proc_stream(ctx, p, "r", &vbuf, &vsz, 0)))
+    if (!(ls = open_proc_stream(ctx, p, "r", &Vbuf, &Vsz, 0)))
         return;
     while (fgets(buf, sizeof(buf), ls)) {
         if (get_fields(ctx, buf, ":", &fp, (int *)NULL, 0) < 10)

lib/lsof.c

@@ -39,6 +39,14 @@
 #    define API_EXPORT
 #endif
 
+/*
+ * Default weak implementation of dialect-specific cleanup.
+ * Dialects can override this with a strong implementation.
+ */
+void __attribute__((weak)) lsof_dialect_destroy(struct lsof_context *ctx) {
+    (void)ctx; /* unused in default implementation */
+}
+
 API_EXPORT
 int lsof_get_api_version() { return LSOF_API_VERSION; }
 
@@ -845,6 +853,9 @@ void lsof_destroy(struct lsof_context *ctx) {
     Nlproc = 0;
     ctx->procs_cap = 0;
 
+    /* Call dialect-specific cleanup */
+    lsof_dialect_destroy(ctx);
+
     CLEAN(ctx);
 }