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