int OsSSLConnectionSocket::read(char* buffer, int bufferLength, UtlString* ipAddress, int* port) { // Overide base class version as recvfrom does not // seem to return host info correctly for TCP // Use base class version without the remote host info int bytesRead = -1; bytesRead = SSL_read (mSSL, buffer, bufferLength); #ifdef VALGRIND_MAKE_READABLE // If we are using Valgrind, we have to compensate for the fact that // Valgrind thinks all the output of SSL_read is undefined. // (This probably comes from SSL's use of uninitialized memory as part // of its key-generation algorithm.) VALGRIND_DISCARD(VALGRIND_MAKE_READABLE(&bytesRead, sizeof (bytesRead))); if (bytesRead > 0) { VALGRIND_DISCARD(VALGRIND_MAKE_READABLE(buffer, bytesRead)); } #endif /* VALGRIND_MAKE_READABLE */ // Explicitly get the remote host info. getRemoteHostIp(ipAddress); *port = getRemoteHostPort(); return(bytesRead); }
int main ( void ) { int i, sum, m; char* aa = calloc(100,1); sum = 0; VALGRIND_CHECK_READABLE(aa,100); m = VALGRIND_MAKE_WRITABLE( &aa[49], 1 ); VALGRIND_CHECK_WRITABLE(aa,100); printf("m_na: returned value is %d\n", m ); for (i = 0; i < 100; i++) sum += aa[i]; printf("sum is %d\n", sum); m = VALGRIND_DISCARD(m); printf("m_rm: returned value is %d\n", m ); for (i = 0; i < 100; i++) sum += aa[i]; printf("sum is %d\n", sum); return 0; }
/* Resize a block of memory, possibly re-allocating it. */ void * ggc_realloc_stat (void *x, size_t size MEM_STAT_DECL) { void *r; size_t old_size; if (x == NULL) return ggc_alloc_stat (size PASS_MEM_STAT); old_size = ggc_get_size (x); if (size <= old_size) { /* Mark the unwanted memory as unaccessible. We also need to make the "new" size accessible, since ggc_get_size returns the size of the pool, not the size of the individually allocated object, the size which was previously made accessible. Unfortunately, we don't know that previously allocated size. Without that knowledge we have to lose some initialization-tracking for the old parts of the object. An alternative is to mark the whole old_size as reachable, but that would lose tracking of writes after the end of the object (by small offsets). Discard the handle to avoid handle leak. */ VALGRIND_DISCARD (VALGRIND_MAKE_NOACCESS ((char *) x + size, old_size - size)); VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, size)); return x; } r = ggc_alloc_stat (size PASS_MEM_STAT); /* Since ggc_get_size returns the size of the pool, not the size of the individually allocated object, we'd access parts of the old object that were marked invalid with the memcpy below. We lose a bit of the initialization-tracking since some of it may be uninitialized. */ VALGRIND_DISCARD (VALGRIND_MAKE_READABLE (x, old_size)); memcpy (r, x, old_size); /* The old object is not supposed to be used anymore. */ ggc_free (x); return r; }
int OsSSLConnectionSocket::read(char* buffer, int bufferLength) { // Use base class implementation int bytesRead = -1; bytesRead = SSL_read (mSSL, buffer, bufferLength); #ifdef VALGRIND_MAKE_READABLE // If we are using Valgrind, we have to compensate for the fact that // Valgrind thinks all the output of SSL_read is undefined. // (This probably comes from SSL's use of uninitialized memory as part // of its key-generation algorithm.) VALGRIND_DISCARD(VALGRIND_MAKE_READABLE(&bytesRead, sizeof (bytesRead))); if (bytesRead > 0) { VALGRIND_DISCARD(VALGRIND_MAKE_READABLE(buffer, bytesRead)); } #endif /* VALGRIND_MAKE_READABLE */ return(bytesRead); }
MemoryPool::~MemoryPool(void) { pool_destroying = true; decrement_usage(used_memory.value()); decrement_mapping(mapped_memory.value()); #ifdef USE_VALGRIND VALGRIND_DESTROY_MEMPOOL(this); // Do not forget to discard stack traces for delayed free blocks for (size_t i = 0; i < delayedFreeCount; i++) { MemBlock* block = delayedFree[i]; void* object = &block->body; VALGRIND_DISCARD( VALGRIND_MAKE_MEM_DEFINED(block, OFFSET(MemBlock*, body))); VALGRIND_DISCARD( VALGRIND_MAKE_WRITABLE(object, block->length)); } #endif if (parent) { MemoryPool::release(freeObjects); } else { releaseRaw(pool_destroying, freeObjects, ((threshold + roundingSize) / roundingSize) * sizeof(void*)); } freeObjects = NULL; for (MemSmallHunk* hunk; hunk = smallHunks;) { smallHunks = hunk->nextHunk; releaseRaw(pool_destroying, hunk, minAllocation); } for (MemBigHunk* hunk; hunk = bigHunks;) { bigHunks = hunk->nextHunk; releaseRaw(pool_destroying, hunk, hunk->length); } }
sparseset sparseset_alloc (SPARSESET_ELT_TYPE n_elms) { unsigned int n_bytes = sizeof (struct sparseset_def) + ((n_elms - 1) * 2 * sizeof (SPARSESET_ELT_TYPE)); sparseset set = XNEWVAR (struct sparseset_def, n_bytes); /* Mark the sparseset as defined to silence some valgrind uninitialized read errors when accessing set->sparse[n] when "n" is not, and never has been, in the set. These uninitialized reads are expected, by design and harmless. */ VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (set, n_bytes)); set->dense = &(set->elms[0]); set->sparse = &(set->elms[n_elms]); set->size = n_elms; sparseset_clear (set); return set; }