2 * Copyright (c) 2003 Kip Macy
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
26 * $DragonFly: src/sys/kern/kern_checkpoint.c,v 1.20 2008/09/17 21:44:18 dillon Exp $
29 #include <sys/types.h>
30 #include <sys/param.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>
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>
45 #include <sys/imgact_elf.h>
46 #include <sys/procfs.h>
50 #include <vm/vm_map.h>
51 #include <vm/vm_extern.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>
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>
69 #include <sys/unistd.h>
71 #include <sys/kern_syscall.h>
72 #include <sys/checkpoint.h>
73 #include <sys/mount.h>
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
*,
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
);
87 static int ckptgroup
= 0; /* wheel only, -1 for any group */
88 SYSCTL_INT(_kern
, OID_AUTO
, ckptgroup
, CTLFLAG_RW
, &ckptgroup
, 0, "");
90 /* ref count to see how many processes that are being checkpointed */
91 static int chptinuse
= 0;
95 read_check(struct file
*fp
, void *buf
, size_t nbyte
)
100 PRINTF(("reading %d bytes\n", nbyte
));
101 error
= fp_read(fp
, buf
, nbyte
, &nread
, 1, UIO_SYSSPACE
);
103 PRINTF(("read failed - %d", error
));
104 } else if (nread
!= nbyte
) {
105 PRINTF(("wanted to read %d - read %d\n", nbyte
, nread
));
112 elf_gethdr(struct file
*fp
, Elf_Ehdr
*ehdr
)
114 size_t nbyte
= sizeof(Elf_Ehdr
);
117 if ((error
= read_check(fp
, ehdr
, nbyte
)) != 0)
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
)));
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
)));
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",
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
));
154 elf_getphdrs(struct file
*fp
, Elf_Phdr
*phdr
, size_t nbyte
)
158 int nheaders
= nbyte
/sizeof(Elf_Phdr
);
160 PRINTF(("reading phdrs section\n"));
161 if ((error
= read_check(fp
, phdr
, nbyte
)) != 0)
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
));
178 elf_getnotes(struct lwp
*lp
, struct file
*fp
, size_t notesz
)
185 prfpregset_t
*fpregset
;
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
)
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
);
199 PRINTF(("reading notes section\n"));
200 if ((error
= read_check(fp
, note
, notesz
)) != 0)
202 error
= elf_demarshalnotes(note
, psinfo
, status
, fpregset
, nthreads
);
205 /* fetch register state from notes */
206 error
= elf_loadnotes(lp
, psinfo
, status
, fpregset
);
209 kfree(psinfo
, M_TEMP
);
211 kfree(status
, M_TEMP
);
213 kfree(fpregset
, M_TEMP
);
220 ckpt_thaw_proc(struct lwp
*lp
, struct file
*fp
)
222 struct proc
*p
= lp
->lwp_proc
;
223 Elf_Phdr
*phdr
= NULL
;
224 Elf_Ehdr
*ehdr
= NULL
;
230 ehdr
= kmalloc(sizeof(Elf_Ehdr
), M_TEMP
, M_ZERO
| M_WAITOK
);
232 if ((error
= elf_gethdr(fp
, ehdr
)) != 0)
234 nbyte
= sizeof(Elf_Phdr
) * ehdr
->e_phnum
;
235 phdr
= kmalloc(nbyte
, M_TEMP
, M_WAITOK
);
237 /* fetch description of program writable mappings */
238 if ((error
= elf_getphdrs(fp
, phdr
, nbyte
)) != 0)
241 /* fetch notes section containing register state */
242 if ((error
= elf_getnotes(lp
, fp
, phdr
->p_filesz
)) != 0)
245 /* fetch program text vnodes */
246 if ((error
= elf_gettextvp(p
, fp
)) != 0)
249 /* fetch signal disposition */
250 if ((error
= elf_getsigs(lp
, fp
)) != 0) {
251 kprintf("failure in recovering signals\n");
255 /* fetch open files */
256 if ((error
= elf_getfiles(p
, fp
)) != 0)
259 /* handle mappings last in case we are reading from a socket */
260 error
= elf_loadphdrs(fp
, phdr
, ehdr
->e_phnum
);
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.
269 if (error
== 0 && fp
->f_data
&& fp
->f_type
== DTYPE_VNODE
) {
272 p
->p_textvp
= (struct vnode
*)fp
->f_data
;
273 p
->p_textvp
->v_flag
|= VCKPT
;
286 elf_loadnotes(struct lwp
*lp
, prpsinfo_t
*psinfo
, prstatus_t
*status
,
287 prfpregset_t
*fpregset
)
289 struct proc
*p
= lp
->lwp_proc
;
292 /* validate status and psinfo */
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"));
304 /* XXX lwp handle more than one lwp*/
305 if ((error
= set_regs(lp
, &status
->pr_reg
)) != 0)
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 */
316 elf_getnote(void *src
, size_t *off
, const char *name
, unsigned int type
,
317 void **desc
, size_t descsz
)
327 bcopy((char *)src
+ *off
, ¬e
, sizeof note
);
329 PRINTF(("at offset: %d expected note of type: %d - got: %d\n",
330 *off
, type
, note
.n_type
));
332 if (type
!= note
.n_type
) {
337 if (strncmp(name
, (char *) src
+ *off
, note
.n_namesz
) != 0) {
341 *off
+= roundup2(note
.n_namesz
, sizeof(Elf_Size
));
342 if (note
.n_descsz
!= descsz
) {
348 bcopy((char *)src
+ *off
, *desc
, note
.n_descsz
);
349 *off
+= roundup2(note
.n_descsz
, sizeof(Elf_Size
));
357 elf_demarshalnotes(void *src
, prpsinfo_t
*psinfo
, prstatus_t
*status
,
358 prfpregset_t
*fpregset
, int nthreads
)
365 error
= elf_getnote(src
, &off
, "FreeBSD", NT_PRPSINFO
,
366 (void **)&psinfo
, sizeof(prpsinfo_t
));
369 error
= elf_getnote(src
, &off
, "FreeBSD", NT_PRSTATUS
,
370 (void **)&status
, sizeof(prstatus_t
));
373 error
= elf_getnote(src
, &off
, "FreeBSD", NT_FPREGSET
,
374 (void **)&fpregset
, sizeof(prfpregset_t
));
379 * The remaining portion needs to be an integer multiple
380 * of prstatus_t and prfpregset_t
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
));
388 error
= elf_getnote(src
, &off
, "FreeBSD", NT_FPREGSET
,
389 (void **)&fpregset
, sizeof(prfpregset_t
));
401 mmap_phdr(struct file
*fp
, Elf_Phdr
*phdr
)
411 pos
= phdr
->p_offset
;
412 len
= phdr
->p_filesz
;
413 addr
= (void *)phdr
->p_vaddr
;
414 flags
= MAP_FIXED
| MAP_NOSYNC
| MAP_PRIVATE
;
416 if (phdr
->p_flags
& PF_R
)
418 if (phdr
->p_flags
& PF_W
)
420 if (phdr
->p_flags
& PF_X
)
422 if ((error
= fp_mmap(addr
, len
, prot
, flags
, fp
, pos
, &addr
)) != 0) {
423 PRINTF(("mmap failed: %d\n", error
); );
425 PRINTF(("map @%08x-%08x fileoff %08x-%08x\n", (int)addr
,
426 (int)((char *)addr
+ len
), (int)pos
, (int)(pos
+ len
)));
432 * Load memory mapped segments. The segments are backed by the checkpoint
436 elf_loadphdrs(struct file
*fp
, Elf_Phdr
*phdr
, int numsegs
)
442 for (i
= 1; i
< numsegs
; i
++) {
443 if ((error
= mmap_phdr(fp
, &phdr
[i
])) != 0)
451 elf_getsigs(struct lwp
*lp
, struct file
*fp
)
453 struct proc
*p
= lp
->lwp_proc
;
455 struct ckpt_siginfo
*csi
;
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)
462 if (csi
->csi_ckptpisz
!= sizeof(struct ckpt_siginfo
)) {
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
;
481 * Returns a locked, refd vnode
484 ckpt_fhtovp(fhandle_t
*fh
, struct vnode
**vpp
)
490 mp
= vfs_getvfs(&fh
->fh_fsid
);
494 PRINTF(("failed to get mount - ESTALE\n"));
498 error
= VFS_FHTOVP(mp
, NULL
, &fh
->fh_fid
, vpp
);
500 PRINTF(("failed with: %d\n", error
));
510 mmap_vp(struct vn_hdr
*vnh
)
518 phdr
= &vnh
->vnh_phdr
;
520 if ((error
= ckpt_fhtovp(&vnh
->vnh_fh
, &vp
)) != 0)
523 * XXX O_RDONLY -> or O_RDWR if file is PROT_WRITE, MAP_SHARED
525 if ((error
= fp_vpopen(vp
, O_RDONLY
, &fp
)) != 0) {
529 error
= mmap_phdr(fp
, phdr
);
537 elf_gettextvp(struct proc
*p
, struct file
*fp
)
542 struct ckpt_vminfo vminfo
;
543 struct vn_hdr
*vnh
= NULL
;
546 if ((error
= read_check(fp
, &vminfo
, sizeof(vminfo
))) != 0)
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
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)
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)
569 for (i
= 0; i
< vpcount
; i
++) {
570 if ((error
= mmap_vp(&vnh
[i
])) != 0)
585 elf_getfiles(struct proc
*p
, struct file
*fp
)
591 struct ckpt_filehdr filehdr
;
592 struct ckpt_fileinfo
*cfi_base
= NULL
;
598 if ((error
= read_check(fp
, &filehdr
, sizeof(filehdr
))) != 0)
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
));
607 * Close all file descriptors >= 3. These descriptors are from the
608 * checkpt(1) program itself and should not be retained.
610 * XXX we need a flag so a checkpoint restore can opt to supply the
611 * descriptors, or the non-regular-file descripors.
613 for (i
= 3; i
< p
->p_fd
->fd_nfiles
; ++i
)
619 for (i
= 0; i
< filecount
; i
++) {
620 struct ckpt_fileinfo
*cfi
= &cfi_base
[i
];
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.
626 if (cfi
->cfi_index
< 0)
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.
636 if (cfi
->cfi_ckflags
& CKFIF_ISCKPTFD
) {
641 error
= ckpt_fhtovp(&cfi
->cfi_fh
, &vp
);
643 error
= fp_vpopen(vp
, OFLAGS(cfi
->cfi_flags
),
651 tempfp
->f_offset
= cfi
->cfi_offset
;
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.
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
);
664 * Allocate the descriptor we want.
666 if (fdalloc(p
, cfi
->cfi_index
, &fd
) != 0) {
667 PRINTF(("can't currently restore fd: %d\n",
672 KKASSERT(fd
== cfi
->cfi_index
);
673 fsetfd(p
, tempfp
, fd
);
676 PRINTF(("restoring %d\n", cfi
->cfi_index
));
681 kfree(cfi_base
, M_TEMP
);
687 ckpt_freeze_proc(struct lwp
*lp
, struct file
*fp
)
689 struct proc
*p
= lp
->lwp_proc
;
693 PRINTF(("calling generic_elf_coredump\n"));
694 limit
= p
->p_rlimit
[RLIMIT_CORE
].rlim_cur
;
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
);
708 sys_sys_checkpoint(struct sys_checkpoint_args
*uap
)
711 struct lwp
*lp
= curthread
->td_lwp
;
712 struct proc
*p
= curthread
->td_proc
;
716 * Only certain groups (to reduce our security exposure). -1
719 if (ckptgroup
>= 0 && groupmember(ckptgroup
, p
->p_ucred
) == 0)
723 * For now we can only checkpoint the current process
725 if (uap
->pid
!= -1 && uap
->pid
!= p
->p_pid
)
731 if (uap
->fd
== -1 && uap
->pid
== (pid_t
)-1)
732 error
= checkpoint_signal_handler(lp
);
733 else if ((fp
= holdfp(p
->p_fd
, uap
->fd
, FWRITE
)) == NULL
)
736 error
= ckpt_freeze_proc(lp
, fp
);
743 if ((fp
= holdfp(p
->p_fd
, uap
->fd
, FREAD
)) == NULL
)
745 uap
->sysmsg_result
= uap
->retval
;
746 error
= ckpt_thaw_proc(lp
, fp
);
757 checkpoint_signal_handler(struct lwp
*lp
)
759 struct proc
*p
= lp
->lwp_proc
;
762 struct nlookupdata nd
;
768 * Being able to checkpoint an suid or sgid program is not a good
771 if (sugid_coredump
== 0 && (p
->p_flag
& P_SUGID
)) {
776 buf
= ckpt_expand_name(p
->p_comm
, p
->p_ucred
->cr_uid
, p
->p_pid
);
782 log(LOG_INFO
, "pid %d (%s), uid %d: checkpointing to %s\n",
784 (p
->p_ucred
? p
->p_ucred
->cr_uid
: -1),
787 PRINTF(("ckpt handler called, using '%s'\n", buf
));
790 * Use the same safety flags that the coredump code uses. Remove
791 * any previous checkpoint file before writing out the new one in
792 * case we are re-checkpointing a program that had been checkpt
793 * restored. Otherwise we will corrupt the program space (which is
794 * made up of mmap()ings of the previous checkpoint file) while we
795 * write out the new one.
797 error
= nlookup_init(&nd
, buf
, UIO_SYSSPACE
, 0);
799 error
= kern_unlink(&nd
);
801 error
= fp_open(buf
, O_WRONLY
|O_CREAT
|O_TRUNC
|O_NOFOLLOW
, 0600, &fp
);
803 error
= ckpt_freeze_proc(lp
, fp
);
806 kprintf("checkpoint failed with open - error: %d\n", error
);
813 static char ckptfilename
[MAXPATHLEN
] = {"%N.ckpt"};
814 SYSCTL_STRING(_kern
, OID_AUTO
, ckptfile
, CTLFLAG_RW
, ckptfilename
,
815 sizeof(ckptfilename
), "process checkpoint name format string");
818 * expand_name(name, uid, pid)
819 * Expand the name described in corefilename, using name, uid, and pid.
820 * corefilename is a kprintf-like string, with three format specifiers:
821 * %N name of process ("name")
822 * %P process id (pid)
824 * For example, "%N.core" is the default; they can be disabled completely
825 * by using "/dev/null", or all core files can be stored in "/cores/%U/%N-%P".
826 * This is controlled by the sysctl variable kern.corefile (see above).
828 * -- taken from the coredump code
833 ckpt_expand_name(const char *name
, uid_t uid
, pid_t pid
)
837 char buf
[11]; /* Buffer for pid/uid -- max 4B */
841 char *format
= ckptfilename
;
844 temp
= kmalloc(MAXPATHLEN
+ 1, M_TEMP
, M_NOWAIT
);
847 namelen
= strlen(name
);
849 if (ckptfilename
[0] != '/') {
850 if ((bp
= kern_getcwd(temp
, MAXPATHLEN
- 1, &error
)) == NULL
) {
855 bcopy(bp
, temp
, n
+ 1); /* normalize location of the path */
859 for (i
= 0; n
< MAXPATHLEN
&& format
[i
]; i
++) {
862 case '%': /* Format character */
868 case 'N': /* process name */
869 if ((n
+ namelen
) > MAXPATHLEN
) {
870 log(LOG_ERR
, "pid %d (%s), uid (%u): Path `%s%s' is too long\n",
871 pid
, name
, uid
, temp
, name
);
875 memcpy(temp
+n
, name
, namelen
);
878 case 'P': /* process id */
879 l
= ksprintf(buf
, "%u", pid
);
880 if ((n
+ l
) > MAXPATHLEN
) {
881 log(LOG_ERR
, "pid %d (%s), uid (%u): Path `%s%s' is too long\n",
882 pid
, name
, uid
, temp
, name
);
886 memcpy(temp
+n
, buf
, l
);
889 case 'U': /* user id */
890 l
= ksprintf(buf
, "%u", uid
);
891 if ((n
+ l
) > MAXPATHLEN
) {
892 log(LOG_ERR
, "pid %d (%s), uid (%u): Path `%s%s' is too long\n",
893 pid
, name
, uid
, temp
, name
);
897 memcpy(temp
+n
, buf
, l
);
901 log(LOG_ERR
, "Unknown format character %c in `%s'\n", format
[i
], format
);
905 temp
[n
++] = format
[i
];