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;
}
