sys/kern/kern_checkpoint.c

   1 /*-
   2  * Copyright (c) 2003 Kip Macy
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $DragonFly: src/sys/kern/kern_checkpoint.c,v 1.20 2008/09/17 21:44:18 dillon Exp $
  27  */
  28
  29 #include <sys/types.h>
  30 #include <sys/param.h>
  31 #include <sys/proc.h>
  32 #include <sys/module.h>
  33 #include <sys/sysent.h>
  34 #include <sys/kernel.h>
  35 #include <sys/systm.h>
  36 #include <sys/nlookup.h>
  37
  38 #include <sys/file.h>
  39 #include <sys/fcntl.h>
  40 #include <sys/signal.h>
  41 #include <vm/vm_param.h>
  42 #include <vm/vm.h>
  43 #include <sys/imgact_elf.h>
  44 #include <sys/procfs.h>
  45
  46 #include <sys/lock.h>
  47 #include <vm/pmap.h>
  48 #include <vm/vm_map.h>
  49 #include <vm/vm_extern.h>
  50 #include <sys/mman.h>
  51 #include <sys/sysent.h>
  52 #include <sys/sysproto.h>
  53 #include <sys/resource.h>
  54 #include <sys/resourcevar.h>
  55 #include <sys/malloc.h>
  56 #include <sys/stat.h>
  57 #include <sys/uio.h>
  58 #include <sys/namei.h>
  59 #include <sys/vnode.h>
  60 #include <machine/limits.h>
  61 #include <machine/frame.h>
  62 #include <sys/signalvar.h>
  63 #include <sys/syslog.h>
  64 #include <sys/sysctl.h>
  65 #include <machine/sigframe.h>
  66 #include <sys/exec.h>
  67 #include <sys/unistd.h>
  68 #include <sys/time.h>
  69 #include <sys/kern_syscall.h>
  70 #include <sys/checkpoint.h>
  71 #include <sys/mount.h>
  72 #include <sys/ckpt.h>
  73
  74 #include <sys/mplock2.h>
  75 #include <sys/file2.h>
  76
  77 static int elf_loadphdrs(struct file *fp,  Elf_Phdr *phdr, int numsegs);
  78 static int elf_getnotes(struct lwp *lp, struct file *fp, size_t notesz);
  79 static int elf_demarshalnotes(void *src, prpsinfo_t *psinfo,
  80                  prstatus_t *status, prfpregset_t *fpregset, int nthreads);
  81 static int elf_loadnotes(struct lwp *, prpsinfo_t *, prstatus_t *,
  82                  prfpregset_t *);
  83 static int elf_getsigs(struct lwp *lp, struct file *fp);
  84 static int elf_getfiles(struct lwp *lp, struct file *fp);
  85 static int elf_gettextvp(struct proc *p, struct file *fp);
  86 static char *ckpt_expand_name(const char *name, uid_t uid, pid_t pid);
  87
  88 static int ckptgroup = 0;       /* wheel only, -1 for any group */
  89 SYSCTL_INT(_kern, OID_AUTO, ckptgroup, CTLFLAG_RW, &ckptgroup, 0, "");
  90
  91 /* ref count to see how many processes that are being checkpointed */
  92 static int chptinuse = 0;
  93
  94 static __inline
  95 int
  96 read_check(struct file *fp, void *buf, size_t nbyte)
  97 {
  98         size_t nread;
  99         int error;
 100
 101         PRINTF(("reading %d bytes\n", nbyte));
 102         error = fp_read(fp, buf, nbyte, &nread, 1, UIO_SYSSPACE);
 103         if (error) {
 104                 PRINTF(("read failed - %d", error));
 105         } else if (nread != nbyte) {
 106                 PRINTF(("wanted to read %d - read %d\n", nbyte, nread));
 107                 error = EINVAL;
 108         }
 109         return error;
 110 }
 111
 112 static int
 113 elf_gethdr(struct file *fp, Elf_Ehdr *ehdr)
 114 {
 115         size_t nbyte = sizeof(Elf_Ehdr);
 116         int error;
 117
 118         if ((error = read_check(fp, ehdr, nbyte)) != 0)
 119                 goto done;
 120         if (!(ehdr->e_ehsize == sizeof(Elf_Ehdr))) {
 121                 PRINTF(("wrong elf header size: %d\n"
 122                        "expected size        : %d\n",
 123                        ehdr->e_ehsize, sizeof(Elf_Ehdr)));
 124                 return EINVAL;
 125         }
 126         if (!(ehdr->e_phentsize == sizeof(Elf_Phdr))) {
 127                 PRINTF(("wrong program header size: %d\n"
 128                        "expected size            : %d\n",
 129                        ehdr->e_phentsize, sizeof(Elf_Phdr)));
 130                 return EINVAL;
 131         }
 132
 133         if (!(ehdr->e_ident[EI_MAG0] == ELFMAG0 &&
 134               ehdr->e_ident[EI_MAG1] == ELFMAG1 &&
 135               ehdr->e_ident[EI_MAG2] == ELFMAG2 &&
 136               ehdr->e_ident[EI_MAG3] == ELFMAG3 &&
 137               ehdr->e_ident[EI_CLASS] == ELF_CLASS &&
 138               ehdr->e_ident[EI_DATA] == ELF_DATA &&
 139               ehdr->e_ident[EI_VERSION] == EV_CURRENT &&
 140               ehdr->e_ident[EI_OSABI] == ELFOSABI_FREEBSD &&
 141               ehdr->e_ident[EI_ABIVERSION] == 0)) {
 142                 PRINTF(("bad elf header\n there are %d segments\n",
 143                        ehdr->e_phnum));
 144                 return EINVAL;
 145
 146         }
 147         PRINTF(("Elf header size:           %d\n", ehdr->e_ehsize));
 148         PRINTF(("Program header size:       %d\n", ehdr->e_phentsize));
 149         PRINTF(("Number of Program headers: %d\n", ehdr->e_phnum));
 150  done:
 151         return error;
 152 }
 153
 154 static int
 155 elf_getphdrs(struct file *fp, Elf_Phdr *phdr, size_t nbyte)
 156 {
 157         int i;
 158         int error;
 159         int nheaders = nbyte/sizeof(Elf_Phdr);
 160
 161         PRINTF(("reading phdrs section\n"));
 162         if ((error = read_check(fp, phdr, nbyte)) != 0)
 163                 goto done;
 164         PRINTF(("headers section:\n"));
 165         for (i = 0; i < nheaders; i++) {
 166                 PRINTF(("entry type:   %d\n", phdr[i].p_type));
 167                 PRINTF(("file offset:  %d\n", phdr[i].p_offset));
 168                 PRINTF(("virt address: %p\n", (uint32_t *)phdr[i].p_vaddr));
 169                 PRINTF(("file size:    %d\n", phdr[i].p_filesz));
 170                 PRINTF(("memory size:  %d\n", phdr[i].p_memsz));
 171                 PRINTF(("\n"));
 172         }
 173  done:
 174         return error;
 175 }
 176
 177
 178 static int
 179 elf_getnotes(struct lwp *lp, struct file *fp, size_t notesz)
 180 {
 181         int error;
 182         int nthreads;
 183         char *note;
 184         prpsinfo_t *psinfo;
 185         prstatus_t *status;
 186         prfpregset_t *fpregset;
 187
 188         nthreads = (notesz - sizeof(prpsinfo_t))/(sizeof(prstatus_t) +
 189                                                   sizeof(prfpregset_t));
 190         PRINTF(("reading notes header nthreads=%d\n", nthreads));
 191         if (nthreads <= 0 || nthreads > CKPT_MAXTHREADS)
 192                 return EINVAL;
 193
 194         psinfo  = kmalloc(sizeof(prpsinfo_t), M_TEMP, M_ZERO | M_WAITOK);
 195         status  = kmalloc(nthreads*sizeof(prstatus_t), M_TEMP, M_WAITOK);
 196         fpregset  = kmalloc(nthreads*sizeof(prfpregset_t), M_TEMP, M_WAITOK);
 197         note = kmalloc(notesz, M_TEMP, M_WAITOK);
 198
 199
 200         PRINTF(("reading notes section\n"));
 201         if ((error = read_check(fp, note, notesz)) != 0)
 202                 goto done;
 203         error = elf_demarshalnotes(note, psinfo, status, fpregset, nthreads);
 204         if (error)
 205                 goto done;
 206         /* fetch register state from notes */
 207         error = elf_loadnotes(lp, psinfo, status, fpregset);
 208  done:
 209         if (psinfo)
 210                 kfree(psinfo, M_TEMP);
 211         if (status)
 212                 kfree(status, M_TEMP);
 213         if (fpregset)
 214                 kfree(fpregset, M_TEMP);
 215         if (note)
 216                 kfree(note, M_TEMP);
 217         return error;
 218 }
 219
 220 static int
 221 ckpt_thaw_proc(struct lwp *lp, struct file *fp)
 222 {
 223         struct proc *p = lp->lwp_proc;
 224         Elf_Phdr *phdr = NULL;
 225         Elf_Ehdr *ehdr = NULL;
 226         int error;
 227         size_t nbyte;
 228
 229         TRACE_ENTER;
 230
 231         ehdr = kmalloc(sizeof(Elf_Ehdr), M_TEMP, M_ZERO | M_WAITOK);
 232
 233         if ((error = elf_gethdr(fp, ehdr)) != 0)
 234                 goto done;
 235         nbyte = sizeof(Elf_Phdr) * ehdr->e_phnum;
 236         phdr = kmalloc(nbyte, M_TEMP, M_WAITOK);
 237
 238         /* fetch description of program writable mappings */
 239         if ((error = elf_getphdrs(fp, phdr, nbyte)) != 0)
 240                 goto done;
 241
 242         /* fetch notes section containing register state */
 243         if ((error = elf_getnotes(lp, fp, phdr->p_filesz)) != 0)
 244                 goto done;
 245
 246         /* fetch program text vnodes */
 247         if ((error = elf_gettextvp(p, fp)) != 0)
 248                 goto done;
 249
 250         /* fetch signal disposition */
 251         if ((error = elf_getsigs(lp, fp)) != 0) {
 252                 kprintf("failure in recovering signals\n");
 253                 goto done;
 254         }
 255
 256         /* fetch open files */
 257         if ((error = elf_getfiles(lp, fp)) != 0)
 258                 goto done;
 259
 260         /* handle mappings last in case we are reading from a socket */
 261         error = elf_loadphdrs(fp, phdr, ehdr->e_phnum);
 262
 263         /*
 264          * Set the textvp to the checkpoint file and mark the vnode so
 265          * a future checkpointing of this checkpoint-restored program
 266          * will copy out the contents of the mappings rather then trying
 267          * to record the vnode info related to the checkpoint file, which
 268          * is likely going to be destroyed when the program is re-checkpointed.
 269          */
 270         if (error == 0 && fp->f_data && fp->f_type == DTYPE_VNODE) {
 271                 if (p->p_textvp)
 272                         vrele(p->p_textvp);
 273                 p->p_textvp = (struct vnode *)fp->f_data;
 274                 p->p_textvp->v_flag |= VCKPT;
 275                 vref(p->p_textvp);
 276         }
 277 done:
 278         if (ehdr)
 279                 kfree(ehdr, M_TEMP);
 280         if (phdr)
 281                 kfree(phdr, M_TEMP);
 282         TRACE_EXIT;
 283         return error;
 284 }
 285
 286 static int
 287 elf_loadnotes(struct lwp *lp, prpsinfo_t *psinfo, prstatus_t *status,
 288            prfpregset_t *fpregset)
 289 {
 290         struct proc *p = lp->lwp_proc;
 291         int error;
 292
 293         /* validate status and psinfo */
 294         TRACE_ENTER;
 295         if (status->pr_version != PRSTATUS_VERSION ||
 296             status->pr_statussz != sizeof(prstatus_t) ||
 297             status->pr_gregsetsz != sizeof(gregset_t) ||
 298             status->pr_fpregsetsz != sizeof(fpregset_t) ||
 299             psinfo->pr_version != PRPSINFO_VERSION ||
 300             psinfo->pr_psinfosz != sizeof(prpsinfo_t)) {
 301                 PRINTF(("status check failed\n"));
 302                 error = EINVAL;
 303                 goto done;
 304         }
 305         /* XXX lwp handle more than one lwp*/
 306         if ((error = set_regs(lp, &status->pr_reg)) != 0)
 307                 goto done;
 308         error = set_fpregs(lp, fpregset);
 309         strlcpy(p->p_comm, psinfo->pr_fname, sizeof(p->p_comm));
 310         /* XXX psinfo->pr_psargs not yet implemented */
 311  done:
 312         TRACE_EXIT;
 313         return error;
 314 }
 315
 316 static int
 317 elf_getnote(void *src, size_t *off, const char *name, unsigned int type,
 318             void **desc, size_t descsz)
 319 {
 320         Elf_Note note;
 321         int error;
 322
 323         TRACE_ENTER;
 324         if (src == NULL) {
 325                 error = EFAULT;
 326                 goto done;
 327         }
 328         bcopy((char *)src + *off, &note, sizeof note);
 329
 330         PRINTF(("at offset: %d expected note of type: %d - got: %d\n",
 331                *off, type, note.n_type));
 332         *off += sizeof note;
 333         if (type != note.n_type) {
 334                 TRACE_ERR;
 335                 error = EINVAL;
 336                 goto done;
 337         }
 338         if (strncmp(name, (char *) src + *off, note.n_namesz) != 0) {
 339                 error = EINVAL;
 340                 goto done;
 341         }
 342         *off += roundup2(note.n_namesz, sizeof(Elf_Size));
 343         if (note.n_descsz != descsz) {
 344                 TRACE_ERR;
 345                 error = EINVAL;
 346                 goto done;
 347         }
 348         if (desc)
 349                 bcopy((char *)src + *off, *desc, note.n_descsz);
 350         *off += roundup2(note.n_descsz, sizeof(Elf_Size));
 351         error = 0;
 352  done:
 353         TRACE_EXIT;
 354         return error;
 355 }
 356
 357 static int
 358 elf_demarshalnotes(void *src, prpsinfo_t *psinfo, prstatus_t *status,
 359                    prfpregset_t *fpregset, int nthreads)
 360 {
 361         int i;
 362         int error;
 363         size_t off = 0;
 364
 365         TRACE_ENTER;
 366         error = elf_getnote(src, &off, "FreeBSD", NT_PRPSINFO,
 367                            (void **)&psinfo, sizeof(prpsinfo_t));
 368         if (error)
 369                 goto done;
 370         error = elf_getnote(src, &off, "FreeBSD", NT_PRSTATUS,
 371                            (void **)&status, sizeof(prstatus_t));
 372         if (error)
 373                 goto done;
 374         error = elf_getnote(src, &off, "FreeBSD", NT_FPREGSET,
 375                            (void **)&fpregset, sizeof(prfpregset_t));
 376         if (error)
 377                 goto done;
 378
 379         /*
 380          * The remaining portion needs to be an integer multiple
 381          * of prstatus_t and prfpregset_t
 382          */
 383         for (i = 0 ; i < nthreads - 1; i++) {
 384                 status++; fpregset++;
 385                 error = elf_getnote(src, &off, "FreeBSD", NT_PRSTATUS,
 386                                    (void **)&status, sizeof (prstatus_t));
 387                 if (error)
 388                         goto done;
 389                 error = elf_getnote(src, &off, "FreeBSD", NT_FPREGSET,
 390                                    (void **)&fpregset, sizeof(prfpregset_t));
 391                 if (error)
 392                         goto done;
 393         }
 394
 395  done:
 396         TRACE_EXIT;
 397         return error;
 398 }
 399
 400
 401 static int
 402 mmap_phdr(struct file *fp, Elf_Phdr *phdr)
 403 {
 404         int error;
 405         size_t len;
 406         int prot;
 407         void *addr;
 408         int flags;
 409         off_t pos;
 410
 411         TRACE_ENTER;
 412         pos = phdr->p_offset;
 413         len = phdr->p_filesz;
 414         addr = (void *)phdr->p_vaddr;
 415         flags = MAP_FIXED | MAP_NOSYNC | MAP_PRIVATE;
 416         prot = 0;
 417         if (phdr->p_flags & PF_R)
 418                 prot |= PROT_READ;
 419         if (phdr->p_flags & PF_W)
 420                 prot |= PROT_WRITE;
 421         if (phdr->p_flags & PF_X)
 422                 prot |= PROT_EXEC;
 423         if ((error = fp_mmap(addr, len, prot, flags, fp, pos, &addr)) != 0) {
 424                 PRINTF(("mmap failed: %d\n", error);       );
 425         }
 426         PRINTF(("map @%08x-%08x fileoff %08x-%08x\n", (int)addr,
 427                    (int)((char *)addr + len), (int)pos, (int)(pos + len)));
 428         TRACE_EXIT;
 429         return error;
 430 }
 431
 432 /*
 433  * Load memory mapped segments.  The segments are backed by the checkpoint
 434  * file.
 435  */
 436 static int
 437 elf_loadphdrs(struct file *fp, Elf_Phdr *phdr, int numsegs)
 438 {
 439         int i;
 440         int error = 0;
 441
 442         TRACE_ENTER;
 443         for (i = 1; i < numsegs; i++)  {
 444                 if ((error = mmap_phdr(fp, &phdr[i])) != 0)
 445                         break;
 446         }
 447         TRACE_EXIT;
 448         return error;
 449 }
 450
 451 static int
 452 elf_getsigs(struct lwp *lp, struct file *fp)
 453 {
 454         struct proc *p = lp->lwp_proc;
 455         int error;
 456         struct ckpt_siginfo *csi;
 457
 458         TRACE_ENTER;
 459         csi = kmalloc(sizeof(struct ckpt_siginfo), M_TEMP, M_ZERO | M_WAITOK);
 460         if ((error = read_check(fp, csi, sizeof(struct ckpt_siginfo))) != 0)
 461                 goto done;
 462
 463         if (csi->csi_ckptpisz != sizeof(struct ckpt_siginfo)) {
 464                 TRACE_ERR;
 465                 error = EINVAL;
 466                 goto done;
 467         }
 468         bcopy(&csi->csi_sigacts, p->p_sigacts, sizeof(p->p_sigacts));
 469         bcopy(&csi->csi_itimerval, &p->p_realtimer, sizeof(struct itimerval));
 470         SIG_CANTMASK(csi->csi_sigmask);
 471         /* XXX lwp handle more than one lwp */
 472         bcopy(&csi->csi_sigmask, &lp->lwp_sigmask, sizeof(sigset_t));
 473         p->p_sigparent = csi->csi_sigparent;
 474  done:
 475         if (csi)
 476                 kfree(csi, M_TEMP);
 477         TRACE_EXIT;
 478         return error;
 479 }
 480
 481 /*
 482  * Returns a locked, refd vnode
 483  */
 484 static int
 485 ckpt_fhtovp(fhandle_t *fh, struct vnode **vpp)
 486 {
 487         struct mount *mp;
 488         int error;
 489
 490         TRACE_ENTER;
 491         mp = vfs_getvfs(&fh->fh_fsid);
 492
 493         if (!mp) {
 494                 TRACE_ERR;
 495                 PRINTF(("failed to get mount - ESTALE\n"));
 496                 TRACE_EXIT;
 497                 return ESTALE;
 498         }
 499         error = VFS_FHTOVP(mp, NULL, &fh->fh_fid, vpp);
 500         if (error) {
 501                 PRINTF(("failed with: %d\n", error));
 502                 TRACE_ERR;
 503                 TRACE_EXIT;
 504                 return error;
 505         }
 506         TRACE_EXIT;
 507         return 0;
 508 }
 509
 510 static int
 511 mmap_vp(struct vn_hdr *vnh)
 512 {
 513         struct vnode *vp;
 514         Elf_Phdr *phdr;
 515         struct file *fp;
 516         int error;
 517         TRACE_ENTER;
 518
 519         phdr = &vnh->vnh_phdr;
 520
 521         if ((error = ckpt_fhtovp(&vnh->vnh_fh, &vp)) != 0)
 522                 return error;
 523         /*
 524          * XXX O_RDONLY -> or O_RDWR if file is PROT_WRITE, MAP_SHARED
 525          */
 526         if ((error = fp_vpopen(vp, O_RDONLY, &fp)) != 0) {
 527                 vput(vp);
 528                 return error;
 529         }
 530         error = mmap_phdr(fp, phdr);
 531         fp_close(fp);
 532         TRACE_EXIT;
 533         return error;
 534 }
 535
 536
 537 static int
 538 elf_gettextvp(struct proc *p, struct file *fp)
 539 {
 540         int i;
 541         int error;
 542         int vpcount;
 543         struct ckpt_vminfo vminfo;
 544         struct vn_hdr *vnh = NULL;
 545
 546         TRACE_ENTER;
 547         if ((error = read_check(fp, &vminfo, sizeof(vminfo))) != 0)
 548                 goto done;
 549         if (vminfo.cvm_dsize < 0 ||
 550             vminfo.cvm_dsize > p->p_rlimit[RLIMIT_DATA].rlim_cur ||
 551             vminfo.cvm_tsize < 0 ||
 552             (u_quad_t)vminfo.cvm_tsize > maxtsiz ||
 553             vminfo.cvm_daddr >= (caddr_t)VM_MAX_USER_ADDRESS ||
 554             vminfo.cvm_taddr >= (caddr_t)VM_MAX_USER_ADDRESS
 555         ) {
 556             error = ERANGE;
 557             goto done;
 558         }
 559
 560         vmspace_exec(p, NULL);
 561         p->p_vmspace->vm_daddr = vminfo.cvm_daddr;
 562         p->p_vmspace->vm_dsize = vminfo.cvm_dsize;
 563         p->p_vmspace->vm_taddr = vminfo.cvm_taddr;
 564         p->p_vmspace->vm_tsize = vminfo.cvm_tsize;
 565         if ((error = read_check(fp, &vpcount, sizeof(int))) != 0)
 566                 goto done;
 567         vnh = kmalloc(sizeof(struct vn_hdr) * vpcount, M_TEMP, M_WAITOK);
 568         if ((error = read_check(fp, vnh, sizeof(struct vn_hdr)*vpcount)) != 0)
 569                 goto done;
 570         for (i = 0; i < vpcount; i++) {
 571                 if ((error = mmap_vp(&vnh[i])) != 0)
 572                         goto done;
 573         }
 574
 575  done:
 576         if (vnh)
 577                 kfree(vnh, M_TEMP);
 578         TRACE_EXIT;
 579         return error;
 580 }
 581
 582
 583
 584 /* place holder */
 585 static int
 586 elf_getfiles(struct lwp *lp, struct file *fp)
 587 {
 588         int error;
 589         int i;
 590         int filecount;
 591         int fd;
 592         struct ckpt_filehdr filehdr;
 593         struct ckpt_fileinfo *cfi_base = NULL;
 594         struct filedesc *fdp = lp->lwp_proc->p_fd;
 595         struct vnode *vp;
 596         struct file *tempfp;
 597         struct file *ofp;
 598
 599         TRACE_ENTER;
 600         if ((error = read_check(fp, &filehdr, sizeof(filehdr))) != 0)
 601                 goto done;
 602         filecount = filehdr.cfh_nfiles;
 603         cfi_base = kmalloc(filecount*sizeof(struct ckpt_fileinfo), M_TEMP, M_WAITOK);
 604         error = read_check(fp, cfi_base, filecount*sizeof(struct ckpt_fileinfo));
 605         if (error)
 606                 goto done;
 607
 608         /*
 609          * Close all file descriptors >= 3.  These descriptors are from the
 610          * checkpt(1) program itself and should not be retained.
 611          *
 612          * XXX we need a flag so a checkpoint restore can opt to supply the
 613          * descriptors, or the non-regular-file descripors.
 614          */
 615         for (i = 3; i < fdp->fd_nfiles; ++i)
 616                 kern_close(i);
 617
 618         /*
 619          * Scan files to load
 620          */
 621         for (i = 0; i < filecount; i++) {
 622                 struct ckpt_fileinfo *cfi= &cfi_base[i];
 623                 /*
 624                  * Ignore placeholder entries where cfi_index is less then
 625                  * zero.  This will occur if the elf core dump code thinks
 626                  * it can save a vnode but winds up not being able to.
 627                  */
 628                 if (cfi->cfi_index < 0)
 629                         continue;
 630
 631                 /*
 632                  * Restore a saved file descriptor.  If CKFIF_ISCKPTFD is
 633                  * set the descriptor represents the checkpoint file itself,
 634                  * probably due to the user calling sys_checkpoint().  We
 635                  * want to use the fp being used to restore the checkpoint
 636                  * instead of trying to restore the original filehandle.
 637                  */
 638                 if (cfi->cfi_ckflags & CKFIF_ISCKPTFD) {
 639                         fhold(fp);
 640                         tempfp = fp;
 641                         error = 0;
 642                 } else {
 643                         error = ckpt_fhtovp(&cfi->cfi_fh, &vp);
 644                         if (error == 0) {
 645                                 error = fp_vpopen(vp, OFLAGS(cfi->cfi_flags),
 646                                                   &tempfp);
 647                                 if (error)
 648                                         vput(vp);
 649                         }
 650                 }
 651                 if (error)
 652                         break;
 653                 tempfp->f_offset = cfi->cfi_offset;
 654
 655                 /*
 656                  * If overwriting a descriptor close the old descriptor.  This
 657                  * only occurs if the saved core saved descriptors that we
 658                  * have not already closed.
 659                  */
 660                 if (cfi->cfi_index < fdp->fd_nfiles &&
 661                     (ofp = fdp->fd_files[cfi->cfi_index].fp) != NULL) {
 662                         kern_close(cfi->cfi_index);
 663                 }
 664
 665                 /*
 666                  * Allocate the descriptor we want.
 667                  */
 668                 if (fdalloc(lp->lwp_proc, cfi->cfi_index, &fd) != 0) {
 669                         PRINTF(("can't currently restore fd: %d\n",
 670                                cfi->cfi_index));
 671                         fp_close(fp);
 672                         goto done;
 673                 }
 674                 KKASSERT(fd == cfi->cfi_index);
 675                 fsetfd(fdp, tempfp, fd);
 676                 fdrop(tempfp);
 677                 cfi++;
 678                 PRINTF(("restoring %d\n", cfi->cfi_index));
 679         }
 680
 681  done:
 682         if (cfi_base)
 683                 kfree(cfi_base, M_TEMP);
 684         TRACE_EXIT;
 685         return error;
 686 }
 687
 688 static int
 689 ckpt_freeze_proc(struct lwp *lp, struct file *fp)
 690 {
 691         struct proc *p = lp->lwp_proc;
 692         rlim_t limit;
 693         int error;
 694
 695         PRINTF(("calling generic_elf_coredump\n"));
 696         limit = p->p_rlimit[RLIMIT_CORE].rlim_cur;
 697         if (limit) {
 698                 proc_stop(p);
 699                 while (p->p_nstopped < p->p_nthreads - 1)
 700                         tsleep(&p->p_nstopped, 0, "freeze", 1);
 701                 error = generic_elf_coredump(lp, SIGCKPT, fp, limit);
 702                 proc_unstop(p);
 703         } else {
 704                 error = ERANGE;
 705         }
 706         return error;
 707 }
 708
 709 /*
 710  * MPALMOSTSAFE
 711  */
 712 int
 713 sys_sys_checkpoint(struct sys_checkpoint_args *uap)
 714 {
 715         int error = 0;
 716         struct thread *td = curthread;
 717         struct proc *p = td->td_proc;
 718         struct filedesc *fdp = p->p_fd;
 719         struct file *fp;
 720
 721         /*
 722          * Only certain groups (to reduce our security exposure).  -1
 723          * allows any group.
 724          */
 725         if (ckptgroup >= 0 && groupmember(ckptgroup, td->td_ucred) == 0)
 726                 return (EPERM);
 727
 728         /*
 729          * For now we can only checkpoint the current process
 730          */
 731         if (uap->pid != -1 && uap->pid != p->p_pid)
 732                 return (EINVAL);
 733
 734         get_mplock();
 735
 736         switch (uap->type) {
 737         case CKPT_FREEZE:
 738                 fp = NULL;
 739                 if (uap->fd == -1 && uap->pid == (pid_t)-1)
 740                         error = checkpoint_signal_handler(td->td_lwp);
 741                 else if ((fp = holdfp(fdp, uap->fd, FWRITE)) == NULL)
 742                         error = EBADF;
 743                 else
 744                         error = ckpt_freeze_proc(td->td_lwp, fp);
 745                 if (fp)
 746                         fdrop(fp);
 747                 break;
 748         case CKPT_THAW:
 749                 if (uap->pid != -1) {
 750                         error = EINVAL;
 751                         break;
 752                 }
 753                 if ((fp = holdfp(fdp, uap->fd, FREAD)) == NULL) {
 754                         error = EBADF;
 755                         break;
 756                 }
 757                 uap->sysmsg_result = uap->retval;
 758                 error = ckpt_thaw_proc(td->td_lwp, fp);
 759                 fdrop(fp);
 760                 break;
 761         default:
 762                 error = EOPNOTSUPP;
 763                 break;
 764         }
 765         rel_mplock();
 766         return error;
 767 }
 768
 769 int
 770 checkpoint_signal_handler(struct lwp *lp)
 771 {
 772         struct thread *td = lp->lwp_thread;
 773         struct proc *p = lp->lwp_proc;
 774         char *buf;
 775         struct file *fp;
 776         struct nlookupdata nd;
 777         int error;
 778
 779         chptinuse++;
 780
 781         /*
 782          * Being able to checkpoint an suid or sgid program is not a good
 783          * idea.
 784          */
 785         if (sugid_coredump == 0 && (p->p_flag & P_SUGID)) {
 786                 chptinuse--;
 787                 return (EPERM);
 788         }
 789
 790         buf = ckpt_expand_name(p->p_comm, td->td_ucred->cr_uid, p->p_pid);
 791         if (buf == NULL) {
 792                 chptinuse--;
 793                 return (ENOMEM);
 794         }
 795
 796         log(LOG_INFO, "pid %d (%s), uid %d: checkpointing to %s\n",
 797                 p->p_pid, p->p_comm,
 798                 (td->td_ucred ? td->td_ucred->cr_uid : -1),
 799                 buf);
 800
 801         PRINTF(("ckpt handler called, using '%s'\n", buf));
 802
 803         /*
 804          * Use the same safety flags that the coredump code uses.  Remove
 805          * any previous checkpoint file before writing out the new one in
 806          * case we are re-checkpointing a program that had been checkpt
 807          * restored.  Otherwise we will corrupt the program space (which is
 808          * made up of mmap()ings of the previous checkpoint file) while we
 809          * write out the new one.
 810          */
 811         error = nlookup_init(&nd, buf, UIO_SYSSPACE, 0);
 812         if (error == 0)
 813                 error = kern_unlink(&nd);
 814         nlookup_done(&nd);
 815         error = fp_open(buf, O_WRONLY|O_CREAT|O_TRUNC|O_NOFOLLOW, 0600, &fp);
 816         if (error == 0) {
 817                 error = ckpt_freeze_proc(lp, fp);
 818                 fp_close(fp);
 819         } else {
 820                 kprintf("checkpoint failed with open - error: %d\n", error);
 821         }
 822         kfree(buf, M_TEMP);
 823         chptinuse--;
 824         return (error);
 825 }
 826
 827 static char ckptfilename[MAXPATHLEN] = {"%N.ckpt"};
 828 SYSCTL_STRING(_kern, OID_AUTO, ckptfile, CTLFLAG_RW, ckptfilename,
 829               sizeof(ckptfilename), "process checkpoint name format string");
 830
 831 /*
 832  * expand_name(name, uid, pid)
 833  * Expand the name described in corefilename, using name, uid, and pid.
 834  * corefilename is a kprintf-like string, with three format specifiers:
 835  *      %N      name of process ("name")
 836  *      %P      process id (pid)
 837  *      %U      user id (uid)
 838  * For example, "%N.core" is the default; they can be disabled completely
 839  * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P".
 840  * This is controlled by the sysctl variable kern.corefile (see above).
 841  *
 842  * -- taken from the coredump code
 843  */
 844
 845 static
 846 char *
 847 ckpt_expand_name(const char *name, uid_t uid, pid_t pid)
 848 {
 849         char *temp;
 850         char *bp;
 851         char buf[11];           /* Buffer for pid/uid -- max 4B */
 852         int error;
 853         int i;
 854         int n;
 855         char *format = ckptfilename;
 856         size_t namelen;
 857
 858         temp = kmalloc(MAXPATHLEN + 1, M_TEMP, M_NOWAIT);
 859         if (temp == NULL)
 860                 return NULL;
 861         namelen = strlen(name);
 862         n = 0;
 863         if (ckptfilename[0] != '/') {
 864                 if ((bp = kern_getcwd(temp, MAXPATHLEN - 1, &error)) == NULL) {
 865                         kfree(temp, M_TEMP);
 866                         return NULL;
 867                 }
 868                 n = strlen(bp);
 869                 bcopy(bp, temp, n + 1); /* normalize location of the path */
 870                 temp[n++] = '/';
 871                 temp[n] = '\0';
 872         }
 873         for (i= 0; n < MAXPATHLEN && format[i]; i++) {
 874                 int l;
 875                 switch (format[i]) {
 876                 case '%':       /* Format character */
 877                         i++;
 878                         switch (format[i]) {
 879                         case '%':
 880                                 temp[n++] = '%';
 881                                 break;
 882                         case 'N':       /* process name */
 883                                 if ((n + namelen) > MAXPATHLEN) {
 884                                         log(LOG_ERR, "pid %d (%s), uid (%u):  Path `%s%s' is too long\n",
 885                                             pid, name, uid, temp, name);
 886                                         kfree(temp, M_TEMP);
 887                                         return NULL;
 888                                 }
 889                                 memcpy(temp+n, name, namelen);
 890                                 n += namelen;
 891                                 break;
 892                         case 'P':       /* process id */
 893                                 l = ksprintf(buf, "%u", pid);
 894                                 if ((n + l) > MAXPATHLEN) {
 895                                         log(LOG_ERR, "pid %d (%s), uid (%u):  Path `%s%s' is too long\n",
 896                                             pid, name, uid, temp, name);
 897                                         kfree(temp, M_TEMP);
 898                                         return NULL;
 899                                 }
 900                                 memcpy(temp+n, buf, l);
 901                                 n += l;
 902                                 break;
 903                         case 'U':       /* user id */
 904                                 l = ksprintf(buf, "%u", uid);
 905                                 if ((n + l) > MAXPATHLEN) {
 906                                         log(LOG_ERR, "pid %d (%s), uid (%u):  Path `%s%s' is too long\n",
 907                                             pid, name, uid, temp, name);
 908                                         kfree(temp, M_TEMP);
 909                                         return NULL;
 910                                 }
 911                                 memcpy(temp+n, buf, l);
 912                                 n += l;
 913                                 break;
 914                         default:
 915                                 log(LOG_ERR, "Unknown format character %c in `%s'\n", format[i], format);
 916                         }
 917                         break;
 918                 default:
 919                         temp[n++] = format[i];
 920                 }
 921         }
 922         temp[n] = '\0';
 923         return temp;
 924 }
 925