1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // This file implements BSD-style setproctitle() for Linux. 6 // It is written such that it can easily be compiled outside Chromium. 7 // 8 // The Linux kernel sets up two locations in memory to pass arguments and 9 // environment variables to processes. First, there are two char* arrays stored 10 // one after another: argv and environ. A pointer to argv is passed to main(), 11 // while glibc sets the global variable |environ| to point at the latter. Both 12 // of these arrays are terminated by a NULL pointer; the environment array is 13 // also followed by some empty space to allow additional variables to be added. 14 // 15 // These arrays contain pointers to a second location in memory, where the 16 // strings themselves are stored one after another: first all the arguments, 17 // then the environment variables. The kernel will allocate a single page of 18 // memory for this purpose, so the end of the page containing argv[0] is the 19 // end of the storage potentially available to store the process title. 20 // 21 // When the kernel reads the command line arguments for a process, it looks at 22 // the range of memory within this page that it initially used for the argument 23 // list. If the terminating '\0' character is still where it expects, nothing 24 // further is done. If it has been overwritten, the kernel will scan up to the 25 // size of a page looking for another. (Note, however, that in general not that 26 // much space is actually mapped, since argv[0] is rarely page-aligned and only 27 // one page is mapped.) 28 // 29 // Thus to change the process title, we must move any environment variables out 30 // of the way to make room for a potentially longer title, and then overwrite 31 // the memory pointed to by argv[0] with a single replacement string, making 32 // sure its size does not exceed the available space. 33 // 34 // It is perhaps worth noting that patches to add a system call to Linux for 35 // this, like in BSD, have never made it in: this is the "official" way to do 36 // this on Linux. Presumably it is not in glibc due to some disagreement over 37 // this position within the glibc project, leaving applications caught in the 38 // middle. (Also, only a very few applications need or want this anyway.) 39 40 #include "content/common/set_process_title_linux.h" 41 42 #include <stdarg.h> 43 #include <stdint.h> 44 #include <stdio.h> 45 #include <string.h> 46 #include <unistd.h> 47 48 extern char** environ; 49 50 static char** g_main_argv = NULL; 51 static char* g_orig_argv0 = NULL; 52 53 void setproctitle(const char* fmt, ...) { 54 va_list ap; 55 size_t i, avail_size; 56 uintptr_t page_size, page, page_end; 57 // Sanity check before we try and set the process title. 58 // The BSD version allows fmt == NULL to restore the original title. 59 if (!g_main_argv || !environ || !fmt) 60 return; 61 if (!g_orig_argv0) { 62 // Save the original argv[0]. 63 g_orig_argv0 = strdup(g_main_argv[0]); 64 if (!g_orig_argv0) 65 return; 66 } 67 page_size = sysconf(_SC_PAGESIZE); 68 // Get the page on which the argument list and environment live. 69 page = (uintptr_t) g_main_argv[0]; 70 page -= page % page_size; 71 page_end = page + page_size; 72 // Move the environment out of the way. Note that we are moving the values, 73 // not the environment array itself (which may not be on the page we need 74 // to overwrite anyway). 75 for (i = 0; environ[i]; ++i) { 76 uintptr_t env_i = (uintptr_t) environ[i]; 77 // Only move the value if it's actually in the way. This avoids 78 // leaking copies of the values if this function is called again. 79 if (page <= env_i && env_i < page_end) { 80 char* copy = strdup(environ[i]); 81 // Be paranoid. Check for allocation failure and bail out. 82 if (!copy) 83 return; 84 environ[i] = copy; 85 } 86 } 87 // Put the title in argv[0]. We have to zero out the space first since the 88 // kernel doesn't actually look for a null terminator unless we make the 89 // argument list longer than it started. 90 avail_size = page_end - (uintptr_t) g_main_argv[0]; 91 memset(g_main_argv[0], 0, avail_size); 92 va_start(ap, fmt); 93 if (fmt[0] == '-') { 94 vsnprintf(g_main_argv[0], avail_size, &fmt[1], ap); 95 } else { 96 size_t size = snprintf(g_main_argv[0], avail_size, "%s ", g_orig_argv0); 97 if (size < avail_size) 98 vsnprintf(g_main_argv[0] + size, avail_size - size, fmt, ap); 99 } 100 va_end(ap); 101 g_main_argv[1] = NULL; 102 } 103 104 // A version of this built into glibc would not need this function, since 105 // it could stash the argv pointer in __libc_start_main(). But we need it. 106 void setproctitle_init(const char** main_argv) { 107 if (g_main_argv) 108 return; 109 110 uintptr_t page_size = sysconf(_SC_PAGESIZE); 111 // Check that the argv array is in fact on the same page of memory 112 // as the environment array just as an added measure of protection. 113 if (((uintptr_t) environ) / page_size == ((uintptr_t) main_argv) / page_size) 114 g_main_argv = const_cast<char**>(main_argv); 115 } 116
