* Implement POSIX (XSI)'s header file re_comp.h
[dragonfly.git] / sys / checkpt / checkpt.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/checkpt/Attic/checkpt.c,v 1.4 2003/12/20 04:07:03 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
37 #include <sys/file.h>
38 /* only on dragonfly */
39 #include <sys/file2.h>
40 #include <sys/fcntl.h>
41 #include <sys/signal.h>
42 #include <vm/vm_param.h>
43 #include <vm/vm.h>
44 #include <sys/imgact_elf.h>
45 #include <sys/procfs.h>
46
47 #include <sys/lock.h>
48 #include <vm/pmap.h>
49 #include <vm/vm_map.h>
50
51 #include <sys/mman.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 <i386/include/frame.h>
62 #include <sys/signalvar.h>
63 #include <sys/syslog.h>
64 #include <sys/sysctl.h>
65 #include <i386/include/sigframe.h>
66 #include <sys/exec.h>
67 #include <sys/unistd.h>
68 #include <sys/time.h>
69 #include "checkpt.h"
70 #include <sys/mount.h>
71 #include <sys/ckpt.h>
72
73
74 static int elf_loadphdrs(struct file *fp,  Elf_Phdr *phdr, int numsegs);
75 static int elf_getnotes(struct proc *p, struct file *fp, size_t notesz);
76 static int elf_demarshalnotes(void *src, prpsinfo_t *psinfo,
77                  prstatus_t *status, prfpregset_t *fpregset, int nthreads); 
78 static int elf_loadnotes(struct proc *, prpsinfo_t *, prstatus_t *, 
79                  prfpregset_t *);
80 static int elf_getsigs(struct proc *p, struct file *fp); 
81 static int elf_getfiles(struct proc *p, struct file *fp);
82 static int elf_gettextvp(struct proc *p, struct file *fp);
83
84 static int ckptgroup = 0;       /* wheel only, -1 for any group */
85 SYSCTL_INT(_kern, OID_AUTO, ckptgroup, CTLFLAG_RW, &ckptgroup, 0, "");
86
87 static __inline
88 int
89 read_check(struct file *fp, void *buf, size_t nbyte)
90 {
91         size_t nread;
92         int error;
93
94         PRINTF(("reading %d bytes\n", nbyte));
95         error = fp_read(fp, buf, nbyte, &nread);
96         if (error) {
97                 PRINTF(("read failed - %d", error));
98         } else if (nread != nbyte) {
99                 PRINTF(("wanted to read %d - read %d\n", nbyte, nread));
100                 error = EINVAL;
101         }
102         return error;
103 }
104
105 static int
106 elf_gethdr(struct file *fp, Elf_Ehdr *ehdr) 
107 {
108         size_t nbyte = sizeof(Elf_Ehdr);
109         int error;
110
111         if ((error = read_check(fp, ehdr, nbyte)) != 0)
112                 goto done;
113         if (!(ehdr->e_ehsize == sizeof(Elf_Ehdr))) {
114                 PRINTF(("wrong elf header size: %d\n"
115                        "expected size        : %d\n", 
116                        ehdr->e_ehsize, sizeof(Elf_Ehdr)));
117                 return EINVAL;
118         }
119         if (!(ehdr->e_phentsize == sizeof(Elf_Phdr))) {
120                 PRINTF(("wrong program header size: %d\n"
121                        "expected size            : %d\n",  
122                        ehdr->e_phentsize, sizeof(Elf_Phdr)));
123                 return EINVAL;
124         }
125
126         if (!(ehdr->e_ident[EI_MAG0] == ELFMAG0 &&
127               ehdr->e_ident[EI_MAG1] == ELFMAG1 &&
128               ehdr->e_ident[EI_MAG2] == ELFMAG2 &&
129               ehdr->e_ident[EI_MAG3] == ELFMAG3 &&
130               ehdr->e_ident[EI_CLASS] == ELF_CLASS &&
131               ehdr->e_ident[EI_DATA] == ELF_DATA &&
132               ehdr->e_ident[EI_VERSION] == EV_CURRENT &&
133               ehdr->e_ident[EI_OSABI] == ELFOSABI_FREEBSD &&
134               ehdr->e_ident[EI_ABIVERSION] == 0)) {
135                 PRINTF(("bad elf header\n there are %d segments\n",
136                        ehdr->e_phnum));
137                 return EINVAL;
138
139         }
140         PRINTF(("Elf header size:           %d\n", ehdr->e_ehsize));
141         PRINTF(("Program header size:       %d\n", ehdr->e_phentsize));
142         PRINTF(("Number of Program headers: %d\n", ehdr->e_phnum));
143  done:
144         return error;
145
146
147 static int
148 elf_getphdrs(struct file *fp, Elf_Phdr *phdr, size_t nbyte) 
149 {
150         int i;
151         int error;
152         int nheaders = nbyte/sizeof(Elf_Phdr); 
153
154         PRINTF(("reading phdrs section\n"));
155         if ((error = read_check(fp, phdr, nbyte)) != 0)
156                 goto done;
157         printf("headers section:\n");
158         for (i = 0; i < nheaders; i++) {
159                 printf("entry type:   %d\n", phdr[i].p_type);
160                 printf("file offset:  %d\n", phdr[i].p_offset);
161                 printf("virt address: %p\n", (uint32_t *)phdr[i].p_vaddr);
162                 printf("file size:    %d\n", phdr[i].p_filesz);
163                 printf("memory size:  %d\n", phdr[i].p_memsz);
164                 printf("\n");
165         }
166  done:
167         return error;
168 }
169
170
171 static int
172 elf_getnotes(struct proc *p, struct file *fp, size_t notesz) 
173 {
174         int error;
175         int nthreads;
176         char *note;
177         prpsinfo_t *psinfo;
178         prstatus_t *status;
179         prfpregset_t *fpregset;
180
181         nthreads = (notesz - sizeof(prpsinfo_t))/(sizeof(prstatus_t) + 
182                                                   sizeof(prfpregset_t));
183         PRINTF(("reading notes header nthreads=%d\n", nthreads));
184         if (nthreads <= 0 || nthreads > CKPT_MAXTHREADS)
185                 return EINVAL;
186
187         psinfo  = malloc(sizeof(prpsinfo_t), M_TEMP, M_ZERO | M_WAITOK);
188         status  = malloc(nthreads*sizeof(prstatus_t), M_TEMP, M_WAITOK);
189         fpregset  = malloc(nthreads*sizeof(prfpregset_t), M_TEMP, M_WAITOK);
190         note = malloc(notesz, M_TEMP, M_WAITOK);
191
192         
193         PRINTF(("reading notes section\n"));
194         if ((error = read_check(fp, note, notesz)) != 0)
195                 goto done;
196         error = elf_demarshalnotes(note, psinfo, status, fpregset, nthreads);
197         if (error)
198                 goto done;
199         /* fetch register state from notes */
200         error = elf_loadnotes(p, psinfo, status, fpregset);
201  done:
202         if (psinfo)
203                 free(psinfo, M_TEMP);
204         if (status)
205                 free(status, M_TEMP);
206         if (fpregset)
207                 free(fpregset, M_TEMP);
208         if (note)
209                 free(note, M_TEMP);
210         return error;
211 }
212
213 static int
214 ckpt_thaw_proc(struct proc *p, struct file *fp)
215 {
216
217         Elf_Phdr *phdr = NULL;
218         Elf_Ehdr *ehdr = NULL;
219         int error;
220         size_t nbyte;
221
222         TRACE_ENTER;
223         
224         ehdr = malloc(sizeof(Elf_Ehdr), M_TEMP, M_ZERO | M_WAITOK);
225
226         if ((error = elf_gethdr(fp, ehdr)) != 0)
227                 goto done;
228         nbyte = sizeof(Elf_Phdr) * ehdr->e_phnum; 
229         phdr = malloc(nbyte, M_TEMP, M_WAITOK); 
230
231         /* fetch description of program writable mappings */
232         if ((error = elf_getphdrs(fp, phdr, nbyte)) != 0)
233                 goto done;
234
235         /* fetch notes section containing register state */
236         if ((error = elf_getnotes(p, fp, phdr->p_filesz)) != 0)
237                 goto done;
238
239         /* fetch program text vnodes */
240         if ((error = elf_gettextvp(p, fp)) != 0)
241                 goto done;
242
243         /* fetch signal disposition */
244         if ((error = elf_getsigs(p, fp)) != 0)
245                 goto done;
246
247         /* fetch open files */
248         if ((error = elf_getfiles(p, fp)) != 0)
249                 goto done;
250
251         /* handle mappings last in case we are reading from a socket */
252         error = elf_loadphdrs(fp, phdr, ehdr->e_phnum);
253 done:
254         if (ehdr)
255                 free(ehdr, M_TEMP);
256         if (phdr)
257                 free(phdr, M_TEMP);
258         TRACE_EXIT;
259         return error;
260 }
261
262 static int
263 elf_loadnotes(struct proc *p, prpsinfo_t *psinfo, prstatus_t *status, 
264            prfpregset_t *fpregset) 
265 {
266         int error;
267
268         /* validate status and psinfo */
269         TRACE_ENTER;
270         if (status->pr_version != PRSTATUS_VERSION ||
271             status->pr_statussz != sizeof(prstatus_t) ||
272             status->pr_gregsetsz != sizeof(gregset_t) ||
273             status->pr_fpregsetsz != sizeof(fpregset_t) ||
274             psinfo->pr_version != PRPSINFO_VERSION ||
275             psinfo->pr_psinfosz != sizeof(prpsinfo_t)) {
276                 PRINTF(("status check failed\n"));
277                 error = EINVAL;
278                 goto done;
279         }
280         if ((error = set_regs(p, &status->pr_reg)) != 0)
281                 goto done;
282         error = set_fpregs(p, fpregset);
283         /* strncpy(psinfo->pr_psargs, p->p_comm, PRARGSZ); */
284  done:  
285         TRACE_EXIT;
286         return error;
287 }
288
289 static int 
290 elf_getnote(void *src, size_t *off, const char *name, unsigned int type,
291             void **desc, size_t descsz) 
292 {
293         Elf_Note note;
294         int error;
295
296         TRACE_ENTER;
297         if (src == NULL) {
298                 error = EFAULT;
299                 goto done;
300         }
301         bcopy((char *)src + *off, &note, sizeof note);
302         
303         PRINTF(("at offset: %d expected note of type: %d - got: %d\n",
304                *off, type, note.n_type));
305         *off += sizeof note;
306         if (type != note.n_type) {
307                 TRACE_ERR;
308                 error = EINVAL;
309                 goto done;
310         }
311         if (strncmp(name, (char *) src + *off, note.n_namesz) != 0) {
312                 error = EINVAL;
313                 goto done;
314         }
315         *off += roundup2(note.n_namesz, sizeof(Elf_Size));
316         if (note.n_descsz != descsz) {
317                 TRACE_ERR;
318                 error = EINVAL;
319                 goto done;
320         }
321         if (desc)
322                 bcopy((char *)src + *off, *desc, note.n_descsz);
323         *off += roundup2(note.n_descsz, sizeof(Elf_Size));
324         error = 0;
325  done:
326         TRACE_EXIT;
327         return error;
328 }
329
330 static int
331 elf_demarshalnotes(void *src, prpsinfo_t *psinfo, prstatus_t *status, 
332                    prfpregset_t *fpregset, int nthreads) 
333 {
334         int i;
335         int error;
336         int off = 0;
337
338         TRACE_ENTER;
339         error = elf_getnote(src, &off, "FreeBSD", NT_PRSTATUS, 
340                            (void **)&status, sizeof(prstatus_t));
341         if (error)
342                 goto done;
343         error = elf_getnote(src, &off, "FreeBSD", NT_FPREGSET, 
344                            (void **)&fpregset, sizeof(prfpregset_t));
345         if (error)
346                 goto done;
347         error = elf_getnote(src, &off, "FreeBSD", NT_PRPSINFO, 
348                            (void **)&psinfo, sizeof(prpsinfo_t));
349         if (error)
350                 goto done;
351
352         /*
353          * The remaining portion needs to be an integer multiple
354          * of prstatus_t and prfpregset_t
355          */
356         for (i = 0 ; i < nthreads - 1; i++) {
357                 status++; fpregset++;
358                 error = elf_getnote(src, &off, "FreeBSD", NT_PRSTATUS, 
359                                    (void **)&status, sizeof (prstatus_t));
360                 if (error)
361                         goto done;
362                 error = elf_getnote(src, &off, "FreeBSD", NT_FPREGSET, 
363                                    (void **)&fpregset, sizeof(prfpregset_t));
364                 if (error)
365                         goto done;
366         }
367         
368  done:
369         TRACE_EXIT;
370         return error;
371 }
372
373
374 static int
375 mmap_phdr(struct file *fp, Elf_Phdr *phdr) 
376 {
377         int error;
378         size_t len;
379         int prot;
380         void *addr;
381         int flags;
382         off_t pos;
383
384         TRACE_ENTER;
385         pos = phdr->p_offset;
386         len = phdr->p_filesz;
387         addr = (void *)phdr->p_vaddr;
388         flags = MAP_FIXED | MAP_NOSYNC | MAP_PRIVATE;
389         prot = 0;
390         if (phdr->p_flags & PF_R)
391                 prot |= PROT_READ;
392         if (phdr->p_flags & PF_W)
393                 prot |= PROT_WRITE;
394         if (phdr->p_flags & PF_X)
395                 prot |= PROT_EXEC;      
396         if ((error = fp_mmap(addr, len, prot, flags, fp, pos, &addr)) != 0) {
397                 PRINTF(("mmap failed: %d\n", error);       );
398         }
399         PRINTF(("map @%08x-%08x fileoff %08x-%08x\n", (int)addr, (int)((char *)addr + len), (int)pos, (int)(pos + len)));
400         TRACE_EXIT;
401         return error;
402 }
403
404
405 static int
406 elf_loadphdrs(struct file *fp, Elf_Phdr *phdr, int numsegs) 
407 {
408         int i;
409         int error = 0;
410
411         TRACE_ENTER;
412         for (i = 1; i < numsegs; i++)  {
413                 if ((error = mmap_phdr(fp, &phdr[i])) != 0)
414                         break;
415         }
416         TRACE_EXIT;
417         return error;
418 }
419
420 static int
421 elf_getsigs(struct proc *p, struct file *fp) 
422 {
423         int error;
424         struct ckpt_siginfo *csi;
425         struct sigacts *tmpsigacts;
426
427         TRACE_ENTER;
428         csi = malloc(sizeof(struct ckpt_siginfo), M_TEMP, M_ZERO | M_WAITOK);
429         if ((error = read_check(fp, csi, sizeof(struct ckpt_siginfo))) != 0)
430                 goto done;
431
432         if (csi->csi_ckptpisz != sizeof(struct ckpt_siginfo)) {
433                 TRACE_ERR;
434                 error = EINVAL;
435                 goto done;
436         }
437         tmpsigacts = p->p_procsig->ps_sigacts;
438         bcopy(&csi->csi_procsig, p->p_procsig, sizeof(struct procsig));
439         p->p_procsig->ps_sigacts = tmpsigacts;
440         bcopy(&csi->csi_sigacts, p->p_procsig->ps_sigacts, sizeof(struct sigacts));
441         bcopy(&csi->csi_itimerval, &p->p_realtimer, sizeof(struct itimerval));
442         p->p_sigparent = csi->csi_sigparent;
443  done:
444         if (csi)
445                 free(csi, M_TEMP);
446         TRACE_EXIT;
447         return error;
448 }
449
450
451 static int
452 ckpt_fhtovp(fhandle_t *fh, struct vnode **vpp) 
453 {
454         struct mount *mp;
455         int error;
456
457         TRACE_ENTER;
458         mp = vfs_getvfs(&fh->fh_fsid);
459
460         if (!mp) {
461                 TRACE_ERR;
462                 PRINTF(("failed to get mount - ESTALE\n"));
463                 TRACE_EXIT;
464                 return ESTALE;
465         }
466         error = VFS_FHTOVP(mp, &fh->fh_fid, vpp);
467         if (error) {
468                 PRINTF(("failed with: %d\n", error));
469                 TRACE_ERR;
470                 TRACE_EXIT;
471                 return error;
472         }
473         TRACE_EXIT;
474         return 0;
475 }
476
477 static int
478 mmap_vp(struct vn_hdr *vnh) 
479 {
480         struct vnode **vpp, *vp;
481         Elf_Phdr *phdr;
482         struct file *fp;
483         int error;
484         TRACE_ENTER;
485         vpp = &vp;
486
487         phdr = &vnh->vnh_phdr;
488
489         if ((error = ckpt_fhtovp(&vnh->vnh_fh, vpp)) != 0)
490                 return error;
491         /*
492          * XXX O_RDONLY -> or O_RDWR if file is PROT_WRITE, MAP_SHARED
493          */
494         if ((error = fp_vpopen(*vpp, O_RDONLY, &fp)) != 0)
495                 return error;
496         error = mmap_phdr(fp, phdr);
497         fp_close(fp);
498         TRACE_EXIT;
499         return error;
500 }
501
502
503 static int
504 elf_gettextvp(struct proc *p, struct file *fp)
505 {
506         int i;
507         int error;
508         int vpcount;
509         struct ckpt_vminfo vminfo;
510         struct vn_hdr *vnh = NULL;
511
512         TRACE_ENTER;
513         if ((error = read_check(fp, &vminfo, sizeof(vminfo))) != 0)
514                 goto done;
515         if (vminfo.cvm_dsize < 0 || 
516             vminfo.cvm_dsize > p->p_rlimit[RLIMIT_DATA].rlim_cur ||
517             vminfo.cvm_tsize < 0 ||
518             (u_quad_t)vminfo.cvm_tsize > maxtsiz ||
519             vminfo.cvm_daddr >= (caddr_t)VM_MAXUSER_ADDRESS ||
520             vminfo.cvm_taddr >= (caddr_t)VM_MAXUSER_ADDRESS
521         ) {
522             error = ERANGE;
523             goto done;
524         }
525         p->p_vmspace->vm_daddr = vminfo.cvm_daddr;
526         p->p_vmspace->vm_dsize = vminfo.cvm_dsize;
527         p->p_vmspace->vm_taddr = vminfo.cvm_taddr;
528         p->p_vmspace->vm_tsize = vminfo.cvm_tsize;
529         if ((error = read_check(fp, &vpcount, sizeof(int))) != 0)
530                 goto done;
531         vnh = malloc(sizeof(struct vn_hdr) * vpcount, M_TEMP, M_WAITOK);
532         if ((error = read_check(fp, vnh, sizeof(struct vn_hdr)*vpcount)) != 0)
533                 goto done;
534         for (i = 0; i < vpcount; i++) {
535                 if ((error = mmap_vp(&vnh[i])) != 0)
536                         goto done;
537         }
538         
539  done:
540         if (vnh)
541                 free(vnh, M_TEMP);
542         TRACE_EXIT;
543         return error;
544 }
545
546
547
548 /* place holder */
549 static int
550 elf_getfiles(struct proc *p, struct file *fp)
551 {
552         int error;
553         int i;
554         int filecount;
555         struct ckpt_filehdr filehdr;
556         struct ckpt_fileinfo *cfi_base = NULL;
557         struct vnode *vp;
558         struct file *tempfp;
559
560         TRACE_ENTER;
561         if ((error = read_check(fp, &filehdr, sizeof(filehdr))) != 0)
562                 goto done;
563         filecount = filehdr.cfh_nfiles;
564         cfi_base = malloc(filecount*sizeof(struct ckpt_fileinfo), M_TEMP, M_WAITOK);
565         error = read_check(fp, cfi_base, filecount*sizeof(struct ckpt_fileinfo));
566         if (error)
567                 goto done;
568
569         for (i = 0; i < filecount; i++) {
570                 struct ckpt_fileinfo *cfi= &cfi_base[i];
571                 /*
572                  * Ignore placeholder entries where cfi_index is less then
573                  * zero.  This will occur if the elf core dump code thinks
574                  * it can save a vnode but winds up not being able to.
575                  */
576                 if (cfi->cfi_index < 0)
577                         continue;
578                 if (cfi->cfi_index >=  p->p_fd->fd_nfiles) {
579                         PRINTF(("can't currently restore fd: %d\n",
580                                cfi->cfi_index));
581                         goto done;
582                 }
583                 if ((error = ckpt_fhtovp(&cfi->cfi_fh, &vp)) != 0)
584                         break;
585                 if ((error = fp_vpopen(vp, OFLAGS(cfi->cfi_flags), &tempfp)) != 0)
586                         break;
587                 tempfp->f_offset = cfi->cfi_offset;
588                 /*  XXX bail for now if we the index is 
589                  *  larger than the current file table 
590                  */
591
592                 PRINTF(("restoring %d\n", cfi->cfi_index));
593                 p->p_fd->fd_ofiles[cfi->cfi_index] = tempfp;            
594                 cfi++;
595         }
596
597  done:
598         if (cfi_base)
599                 free(cfi_base, M_TEMP);
600         TRACE_EXIT;
601         return error;
602 }
603
604 static int
605 ckpt_freeze_proc (struct proc *p, struct file *fp)
606 {
607         rlim_t limit;
608         int error;
609
610         PRINTF(("calling generic_elf_coredump\n"));
611         limit = p->p_rlimit[RLIMIT_CORE].rlim_cur;
612         if (limit) {
613                 error = generic_elf_coredump(p, fp, limit);
614         } else {
615                 error = ERANGE;
616         }
617         return error;
618 }
619
620 #if 0
621 /* THIS CAN'T WORK */
622 static int
623 ckpt_freeze_pid(int pid, struct file *fp) 
624 {
625         struct proc *p;
626
627         if ((p = pfind(pid)) == NULL)
628                 return ESRCH;
629         return ckpt_freeze_proc(p, fp);
630 }
631 #endif
632
633 static int 
634 ckpt_proc(void *uap /* struct ckpt_args */)
635 {
636         int error = 0;
637         int *res;
638         struct proc *p = curthread->td_proc;
639         struct ckpt_args *ca = (struct ckpt_args *)uap; 
640         struct file *fp;
641
642         res = &((struct nosys_args *)uap)->sysmsg_result;
643
644         /*
645          * Only certain groups (to reduce our security exposure).  -1
646          * allows any group.
647          */
648         if (ckptgroup >= 0 && groupmember(ckptgroup, p->p_ucred) == 0) {
649                 error = EPERM;
650                 goto done;
651         }
652         switch (ca->args.gen.type) {
653         case CKPT_FREEZE:
654                 if ((fp = holdfp(p->p_fd, ca->args.gen.fd, FWRITE)) == NULL)
655                         return EBADF;
656                 error = ckpt_freeze_proc(p, fp);
657                 fdrop(fp, curthread);
658                 break;
659         case CKPT_THAW:
660                 if ((fp = holdfp(p->p_fd, ca->args.gen.fd, FREAD)) == NULL)
661                         return EBADF;
662                 *res = ca->args.cta.retval;
663                 error = ckpt_thaw_proc(p, fp);
664                 fdrop(fp, curthread);
665                 break;
666         case CKPT_FREEZEPID:
667                 error = ENOSYS;
668                 break; 
669 #if 0
670                 /* doesn't work */
671                 if ((fp = holdfp(p->p_fd, ca->args.gen.fd, FWRITE)) == NULL)
672                         return EBADF;
673                 error = ckpt_freeze_pid(ca->args.cfpa.pid, fp);
674                 fdrop(fp, curthread);
675                 break;
676 #endif
677         case CKPT_THAWBIN:
678                 error = ENOSYS;
679                 break;
680 #if 0
681                 /* not supported */
682                 if ((fp = holdfp(p->p_fd, ca->args.gen.fd, FREAD)) == NULL)
683                         return EBADF;
684                 error = ckpt_thaw_bin(p, fp,
685                                 ca->args.ctba.bin, ca->args.ctba.binlen);
686                 fdrop(fp, curthread);
687                 break;
688 #endif
689         default:
690                 error = ENOSYS;
691                 break;
692         }
693 done:
694         PRINTF(("error of ckpt_proc is %d, retval is %d\n", error, *res));
695         return error;
696 }
697
698 static void
699 ckpt_handler(struct proc *p) 
700 {
701         char *buf;
702         struct file *fp;
703         int error;
704
705         /*
706          * Being able to checkpoint an suid or sgid program is not a good
707          * idea.
708          */
709         if (sugid_coredump == 0 && (p->p_flag & P_SUGID))
710                 return;
711
712         buf = ckpt_expand_name(p->p_comm, p->p_ucred->cr_uid, p->p_pid);
713         if (buf == NULL)
714                 return;
715
716         log(LOG_INFO, "pid %d (%s), uid %d: checkpointing to %s\n",
717                 p->p_pid, p->p_comm, 
718                 (p->p_ucred ? p->p_ucred->cr_uid : -1),
719                 buf);
720
721         PRINTF(("ckpt handler called, using '%s'\n", buf));
722
723         /*
724          * Use the same safety flags that the coredump code uses.
725          */
726         error = fp_open(buf, O_WRONLY|O_CREAT|O_NOFOLLOW, 0600, &fp);
727         if (error == 0) {
728                 (void)ckpt_freeze_proc(p, fp);
729                 fp_close(fp);
730         } else {
731                 printf("checkpoint failed with open - error: %d\n", error);
732         }
733         free(buf, M_TEMP);
734 }
735
736
737 /*
738  * The `sysent' for the new syscall
739  */
740 static struct sysent ckpt_sysent = {
741         4,              /* sy_narg */
742         ckpt_proc       /* sy_call */
743 };
744
745 static int ckpt_offset = 210;
746
747 static int
748 load (struct module *module, int cmd, void *arg)
749 {
750         int error = 0;
751        
752         switch (cmd) {
753         case MOD_LOAD :         
754                 PRINTF( ("ckpt loaded at %d\n", ckpt_offset));
755                 (void)register_ckpt_func(ckpt_handler);
756                 break;
757         case MOD_UNLOAD :
758                 PRINTF( ("ckpt unloaded from %d\n", ckpt_offset);       );
759                 /* if we are unloaded while a process is being checkpointed
760                  * the kernel will likely crash  XXX
761                  */
762                 (void)register_ckpt_func(NULL);
763                 break;
764         default :
765                 error = EINVAL;
766                 break;
767         }
768         return error;
769 }
770
771 SYSCALL_MODULE(syscall, &ckpt_offset, &ckpt_sysent, load, NULL);