ओएस एक्स: प्रक्रिया को कम किए बिना कोर डंप उत्पन्न करें?

Question

मुझे पता है कि एक प्रक्रिया क्रैश होने पर ओएस एक्स पर कोर डंप कैसे उत्पन्न करें, लेकिन मुझे वास्तव में क्या करना है, एक प्रक्रिया से जुड़ा हुआ है, कोर डंप उत्पन्न करता है, फिर उस प्रक्रिया को फिर से शुरू करें (इसे मारने के बिना)।

बहुत समय पहले (शायद डेढ़ साल पहले) मेरे पास सी कोड था जो ऐसा करेगा ... यह एक प्रक्रिया से कनेक्ट करने के लिए ओएस एक्स कर्नेल पुस्तकालयों का उपयोग करता था, इसके सभी धागे राज्यों और स्मृति को पढ़ता था, और डिस्क पर एक Mach-O फ़ाइल में लिखें। यह बहुत अच्छा काम करता है (और यह वही है जो मैं ढूंढ रहा हूं), लेकिन अब मुझे लगता है कि वह मेरे जीवन के लिए कोड नहीं ढूंढ रहा है। मुझे याद है कि कोड कुछ हद तक ओएस एक्स सिस्टम आंतरिक पुस्तक से संबंधित था, लेकिन यह सिर्फ एक अस्पष्ट याद है।

क्या कोई भी उस कोड को जानता है जिसके बारे में मैं बात कर रहा हूं और मुझे उस पर इंगित कर सकता है? अगर किसी को कुछ उदाहरण कोड के साथ ऐसा करने का अच्छा तरीका नहीं है?

संपादित करें: यहां जवाब है।

जानकारी: http://osxbook.com/book/bonus/chapter8/core/

कार्यक्रम है कि यह आप के लिए क्या करेंगे: http://osxbook.com/book/bonus/chapter8/core/download/gcore-1.3.tar.gz

Answer 1

मैं आपको लगता है कि this information

विशेष रूप

लिए देख रहे हैं:

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