sys/kern/kern_core.c

   1 /*      $NetBSD: kern_core.c,v 1.14 2009/01/11 02:45:52 christos Exp $  */
   2
   3 /*
   4  * Copyright (c) 1982, 1986, 1989, 1991, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  * (c) UNIX System Laboratories, Inc.
   7  * All or some portions of this file are derived from material licensed
   8  * to the University of California by American Telephone and Telegraph
   9  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  10  * the permission of UNIX System Laboratories, Inc.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  *      @(#)kern_sig.c  8.14 (Berkeley) 5/14/95
  37  */
  38
  39 #include <sys/cdefs.h>
  40 __KERNEL_RCSID(0, "$NetBSD: kern_core.c,v 1.14 2009/01/11 02:45:52 christos Exp $");
  41
  42 #include <sys/param.h>
  43 #include <sys/vnode.h>
  44 #include <sys/namei.h>
  45 #include <sys/acct.h>
  46 #include <sys/file.h>
  47 #include <sys/stat.h>
  48 #include <sys/proc.h>
  49 #include <sys/exec.h>
  50 #include <sys/filedesc.h>
  51 #include <sys/kauth.h>
  52 #include <sys/module.h>
  53
  54 MODULE(MODULE_CLASS_MISC, coredump, NULL);
  55
  56 struct coredump_iostate {
  57         struct lwp *io_lwp;
  58         struct vnode *io_vp;
  59         kauth_cred_t io_cred;
  60         off_t io_offset;
  61 };
  62
  63 static int      coredump(struct lwp *, const char *);
  64 static int      coredump_buildname(struct proc *, char *, const char *, size_t);
  65
  66 static int
  67 coredump_modcmd(modcmd_t cmd, void *arg)
  68 {
  69
  70         switch (cmd) {
  71         case MODULE_CMD_INIT:
  72                 coredump_vec = coredump;
  73                 return 0;
  74         case MODULE_CMD_FINI:
  75                 /*
  76                  * In theory we don't need to patch this, as the various
  77                  * exec formats depend on this module.  If this module has
  78                  * no references, and so can be unloaded, no user programs
  79                  * can be running and so nothing can call *coredump_vec.
  80                  */
  81                 coredump_vec = (int (*)(struct lwp *, const char *))enosys;
  82                 return 0;
  83         default:
  84                 return ENOTTY;
  85         }
  86 }
  87
  88 /*
  89  * Dump core, into a file named "progname.core" or "core" (depending on the
  90  * value of shortcorename), unless the process was setuid/setgid.
  91  */
  92 static int
  93 coredump(struct lwp *l, const char *pattern)
  94 {
  95         struct vnode            *vp;
  96         struct proc             *p;
  97         struct vmspace          *vm;
  98         kauth_cred_t            cred;
  99         struct nameidata        nd;
 100         struct vattr            vattr;
 101         struct coredump_iostate io;
 102         struct plimit           *lim;
 103         int                     error, error1;
 104         char                    *name;
 105
 106         name = PNBUF_GET();
 107
 108         p = l->l_proc;
 109         vm = p->p_vmspace;
 110
 111         mutex_enter(proc_lock);         /* p_session */
 112         mutex_enter(p->p_lock);
 113
 114         /*
 115          * Refuse to core if the data + stack + user size is larger than
 116          * the core dump limit.  XXX THIS IS WRONG, because of mapped
 117          * data.
 118          */
 119         if (USPACE + ctob(vm->vm_dsize + vm->vm_ssize) >=
 120             p->p_rlimit[RLIMIT_CORE].rlim_cur) {
 121                 error = EFBIG;          /* better error code? */
 122                 mutex_exit(p->p_lock);
 123                 mutex_exit(proc_lock);
 124                 goto done;
 125         }
 126
 127         /*
 128          * It may well not be curproc, so grab a reference to its current
 129          * credentials.
 130          */
 131         kauth_cred_hold(p->p_cred);
 132         cred = p->p_cred;
 133
 134         /*
 135          * The core dump will go in the current working directory.  Make
 136          * sure that the directory is still there and that the mount flags
 137          * allow us to write core dumps there.
 138          *
 139          * XXX: this is partially bogus, it should be checking the directory
 140          * into which the file is actually written - which probably needs
 141          * a flag on namei()
 142          */
 143         vp = p->p_cwdi->cwdi_cdir;
 144         if (vp->v_mount == NULL ||
 145             (vp->v_mount->mnt_flag & MNT_NOCOREDUMP) != 0) {
 146                 error = EPERM;
 147                 mutex_exit(p->p_lock);
 148                 mutex_exit(proc_lock);
 149                 goto done;
 150         }
 151
 152         /*
 153          * Make sure the process has not set-id, to prevent data leaks,
 154          * unless it was specifically requested to allow set-id coredumps.
 155          */
 156         if (p->p_flag & PK_SUGID) {
 157                 if (!security_setidcore_dump) {
 158                         error = EPERM;
 159                         mutex_exit(p->p_lock);
 160                         mutex_exit(proc_lock);
 161                         goto done;
 162                 }
 163                 pattern = security_setidcore_path;
 164         }
 165
 166         /* It is (just) possible for p_limit and pl_corename to change */
 167         lim = p->p_limit;
 168         mutex_enter(&lim->pl_lock);
 169         if (pattern == NULL)
 170                 pattern = lim->pl_corename;
 171         error = coredump_buildname(p, name, pattern, MAXPATHLEN);
 172         mutex_exit(&lim->pl_lock);
 173         mutex_exit(p->p_lock);
 174         mutex_exit(proc_lock);
 175         if (error)
 176                 goto done;
 177         NDINIT(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, name);
 178         if ((error = vn_open(&nd, O_CREAT | O_NOFOLLOW | FWRITE,
 179             S_IRUSR | S_IWUSR)) != 0)
 180                 goto done;
 181         vp = nd.ni_vp;
 182
 183         /* Don't dump to non-regular files or files with links. */
 184         if (vp->v_type != VREG ||
 185             VOP_GETATTR(vp, &vattr, cred) || vattr.va_nlink != 1) {
 186                 error = EINVAL;
 187                 goto out;
 188         }
 189         vattr_null(&vattr);
 190         vattr.va_size = 0;
 191
 192         if ((p->p_flag & PK_SUGID) && security_setidcore_dump) {
 193                 vattr.va_uid = security_setidcore_owner;
 194                 vattr.va_gid = security_setidcore_group;
 195                 vattr.va_mode = security_setidcore_mode;
 196         }
 197
 198         VOP_SETATTR(vp, &vattr, cred);
 199         p->p_acflag |= ACORE;
 200
 201         io.io_lwp = l;
 202         io.io_vp = vp;
 203         io.io_cred = cred;
 204         io.io_offset = 0;
 205
 206         /* Now dump the actual core file. */
 207         error = (*p->p_execsw->es_coredump)(l, &io);
 208  out:
 209         VOP_UNLOCK(vp, 0);
 210         error1 = vn_close(vp, FWRITE, cred);
 211         if (error == 0)
 212                 error = error1;
 213 done:
 214         if (name != NULL)
 215                 PNBUF_PUT(name);
 216         return error;
 217 }
 218
 219 static int
 220 coredump_buildname(struct proc *p, char *dst, const char *src, size_t len)
 221 {
 222         const char      *s;
 223         char            *d, *end;
 224         int             i;
 225
 226         KASSERT(mutex_owned(proc_lock));
 227
 228         for (s = src, d = dst, end = d + len; *s != '\0'; s++) {
 229                 if (*s == '%') {
 230                         switch (*(s + 1)) {
 231                         case 'n':
 232                                 i = snprintf(d, end - d, "%s", p->p_comm);
 233                                 break;
 234                         case 'p':
 235                                 i = snprintf(d, end - d, "%d", p->p_pid);
 236                                 break;
 237                         case 'u':
 238                                 i = snprintf(d, end - d, "%.*s",
 239                                     (int)sizeof p->p_pgrp->pg_session->s_login,
 240                                     p->p_pgrp->pg_session->s_login);
 241                                 break;
 242                         case 't':
 243                                 i = snprintf(d, end - d, "%lld",
 244                                     (long long)p->p_stats->p_start.tv_sec);
 245                                 break;
 246                         default:
 247                                 goto copy;
 248                         }
 249                         d += i;
 250                         s++;
 251                 } else {
 252  copy:                  *d = *s;
 253                         d++;
 254                 }
 255                 if (d >= end)
 256                         return (ENAMETOOLONG);
 257         }
 258         *d = '\0';
 259         return 0;
 260 }
 261
 262 int
 263 coredump_write(void *cookie, enum uio_seg segflg, const void *data, size_t len)
 264 {
 265         struct coredump_iostate *io = cookie;
 266         int error;
 267
 268         error = vn_rdwr(UIO_WRITE, io->io_vp, __UNCONST(data), len,
 269             io->io_offset, segflg,
 270             IO_NODELOCKED|IO_UNIT, io->io_cred, NULL,
 271             segflg == UIO_USERSPACE ? io->io_lwp : NULL);
 272         if (error) {
 273                 printf("pid %d (%s): %s write of %zu@%p at %lld failed: %d\n",
 274                     io->io_lwp->l_proc->p_pid, io->io_lwp->l_proc->p_comm,
 275                     segflg == UIO_USERSPACE ? "user" : "system",
 276                     len, data, (long long) io->io_offset, error);
 277                 return (error);
 278         }
 279
 280         io->io_offset += len;
 281         return (0);
 282 }