[insert project logo here (125x200px max)] Navigator Home Downloads Documentation Research News Forums Project Summary CVS repository Mailinglists Help Announcement Developer Please report any errors or ommissions you find to our `Help' mailinglist, or post a message in the Forums. Copyright and Licensing Information Snap is (c) Jonathan T. Moore, 1999-2002 and licensed under the GNU General Public License (GPL). All other parts of Splash are (c) Willem de Bruijn, 2002-2003 and licensed under the BSD Open Source License. All sourcecode is made publicly available. Acknowledgement Splash and the Splash website are hosted by SourceForge.net

Splash - Documentation SNMP Plus a Lightweight API for SNAP Handling             snap-1.1-wjdb/lib/snap_io.c Go to the documentation of this file. /* $Id: snap_io.c,v 1.3 2003/04/16 10:58:59 wdebruij Exp $ */ #include <errno.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <netinet/in.h> #include <linux/ip.h> #include "snap.h" #include "config.h" #include "myassert.h" #include "consts.h" #include "bytecode.h" #include "io.h" #include "memalloc.h" #include "packet.h" #include "timers.h" #include "d_printf.h" #include "wassert.h" static void *scan_value(value_t *v, void *fromh, void *fromhmax, void *fromhalloc, void *fromhallocmax, void *tohmin, void *tohalloc, void *tohmax); static void *copy_heap_obj(heap_obj *hsrc, int sizeb, void *tohmin, void *tohalloc, void *tohmax); static void reset_heap(packet_t *p, void *to_heap, void *to_heap_max); /* used to verify packet integrity */ #define VERIFY(e) \ if (e); \ else { \ fprintf(stderr,"%s:%d: packet check failed\n",__FILE__,__LINE__); \ return NULL; \ } /* checks if the given heap_obj ptr is within the heap bounds. side-effects sizeb to contain the object's length (word-aligned) */ #define IF_IN_FROM_HEAP(ho,sizeb,hmin,hmax,hmin2,hmax2) \ if ((((void *)(ho) >= (void *)(hmin)) && \ ((void *)(ho) < (void *)(hmax)) && \ (((void *)(ho) + \ ((sizeb) = (ho)->len + sizeof(heap_obj))) <= (void *)(hmax))) || \ (((void *)(ho) >= (void *)(hmin2)) && \ ((void *)(ho) < (void *)(hmax2)) && \ (((void *)(ho) + \ ((sizeb) = (ho)->len + sizeof(heap_obj))) <= (void *)(hmax2)))) { \ if (((sizeb) & 0x3) != 0) { \ (sizeb) = ((sizeb) & ~0x3) + 4; \ } #define ELSE_NOT_IN_FROM_HEAP } else #define IN_TOSPACE_HEAP(hdst,sizeb,toh,tohmax) \ (((void *)(hdst) >= (toh)) && (((void *)(hdst) + (sizeb)) <= (tohmax))) /* cache the packet_t struct */ static packet_t phandle; /* given a buffer containing a packet, find pointers to the header, code, stack, and heap portions */ packet_t *unmarshal_packet(char *buffer, int packet_lenb, int buf_lenb) { packet_t *p; /* packet struct to return */ void *buf_end = buffer + buf_lenb; void *packet_end = buffer + packet_lenb; unsigned short int code_lenb, entry_point, stack_lenb, heap_lenb; assert(sizeof(unsigned long int) == sizeof(unsigned int)); assert(packet_lenb <= buf_lenb); d_printf(100,"%s:%d: unmarshal_packet, buf=0x%x, plen=%d, blen=%d\n", __FILE__,__LINE__,(unsigned int)buffer,packet_lenb,buf_lenb); print_anti_timer(7,"unmarshal_packet"); p = &phandle; p->iph = (struct iphdr *)buffer; /* set up header */ { struct iphdr *iph = (struct iphdr *)buffer; p->hdr = (header_t *)((void *)iph + (iph->ihl << 2)); } code_lenb = ntohs(p->hdr->code_sizeb); stack_lenb = ntohs(p->hdr->stack_sizeb); heap_lenb = ntohs(p->hdr->heap_sizeb); entry_point = ntohs(p->hdr->entry_point); /* set up code */ print_anti_timer(9,"unmarshal_code"); p->code_min = (instr_t *)((void *)p->hdr + sizeof(header_t)); p->code_max = (instr_t *)((void *)p->code_min + code_lenb); p->pc = p->code_min + entry_point; p->handler = p->code_max; /* default exception handler quits */ VERIFY((entry_point * sizeof(instr_t)) <= code_lenb); print_timer(9,"unmarshal_code"); /* set up heap */ print_anti_timer(11,"unmarshal_heap"); p->heap_min = (void *)p->code_max; p->heap_max = p->heap_min + heap_lenb; print_timer(11,"unmarshal_heap"); /* set up stack */ print_anti_timer(10,"unmarshal_stack"); p->stack_min = (value_t *)p->heap_max; p->stack_max = (value_t *)buf_end; p->sp = (value_t *)((void *)p->stack_min + stack_lenb); VERIFY(((void *)(p->sp) <= packet_end)); print_timer(10,"unmarshal_stack"); /* top of buffer */ p->h_alloc_heap_max = (void *)p->stack_max; p->is_contiguous = 1; d_printf(150,"%s:%d: @hdr = %#x\n", __FILE__,__LINE__,(uint32)p->hdr); d_printf(150,"%s:%d: @code_min = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->code_min,(void *)p->code_min - (void *)p->hdr); d_printf(150,"%s:%d: @pc = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->pc, (void *)p->pc - (void *)p->code_min); d_printf(150,"%s:%d: @code_max = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->code_max, (void *)p->code_max - (void *)p->pc); d_printf(150,"%s:%d: @heap_min = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->heap_min, (void *)p->heap_min - (void *)p->code_max); d_printf(150,"%s:%d: @heap_max = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->heap_max, (void *)p->heap_max - (void *)p->heap_min); d_printf(150,"%s:%d: @stack_min = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->stack_min, (void *)p->stack_min - (void *)p->heap_max); d_printf(150,"%s:%d: @sp = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->sp, (void *)p->sp - (void *)p->stack_min); d_printf(150,"%s:%d: @stack_max = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->stack_max, (void *)p->stack_max - (void *)p->sp); d_printf(150,"%s:%d: @h_alloc_heap_max = %#x, delta = %d\n", __FILE__,__LINE__, (uint32)p->h_alloc_heap_max, (void *)p->h_alloc_heap_max - (void *)p->stack_max); print_timer(7,"unmarshal_packet"); return(p); } /* cache a 10k output buffer */ static char *io_outbuf = NULL; static int io_outbuf_sizeb = 10 * 1024; /* given a packet and the amount of stack to take, marshal up a packet into a continuous block of bytes. We assume that the packet_t structure is well-formed, but don't assume anything about the contents of the stack and the heap (there may be bogus values), so we require some extra checks. */ int marshal_packet(packet_t *p, int stack_amt, buffer_t *bufstr) { int sizeb; /* size in bytes of new buffer */ instr_t *codesrc; /* code pointer in old packet */ instr_t *codedst; /* code pointer in new packet */ value_t *stacksrc; /* stack pointer in old packet */ value_t *stackdst; /* stack pointer in new packet */ void *newhmin; /* bottom of new heap */ void *newhalloc; /* new heap allocation pointer */ void *newhscan; /* new heap scan pointer */ void *newhmax; /* high limit for new heap */ header_t *newhdr; /* header for the new packet */ d_printf(150,"%s:%d: @hdr = %#x\n", __FILE__,__LINE__,(unsigned int)p->hdr); d_printf(150,"%s:%d: @code_min = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->code_min,(void *)p->code_min - (void *)p->hdr); d_printf(150,"%s:%d: @pc = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->pc, (void *)p->pc - (void *)p->code_min); d_printf(150,"%s:%d: @code_max = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->code_max, (void *)p->code_max - (void *)p->pc); d_printf(150,"%s:%d: @heap_min = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->heap_min, (void *)p->heap_min - (void *)p->code_max); d_printf(150,"%s:%d: @heap_max = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->heap_max, (void *)p->heap_max - (void *)p->heap_min); d_printf(150,"%s:%d: @stack_min = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->stack_min, (void *)p->stack_min - (void *)p->heap_max); d_printf(150,"%s:%d: @sp = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->sp, (void *)p->sp - (void *)p->stack_min); d_printf(150,"%s:%d: @stack_max = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->stack_max, (void *)p->stack_max - (void *)p->sp); d_printf(150,"%s:%d: @h_alloc_heap_max = %#x, delta = %d\n", __FILE__,__LINE__, (unsigned int)p->h_alloc_heap_max, (void *)p->h_alloc_heap_max - (void *)p->stack_max); print_anti_timer(8,"marshal_packet"); /* check for valid args */ assert(stack_amt >= 0); assert(p != NULL); assert(bufstr != NULL); /* see if we can reuse this buffer. We can if the entire stack is to be transmitted and if we haven't done any further heap allocation. */ /* XXX this optimization won't work in the kernel case yet unless this send is resulting from a forw or a forwto (as then we won't compute any further). Might be possible to clone the buffer, though. */ if (((p->sp - p->stack_min) == stack_amt) && (p->h_alloc_heap_max == p->stack_max) && (p->is_contiguous)) { d_printf(100,"%s:%d: reusing old buffer during marshalling\n", __FILE__,__LINE__); p->hdr->stack_sizeb = htons(stack_amt * sizeof(value_t)); bufstr->lenb = (void *)p->sp - (void *)p->iph; bufstr->s = (char *)p->iph; print_timer(8,"marshal_packet"); return 0; } /* take a conservative size for the packet-- the actual heap may be smaller than the space we provide */ /* XXX should be statically allocated */ d_printf(100,"%s:%d: sh:%d B,cs:%d B,ss:%d B,hs1:%d B,hs2:%d B\n", __FILE__,__LINE__, sizeof(header_t), ((void *)(p->code_max) - (void *)(p->code_min)), (stack_amt * sizeof(value_t)), ((void *)p->heap_max - (void *)p->heap_min), ((void *)p->h_alloc_heap_max - (void *)p->stack_max)); sizeb = /* IP hdr */ sizeof(struct iphdr) + /* RA option */ 4 + /* header */ sizeof(header_t) + /* code */ ((void *)(p->code_max) - (void *)(p->code_min)) + /* stack */ (stack_amt * sizeof(value_t)) + /* heap1 */ ((void *)p->heap_max - (void *)p->heap_min) + /* heap2 */ ((void *)p->h_alloc_heap_max - (void *)p->stack_max); d_printf(100, "%s:%d: out sizeb = %d bytes\n", __FILE__,__LINE__,sizeb); if (io_outbuf == NULL) { if (sizeb > io_outbuf_sizeb) { io_outbuf_sizeb = sizeb; } memalloc(io_outbuf,char *,io_outbuf_sizeb); } else { if (sizeb > io_outbuf_sizeb) { io_outbuf_sizeb = sizeb; free(io_outbuf); memalloc(io_outbuf,char *,io_outbuf_sizeb); } } /* copy over the IP header from the current packet */ { if (p && p->iph){ unsigned char *where = io_outbuf; d_printf(250,"marshall_packet : where=%p, p->iph=%p, size of header=%u",where,p->iph, sizeof(struct iphdr)); memcpy(where, p->iph, sizeof(struct iphdr)); /* copy over RA option */ memcpy(where + sizeof(struct iphdr),(void *)p->iph + sizeof(struct iphdr),4); } /* the following is only used by snapas (the assembler, can be found in the utils subdir) */ else{ d_printf(250,"creating new IP header"); } } /* set up all the source and destination pointers */ newhdr = (header_t *)(io_outbuf + sizeof(struct iphdr) + 4 ); codesrc = p->code_min; codedst = (instr_t *)(newhdr+1); newhmin = newhscan = newhalloc = (void *)codedst + ((void *)p->code_max - (void *)p->code_min); newhmax = (void *)newhmin + ((void *)p->heap_max - (void *)p->heap_min) + ((void *)p->h_alloc_heap_max - (void *)p->stack_max); stacksrc = p->sp - stack_amt; stackdst = (value_t *)newhmax; /* first copy the header */ memcpy(newhdr,p->hdr,sizeof(header_t)); /* now copy code */ d_printf(150,"%s:%d: scanning code\n",__FILE__,__LINE__); { int sizeb = (int)((void *)p->code_max - (void *)codesrc); instr_t *codemax = (instr_t *)((void *)codedst + sizeb); memcpy(codedst,codesrc,sizeb); /* scan it, forwarding pointers to moved objects */ while (codedst < codemax) { #ifdef SMALL_INSTRS switch (GET_OP(*codedst)) { case SVCV: case CALLS: case PSTR: case EQSTR: case NQSTR: case PTUP: case EQTUP: case NQTUP: case PADDR: case EQADR: case NQADR: case PFLT: case EQFLT: case NQFLT: case FGTI: case FGEQI: case FLEQI: case FLTI: case FADDI: case FSUBI: case FMULI: case FDIVI: case SNETI: case BCASTI: { int hoffs; heap_obj *hsrc; int sizeb; GET_LIT(hoffs,BOGUSV,*codedst); hsrc = (heap_obj *)(p->heap_min + hoffs); IF_IN_FROM_HEAP(hsrc,sizeb,p->heap_min,p->heap_max, p->stack_max,p->h_alloc_heap_max) { newhalloc = copy_heap_obj(hsrc, sizeb, newhmin, newhalloc, newhmax); /* forward it */ /* note that if copy_heap_obj doesn't copy the object because it is bogus (or a previous object was), then this will result in a bogus pointer. This doesn't matter as we check against it later in both the GC and the interpreter. */ SET_LIT(*codedst,BOGUSV,hsrc->flag - 4); /* subtract the extra 4 from the offset */ } /* bogus pointer, leave it XXX */ ELSE_NOT_IN_FROM_HEAP { fprintf (stderr,"%s:%d: warning, pointer @%#x not in heap\n", __FILE__,__LINE__,(unsigned int)hsrc); } break; } default: break; } /* end switch */ #else switch (GET_OP(*codedst)) { #ifdef ADDR_IN_HEAP case SNETI: case BCASTI: /* these may contain floating point values */ case GTI: case GEQI: case LTI: case LEQI: case ADDI: case SUBI: case MULTI: case DIVI: #endif case PUSH: case EQI: case NEQI: case SVCV: case CALLS: newhalloc = scan_value(&(codedst->arg), p->heap_min, p->heap_max, p->stack_max, p->h_alloc_heap_max, newhmin, newhalloc, newhmax); break; default: break; } /* end switch */ #endif codedst++; } /* end while */ } d_printf(150,"%s:%d: done scanning code\n",__FILE__,__LINE__); /* copy stack */ d_printf(150,"%s:%d: scanning stack\n",__FILE__,__LINE__); { int sizeb = (int)((void *)p->sp - (void *)stacksrc); value_t *stackmax = (value_t *)((void *)stackdst + sizeb); memcpy(stackdst,stacksrc,sizeb); while (stackdst < stackmax) { newhalloc = scan_value(stackdst, p->heap_min, p->heap_max, p->stack_max, p->h_alloc_heap_max, newhmin, newhalloc, newhmax); stackdst++; } } d_printf(150,"%s:%d: done scanning stack\n",__FILE__,__LINE__); /* scan the topspace heap, copying any reachable, uncopied objects */ d_printf(150,"%s:%d: scanning heap, @%#x to @%#x\n", __FILE__,__LINE__,(unsigned int)newhscan,(unsigned int)newhalloc); while (newhscan < newhalloc) { heap_obj *hsrc = (heap_obj *)newhscan; int sizeb = sizeof(heap_obj) + hsrc->len; /* note that we can assume that hsrc->len is within the heap since it was copied here by the GC. */ if ((sizeb & 0x3) != 0) { sizeb = (sizeb & ~0x3) + 4; } /* if contains pointers, scan the contents of the object */ /* note we check for ==1 exactly in case this object is bogus (don't want to scan a bogus object, just skip it) */ if (hsrc->flag == 1) { value_t *vsrc = (value_t *)hsrc->s, *vsrcend = (value_t *)(hsrc->s + hsrc->len); while (vsrc < vsrcend) { newhalloc = scan_value(vsrc, p->heap_min, p->heap_max, p->stack_max, p->h_alloc_heap_max, newhmin, newhalloc, newhmax); vsrc++; } } newhscan += sizeb; } d_printf(150,"%s:%d: done scanning heap\n",__FILE__,__LINE__); /* compress the heap */ if (newhalloc != newhmax) { d_printf(150,"%s:%d: compressing heap/sliding stack down\n", __FILE__,__LINE__); memmove(newhalloc,newhmax,(stack_amt * sizeof(value_t))); stackdst = (value_t *)((void *)stackdst - (newhmax - newhalloc)); } /* remove forwarding pointers from current packet's heap */ d_printf(150,"%s:%d: removing forwarding pointers from current packet\n", __FILE__,__LINE__); reset_heap(p,newhmin,newhalloc); /* note sizes of various things in the new packet */ assert((void *)p->code_max > (void *)p->code_min); newhdr->code_sizeb = htons((void *)p->code_max - (void *)p->code_min); assert(stack_amt >= 0); newhdr->stack_sizeb = htons(stack_amt * sizeof(value_t)); assert(newhalloc >= newhmin); newhdr->heap_sizeb = htons(newhalloc - newhmin); { int actual_sizeb = sizeof(struct iphdr) + 4 + sizeof(struct snaphdr) + ntohs(newhdr->code_sizeb) + ntohs(newhdr->stack_sizeb) + ntohs(newhdr->heap_sizeb); struct iphdr *newiph = (struct iphdr *)io_outbuf; newiph->tot_len = htons(actual_sizeb); } d_printf(25,"%s:%d: newcs=%d newss=%d newhs=%d\n",__FILE__,__LINE__, ntohs(newhdr->code_sizeb), ntohs(newhdr->stack_sizeb), ntohs(newhdr->heap_sizeb)); bufstr->lenb = (void *)stackdst - (void *)io_outbuf; bufstr->s = io_outbuf; print_timer(8,"marshal_packet"); return 0; } /* invariants (pre and post conditions): tohalloc and tohmax are word-aligned tohalloc <= tohmax tohalloc >= tohmin hsrc is within fromspace heap, sizeb = hsrc->len + sizeof(heap_obj) rounded up to word boundary */ static void *copy_heap_obj(heap_obj *hsrc, int sizeb, void *tohmin, void *tohalloc, void *tohmax) { heap_obj *hdst; d_printf(150,"%s:%d: heap obj @%#x (size:%d,f:%d) --", __FILE__,__LINE__,(uint32)hsrc,hsrc->len,hsrc->flag); /* check 2, rather than 4, to avoid copying heap objs that have bogus flag values of 2 and 3 */ if (hsrc->flag < 2) { /* not forwarded yet, do it now */ hdst = (heap_obj *)tohalloc; tohalloc += sizeb; /* this check will only succeed if we're processing a bogus object. */ if (tohalloc > tohmax) { fprintf(stderr,"%s:%d: Warning, processed bogus object, @%#x\n", __FILE__,__LINE__,(unsigned int)hsrc); /* don't do the copy */ return (void *)hdst; } hdst->len = hsrc->len; /* now is essentially "legal", thanks to check */ hdst->flag = hsrc->flag; /* may be bogus */ memcpy(&(hdst->s),&(hsrc->s),hsrc->len); /* XXX switch to word-aligned offsets ? */ assert((tohalloc - tohmin + 4) <= 65536); /* forward it, add 4 to diff from legal flag val 0 */ hsrc->flag = (void *)hdst - tohmin + 4; d_printf(150,"copied to offs %d, @%#x\n", hsrc->flag - 4, (unsigned int)hdst); } #ifndef NDEBUG else d_printf(150,"forwarded with offs %d, @%#x\n", hsrc->flag - 4,(unsigned int)(tohmin + (hsrc->flag - 4))); #endif return(tohalloc); } /* invariants (pre and post conditions): tohalloc and tohmax are word-aligned tohalloc <= tohmax tohalloc >= tohmin if the stack value is a bogus pointer (i.e., it might point outside the heap, or it might be too big), then it will also be bogus on the way out (in fact, it will be some very large integer). */ static void *scan_value(value_t *v, void *fromh, void *fromhmax, void *fromhalloc, void *fromhallocmax, void *tohmin, void *tohalloc, void *tohmax) { switch(GET_TAG(*v)) { case INTV: case EXCV: default: break; case ADDRV: case FLOATV: #ifndef ADDR_IN_HEAP break; #endif case STRV: case TUPLEV: { int sizeb; heap_obj *hsrc = (heap_obj *)(fromh + GET_OFFS(*v)); /* make sure it's in the fromspace heap */ IF_IN_FROM_HEAP(hsrc,sizeb,fromh,fromhmax,fromhalloc,fromhallocmax) { tohalloc = copy_heap_obj(hsrc,sizeb,tohmin,tohalloc,tohmax); /* apply forwarding pointer */ SET_OFFS(*v,hsrc->flag - 4); /* subtract the extra 4 from the offset */ assert(GET_OFFS(*v) == (hsrc->flag - 4)); wassert(GET_OFFS(*v) >= 0); wassert((GET_OFFS(*v) % 4) == 0); } /* otherwise, set the value to a NULL */ ELSE_NOT_IN_FROM_HEAP { fprintf (stderr,"%s:%d: warning, pointer @%#x not in heap, NULLing\n", __FILE__,__LINE__,(unsigned int)hsrc); SET_TAG(*v,INTV); SET_INT(*v,0); } break; } } return(tohalloc); } static void clear_forw_offs(value_t *v, void *fromh, void *fromhmax, void *fromhalloc, void *fromhallocmax, void *toh, void *tohmax); /* invariant: hsrc is the fromspace heap postcond: hsrc->flag = 0 or 1 (prevents GC loops) */ static void reset_heap_obj(heap_obj *hsrc, void *fromh, void *fromhmax, void *fromhalloc, void *fromhallocmax, void *toh, void *tohmax) { /* check >= 2 (rather than 4) to process bogus pointers */ if (hsrc->flag >= 2) { heap_obj *hdst; int sizeb = sizeof(heap_obj) + hsrc->len; if ((sizeb & 0x3) != 0) { sizeb = (sizeb & ~0x3) + 4; } wassert((hsrc->flag % 4) == 0); hdst = (heap_obj *)(toh + hsrc->flag - 4); /* make sure the object is in the tospace heap */ if (IN_TOSPACE_HEAP(hdst,sizeb,toh,tohmax)) { /* restore the old flag value, removing the forwarding offs */ /* note we need to set the flag to 0 here to in case the hsrc flag was bogus and happened to point to tospace. */ hsrc->flag = (hdst->flag == 1 ? 1 : 0); /* scan the object, if necessary, and recurse */ if (hsrc->flag) { value_t *vsrc = (value_t *)hsrc->s, *vsrcend = (value_t *)(hsrc->s + hsrc->len); while (vsrc < vsrcend) { clear_forw_offs(vsrc, fromh, fromhmax, fromhalloc, fromhallocmax, toh, tohmax); vsrc++; } } /* doesn't contain pointers, don't scan */ } /* bogus pointer, leave it */ else { fprintf (stderr,"%s:%d: warning, forw offs to @%#x not in heap\n", __FILE__,__LINE__,(unsigned int)hdst); } } /* else nothing to do */ } static void clear_forw_offs(value_t *v, void *fromh, void *fromhmax, void *fromhalloc, void *fromhallocmax, void *toh, void *tohmax) { switch(GET_TAG(*v)) { case INTV: case EXCV: default: break; case ADDRV: case FLOATV: #ifndef ADDR_IN_HEAP break; #endif case STRV: case TUPLEV: { heap_obj *hsrc = (heap_obj *)(fromh + GET_OFFS(*v)); int sizeb; IF_IN_FROM_HEAP(hsrc,sizeb,fromh,fromhmax, fromhalloc,fromhallocmax) reset_heap_obj(hsrc,fromh,fromhmax, fromhalloc,fromhallocmax, toh,tohmax); ELSE_NOT_IN_FROM_HEAP { fprintf (stderr,"%s:%d: warning, pointer @%#x not in heap\n", __FILE__,__LINE__,(unsigned int)hsrc); } } } } /* clears all of the forwarding pointers left by the marshalling process */ static void reset_heap(packet_t *p, void *to_heap, void *to_heap_max) { instr_t *codesrc = p->code_min; value_t *stacksrc = p->stack_min; while (codesrc < p->code_max) { #ifdef SMALL_INSTRS switch (GET_OP(*codesrc)) { case SVCV: case CALLS: case PSTR: case EQSTR: case NQSTR: case PTUP: case EQTUP: case NQTUP: case PADDR: case EQADR: case NQADR: case FGTI: case FGEQI: case FLEQI: case FLTI: case FADDI: case FSUBI: case FMULI: case FDIVI: case SNETI: case BCASTI: { int hoffs, sizeb; heap_obj *hsrc; GET_LIT(hoffs,BOGUSV,*codesrc); hsrc = (heap_obj *)(p->heap_min + hoffs); IF_IN_FROM_HEAP(hsrc,sizeb,p->heap_min,p->heap_max, p->stack_max,p->h_alloc_heap_max) { reset_heap_obj(hsrc, p->heap_min, p->heap_max, p->stack_max, p->h_alloc_heap_max, to_heap, to_heap_max); } ELSE_NOT_IN_FROM_HEAP { fprintf (stderr,"%s:%d: warning, pointer @%#x not in heap\n", __FILE__,__LINE__,(unsigned int)hsrc); } break; } default: break; } /* end switch */ #else switch (GET_OP(*codesrc)) { #ifdef ADDR_IN_HEAP case SNETI: case BCASTI: /* these may contain floating point values */ case GTI: case GEQI: case LTI: case LEQI: case ADDI: case SUBI: case MULTI: case DIVI: #endif case PUSH: case EQI: case NEQI: case SVCV: case CALLS: clear_forw_offs(&(codesrc->arg), p->heap_min, p->heap_max, p->stack_max, p->h_alloc_heap_max, to_heap, to_heap_max); break; default: break; } /* end switch */ #endif codesrc++; } while (stacksrc < p->sp) { clear_forw_offs(stacksrc, p->heap_min, p->heap_max, p->stack_max, p->h_alloc_heap_max, to_heap, to_heap_max); stacksrc++; } /* no need to scan the heap; this was done recursively while scanning the stack */ } int file_to_str(int fd, buffer_t *buf) { int bufinc = 1024; int newlen; char *newbuf; char *inptr; int bytes_read; int total_bytes_read = 0; memalloc(buf->s, char *, bufinc); buf->lenb = bufinc; inptr = buf->s; while(1) { int space_left = buf->lenb - (inptr - buf->s); bytes_read = read(fd,inptr,space_left); if (bytes_read == -1 && (errno == EINTR || errno == EAGAIN)) continue; total_bytes_read += bytes_read; if (bytes_read == space_left) { newlen = buf->lenb + bufinc; memalloc(newbuf, char *, newlen); memcpy(newbuf,buf->s,buf->lenb); inptr = newbuf + buf->lenb; buf->lenb = newlen; free(buf->s); buf->s = newbuf; continue; } /* buf->lenb = (inptr - buf->s) + bytes_read; */ break; } return total_bytes_read; }