/* Copyright 1997 Acorn Computers Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************/
/* File : RMA.c */
/* */
/* Purpose: The browser needs to claim RMA space */
/* for some of the grottier protocols out */
/* there now and again. There are a */
/* sufficiently large number of claims to */
/* warrant a thin veneer over claim and */
/* release of RMA to keep track of blocks */
/* and make sure leaks don't occur. */
/* */
/* Author : A.D.Hodgkinson */
/* */
/* History: 24-Oct-97: Created. */
/***************************************************/
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "swis.h"
#include "wimp.h"
#include "wimplib.h"
#include "event.h"
#include "svcprint.h"
#include "Global.h"
#include "Utils.h"
#include "RMA.h"
/* Structures */
typedef struct rma_array_item
{
unsigned int flags; /* Currently undefined (0) */
browser_data * allocator;
void * rma_block;
}
rma_array_item;
/* Locals */
rma_array_item * rma_array = NULL;
int rma_array_elements = 0;
/* Static function prototypes */
static _kernel_oserror * rma_add_item (int * new_item);
static _kernel_oserror * rma_remove_item (int item);
/*************************************************/
/* rma_claim() */
/* */
/* Claims a block of RMA, recording the usage by */
/* adding an item to the rma_array_item array. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* for which the claim is taking */
/* place, or NULL for a misc block - */
/* in that case the block can only */
/* be identified for later freeing */
/* by its address; */
/* */
/* Size of the block to allocate, in */
/* bytes; */
/* */
/* Pointer to a void * which will be */
/* filled in with the address of the */
/* new block. */
/* */
/* Assumes: The void * pointer is not NULL. */
/*************************************************/
_kernel_oserror * rma_claim(browser_data * allocator, int size, void ** rma_block)
{
_kernel_oserror * e;
int new_item;
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_claim: Called for allocator %p, block size %d\n",allocator,size);
#endif
if (rma_block) *rma_block = NULL;
else return NULL;
/* First add an array item to hold details on the RMA claim */
RetError(rma_add_item(&new_item));
/* The above should return an error if allocation fails, */
/* but 'just in case'... */
if (new_item == -1) return make_no_memory_error(22);
/* Fill it in, claiming the RMA space in passing */
rma_array[new_item].flags = 0;
rma_array[new_item].allocator = allocator;
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_claim: \0211Allocating %d bytes RMA\0217\n",size);
#endif
e = _swix(OS_Module,
_IN(0) | _IN(3) | _OUT(2),
6,
size,
&rma_array[new_item].rma_block);
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_claim: \0211Been given block %p\0217\n",rma_array[new_item].rma_block);
#endif
/* If the claim appears to have failed, free the array item */
/* again and return a generic out of memory error. */
if (!rma_array[new_item].rma_block)
{
rma_remove_item(new_item);
return make_no_memory_error(22);
}
/* Otherwise, we've finished */
if (rma_block) *rma_block = rma_array[new_item].rma_block;
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_claim: Successful\n");
#endif
return NULL;
}
/*************************************************/
/* rma_release() */
/* */
/* Releases (frees) one or several blocks of RMA */
/* claimed by rma_claim, identified by block */
/* address or an owning browser. */
/* */
/* Parameters: Pointer to a browser_data struct */
/* for which the claim originally */
/* took place to free all blocks */
/* claimed for that browser - this */
/* is ignored if the second */
/* parameter is non-NULL (see */
/* below); */
/* */
/* Address of the block - this is */
/* always used in preference to the */
/* browser pointer, so it *must* be */
/* NULL if all blocks for a given */
/* browser are to be freed. */
/*************************************************/
_kernel_oserror * rma_release(browser_data * allocator, void * rma_block)
{
int search, found, found_any = 0;
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_release: Called for allocator %p, block %p\n",allocator,rma_block);
#endif
/* Sanity check */
if (!allocator && !rma_block)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
StrNCpy0(erb.errmess,
"Null allocator and RMA block pointer given to rma_release");
return &erb;
#endif
return NULL;
}
/* If we've been given a specific block, search by that. Otherwise, */
/* remove all items owned by the given browser. */
if (rma_block)
{
do
{
found = 0;
search = 0;
while (search < rma_array_elements)
{
if (rma_array[search].rma_block == rma_block)
{
/* If an allocator was given, and the block doesn't */
/* match it, then warn about this in TRACE builds. */
#ifdef TRACE
if (allocator && rma_array[search].allocator != allocator)
{
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Going to free block %p for browser %p, though the block's allocator was %p, in rma_release",
rma_block,
allocator,
rma_array[search].allocator);
show_error_ret(&erb);
}
#endif
/* Now free the block */
rma_remove_item(search);
found = found_any = 1;
break;
}
search++;
}
}
while (found);
}
else
{
do
{
found = 0;
search = 0;
while (search < rma_array_elements)
{
if (rma_array[search].allocator == allocator)
{
rma_remove_item(search);
found = found_any = 1;
break;
}
search++;
}
}
while (found);
}
/* Trace builds will complain if no item was found */
/* - found_any isn't used for non-TRACE builds at */
/* the moment but could be in future, and so is */
/* unconditionally compiled in. */
#ifdef TRACE
if (!found_any)
{
erb.errnum = Utils_Error_Custom_Message;
sprintf(erb.errmess,
"Didn't find the item for allocator %p, address %p in rma_release",
allocator,
rma_block);
show_error_ret(&erb);
}
#endif
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_release: Successful\n");
#endif
return NULL;
}
/*************************************************/
/* rma_shutdown() */
/* */
/* Frees all items in array of claimed blocks, */
/* and all associated RMA blocks. */
/* */
/* TRACE builds will complain if there are any */
/* items to free, as usually other processes */
/* should have tidied up and this function */
/* will have nothing to do except exit. */
/*************************************************/
void rma_shutdown(void)
{
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_shutdown: Called\n");
#endif
if (rma_array_elements)
{
int item;
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_shutdown: Have item(s) to free\n");
erb.errnum = Utils_Error_Custom_Message;
if (rma_array_elements == 1)
{
StrNCpy0(erb.errmess,
"Possible RMA leak; rma_shutdown has a block to free");
}
else
{
sprintf(erb.errmess,
"Possible RMA leak; rma_shutdown has %d blocks to free",
rma_array_elements);
}
show_error_ret(&erb);
#endif
/* Free all of the RMA blocks */
for (item = 0; item < rma_array_elements; item++)
{
if (rma_array[item].rma_block)
{
_swix(OS_Module,
_IN(0) | _IN(2),
7,
rma_array[item].rma_block);
}
}
/* Free the array itself */
free(rma_array);
rma_array = NULL;
rma_array_elements = 0;
}
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_shutdown: Successful\n");
#endif
return;
}
/*************************************************/
/* rma_add_item() */
/* */
/* Adds an rma_array_item struct to the array of */
/* such structures. The contents are not */
/* initialised. */
/* */
/* Parameters: Pointer to an int, in which the */
/* array index of the new item is */
/* placed, or -1 for an error - this */
/* will be in addition to an error */
/* returned directly. */
/* */
/* Assumes: The pointer may not be NULL. */
/*************************************************/
static _kernel_oserror * rma_add_item(int * new_item)
{
rma_array_item * new_array;
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_add_item: Called\n");
#endif
if (!new_item)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
StrNCpy0(erb.errmess,
"Null new_item int pointer passed to rma_add_item");
return &erb;
#endif
return NULL;
}
if (!rma_array_elements) new_array = malloc (sizeof(rma_array_item));
else new_array = realloc(rma_array, sizeof(rma_array_item) * (rma_array_elements + 1));
if (!new_array) return make_no_memory_error(22);
else rma_array = new_array;
*new_item = rma_array_elements++; /* (Post-increment as we want to return an array index, not how many elements there are) */
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_add_item: Successful, item count is now %d\n", rma_array_elements);
#endif
return NULL;
}
/*************************************************/
/* rma_remove_item() */
/* */
/* Removes an rma_array_item from the array of */
/* such structures. */
/* */
/* Parameters: Index into the array of the item */
/* to remove. */
/*************************************************/
static _kernel_oserror * rma_remove_item(int item)
{
rma_array_item * new_array;
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_remove_item: Called for item %d\n",item);
#endif
/* Limit check 'item' */
if (item >= rma_array_elements)
{
#ifdef TRACE
erb.errnum = Utils_Error_Custom_Normal;
sprintf(erb.errmess,
"Invalid item number (%d, with %d elements) passed to rma_remove_item",
item,
rma_array_elements);
return &erb;
#endif
return NULL;
}
/* Is there an associated RMA block to free? If so, */
/* free it! */
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_remove_item: \0212Freeing RMA block %p\0217\n",rma_array[item].rma_block);
#endif
if (rma_array[item].rma_block)
{
RetError(_swix(OS_Module,
_IN(0) | _IN(2),
7,
rma_array[item].rma_block));
rma_array[item].rma_block = NULL;
}
/* Are we removing the only item? If so, just free the array */
if (rma_array_elements == 1)
{
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_remove_item: This is the last item, so freeing the array\n");
#endif
free(rma_array);
rma_array = NULL;
rma_array_elements = 0;
}
else
{
/* Are we removing the last item? If not, must shuffle */
/* the other elements down a bit. */
if (item != rma_array_elements - 1)
{
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_remove_item: This is not the head item, so shuffling higher items down\n");
#endif
memmove(&rma_array[item],
&rma_array[item + 1],
sizeof(rma_array_item) * (rma_array_elements - (item + 1)));
}
/* Now shrink the array */
new_array = realloc(rma_array, sizeof(rma_array_item) * (rma_array_elements - 1));
if (new_array) rma_array = new_array, rma_array_elements--;
}
/* Finished. */
#ifdef TRACE
if (tl & (1u<<12)) Printf("rma_remove_item: Successful, item count is now %d\n", rma_array_elements);
#endif
return NULL;
}