source3/lib/dumpcore.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4
   5    Copyright (C) Andrew Tridgell 1992-2011
   6
   7    based on old fault.c code, which had:
   8
   9    Copyright (C) Jeremy Allison 2001-2007
  10    Copyright (C) Simo Sorce 2001
  11    Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
  12    Copyright (C) James Peach 2006
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 3 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  26 */
  27
  28 #include "includes.h"
  29 #include "system/filesys.h"
  30
  31 #ifdef HAVE_SYS_SYSCTL_H
  32 #include <sys/sysctl.h>
  33 #endif
  34
  35 #ifdef HAVE_SYS_PRCTL_H
  36 #include <sys/prctl.h>
  37 #endif
  38
  39 static char *corepath;
  40
  41 /**
  42  * Build up the default corepath as "<logbase>/cores/<progname>"
  43  */
  44 static char *get_default_corepath(const char *logbase, const char *progname)
  45 {
  46         const mode_t mode = 0700;
  47         const uid_t uid = getuid();
  48         char *tmp_corepath;
  49
  50         /* Setup core dir in logbase. */
  51         tmp_corepath = talloc_asprintf(NULL, "%s/cores", logbase);
  52         if (!tmp_corepath) {
  53                 DEBUG(0, ("Out of memory\n"));
  54                 return NULL;
  55         }
  56
  57         if (!directory_create_or_exist_strict(tmp_corepath, uid, mode)) {
  58                 DEBUG(0, ("Failed to create %s for user %d with mode 0%o\n",
  59                           tmp_corepath, (int)uid, (int)mode));
  60                 goto err_out;
  61         }
  62
  63         /* Setup progname-specific core subdir */
  64         tmp_corepath = talloc_asprintf_append(tmp_corepath, "/%s", progname);
  65         if (!tmp_corepath) {
  66                 DEBUG(0, ("Out of memory\n"));
  67                 goto err_out;
  68         }
  69
  70         if (!directory_create_or_exist(tmp_corepath, uid, mode)) {
  71                 DEBUG(0, ("Failed to create %s for user %d with mode 0%o\n",
  72                           tmp_corepath, (int)uid, (int)mode));
  73                 goto err_out;
  74         }
  75
  76         return tmp_corepath;
  77
  78  err_out:
  79         talloc_free(tmp_corepath);
  80         return NULL;
  81 }
  82
  83
  84 /**
  85  * Get the FreeBSD corepath.
  86  *
  87  * On FreeBSD the current working directory is ignored when creating a core
  88  * file.  Instead the core directory is controlled via sysctl.  This consults
  89  * the value of "kern.corefile" so the correct corepath can be printed out
  90  * before dump_core() calls abort.
  91  */
  92 #if (defined(FREEBSD) && defined(HAVE_SYSCTLBYNAME))
  93 static char *get_freebsd_corepath(void)
  94 {
  95         char *tmp_corepath = NULL;
  96         char *end = NULL;
  97         size_t len = 128;
  98         int ret;
  99
 100         /* Loop with increasing sizes so we don't allocate too much. */
 101         do {
 102                 if (len > 1024)  {
 103                         goto err_out;
 104                 }
 105
 106                 tmp_corepath = (char *)talloc_realloc(NULL, tmp_corepath,
 107                                                       char, len);
 108                 if (!tmp_corepath) {
 109                         return NULL;
 110                 }
 111
 112                 ret = sysctlbyname("kern.corefile", tmp_corepath, &len, NULL,
 113                                    0);
 114                 if (ret == -1) {
 115                         if (errno != ENOMEM) {
 116                                 DEBUG(0, ("sysctlbyname failed getting "
 117                                           "kern.corefile %s\n",
 118                                           strerror(errno)));
 119                                 goto err_out;
 120                         }
 121
 122                         /* Not a large enough array, try a bigger one. */
 123                         len = len << 1;
 124                 }
 125         } while (ret == -1);
 126
 127         /* Strip off the common filename expansion */
 128         if ((end = strrchr_m(tmp_corepath, '/'))) {
 129                 *end = '\0';
 130         }
 131
 132         return tmp_corepath;
 133
 134  err_out:
 135         if (tmp_corepath) {
 136                 talloc_free(tmp_corepath);
 137         }
 138         return NULL;
 139 }
 140 #endif
 141
 142 #if defined(HAVE_SYS_KERNEL_PROC_CORE_PATTERN)
 143
 144 /**
 145  * Get the Linux corepath.
 146  *
 147  * On Linux the contents of /proc/sys/kernel/core_pattern indicates the
 148  * location of the core path.
 149  */
 150 static char *get_linux_corepath(void)
 151 {
 152         char *end;
 153         int fd;
 154         char *result;
 155
 156         fd = open("/proc/sys/kernel/core_pattern", O_RDONLY, 0);
 157         if (fd == -1) {
 158                 return NULL;
 159         }
 160
 161         result = afdgets(fd, NULL, 0);
 162         close(fd);
 163
 164         if (result == NULL) {
 165                 return NULL;
 166         }
 167
 168         if (result[0] != '/') {
 169                 /*
 170                  * No absolute path, use the default (cwd)
 171                  */
 172                 TALLOC_FREE(result);
 173                 return NULL;
 174         }
 175         /* Strip off the common filename expansion */
 176
 177         end = strrchr_m(result, '/');
 178
 179         if ((end != result) /* this would be the only / */
 180             && (end != NULL)) {
 181                 *end = '\0';
 182         }
 183         return result;
 184 }
 185 #endif
 186
 187
 188 /**
 189  * Try getting system-specific corepath if one exists.
 190  *
 191  * If the system doesn't define a corepath, then the default is used.
 192  */
 193 static char *get_corepath(const char *logbase, const char *progname)
 194 {
 195 #if (defined(FREEBSD) && defined(HAVE_SYSCTLBYNAME))
 196         char *tmp_corepath = NULL;
 197         tmp_corepath = get_freebsd_corepath();
 198
 199         /* If this has been set correctly, we're done. */
 200         if (tmp_corepath) {
 201                 return tmp_corepath;
 202         }
 203 #endif
 204
 205 #if defined(HAVE_SYS_KERNEL_PROC_CORE_PATTERN)
 206         char *tmp_corepath = NULL;
 207         tmp_corepath = get_linux_corepath();
 208
 209         /* If this has been set correctly, we're done. */
 210         if (tmp_corepath) {
 211                 return tmp_corepath;
 212         }
 213 #endif
 214
 215         /* Fall back to the default. */
 216         return get_default_corepath(logbase, progname);
 217 }
 218
 219 /*******************************************************************
 220 make all the preparations to safely dump a core file
 221 ********************************************************************/
 222
 223 void dump_core_setup(const char *progname, const char *log_file)
 224 {
 225         char *logbase = NULL;
 226         char *end = NULL;
 227
 228         if (log_file && *log_file) {
 229                 if (asprintf(&logbase, "%s", log_file) < 0) {
 230                         return;
 231                 }
 232                 if ((end = strrchr_m(logbase, '/'))) {
 233                         *end = '\0';
 234                 }
 235         } else {
 236                 /* We will end up here if the log file is given on the command
 237                  * line by the -l option but the "log file" option is not set
 238                  * in smb.conf.
 239                  */
 240                 if (asprintf(&logbase, "%s", get_dyn_LOGFILEBASE()) < 0) {
 241                         return;
 242                 }
 243         }
 244
 245         SMB_ASSERT(progname != NULL);
 246
 247         corepath = get_corepath(logbase, progname);
 248         if (!corepath) {
 249                 DEBUG(0, ("Unable to setup corepath for %s: %s\n", progname,
 250                           strerror(errno)));
 251                 goto out;
 252         }
 253
 254
 255 #ifdef HAVE_GETRLIMIT
 256 #ifdef RLIMIT_CORE
 257         {
 258                 struct rlimit rlp;
 259                 getrlimit(RLIMIT_CORE, &rlp);
 260                 rlp.rlim_cur = MAX(16*1024*1024,rlp.rlim_cur);
 261                 setrlimit(RLIMIT_CORE, &rlp);
 262                 getrlimit(RLIMIT_CORE, &rlp);
 263                 DEBUG(3,("Maximum core file size limits now %d(soft) %d(hard)\n",
 264                          (int)rlp.rlim_cur,(int)rlp.rlim_max));
 265         }
 266 #endif
 267 #endif
 268
 269         /* FIXME: if we have a core-plus-pid facility, configurably set
 270          * this up here.
 271          */
 272  out:
 273         SAFE_FREE(logbase);
 274 }
 275
 276  void dump_core(void)
 277 {
 278         static bool called;
 279
 280         if (called) {
 281                 DEBUG(0, ("dump_core() called recursive\n"));
 282                 exit(1);
 283         }
 284         called = true;
 285
 286         /* Note that even if core dumping has been disabled, we still set up
 287          * the core path. This is to handle the case where core dumping is
 288          * turned on in smb.conf and the relevant daemon is not restarted.
 289          */
 290         if (!lp_enable_core_files()) {
 291                 DEBUG(0, ("Exiting on internal error (core file administratively disabled)\n"));
 292                 exit(1);
 293         }
 294
 295 #if DUMP_CORE
 296         /* If we're running as non root we might not be able to dump the core
 297          * file to the corepath.  There must not be an unbecome_root() before
 298          * we call abort(). */
 299         if (geteuid() != sec_initial_uid()) {
 300                 become_root();
 301         }
 302
 303         if (corepath == NULL) {
 304                 DEBUG(0, ("Can not dump core: corepath not set up\n"));
 305                 exit(1);
 306         }
 307
 308         if (*corepath != '\0') {
 309                 /* The chdir might fail if we dump core before we finish
 310                  * processing the config file.
 311                  */
 312                 if (chdir(corepath) != 0) {
 313                         DEBUG(0, ("unable to change to %s\n", corepath));
 314                         DEBUGADD(0, ("refusing to dump core\n"));
 315                         exit(1);
 316                 }
 317
 318                 DEBUG(0,("dumping core in %s\n", corepath));
 319         }
 320
 321         umask(~(0700));
 322         dbgflush();
 323
 324 #if defined(HAVE_PRCTL) && defined(PR_SET_DUMPABLE)
 325         /* On Linux we lose the ability to dump core when we change our user
 326          * ID. We know how to dump core safely, so let's make sure we have our
 327          * dumpable flag set.
 328          */
 329         prctl(PR_SET_DUMPABLE, 1);
 330 #endif
 331
 332         /* Ensure we don't have a signal handler for abort. */
 333 #ifdef SIGABRT
 334         CatchSignal(SIGABRT, SIG_DFL);
 335 #endif
 336
 337         abort();
 338
 339 #else /* DUMP_CORE */
 340         exit(1);
 341 #endif /* DUMP_CORE */
 342 }