emacs: src/alloc.c comparison

comparison src/alloc.c @ 58707:57741ce4cd6b

Add commentary for last change. (XMALLOC_PUT_SIZE, XMALLOC_GET_SIZE): New macros to handle sizeof(size_t) != 4. (overrun_check_malloc, overrun_check_realloc, overrun_check_free): Use them. Also clear header and trailer of freed memory. (GC_STRING_OVERRUN_COOKIE_SIZE): Rename from GC_STRING_EXTRA. (string_overrun_cookie): Rename from string_overrun_pattern. (GC_STRING_EXTRA): Define from GC_STRING_OVERRUN_COOKIE_SIZE.

author	Kim F. Storm <storm@cua.dk>
date	Wed, 01 Dec 2004 14:10:23 +0000
parents	7c469d30a12d
children	f8cddae7d959

comparison

equal deleted inserted replaced

-:1d7bc0df04ed
+:57741ce4cd6b
 while (1)
 Fsignal (Qnil, Vmemory_signal_data);
 }
-/* Like malloc but check for no memory and block interrupt input..  */
 #ifdef XMALLOC_OVERRUN_CHECK
+/* Check for overrun in malloc'ed buffers by wrapping a 16 byte header
+and a 16 byte trailer around each block.
+The header consists of 12 fixed bytes + a 4 byte integer contaning the
+original block size, while the trailer consists of 16 fixed bytes.
+The header is used to detect whether this block has been allocated
+through these functions -- as it seems that some low-level libc
+functions may bypass the malloc hooks.
+*/
 #define XMALLOC_OVERRUN_CHECK_SIZE 16
 static char xmalloc_overrun_check_header[XMALLOC_OVERRUN_CHECK_SIZE-4] =
 { 0x9a, 0x9b, 0xae, 0xaf,
 0xbf, 0xbe, 0xce, 0xcf,
 0xea, 0xeb, 0xec, 0xed };
 { 0xaa, 0xab, 0xac, 0xad,
 0xba, 0xbb, 0xbc, 0xbd,
 0xca, 0xcb, 0xcc, 0xcd,
 0xda, 0xdb, 0xdc, 0xdd };
+/* Macros to insert and extract the block size in the header.  */
+#define XMALLOC_PUT_SIZE(ptr, size)	\
+(ptr[-1] = (size & 0xff),		\
+ptr[-2] = ((size >> 8) & 0xff),	\
+ptr[-3] = ((size >> 16) & 0xff),	\
+ptr[-4] = ((size >> 24) & 0xff))
+#define XMALLOC_GET_SIZE(ptr)			\
+(size_t)((unsigned)(ptr[-1])		|	\
+	   ((unsigned)(ptr[-2]) << 8)	|	\
+	   ((unsigned)(ptr[-3]) << 16)	|	\
+	   ((unsigned)(ptr[-4]) << 24))
+/* Like malloc, but wraps allocated block with header and trailer.  */
 POINTER_TYPE *
 overrun_check_malloc (size)
 size_t size;
 {
-register char *val;
+register unsigned char *val;
-val = (char *) malloc (size + XMALLOC_OVERRUN_CHECK_SIZE*2);
+val = (unsigned char *) malloc (size + XMALLOC_OVERRUN_CHECK_SIZE*2);
 if (val)
 {
 bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
-bcopy (&size, val + XMALLOC_OVERRUN_CHECK_SIZE - 4, sizeof (size));
 val += XMALLOC_OVERRUN_CHECK_SIZE;
+XMALLOC_PUT_SIZE(val, size);
 bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
 }
 return (POINTER_TYPE *)val;
 }
+/* Like realloc, but checks old block for overrun, and wraps new block
+with header and trailer.  */
 POINTER_TYPE *
 overrun_check_realloc (block, size)
 POINTER_TYPE *block;
 size_t size;
 {
-register char *val = (char *)block;
+register unsigned char *val = (unsigned char *)block;
 if (val
 && bcmp (xmalloc_overrun_check_header,
 	       val - XMALLOC_OVERRUN_CHECK_SIZE,
 	       XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
 {
-size_t osize;
+size_t osize = XMALLOC_GET_SIZE (val);
-bcopy (val - 4, &osize, sizeof (osize));
 if (bcmp (xmalloc_overrun_check_trailer,
 		val + osize,
 		XMALLOC_OVERRUN_CHECK_SIZE))
 	abort ();
+bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
 val -= XMALLOC_OVERRUN_CHECK_SIZE;
-}
+bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
+}
-val = (char *) realloc ((POINTER_TYPE *)val, size + XMALLOC_OVERRUN_CHECK_SIZE*2);
+val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + XMALLOC_OVERRUN_CHECK_SIZE*2);
 if (val)
 {
 bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
-bcopy (&size, val + XMALLOC_OVERRUN_CHECK_SIZE - 4, sizeof (size));
 val += XMALLOC_OVERRUN_CHECK_SIZE;
+XMALLOC_PUT_SIZE(val, size);
 bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
 }
 return (POINTER_TYPE *)val;
 }
+/* Like free, but checks block for overrun.  */
 void
 overrun_check_free (block)
 POINTER_TYPE *block;
 {
-char *val = (char *)block;
+unsigned char *val = (unsigned char *)block;
 if (val
 && bcmp (xmalloc_overrun_check_header,
 	       val - XMALLOC_OVERRUN_CHECK_SIZE,
 	       XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
 {
-size_t osize;
+size_t osize = XMALLOC_GET_SIZE (val);
-bcopy (val - 4, &osize, sizeof (osize));
 if (bcmp (xmalloc_overrun_check_trailer,
 		val + osize,
 		XMALLOC_OVERRUN_CHECK_SIZE))
 	abort ();
+bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
 val -= XMALLOC_OVERRUN_CHECK_SIZE;
+bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
 }
 free (val);
 }
 #undef free
 #define malloc overrun_check_malloc
 #define realloc overrun_check_realloc
 #define free overrun_check_free
 #endif
+/* Like malloc but check for no memory and block interrupt input..  */
 POINTER_TYPE *
 xmalloc (size)
 size_t size;
 {
 #endif /* not GC_CHECK_STRING_BYTES */
 #ifdef GC_CHECK_STRING_OVERRUN
-#define GC_STRING_EXTRA	4
-static char string_overrun_pattern[GC_STRING_EXTRA] = { 0xde, 0xad, 0xbe, 0xef };
+/* We check for overrun in string data blocks by appending a small
+"cookie" after each allocated string data block, and check for the
+presense of this cookie during GC.  */
+#define GC_STRING_OVERRUN_COOKIE_SIZE	4
+static char string_overrun_cookie[GC_STRING_OVERRUN_COOKIE_SIZE] =
+{ 0xde, 0xad, 0xbe, 0xef };
 #else
-#define GC_STRING_EXTRA 0
+#define GC_STRING_OVERRUN_COOKIE_SIZE 0
 #endif
 /* Value is the size of an sdata structure large enough to hold NBYTES
 bytes of string data.  The value returned includes a terminating
 NUL byte, the size of the sdata structure, and padding.  */
 + sizeof (EMACS_INT) - 1)		\
 & ~(sizeof (EMACS_INT) - 1))
 #endif /* not GC_CHECK_STRING_BYTES */
+/* Extra bytes to allocate for each string.  */
+#define GC_STRING_EXTRA (GC_STRING_OVERRUN_COOKIE_SIZE)
 /* Initialize string allocation.  Called from init_alloc_once.  */
 void
 init_strings ()
 {
 #endif /* GC_CHECK_STRING_BYTES */
 #ifdef GC_CHECK_STRING_FREE_LIST
+/* Walk through the string free list looking for bogus next pointers.
+This may catch buffer overrun from a previous string.  */
 static void
 check_string_free_list ()
 {
 struct Lisp_String *s;
 	}
 total_free_strings += STRING_BLOCK_SIZE;
 }
-check_string_free_list();
+check_string_free_list ();
 /* Pop a Lisp_String off the free-list.  */
 s = string_free_list;
 string_free_list = NEXT_FREE_LISP_STRING (s);
 #endif
 s->size = nchars;
 s->size_byte = nbytes;
 s->data[nbytes] = '\0';
 #ifdef GC_CHECK_STRING_OVERRUN
-bcopy(string_overrun_pattern, (char *) data + needed, GC_STRING_EXTRA);
+bcopy (string_overrun_cookie, (char *) data + needed,
+	 GC_STRING_OVERRUN_COOKIE_SIZE);
 #endif
 b->next_free = (struct sdata *) ((char *) data + needed + GC_STRING_EXTRA);
 /* If S had already data assigned, mark that as free by setting its
 string back-pointer to null, and recording the size of the data
 	  b->next = live_blocks;
 	  live_blocks = b;
 	}
 }
-check_string_free_list();
+check_string_free_list ();
 string_blocks = live_blocks;
 free_large_strings ();
 compact_small_strings ();
-check_string_free_list();
+check_string_free_list ();
 }
 /* Free dead large strings.  */
 	  if (from->string)
 	    nbytes = GC_STRING_BYTES (from->string);
 	  else
 	    nbytes = SDATA_NBYTES (from);
-#ifdef GC_CHECK_STRING_BYTES
 	  if (nbytes > LARGE_STRING_BYTES)
 	    abort ();
-#endif
 	  nbytes = SDATA_SIZE (nbytes);
 	  from_end = (struct sdata *) ((char *) from + nbytes + GC_STRING_EXTRA);
 #ifdef GC_CHECK_STRING_OVERRUN
-	  if (bcmp(string_overrun_pattern, ((char *) from_end) - GC_STRING_EXTRA, GC_STRING_EXTRA))
+	  if (bcmp (string_overrun_cookie,
+		    ((char *) from_end) - GC_STRING_OVERRUN_COOKIE_SIZE,
+		    GC_STRING_OVERRUN_COOKIE_SIZE))
 	    abort ();
 #endif
 	  /* FROM->string non-null means it's alive.  Copy its data.  */
 	  if (from->string)

Mercurial > emacs

comparison src/alloc.c @ 58707:57741ce4cd6b