b515a9e6b5de87fbcb9d4db3099217091185659d
[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 #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_NONE &&
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                 vsetflags(p->p_textvp, 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, "CORE", NT_PRPSINFO,
367                            (void **)&psinfo, sizeof(prpsinfo_t));
368         if (error)
369                 goto done;
370         error = elf_getnote(src, &off, "CORE", NT_PRSTATUS,
371                            (void **)&status, sizeof(prstatus_t));
372         if (error)
373                 goto done;
374         error = elf_getnote(src, &off, "CORE", 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, "CORE", NT_PRSTATUS,
386                                    (void **)&status, sizeof (prstatus_t));
387                 if (error)
388                         goto done;
389                 error = elf_getnote(src, &off, "CORE", 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         lwkt_gettoken(&proc_token);     /* needed for proc_*() calls */
696
697         PRINTF(("calling generic_elf_coredump\n"));
698         limit = p->p_rlimit[RLIMIT_CORE].rlim_cur;
699         if (limit) {
700                 proc_stop(p);
701                 while (p->p_nstopped < p->p_nthreads - 1)
702                         tsleep(&p->p_nstopped, 0, "freeze", 1);
703                 error = generic_elf_coredump(lp, SIGCKPT, fp, limit);
704                 proc_unstop(p);
705         } else {
706                 error = ERANGE;
707         }
708         lwkt_reltoken(&proc_token);
709         return error;
710 }
711
712 /*
713  * MPALMOSTSAFE
714  */
715 int 
716 sys_sys_checkpoint(struct sys_checkpoint_args *uap)
717 {
718         int error = 0;
719         struct thread *td = curthread;
720         struct proc *p = td->td_proc;
721         struct filedesc *fdp = p->p_fd;
722         struct file *fp;
723
724         /*
725          * Only certain groups (to reduce our security exposure).  -1
726          * allows any group.
727          */
728         if (ckptgroup >= 0 && groupmember(ckptgroup, td->td_ucred) == 0)
729                 return (EPERM);
730
731         /*
732          * For now we can only checkpoint the current process
733          */
734         if (uap->pid != -1 && uap->pid != p->p_pid)
735                 return (EINVAL);
736
737         get_mplock();
738
739         switch (uap->type) {
740         case CKPT_FREEZE:
741                 fp = NULL;
742                 if (uap->fd == -1 && uap->pid == (pid_t)-1)
743                         error = checkpoint_signal_handler(td->td_lwp);
744                 else if ((fp = holdfp(fdp, uap->fd, FWRITE)) == NULL)
745                         error = EBADF;
746                 else
747                         error = ckpt_freeze_proc(td->td_lwp, fp);
748                 if (fp)
749                         fdrop(fp);
750                 break;
751         case CKPT_THAW:
752                 if (uap->pid != -1) {
753                         error = EINVAL;
754                         break;
755                 }
756                 if ((fp = holdfp(fdp, uap->fd, FREAD)) == NULL) {
757                         error = EBADF;
758                         break;
759                 }
760                 uap->sysmsg_result = uap->retval;
761                 error = ckpt_thaw_proc(td->td_lwp, fp);
762                 fdrop(fp);
763                 break;
764         default:
765                 error = EOPNOTSUPP;
766                 break;
767         }
768         rel_mplock();
769         return error;
770 }
771
772 int
773 checkpoint_signal_handler(struct lwp *lp)
774 {
775         struct thread *td = lp->lwp_thread;
776         struct proc *p = lp->lwp_proc;
777         char *buf;
778         struct file *fp;
779         struct nlookupdata nd;
780         int error;
781
782         chptinuse++;
783
784         /*
785          * Being able to checkpoint an suid or sgid program is not a good
786          * idea.
787          */
788         if (sugid_coredump == 0 && (p->p_flag & P_SUGID)) {
789                 chptinuse--;
790                 return (EPERM);
791         }
792
793         buf = ckpt_expand_name(p->p_comm, td->td_ucred->cr_uid, p->p_pid);
794         if (buf == NULL) {
795                 chptinuse--;
796                 return (ENOMEM);
797         }
798
799         log(LOG_INFO, "pid %d (%s), uid %d: checkpointing to %s\n",
800                 p->p_pid, p->p_comm, 
801                 (td->td_ucred ? td->td_ucred->cr_uid : -1),
802                 buf);
803
804         PRINTF(("ckpt handler called, using '%s'\n", buf));
805
806         /*
807          * Use the same safety flags that the coredump code uses.  Remove
808          * any previous checkpoint file before writing out the new one in
809          * case we are re-checkpointing a program that had been checkpt
810          * restored.  Otherwise we will corrupt the program space (which is
811          * made up of mmap()ings of the previous checkpoint file) while we
812          * write out the new one.
813          */
814         error = nlookup_init(&nd, buf, UIO_SYSSPACE, 0);
815         if (error == 0)
816                 error = kern_unlink(&nd);
817         nlookup_done(&nd);
818         error = fp_open(buf, O_WRONLY|O_CREAT|O_TRUNC|O_NOFOLLOW, 0600, &fp);
819         if (error == 0) {
820                 error = ckpt_freeze_proc(lp, fp);
821                 fp_close(fp);
822         } else {
823                 kprintf("checkpoint failed with open - error: %d\n", error);
824         }
825         kfree(buf, M_TEMP);
826         chptinuse--;
827         return (error);
828 }
829
830 static char ckptfilename[MAXPATHLEN] = {"%N.ckpt"};
831 SYSCTL_STRING(_kern, OID_AUTO, ckptfile, CTLFLAG_RW, ckptfilename,
832               sizeof(ckptfilename), "process checkpoint name format string");
833
834 /*
835  * expand_name(name, uid, pid)
836  * Expand the name described in corefilename, using name, uid, and pid.
837  * corefilename is a kprintf-like string, with three format specifiers:
838  *      %N      name of process ("name")
839  *      %P      process id (pid)
840  *      %U      user id (uid)
841  * For example, "%N.core" is the default; they can be disabled completely
842  * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P".
843  * This is controlled by the sysctl variable kern.corefile (see above).
844  *
845  * -- taken from the coredump code
846  */
847
848 static
849 char *
850 ckpt_expand_name(const char *name, uid_t uid, pid_t pid)
851 {
852         char *temp;
853         char *bp;
854         char buf[11];           /* Buffer for pid/uid -- max 4B */
855         int error;
856         int i;
857         int n;
858         char *format = ckptfilename;
859         size_t namelen;
860
861         temp = kmalloc(MAXPATHLEN + 1, M_TEMP, M_NOWAIT);
862         if (temp == NULL)
863                 return NULL;
864         namelen = strlen(name);
865         n = 0;
866         if (ckptfilename[0] != '/') {
867                 if ((bp = kern_getcwd(temp, MAXPATHLEN - 1, &error)) == NULL) {
868                         kfree(temp, M_TEMP);
869                         return NULL;
870                 }
871                 n = strlen(bp);
872                 bcopy(bp, temp, n + 1); /* normalize location of the path */
873                 temp[n++] = '/';
874                 temp[n] = '\0';
875         }
876         for (i= 0; n < MAXPATHLEN && format[i]; i++) {
877                 int l;
878                 switch (format[i]) {
879                 case '%':       /* Format character */
880                         i++;
881                         switch (format[i]) {
882                         case '%':
883                                 temp[n++] = '%';
884                                 break;
885                         case 'N':       /* process name */
886                                 if ((n + namelen) > MAXPATHLEN) {
887                                         log(LOG_ERR, "pid %d (%s), uid (%u):  Path `%s%s' is too long\n",
888                                             pid, name, uid, temp, name);
889                                         kfree(temp, M_TEMP);
890                                         return NULL;
891                                 }
892                                 memcpy(temp+n, name, namelen);
893                                 n += namelen;
894                                 break;
895                         case 'P':       /* process id */
896                                 l = ksprintf(buf, "%u", pid);
897                                 if ((n + l) > MAXPATHLEN) {
898                                         log(LOG_ERR, "pid %d (%s), uid (%u):  Path `%s%s' is too long\n",
899                                             pid, name, uid, temp, name);
900                                         kfree(temp, M_TEMP);
901                                         return NULL;
902                                 }
903                                 memcpy(temp+n, buf, l);
904                                 n += l;
905                                 break;
906                         case 'U':       /* user id */
907                                 l = ksprintf(buf, "%u", uid);
908                                 if ((n + l) > MAXPATHLEN) {
909                                         log(LOG_ERR, "pid %d (%s), uid (%u):  Path `%s%s' is too long\n",
910                                             pid, name, uid, temp, name);
911                                         kfree(temp, M_TEMP);
912                                         return NULL;
913                                 }
914                                 memcpy(temp+n, buf, l);
915                                 n += l;
916                                 break;
917                         default:
918                                 log(LOG_ERR, "Unknown format character %c in `%s'\n", format[i], format);
919                         }
920                         break;
921                 default:
922                         temp[n++] = format[i];
923                 }
924         }
925         temp[n] = '\0';
926         return temp;
927 }
928