base

rcts/rc_balanced/lib/ProcessRename.cpp

@@ -0,0 +1,185 @@
+#include "ProcessRename.h"
+#include <stdlib.h>
+#include <string.h>
+
+
+typedef size_t Size;
+#define LONG_ALIGN_MASK (sizeof(long) - 1)
+#define MEMSET_LOOP_LIMIT 1024          
+#define MemSet(start, val, len) \
+        do \
+        { \
+                /* must be void* because we don't know if it is integer aligned yet */ \
+                void   *_vstart = (void *) (start); \
+                int             _val = (val); \
+                Size    _len = (len); \
+\
+                if ((((long) _vstart) & LONG_ALIGN_MASK) == 0 && \
+                        (_len & LONG_ALIGN_MASK) == 0 && \
+                        _val == 0 && \
+                        _len <= MEMSET_LOOP_LIMIT && \
+                        /* \
+                         *      If MEMSET_LOOP_LIMIT == 0, optimizer should find \
+						 *      the whole "if" false at compile time. \
+						*/ \
+                        MEMSET_LOOP_LIMIT != 0) \
+                { \
+                        long *_start = (long *) _vstart; \
+                        long *_stop = (long *) ((char *) _start + _len); \
+                        while (_start < _stop) \
+                                *_start++ = 0; \
+                } \
+                else \
+                        memset(_vstart, _val, _len); \
+        } while (0)
+
+#define PS_PADDING '\0'
+
+extern char **environ;
+bool            update_process_title = true;
+
+static char *ps_buffer;				/* will point to argv area */
+static size_t ps_buffer_size;		/* space determined at run time */
+static size_t last_status_len;		/* use to minimize length of clobber */
+static size_t ps_buffer_cur_len;	/* nominal strlen(ps_buffer) */
+static size_t ps_buffer_fixed_size;	/* size of the constant prefix */
+
+static int      save_argc;
+static char **save_argv;
+
+size_t strlcpy(char *dst, const char *src, size_t siz)
+{
+        char       *d = dst;
+        const char *s = src;
+        size_t          n = siz;
+
+        /* Copy as many bytes as will fit */
+        if (n != 0)
+        {
+                while (--n != 0)
+                {
+                        if ((*d++ = *s++) == '\0')
+                                break;
+                }
+        }
+
+        /* Not enough room in dst, add NUL and traverse rest of src */
+        if (n == 0)
+        {
+                if (siz != 0)
+                        *d = '\0';                      /* NUL-terminate dst */
+                while (*s++)
+                        ;
+        }
+
+        return (s - src - 1);           /* count does not include NUL */
+}
+
+
+void set_ps_display(const char *activity, bool force)
+{     
+        /* update_process_title=off disables updates, unless force = true */
+        if (!force && !update_process_title)
+                return;
+
+        /* no ps display for stand-alone backend */
+        //if (!IsUnderPostmaster)
+        //        return;
+
+        /* If ps_buffer is a pointer, it might still be null */
+        if (!ps_buffer)
+                return;
+        /* Update ps_buffer to contain both fixed part and activity */
+        strlcpy(ps_buffer + ps_buffer_fixed_size, activity,
+                        ps_buffer_size - ps_buffer_fixed_size);
+        ps_buffer_cur_len = strlen(ps_buffer);
+
+        /* pad unused memory; need only clobber remainder of old status string */
+        if (last_status_len > ps_buffer_cur_len)
+                MemSet(ps_buffer + ps_buffer_cur_len, PS_PADDING,
+                           last_status_len - ps_buffer_cur_len);
+        last_status_len = ps_buffer_cur_len;
+
+}
+
+
+char ** save_ps_display_args(int argc, char **argv)
+{
+        save_argc = argc;
+        save_argv = argv;
+
+        /*
+         * If we're going to overwrite the argv area, count the available space.
+         * Also move the environment to make additional room.
+         */
+        {
+                char       *end_of_area = NULL;
+                char      **new_environ;
+                int                     i;
+
+                /*
+                 * check for contiguous argv strings
+                 */
+                for (i = 0; i < argc; i++)
+                {
+                        if (i == 0 || end_of_area + 1 == argv[i])
+                                end_of_area = argv[i] + strlen(argv[i]);
+                }
+
+                if (end_of_area == NULL)        /* probably can't happen? */
+                {
+                        ps_buffer = NULL;
+                        ps_buffer_size = 0;
+                        return argv;
+                }
+
+                /*
+                 * check for contiguous environ strings following argv
+                 */
+                for (i = 0; environ[i] != NULL; i++)
+                {
+                        if (end_of_area + 1 == environ[i])
+                                end_of_area = environ[i] + strlen(environ[i]);
+                }
+
+                ps_buffer = argv[0];
+                last_status_len = ps_buffer_size = end_of_area - argv[0];
+
+                /*
+                 * move the environment out of the way
+               */
+                new_environ = (char **) malloc((i + 1) * sizeof(char *));
+                for (i = 0; environ[i] != NULL; i++)
+                        new_environ[i] = strdup(environ[i]);
+                new_environ[i] = NULL;
+                environ = new_environ;
+        }
+
+        /*
+         * If we're going to change the original argv[] then make a copy for
+         * argument parsing purposes.
+         *
+         * (NB: do NOT think to remove the copying of argv[], even though
+         * postmaster.c finishes looking at argv[] long before we ever consider
+         * changing the ps display.  On some platforms, getopt() keeps pointers
+         * into the argv array, and will get horribly confused when it is
+         * re-called to analyze a subprocess' argument string if the argv storage
+         * has been clobbered meanwhile.  Other platforms have other dependencies
+         * on argv[].
+         */
+        {
+                char      **new_argv;
+                int                     i;
+
+                new_argv = (char **) malloc((argc + 1) * sizeof(char *));
+                for (i = 0; i < argc; i++)
+                        new_argv[i] = strdup(argv[i]);
+                new_argv[argc] = NULL;
+
+                argv = new_argv;
+        }
+
+ return argv;
+
+}
+