OS X: ¿Genera volcado del núcleo sin que se reduzca el proceso?

Question

Sé cómo generar un volcado de núcleo en OS X cuando un proceso falla, pero lo que realmente necesito hacer es conectarlo a un proceso, generar un volcado de núcleo y luego reanudar ese proceso (sin matarlo).

Hace mucho tiempo (quizás hace un año y medio) Tenía el código C que haría esto ... Utilizó las bibliotecas del kernel OS X para conectarse a un proceso, leer todos sus estados de hilos y memoria, y escribir eso en un archivo Mach-O en el disco. Esto funcionó muy bien (y es exactamente lo que estoy buscando), pero ahora parece que no puedo encontrar ese código por mi vida. Me parece recordar que el código estaba relacionado de alguna manera con el libro interno del sistema OS X, pero eso es solo una vaga reminiscencia.

¿Alguien sabe el código del que estoy hablando y podría señalarme? Si no, ¿alguien sabe una buena forma de hacerlo preferiblemente con algún código de ejemplo?

Editar: Aquí está la respuesta.

información: http://osxbook.com/book/bonus/chapter8/core/

programa que lo haga por usted: http://osxbook.com/book/bonus/chapter8/core/download/gcore-1.3.tar.gz

Answer 1

Te creo están buscando this information

Específicamente:

/* UNIX Third Edition, circa early 1973 */ 
/* ken/sig.c */ 

core() 
{ 
int s, *ip; 
extern schar; 

/* u is the user area */ 
u.u_error = 0;   /* reset error code to "no error" */ 
u.u_dirp = "core";  /* file name to search for */ 
ip = namei(&schar, 1); /* do search; schar means it's a kernel string */ 

if (ip == NULL) {  /* failed to find */ 
    if (u.u_error)  /* because of some error */ 
     return(0);  /* so bail out */ 
    ip = maknode(0666); /* didn't exist; so create it */ 
} 

if (!access(ip, IWRITE)) { /* check "write" permission; 0 means OK */ 
    itrunc(ip);   /* truncate the core file */ 

    /* first we write the user area */ 
    u.u_offset[0] = 0;  /* offset for I/O */ 
    u.u_offset[1] = 0;  /* offset for I/O */ 
    u.u_base = &u;   /* base address for I/O (user area itself) */ 
    u.u_count = USIZE*64; /* bytes remaining for I/O; USIZE=8 */ 
    u.u_segflg = 1;  /* specify kernel address space */ 
    writei(ip);   /* do the write */ 

    /* 
    * u_procp points to the process structure 
    * p_size is the size of the process's swappable image (x 64 bytes) */ 
    */ 
    s = u.u_procp->p_size - USIZE; /* compute size left to write */ 

    /* 
    * This sets up software prototype segmentation registers to implement 
    * text(=0 here), data(=s here), and stack(=0 here) sizes specified. 
    */ 
    estabur(0, s, 0); 

    u.u_base = 0;   /* base address for I/O (start of space) */ 
    u.u_count = s*64;  /* s is in units of 64 bytes, so adjust */ 
    u.u_segflg = 0;  /* specify user address space */ 
    writei(ip);   /* do the write */ 
} 
iput(ip);     /* decrement inode reference count */ 
return(u.u_error==0);  /* done */ 
}