/** Free a shared memory buffer */
MMAL_STATUS_T mmal_vc_shm_free(uint8_t *mem)
{
MMAL_VC_PAYLOAD_ELEM_T *payload_elem = mmal_vc_payload_list_find_mem(mem);
if (payload_elem)
{
#ifdef ENABLE_MMAL_VCSM
vcsm_free((unsigned int)payload_elem->handle);
#endif /* ENABLE_MMAL_VCSM */
mmal_vc_payload_list_release(payload_elem);
return MMAL_SUCCESS;
}
return MMAL_EINVAL;
}
/** Allocate a shared memory buffer */
uint8_t *mmal_vc_shm_alloc(uint32_t size)
{
uint8_t *mem = NULL;
MMAL_VC_PAYLOAD_ELEM_T *payload_elem = mmal_vc_payload_list_get();
if (!payload_elem)
{
LOG_ERROR("could not get a free slot in the payload list");
return NULL;
}
#ifdef ENABLE_MMAL_VCSM
unsigned int vcsm_handle = vcsm_malloc_cache(size, VCSM_CACHE_TYPE_NONE, "mmal_vc_port buffer");
unsigned int vc_handle = vcsm_vc_hdl_from_hdl(vcsm_handle);
mem = (uint8_t *)vcsm_lock( vcsm_handle );
if (!mem || !vc_handle)
{
LOG_ERROR("could not allocate %i bytes of shared memory (handle %x)",
(int)size, vcsm_handle);
if (mem)
vcsm_unlock_hdl(vcsm_handle);
if (vcsm_handle)
vcsm_free(vcsm_handle);
mmal_vc_payload_list_release(payload_elem);
return NULL;
}
payload_elem->mem = mem;
payload_elem->handle = (void *)vcsm_handle;
payload_elem->vc_handle = (void *)vc_handle;
#else /* ENABLE_MMAL_VCSM */
MMAL_PARAM_UNUSED(size);
mmal_vc_payload_list_release(payload_elem);
#endif /* ENABLE_MMAL_VCSM */
return mem;
}
int main( int argc, char **argv )
{
int32_t ret;
char optstring[OPTSTRING_LEN];
int opt;
int opt_alloc = 0;
int opt_status = 0;
uint32_t alloc_size = 0;
int opt_pid = -1;
VCSM_STATUS_T status_mode = VCSM_STATUS_NONE;
void *usr_ptr_1;
unsigned int usr_hdl_1;
#if defined(DOUBLE_ALLOC) || defined(RESIZE_ALLOC)
void *usr_ptr_2;
unsigned int usr_hdl_2;
#endif
// Initialize VCOS
vcos_init();
vcos_log_set_level(&smem_log_category, VCOS_LOG_INFO);
smem_log_category.flags.want_prefix = 0;
vcos_log_register( "smem", &smem_log_category );
// Create the option string that we will be using to parse the arguments
create_optstring( optstring );
// Parse the command line arguments
while (( opt = getopt_long_only( argc, argv, optstring, long_opts,
NULL )) != -1 )
{
switch ( opt )
{
case 0:
{
// getopt_long returns 0 for entries where flag is non-NULL
break;
}
case OPT_ALLOC:
{
char *end;
alloc_size = (uint32_t)strtoul( optarg, &end, 10 );
if (end == optarg)
{
vcos_log_info( "Invalid arguments '%s'", optarg );
goto err_out;
}
opt_alloc = 1;
break;
}
case OPT_PID:
{
char *end;
opt_pid = (int)strtol( optarg, &end, 10 );
if (end == optarg)
{
vcos_log_info( "Invalid arguments '%s'", optarg );
goto err_out;
}
break;
}
case OPT_STATUS:
{
char status_str[32];
/* coverity[secure_coding] String length specified, so can't overflow */
if ( sscanf( optarg, "%31s", status_str ) != 1 )
{
vcos_log_info( "Invalid arguments '%s'", optarg );
goto err_out;
}
if ( vcos_strcasecmp( status_str, "all" ) == 0 )
{
status_mode = VCSM_STATUS_VC_MAP_ALL;
}
else if ( vcos_strcasecmp( status_str, "vc" ) == 0 )
{
status_mode = VCSM_STATUS_VC_WALK_ALLOC;
}
else if ( vcos_strcasecmp( status_str, "map" ) == 0 )
{
status_mode = VCSM_STATUS_HOST_WALK_MAP;
}
else if ( vcos_strcasecmp( status_str, "host" ) == 0 )
{
status_mode = VCSM_STATUS_HOST_WALK_PID_ALLOC;
}
else
{
goto err_out;
}
opt_status = 1;
break;
}
default:
{
vcos_log_info( "Unrecognized option '%d'", opt );
goto err_usage;
}
case '?':
case OPT_HELP:
{
goto err_usage;
}
} // end switch
} // end while
argc -= optind;
argv += optind;
if (( optind == 1 ) || ( argc > 0 ))
{
if ( argc > 0 )
{
vcos_log_info( "Unrecognized argument -- '%s'", *argv );
}
goto err_usage;
}
// Start the shared memory support.
if ( vcsm_init() == -1 )
{
vcos_log_info( "Cannot initialize smem device" );
goto err_out;
}
if ( opt_alloc == 1 )
{
vcos_log_info( "Allocating 2 times %u-bytes in shared memory", alloc_size );
usr_hdl_1 = vcsm_malloc( alloc_size,
"smem-test-alloc" );
vcos_log_info( "Allocation 1 result: user %x, vc-hdl %x",
usr_hdl_1, vcsm_vc_hdl_from_hdl( usr_hdl_1 ) );
#if defined(DOUBLE_ALLOC) || defined(RESIZE_ALLOC)
usr_hdl_2 = vcsm_malloc( alloc_size,
NULL );
vcos_log_info( "Allocation 2 result: user %x",
usr_hdl_2 );
usr_ptr_2 = vcsm_lock( usr_hdl_2 );
vcos_log_info( "Allocation 2 : lock %p",
usr_ptr_2 );
vcos_log_info( "Allocation 2 : unlock %d",
vcsm_unlock_hdl( usr_hdl_2 ) );
#endif
// Do a simple write/read test.
if ( usr_hdl_1 != 0 )
{
usr_ptr_1 = vcsm_lock( usr_hdl_1 );
vcos_log_info( "Allocation 1 : lock %p",
usr_ptr_1 );
if ( usr_ptr_1 )
{
memset ( usr_ptr_1,
0,
alloc_size );
memcpy ( usr_ptr_1,
blah_blah,
32 );
vcos_log_info( "Allocation 1 contains: \"%s\"",
(char *)usr_ptr_1 );
vcos_log_info( "Allocation 1: vc-hdl %x",
vcsm_vc_hdl_from_ptr ( usr_ptr_1 ) );
vcos_log_info( "Allocation 1: usr-hdl %x",
vcsm_usr_handle ( usr_ptr_1 ) );
vcos_log_info( "Allocation 1 : unlock %d",
vcsm_unlock_ptr( usr_ptr_1 ) );
}
usr_ptr_1 = vcsm_lock( usr_hdl_1 );
vcos_log_info( "Allocation 1 (relock) : lock %p",
usr_ptr_1 );
if ( usr_ptr_1 )
{
vcos_log_info( "Allocation 1 (relock) : unlock %d",
vcsm_unlock_hdl( usr_hdl_1 ) );
}
}
#if defined(RESIZE_ALLOC)
ret = vcsm_resize( usr_hdl_1, 2 * alloc_size );
vcos_log_info( "Allocation 1 : resize %d", ret );
if ( ret == 0 )
{
usr_ptr_1 = vcsm_lock( usr_hdl_1 );
vcos_log_info( "Allocation 1 (resize) : lock %p",
usr_ptr_1 );
if ( usr_ptr_1 )
{
memset ( usr_ptr_1,
0,
2 * alloc_size );
memcpy ( usr_ptr_1,
blah_blah,
32 );
vcos_log_info( "Allocation 1 (resized) contains: \"%s\"",
(char *)usr_ptr_1 );
vcos_log_info( "Allocation 1 (resized) : unlock %d",
vcsm_unlock_ptr( usr_ptr_1 ) );
}
}
// This checks that the memory can be remapped properly
// because the Block 1 expanded beyond Block 2 boundary.
//
usr_ptr_2 = vcsm_lock( usr_hdl_2 );
vcos_log_info( "Allocation 2 : lock %p",
usr_ptr_2 );
vcos_log_info( "Allocation 2 : unlock %d",
vcsm_unlock_hdl( usr_hdl_2 ) );
// This checks that we can free a memory block even if it
// is locked, which could be the case if the application
// dies.
//
usr_ptr_2 = vcsm_lock( usr_hdl_2 );
vcos_log_info( "Allocation 2 : lock %p",
usr_ptr_2 );
vcsm_free ( usr_hdl_2 );
#endif
#if defined(DOUBLE_ALLOC)
#endif
}
if ( opt_status == 1 )
{
get_status( status_mode, opt_pid );
}
// If we allocated something, wait for the signal to exit to give chance for the
// user to poke around the allocation test.
//
if ( opt_alloc == 1 )
{
start_monitor();
vcos_event_wait( &quit_event );
vcos_event_delete( &quit_event );
}
// Terminate the shared memory support.
vcsm_exit ();
goto err_out;
err_usage:
show_usage();
err_out:
exit( 1 );
}
