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