OS X: Core-Dump generieren, ohne den Prozess herunterzufahren?

Question

Ich weiß, wie man einen Core-Dump auf OS X erzeugt, wenn ein Prozess abstürzt, aber was ich wirklich tun muss, ist an einen Prozess anzuhängen, einen Core-Dump zu generieren und dann diesen Prozess fortzusetzen (ohne ihn zu töten).

Vor langer Zeit (vielleicht vor anderthalb Jahren) hatte ich C-Code, der das tun würde ... Er verwendete die OS X-Kernel-Bibliotheken, um sich mit einem Prozess zu verbinden, alle Thread-Zustände und Speicher zu lesen. und schreibe das in eine Mach-O-Datei auf der Festplatte. Das hat gut funktioniert (und genau das suche ich), aber jetzt kann ich diesen Code für mein Leben nicht mehr finden. Ich erinnere mich, dass der Code etwas mit dem OS X System Interna Buch verwandt war, aber das ist nur eine vage Erinnerung.

Kennt jemand den Code, über den ich spreche und könnte mich darauf hinweisen? Wenn nicht, weiß jemand einen guten Weg, dies vorzugsweise mit einem Beispielcode zu tun?

Edit: Hier ist die Antwort.

Information: http://osxbook.com/book/bonus/chapter8/core/

Programm, das es für Sie tun: http://osxbook.com/book/bonus/chapter8/core/download/gcore-1.3.tar.gz

Answer 1

Ich glaube, Sie suchen this information

Im Einzelnen:

/* 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 */ 
}