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