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.1 2004/11/23 06:32:32 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 /* only on dragonfly */ 40 #include <sys/file2.h> 41 #include <sys/fcntl.h> 42 #include <sys/signal.h> 43 #include <vm/vm_param.h> 44 #include <vm/vm.h> 45 #include <sys/imgact_elf.h> 46 #include <sys/procfs.h> 47 48 #include <sys/lock.h> 49 #include <vm/pmap.h> 50 #include <vm/vm_map.h> 51 #include <vm/vm_extern.h> 52 #include <sys/mman.h> 53 #include <sys/sysent.h> 54 #include <sys/sysproto.h> 55 #include <sys/resource.h> 56 #include <sys/resourcevar.h> 57 #include <sys/malloc.h> 58 #include <sys/stat.h> 59 #include <sys/uio.h> 60 #include <sys/namei.h> 61 #include <sys/vnode.h> 62 #include <machine/limits.h> 63 #include <i386/include/frame.h> 64 #include <sys/signalvar.h> 65 #include <sys/syslog.h> 66 #include <sys/sysctl.h> 67 #include <i386/include/sigframe.h> 68 #include <sys/exec.h> 69 #include <sys/unistd.h> 70 #include <sys/time.h> 71 #include <sys/kern_syscall.h> 72 #include <sys/checkpoint.h> 73 #include <sys/mount.h> 74 #include <sys/ckpt.h> 75 76 77 static int elf_loadphdrs(struct file *fp, Elf_Phdr *phdr, int numsegs); 78 static int elf_getnotes(struct proc *p, 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 proc *, prpsinfo_t *, prstatus_t *, 82 prfpregset_t *); 83 static int elf_getsigs(struct proc *p, struct file *fp); 84 static int elf_getfiles(struct proc *p, 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); 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 proc *p, 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 = malloc(sizeof(prpsinfo_t), M_TEMP, M_ZERO | M_WAITOK); 195 status = malloc(nthreads*sizeof(prstatus_t), M_TEMP, M_WAITOK); 196 fpregset = malloc(nthreads*sizeof(prfpregset_t), M_TEMP, M_WAITOK); 197 note = malloc(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(p, psinfo, status, fpregset); 208 done: 209 if (psinfo) 210 free(psinfo, M_TEMP); 211 if (status) 212 free(status, M_TEMP); 213 if (fpregset) 214 free(fpregset, M_TEMP); 215 if (note) 216 free(note, M_TEMP); 217 return error; 218 } 219 220 static int 221 ckpt_thaw_proc(struct proc *p, struct file *fp) 222 { 223 224 Elf_Phdr *phdr = NULL; 225 Elf_Ehdr *ehdr = NULL; 226 int error; 227 size_t nbyte; 228 229 TRACE_ENTER; 230 231 ehdr = malloc(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 = malloc(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(p, 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(p, fp)) != 0) 252 goto done; 253 254 /* fetch open files */ 255 if ((error = elf_getfiles(p, fp)) != 0) 256 goto done; 257 258 /* handle mappings last in case we are reading from a socket */ 259 error = elf_loadphdrs(fp, phdr, ehdr->e_phnum); 260 261 /* 262 * Set the textvp to the checkpoint file and mark the vnode so 263 * a future checkpointing of this checkpoint-restored program 264 * will copy out the contents of the mappings rather then trying 265 * to record the vnode info related to the checkpoint file, which 266 * is likely going to be destroyed when the program is re-checkpointed. 267 */ 268 if (error == 0 && fp->f_data && fp->f_type == DTYPE_VNODE) { 269 if (p->p_textvp) 270 vrele(p->p_textvp); 271 p->p_textvp = (struct vnode *)fp->f_data; 272 p->p_textvp->v_flag |= VCKPT; 273 vref(p->p_textvp); 274 } 275 done: 276 if (ehdr) 277 free(ehdr, M_TEMP); 278 if (phdr) 279 free(phdr, M_TEMP); 280 TRACE_EXIT; 281 return error; 282 } 283 284 static int 285 elf_loadnotes(struct proc *p, prpsinfo_t *psinfo, prstatus_t *status, 286 prfpregset_t *fpregset) 287 { 288 int error; 289 290 /* validate status and psinfo */ 291 TRACE_ENTER; 292 if (status->pr_version != PRSTATUS_VERSION || 293 status->pr_statussz != sizeof(prstatus_t) || 294 status->pr_gregsetsz != sizeof(gregset_t) || 295 status->pr_fpregsetsz != sizeof(fpregset_t) || 296 psinfo->pr_version != PRPSINFO_VERSION || 297 psinfo->pr_psinfosz != sizeof(prpsinfo_t)) { 298 PRINTF(("status check failed\n")); 299 error = EINVAL; 300 goto done; 301 } 302 if ((error = set_regs(p, &status->pr_reg)) != 0) 303 goto done; 304 error = set_fpregs(p, fpregset); 305 strlcpy(p->p_comm, psinfo->pr_fname, sizeof(p->p_comm)); 306 /* XXX psinfo->pr_psargs not yet implemented */ 307 done: 308 TRACE_EXIT; 309 return error; 310 } 311 312 static int 313 elf_getnote(void *src, size_t *off, const char *name, unsigned int type, 314 void **desc, size_t descsz) 315 { 316 Elf_Note note; 317 int error; 318 319 TRACE_ENTER; 320 if (src == NULL) { 321 error = EFAULT; 322 goto done; 323 } 324 bcopy((char *)src + *off, ¬e, sizeof note); 325 326 PRINTF(("at offset: %d expected note of type: %d - got: %d\n", 327 *off, type, note.n_type)); 328 *off += sizeof note; 329 if (type != note.n_type) { 330 TRACE_ERR; 331 error = EINVAL; 332 goto done; 333 } 334 if (strncmp(name, (char *) src + *off, note.n_namesz) != 0) { 335 error = EINVAL; 336 goto done; 337 } 338 *off += roundup2(note.n_namesz, sizeof(Elf_Size)); 339 if (note.n_descsz != descsz) { 340 TRACE_ERR; 341 error = EINVAL; 342 goto done; 343 } 344 if (desc) 345 bcopy((char *)src + *off, *desc, note.n_descsz); 346 *off += roundup2(note.n_descsz, sizeof(Elf_Size)); 347 error = 0; 348 done: 349 TRACE_EXIT; 350 return error; 351 } 352 353 static int 354 elf_demarshalnotes(void *src, prpsinfo_t *psinfo, prstatus_t *status, 355 prfpregset_t *fpregset, int nthreads) 356 { 357 int i; 358 int error; 359 int off = 0; 360 361 TRACE_ENTER; 362 error = elf_getnote(src, &off, "FreeBSD", NT_PRSTATUS, 363 (void **)&status, sizeof(prstatus_t)); 364 if (error) 365 goto done; 366 error = elf_getnote(src, &off, "FreeBSD", NT_FPREGSET, 367 (void **)&fpregset, sizeof(prfpregset_t)); 368 if (error) 369 goto done; 370 error = elf_getnote(src, &off, "FreeBSD", NT_PRPSINFO, 371 (void **)&psinfo, sizeof(prpsinfo_t)); 372 if (error) 373 goto done; 374 375 /* 376 * The remaining portion needs to be an integer multiple 377 * of prstatus_t and prfpregset_t 378 */ 379 for (i = 0 ; i < nthreads - 1; i++) { 380 status++; fpregset++; 381 error = elf_getnote(src, &off, "FreeBSD", NT_PRSTATUS, 382 (void **)&status, sizeof (prstatus_t)); 383 if (error) 384 goto done; 385 error = elf_getnote(src, &off, "FreeBSD", NT_FPREGSET, 386 (void **)&fpregset, sizeof(prfpregset_t)); 387 if (error) 388 goto done; 389 } 390 391 done: 392 TRACE_EXIT; 393 return error; 394 } 395 396 397 static int 398 mmap_phdr(struct file *fp, Elf_Phdr *phdr) 399 { 400 int error; 401 size_t len; 402 int prot; 403 void *addr; 404 int flags; 405 off_t pos; 406 407 TRACE_ENTER; 408 pos = phdr->p_offset; 409 len = phdr->p_filesz; 410 addr = (void *)phdr->p_vaddr; 411 flags = MAP_FIXED | MAP_NOSYNC | MAP_PRIVATE; 412 prot = 0; 413 if (phdr->p_flags & PF_R) 414 prot |= PROT_READ; 415 if (phdr->p_flags & PF_W) 416 prot |= PROT_WRITE; 417 if (phdr->p_flags & PF_X) 418 prot |= PROT_EXEC; 419 if ((error = fp_mmap(addr, len, prot, flags, fp, pos, &addr)) != 0) { 420 PRINTF(("mmap failed: %d\n", error); ); 421 } 422 PRINTF(("map @%08x-%08x fileoff %08x-%08x\n", (int)addr, (int)((char *)addr + len), (int)pos, (int)(pos + len))); 423 TRACE_EXIT; 424 return error; 425 } 426 427 428 static int 429 elf_loadphdrs(struct file *fp, Elf_Phdr *phdr, int numsegs) 430 { 431 int i; 432 int error = 0; 433 434 TRACE_ENTER; 435 for (i = 1; i < numsegs; i++) { 436 if ((error = mmap_phdr(fp, &phdr[i])) != 0) 437 break; 438 } 439 TRACE_EXIT; 440 return error; 441 } 442 443 static int 444 elf_getsigs(struct proc *p, struct file *fp) 445 { 446 int error; 447 struct ckpt_siginfo *csi; 448 struct sigacts *tmpsigacts; 449 450 TRACE_ENTER; 451 csi = malloc(sizeof(struct ckpt_siginfo), M_TEMP, M_ZERO | M_WAITOK); 452 if ((error = read_check(fp, csi, sizeof(struct ckpt_siginfo))) != 0) 453 goto done; 454 455 if (csi->csi_ckptpisz != sizeof(struct ckpt_siginfo)) { 456 TRACE_ERR; 457 error = EINVAL; 458 goto done; 459 } 460 tmpsigacts = p->p_procsig->ps_sigacts; 461 bcopy(&csi->csi_procsig, p->p_procsig, sizeof(struct procsig)); 462 p->p_procsig->ps_sigacts = tmpsigacts; 463 bcopy(&csi->csi_sigacts, p->p_procsig->ps_sigacts, sizeof(struct sigacts)); 464 bcopy(&csi->csi_itimerval, &p->p_realtimer, sizeof(struct itimerval)); 465 p->p_sigparent = csi->csi_sigparent; 466 done: 467 if (csi) 468 free(csi, M_TEMP); 469 TRACE_EXIT; 470 return error; 471 } 472 473 /* 474 * Returns a locked, refd vnode 475 */ 476 static int 477 ckpt_fhtovp(fhandle_t *fh, struct vnode **vpp) 478 { 479 struct mount *mp; 480 int error; 481 482 TRACE_ENTER; 483 mp = vfs_getvfs(&fh->fh_fsid); 484 485 if (!mp) { 486 TRACE_ERR; 487 PRINTF(("failed to get mount - ESTALE\n")); 488 TRACE_EXIT; 489 return ESTALE; 490 } 491 error = VFS_FHTOVP(mp, &fh->fh_fid, vpp); 492 if (error) { 493 PRINTF(("failed with: %d\n", error)); 494 TRACE_ERR; 495 TRACE_EXIT; 496 return error; 497 } 498 TRACE_EXIT; 499 return 0; 500 } 501 502 static int 503 mmap_vp(struct vn_hdr *vnh) 504 { 505 struct vnode *vp; 506 Elf_Phdr *phdr; 507 struct file *fp; 508 int error; 509 TRACE_ENTER; 510 511 phdr = &vnh->vnh_phdr; 512 513 if ((error = ckpt_fhtovp(&vnh->vnh_fh, &vp)) != 0) 514 return error; 515 /* 516 * XXX O_RDONLY -> or O_RDWR if file is PROT_WRITE, MAP_SHARED 517 */ 518 if ((error = fp_vpopen(vp, O_RDONLY, &fp)) != 0) { 519 vput(vp); 520 return error; 521 } 522 error = mmap_phdr(fp, phdr); 523 fp_close(fp); 524 TRACE_EXIT; 525 return error; 526 } 527 528 529 static int 530 elf_gettextvp(struct proc *p, struct file *fp) 531 { 532 int i; 533 int error; 534 int vpcount; 535 struct ckpt_vminfo vminfo; 536 struct vn_hdr *vnh = NULL; 537 538 TRACE_ENTER; 539 if ((error = read_check(fp, &vminfo, sizeof(vminfo))) != 0) 540 goto done; 541 if (vminfo.cvm_dsize < 0 || 542 vminfo.cvm_dsize > p->p_rlimit[RLIMIT_DATA].rlim_cur || 543 vminfo.cvm_tsize < 0 || 544 (u_quad_t)vminfo.cvm_tsize > maxtsiz || 545 vminfo.cvm_daddr >= (caddr_t)VM_MAXUSER_ADDRESS || 546 vminfo.cvm_taddr >= (caddr_t)VM_MAXUSER_ADDRESS 547 ) { 548 error = ERANGE; 549 goto done; 550 } 551 552 vmspace_exec(p, NULL); 553 p->p_vmspace->vm_daddr = vminfo.cvm_daddr; 554 p->p_vmspace->vm_dsize = vminfo.cvm_dsize; 555 p->p_vmspace->vm_taddr = vminfo.cvm_taddr; 556 p->p_vmspace->vm_tsize = vminfo.cvm_tsize; 557 if ((error = read_check(fp, &vpcount, sizeof(int))) != 0) 558 goto done; 559 vnh = malloc(sizeof(struct vn_hdr) * vpcount, M_TEMP, M_WAITOK); 560 if ((error = read_check(fp, vnh, sizeof(struct vn_hdr)*vpcount)) != 0) 561 goto done; 562 for (i = 0; i < vpcount; i++) { 563 if ((error = mmap_vp(&vnh[i])) != 0) 564 goto done; 565 } 566 567 done: 568 if (vnh) 569 free(vnh, M_TEMP); 570 TRACE_EXIT; 571 return error; 572 } 573 574 575 576 /* place holder */ 577 static int 578 elf_getfiles(struct proc *p, struct file *fp) 579 { 580 int error; 581 int i; 582 int filecount; 583 int fd; 584 struct ckpt_filehdr filehdr; 585 struct ckpt_fileinfo *cfi_base = NULL; 586 struct vnode *vp; 587 struct file *tempfp; 588 struct file *ofp; 589 590 TRACE_ENTER; 591 if ((error = read_check(fp, &filehdr, sizeof(filehdr))) != 0) 592 goto done; 593 filecount = filehdr.cfh_nfiles; 594 cfi_base = malloc(filecount*sizeof(struct ckpt_fileinfo), M_TEMP, M_WAITOK); 595 error = read_check(fp, cfi_base, filecount*sizeof(struct ckpt_fileinfo)); 596 if (error) 597 goto done; 598 599 /* 600 * Close all descriptors >= 3. These descriptors are from the 601 * checkpt(1) program itself and should not be retained. 602 */ 603 for (i = 3; i < p->p_fd->fd_nfiles; ++i) 604 kern_close(i); 605 606 /* 607 * Scan files to load 608 */ 609 for (i = 0; i < filecount; i++) { 610 struct ckpt_fileinfo *cfi= &cfi_base[i]; 611 /* 612 * Ignore placeholder entries where cfi_index is less then 613 * zero. This will occur if the elf core dump code thinks 614 * it can save a vnode but winds up not being able to. 615 */ 616 if (cfi->cfi_index < 0) 617 continue; 618 619 if ((error = ckpt_fhtovp(&cfi->cfi_fh, &vp)) != 0) 620 break; 621 if ((error = fp_vpopen(vp, OFLAGS(cfi->cfi_flags), &tempfp)) != 0) { 622 vput(vp); 623 break; 624 } 625 tempfp->f_offset = cfi->cfi_offset; 626 627 /* 628 * If overwriting a descriptor close the old descriptor. This 629 * only occurs if the saved core saved descriptors that we 630 * have not already closed. 631 */ 632 if (cfi->cfi_index < p->p_fd->fd_nfiles && 633 (ofp = p->p_fd->fd_ofiles[cfi->cfi_index]) != NULL) { 634 kern_close(cfi->cfi_index); 635 } 636 637 /* 638 * Allocate the descriptor we want. 639 */ 640 if (fdalloc(p, cfi->cfi_index, &fd) != 0) { 641 PRINTF(("can't currently restore fd: %d\n", 642 cfi->cfi_index)); 643 fp_close(fp); 644 goto done; 645 } 646 KKASSERT(fd == cfi->cfi_index); 647 p->p_fd->fd_ofiles[cfi->cfi_index] = tempfp; 648 cfi++; 649 PRINTF(("restoring %d\n", cfi->cfi_index)); 650 } 651 652 done: 653 if (cfi_base) 654 free(cfi_base, M_TEMP); 655 TRACE_EXIT; 656 return error; 657 } 658 659 static int 660 ckpt_freeze_proc (struct proc *p, struct file *fp) 661 { 662 rlim_t limit; 663 int error; 664 665 PRINTF(("calling generic_elf_coredump\n")); 666 limit = p->p_rlimit[RLIMIT_CORE].rlim_cur; 667 if (limit) { 668 error = generic_elf_coredump(p, fp, limit); 669 } else { 670 error = ERANGE; 671 } 672 return error; 673 } 674 675 int 676 sys_checkpoint(struct sys_checkpoint_args *uap) 677 { 678 int error = 0; 679 struct proc *p = curthread->td_proc; 680 struct file *fp; 681 682 /* 683 * Only certain groups (to reduce our security exposure). -1 684 * allows any group. 685 */ 686 if (ckptgroup >= 0 && groupmember(ckptgroup, p->p_ucred) == 0) 687 return (EPERM); 688 689 /* 690 * For now we can only checkpoint the current process 691 */ 692 if (uap->pid != -1 && uap->pid != p->p_pid) 693 return (EINVAL); 694 695 switch (uap->type) { 696 case CKPT_FREEZE: 697 fp = NULL; 698 if (uap->fd == -1 && uap->pid == (pid_t)-1) 699 error = checkpoint_signal_handler(p); 700 else if ((fp = holdfp(p->p_fd, uap->fd, FWRITE)) == NULL) 701 error = EBADF; 702 else 703 error = ckpt_freeze_proc(p, fp); 704 if (fp) 705 fdrop(fp, curthread); 706 break; 707 case CKPT_THAW: 708 if (uap->pid != -1) 709 return EINVAL; 710 if ((fp = holdfp(p->p_fd, uap->fd, FREAD)) == NULL) 711 return EBADF; 712 uap->sysmsg_result = uap->retval; 713 error = ckpt_thaw_proc(p, fp); 714 fdrop(fp, curthread); 715 break; 716 default: 717 error = EOPNOTSUPP; 718 break; 719 } 720 return error; 721 } 722 723 int 724 checkpoint_signal_handler(struct proc *p) 725 { 726 char *buf; 727 struct file *fp; 728 struct nlookupdata nd; 729 int error; 730 731 chptinuse++; 732 733 /* 734 * Being able to checkpoint an suid or sgid program is not a good 735 * idea. 736 */ 737 if (sugid_coredump == 0 && (p->p_flag & P_SUGID)) { 738 chptinuse--; 739 return (EPERM); 740 } 741 742 buf = ckpt_expand_name(p->p_comm, p->p_ucred->cr_uid, p->p_pid); 743 if (buf == NULL) { 744 chptinuse--; 745 return (ENOMEM); 746 } 747 748 log(LOG_INFO, "pid %d (%s), uid %d: checkpointing to %s\n", 749 p->p_pid, p->p_comm, 750 (p->p_ucred ? p->p_ucred->cr_uid : -1), 751 buf); 752 753 PRINTF(("ckpt handler called, using '%s'\n", buf)); 754 755 /* 756 * Use the same safety flags that the coredump code uses. Remove 757 * any previous checkpoint file before writing out the new one in 758 * case we are re-checkpointing a program that had been checkpt 759 * restored. Otherwise we will corrupt the program space (which is 760 * made up of mmap()ings of the previous checkpoint file) while we 761 * write out the new one. 762 */ 763 error = nlookup_init(&nd, buf, UIO_SYSSPACE, 0); 764 if (error == 0) 765 error = kern_unlink(&nd); 766 nlookup_done(&nd); 767 error = fp_open(buf, O_WRONLY|O_CREAT|O_TRUNC|O_NOFOLLOW, 0600, &fp); 768 if (error == 0) { 769 error = ckpt_freeze_proc(p, fp); 770 fp_close(fp); 771 } else { 772 printf("checkpoint failed with open - error: %d\n", error); 773 } 774 free(buf, M_TEMP); 775 chptinuse--; 776 return (error); 777 } 778 779 static char ckptfilename[MAXPATHLEN] = {"%N.ckpt"}; 780 SYSCTL_STRING(_kern, OID_AUTO, ckptfile, CTLFLAG_RW, ckptfilename, 781 sizeof(ckptfilename), "process checkpoint name format string"); 782 783 /* 784 * expand_name(name, uid, pid) 785 * Expand the name described in corefilename, using name, uid, and pid. 786 * corefilename is a printf-like string, with three format specifiers: 787 * %N name of process ("name") 788 * %P process id (pid) 789 * %U user id (uid) 790 * For example, "%N.core" is the default; they can be disabled completely 791 * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P". 792 * This is controlled by the sysctl variable kern.corefile (see above). 793 * 794 * -- taken from the coredump code 795 */ 796 797 static 798 char * 799 ckpt_expand_name(const char *name, uid_t uid, pid_t pid) 800 { 801 char *temp; 802 char *bp; 803 char buf[11]; /* Buffer for pid/uid -- max 4B */ 804 int error; 805 int i; 806 int n; 807 char *format = ckptfilename; 808 size_t namelen; 809 810 temp = malloc(MAXPATHLEN + 1, M_TEMP, M_NOWAIT); 811 if (temp == NULL) 812 return NULL; 813 namelen = strlen(name); 814 n = 0; 815 if (ckptfilename[0] != '/') { 816 if ((bp = kern_getcwd(temp, MAXPATHLEN - 1, &error)) == NULL) { 817 free(temp, M_TEMP); 818 return NULL; 819 } 820 n = strlen(bp); 821 bcopy(bp, temp, n + 1); /* normalize location of the path */ 822 temp[n++] = '/'; 823 temp[n] = '\0'; 824 } 825 for (i= 0; n < MAXPATHLEN && format[i]; i++) { 826 int l; 827 switch (format[i]) { 828 case '%': /* Format character */ 829 i++; 830 switch (format[i]) { 831 case '%': 832 temp[n++] = '%'; 833 break; 834 case 'N': /* process name */ 835 if ((n + namelen) > MAXPATHLEN) { 836 log(LOG_ERR, "pid %d (%s), uid (%u): Path `%s%s' is too long\n", 837 pid, name, uid, temp, name); 838 free(temp, M_TEMP); 839 return NULL; 840 } 841 memcpy(temp+n, name, namelen); 842 n += namelen; 843 break; 844 case 'P': /* process id */ 845 l = sprintf(buf, "%u", pid); 846 if ((n + l) > MAXPATHLEN) { 847 log(LOG_ERR, "pid %d (%s), uid (%u): Path `%s%s' is too long\n", 848 pid, name, uid, temp, name); 849 free(temp, M_TEMP); 850 return NULL; 851 } 852 memcpy(temp+n, buf, l); 853 n += l; 854 break; 855 case 'U': /* user id */ 856 l = sprintf(buf, "%u", uid); 857 if ((n + l) > MAXPATHLEN) { 858 log(LOG_ERR, "pid %d (%s), uid (%u): Path `%s%s' is too long\n", 859 pid, name, uid, temp, name); 860 free(temp, M_TEMP); 861 return NULL; 862 } 863 memcpy(temp+n, buf, l); 864 n += l; 865 break; 866 default: 867 log(LOG_ERR, "Unknown format character %c in `%s'\n", format[i], format); 868 } 869 break; 870 default: 871 temp[n++] = format[i]; 872 } 873 } 874 temp[n] = '\0'; 875 return temp; 876 } 877 878