LCOV - code coverage report
Current view: top level - src/backend/utils/misc - ps_status.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 53 71 74.6 %
Date: 2019-06-19 16:07:09 Functions: 4 4 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*--------------------------------------------------------------------
       2             :  * ps_status.c
       3             :  *
       4             :  * Routines to support changing the ps display of PostgreSQL backends
       5             :  * to contain some useful information. Mechanism differs wildly across
       6             :  * platforms.
       7             :  *
       8             :  * src/backend/utils/misc/ps_status.c
       9             :  *
      10             :  * Copyright (c) 2000-2019, PostgreSQL Global Development Group
      11             :  * various details abducted from various places
      12             :  *--------------------------------------------------------------------
      13             :  */
      14             : 
      15             : #include "postgres.h"
      16             : 
      17             : #include <unistd.h>
      18             : #ifdef HAVE_SYS_PSTAT_H
      19             : #include <sys/pstat.h>            /* for HP-UX */
      20             : #endif
      21             : #ifdef HAVE_PS_STRINGS
      22             : #include <machine/vmparam.h>  /* for old BSD */
      23             : #include <sys/exec.h>
      24             : #endif
      25             : #if defined(__darwin__)
      26             : #include <crt_externs.h>
      27             : #endif
      28             : 
      29             : #include "libpq/libpq.h"
      30             : #include "miscadmin.h"
      31             : #include "utils/ps_status.h"
      32             : #include "utils/guc.h"
      33             : 
      34             : extern char **environ;
      35             : bool        update_process_title = true;
      36             : 
      37             : 
      38             : /*
      39             :  * Alternative ways of updating ps display:
      40             :  *
      41             :  * PS_USE_SETPROCTITLE_FAST
      42             :  *     use the function setproctitle_fast(const char *, ...)
      43             :  *     (newer FreeBSD systems)
      44             :  * PS_USE_SETPROCTITLE
      45             :  *     use the function setproctitle(const char *, ...)
      46             :  *     (newer BSD systems)
      47             :  * PS_USE_PSTAT
      48             :  *     use the pstat(PSTAT_SETCMD, )
      49             :  *     (HPUX)
      50             :  * PS_USE_PS_STRINGS
      51             :  *     assign PS_STRINGS->ps_argvstr = "string"
      52             :  *     (some BSD systems)
      53             :  * PS_USE_CHANGE_ARGV
      54             :  *     assign argv[0] = "string"
      55             :  *     (some other BSD systems)
      56             :  * PS_USE_CLOBBER_ARGV
      57             :  *     write over the argv and environment area
      58             :  *     (Linux and most SysV-like systems)
      59             :  * PS_USE_WIN32
      60             :  *     push the string out as the name of a Windows event
      61             :  * PS_USE_NONE
      62             :  *     don't update ps display
      63             :  *     (This is the default, as it is safest.)
      64             :  */
      65             : #if defined(HAVE_SETPROCTITLE_FAST)
      66             : #define PS_USE_SETPROCTITLE_FAST
      67             : #elif defined(HAVE_SETPROCTITLE)
      68             : #define PS_USE_SETPROCTITLE
      69             : #elif defined(HAVE_PSTAT) && defined(PSTAT_SETCMD)
      70             : #define PS_USE_PSTAT
      71             : #elif defined(HAVE_PS_STRINGS)
      72             : #define PS_USE_PS_STRINGS
      73             : #elif (defined(BSD) || defined(__hurd__)) && !defined(__darwin__)
      74             : #define PS_USE_CHANGE_ARGV
      75             : #elif defined(__linux__) || defined(_AIX) || defined(__sgi) || (defined(sun) && !defined(BSD)) || defined(__svr5__) || defined(__darwin__)
      76             : #define PS_USE_CLOBBER_ARGV
      77             : #elif defined(WIN32)
      78             : #define PS_USE_WIN32
      79             : #else
      80             : #define PS_USE_NONE
      81             : #endif
      82             : 
      83             : 
      84             : /* Different systems want the buffer padded differently */
      85             : #if defined(_AIX) || defined(__linux__) || defined(__darwin__)
      86             : #define PS_PADDING '\0'
      87             : #else
      88             : #define PS_PADDING ' '
      89             : #endif
      90             : 
      91             : 
      92             : #ifndef PS_USE_CLOBBER_ARGV
      93             : /* all but one option need a buffer to write their ps line in */
      94             : #define PS_BUFFER_SIZE 256
      95             : static char ps_buffer[PS_BUFFER_SIZE];
      96             : static const size_t ps_buffer_size = PS_BUFFER_SIZE;
      97             : #else                           /* PS_USE_CLOBBER_ARGV */
      98             : static char *ps_buffer;         /* will point to argv area */
      99             : static size_t ps_buffer_size;   /* space determined at run time */
     100             : static size_t last_status_len;  /* use to minimize length of clobber */
     101             : #endif                          /* PS_USE_CLOBBER_ARGV */
     102             : 
     103             : static size_t ps_buffer_cur_len;    /* nominal strlen(ps_buffer) */
     104             : 
     105             : static size_t ps_buffer_fixed_size; /* size of the constant prefix */
     106             : 
     107             : /* save the original argv[] location here */
     108             : static int  save_argc;
     109             : static char **save_argv;
     110             : 
     111             : 
     112             : /*
     113             :  * Call this early in startup to save the original argc/argv values.
     114             :  * If needed, we make a copy of the original argv[] array to preserve it
     115             :  * from being clobbered by subsequent ps_display actions.
     116             :  *
     117             :  * (The original argv[] will not be overwritten by this routine, but may be
     118             :  * overwritten during init_ps_display.  Also, the physical location of the
     119             :  * environment strings may be moved, so this should be called before any code
     120             :  * that might try to hang onto a getenv() result.)
     121             :  *
     122             :  * Note that in case of failure this cannot call elog() as that is not
     123             :  * initialized yet.  We rely on write_stderr() instead.
     124             :  */
     125             : char      **
     126        2550 : save_ps_display_args(int argc, char **argv)
     127             : {
     128        2550 :     save_argc = argc;
     129        2550 :     save_argv = argv;
     130             : 
     131             : #if defined(PS_USE_CLOBBER_ARGV)
     132             : 
     133             :     /*
     134             :      * If we're going to overwrite the argv area, count the available space.
     135             :      * Also move the environment to make additional room.
     136             :      */
     137             :     {
     138        2550 :         char       *end_of_area = NULL;
     139             :         char      **new_environ;
     140             :         int         i;
     141             : 
     142             :         /*
     143             :          * check for contiguous argv strings
     144             :          */
     145       18306 :         for (i = 0; i < argc; i++)
     146             :         {
     147       15756 :             if (i == 0 || end_of_area + 1 == argv[i])
     148       15756 :                 end_of_area = argv[i] + strlen(argv[i]);
     149             :         }
     150             : 
     151        2550 :         if (end_of_area == NULL)    /* probably can't happen? */
     152             :         {
     153           0 :             ps_buffer = NULL;
     154           0 :             ps_buffer_size = 0;
     155           0 :             return argv;
     156             :         }
     157             : 
     158             :         /*
     159             :          * check for contiguous environ strings following argv
     160             :          */
     161       77254 :         for (i = 0; environ[i] != NULL; i++)
     162             :         {
     163       74704 :             if (end_of_area + 1 == environ[i])
     164       74704 :                 end_of_area = environ[i] + strlen(environ[i]);
     165             :         }
     166             : 
     167        2550 :         ps_buffer = argv[0];
     168        2550 :         last_status_len = ps_buffer_size = end_of_area - argv[0];
     169             : 
     170             :         /*
     171             :          * move the environment out of the way
     172             :          */
     173        2550 :         new_environ = (char **) malloc((i + 1) * sizeof(char *));
     174        2550 :         if (!new_environ)
     175             :         {
     176           0 :             write_stderr("out of memory\n");
     177           0 :             exit(1);
     178             :         }
     179       77254 :         for (i = 0; environ[i] != NULL; i++)
     180             :         {
     181       74704 :             new_environ[i] = strdup(environ[i]);
     182       74704 :             if (!new_environ[i])
     183             :             {
     184           0 :                 write_stderr("out of memory\n");
     185           0 :                 exit(1);
     186             :             }
     187             :         }
     188        2550 :         new_environ[i] = NULL;
     189        2550 :         environ = new_environ;
     190             :     }
     191             : #endif                          /* PS_USE_CLOBBER_ARGV */
     192             : 
     193             : #if defined(PS_USE_CHANGE_ARGV) || defined(PS_USE_CLOBBER_ARGV)
     194             : 
     195             :     /*
     196             :      * If we're going to change the original argv[] then make a copy for
     197             :      * argument parsing purposes.
     198             :      *
     199             :      * (NB: do NOT think to remove the copying of argv[], even though
     200             :      * postmaster.c finishes looking at argv[] long before we ever consider
     201             :      * changing the ps display.  On some platforms, getopt() keeps pointers
     202             :      * into the argv array, and will get horribly confused when it is
     203             :      * re-called to analyze a subprocess' argument string if the argv storage
     204             :      * has been clobbered meanwhile.  Other platforms have other dependencies
     205             :      * on argv[].
     206             :      */
     207             :     {
     208             :         char      **new_argv;
     209             :         int         i;
     210             : 
     211        2550 :         new_argv = (char **) malloc((argc + 1) * sizeof(char *));
     212        2550 :         if (!new_argv)
     213             :         {
     214           0 :             write_stderr("out of memory\n");
     215           0 :             exit(1);
     216             :         }
     217       18306 :         for (i = 0; i < argc; i++)
     218             :         {
     219       15756 :             new_argv[i] = strdup(argv[i]);
     220       15756 :             if (!new_argv[i])
     221             :             {
     222           0 :                 write_stderr("out of memory\n");
     223           0 :                 exit(1);
     224             :             }
     225             :         }
     226        2550 :         new_argv[argc] = NULL;
     227             : 
     228             : #if defined(__darwin__)
     229             : 
     230             :         /*
     231             :          * macOS (and perhaps other NeXT-derived platforms?) has a static copy
     232             :          * of the argv pointer, which we may fix like so:
     233             :          */
     234             :         *_NSGetArgv() = new_argv;
     235             : #endif
     236             : 
     237        2550 :         argv = new_argv;
     238             :     }
     239             : #endif                          /* PS_USE_CHANGE_ARGV or PS_USE_CLOBBER_ARGV */
     240             : 
     241        2550 :     return argv;
     242             : }
     243             : 
     244             : /*
     245             :  * Call this once during subprocess startup to set the identification
     246             :  * values.  At this point, the original argv[] array may be overwritten.
     247             :  */
     248             : void
     249       11640 : init_ps_display(const char *username, const char *dbname,
     250             :                 const char *host_info, const char *initial_str)
     251             : {
     252             :     Assert(username);
     253             :     Assert(dbname);
     254             :     Assert(host_info);
     255             : 
     256             : #ifndef PS_USE_NONE
     257             :     /* no ps display for stand-alone backend */
     258       11640 :     if (!IsUnderPostmaster)
     259           0 :         return;
     260             : 
     261             :     /* no ps display if you didn't call save_ps_display_args() */
     262       11640 :     if (!save_argv)
     263           0 :         return;
     264             : 
     265             : #ifdef PS_USE_CLOBBER_ARGV
     266             :     /* If ps_buffer is a pointer, it might still be null */
     267       11640 :     if (!ps_buffer)
     268           0 :         return;
     269             : #endif
     270             : 
     271             :     /*
     272             :      * Overwrite argv[] to point at appropriate space, if needed
     273             :      */
     274             : 
     275             : #ifdef PS_USE_CHANGE_ARGV
     276             :     save_argv[0] = ps_buffer;
     277             :     save_argv[1] = NULL;
     278             : #endif                          /* PS_USE_CHANGE_ARGV */
     279             : 
     280             : #ifdef PS_USE_CLOBBER_ARGV
     281             :     {
     282             :         int         i;
     283             : 
     284             :         /* make extra argv slots point at end_of_area (a NUL) */
     285       68970 :         for (i = 1; i < save_argc; i++)
     286       57330 :             save_argv[i] = ps_buffer + ps_buffer_size;
     287             :     }
     288             : #endif                          /* PS_USE_CLOBBER_ARGV */
     289             : 
     290             :     /*
     291             :      * Make fixed prefix of ps display.
     292             :      */
     293             : 
     294             : #if defined(PS_USE_SETPROCTITLE) || defined(PS_USE_SETPROCTITLE_FAST)
     295             : 
     296             :     /*
     297             :      * apparently setproctitle() already adds a `progname:' prefix to the ps
     298             :      * line
     299             :      */
     300             : #define PROGRAM_NAME_PREFIX ""
     301             : #else
     302             : #define PROGRAM_NAME_PREFIX "postgres: "
     303             : #endif
     304             : 
     305       11640 :     if (*cluster_name == '\0')
     306             :     {
     307        6058 :         snprintf(ps_buffer, ps_buffer_size,
     308             :                  PROGRAM_NAME_PREFIX "%s %s %s ",
     309             :                  username, dbname, host_info);
     310             :     }
     311             :     else
     312             :     {
     313        5582 :         snprintf(ps_buffer, ps_buffer_size,
     314             :                  PROGRAM_NAME_PREFIX "%s: %s %s %s ",
     315             :                  cluster_name, username, dbname, host_info);
     316             :     }
     317             : 
     318       11640 :     ps_buffer_cur_len = ps_buffer_fixed_size = strlen(ps_buffer);
     319             : 
     320       11640 :     set_ps_display(initial_str, true);
     321             : #endif                          /* not PS_USE_NONE */
     322             : }
     323             : 
     324             : 
     325             : 
     326             : /*
     327             :  * Call this to update the ps status display to a fixed prefix plus an
     328             :  * indication of what you're currently doing passed in the argument.
     329             :  */
     330             : void
     331     1016430 : set_ps_display(const char *activity, bool force)
     332             : {
     333             : #ifndef PS_USE_NONE
     334             :     /* update_process_title=off disables updates, unless force = true */
     335     1016430 :     if (!force && !update_process_title)
     336           0 :         return;
     337             : 
     338             :     /* no ps display for stand-alone backend */
     339     1016430 :     if (!IsUnderPostmaster)
     340      327858 :         return;
     341             : 
     342             : #ifdef PS_USE_CLOBBER_ARGV
     343             :     /* If ps_buffer is a pointer, it might still be null */
     344      688572 :     if (!ps_buffer)
     345           0 :         return;
     346             : #endif
     347             : 
     348             :     /* Update ps_buffer to contain both fixed part and activity */
     349      688572 :     strlcpy(ps_buffer + ps_buffer_fixed_size, activity,
     350             :             ps_buffer_size - ps_buffer_fixed_size);
     351      688572 :     ps_buffer_cur_len = strlen(ps_buffer);
     352             : 
     353             :     /* Transmit new setting to kernel, if necessary */
     354             : 
     355             : #ifdef PS_USE_SETPROCTITLE
     356             :     setproctitle("%s", ps_buffer);
     357             : #elif defined(PS_USE_SETPROCTITLE_FAST)
     358             :     setproctitle_fast("%s", ps_buffer);
     359             : #endif
     360             : 
     361             : #ifdef PS_USE_PSTAT
     362             :     {
     363             :         union pstun pst;
     364             : 
     365             :         pst.pst_command = ps_buffer;
     366             :         pstat(PSTAT_SETCMD, pst, ps_buffer_cur_len, 0, 0);
     367             :     }
     368             : #endif                          /* PS_USE_PSTAT */
     369             : 
     370             : #ifdef PS_USE_PS_STRINGS
     371             :     PS_STRINGS->ps_nargvstr = 1;
     372             :     PS_STRINGS->ps_argvstr = ps_buffer;
     373             : #endif                          /* PS_USE_PS_STRINGS */
     374             : 
     375             : #ifdef PS_USE_CLOBBER_ARGV
     376             :     /* pad unused memory; need only clobber remainder of old status string */
     377      688572 :     if (last_status_len > ps_buffer_cur_len)
     378      336358 :         MemSet(ps_buffer + ps_buffer_cur_len, PS_PADDING,
     379             :                last_status_len - ps_buffer_cur_len);
     380      688572 :     last_status_len = ps_buffer_cur_len;
     381             : #endif                          /* PS_USE_CLOBBER_ARGV */
     382             : 
     383             : #ifdef PS_USE_WIN32
     384             :     {
     385             :         /*
     386             :          * Win32 does not support showing any changed arguments. To make it at
     387             :          * all possible to track which backend is doing what, we create a
     388             :          * named object that can be viewed with for example Process Explorer.
     389             :          */
     390             :         static HANDLE ident_handle = INVALID_HANDLE_VALUE;
     391             :         char        name[PS_BUFFER_SIZE + 32];
     392             : 
     393             :         if (ident_handle != INVALID_HANDLE_VALUE)
     394             :             CloseHandle(ident_handle);
     395             : 
     396             :         sprintf(name, "pgident(%d): %s", MyProcPid, ps_buffer);
     397             : 
     398             :         ident_handle = CreateEvent(NULL, TRUE, FALSE, name);
     399             :     }
     400             : #endif                          /* PS_USE_WIN32 */
     401             : #endif                          /* not PS_USE_NONE */
     402             : }
     403             : 
     404             : 
     405             : /*
     406             :  * Returns what's currently in the ps display, in case someone needs
     407             :  * it.  Note that only the activity part is returned.  On some platforms
     408             :  * the string will not be null-terminated, so return the effective
     409             :  * length into *displen.
     410             :  */
     411             : const char *
     412        1074 : get_ps_display(int *displen)
     413             : {
     414             : #ifdef PS_USE_CLOBBER_ARGV
     415             :     /* If ps_buffer is a pointer, it might still be null */
     416        1074 :     if (!ps_buffer)
     417             :     {
     418           0 :         *displen = 0;
     419           0 :         return "";
     420             :     }
     421             : #endif
     422             : 
     423        1074 :     *displen = (int) (ps_buffer_cur_len - ps_buffer_fixed_size);
     424             : 
     425        1074 :     return ps_buffer + ps_buffer_fixed_size;
     426             : }

Generated by: LCOV version 1.13