/*
* ======== NameServerDrv_ioctl ========
*
*/
static long NameServerDrv_ioctl(struct file *filp, unsigned int cmd,
unsigned long args)
{
int osStatus = 0;
Int32 status = NameServer_S_SUCCESS;
Int32 ret;
NameServerDrv_CmdArgs cargs;
Osal_Pid pid;
GT_3trace(curTrace, GT_ENTER, "NameServerDrv_ioctl", filp, cmd, args);
/* save the process id for resource tracking */
pid = pid_nr(filp->f_owner.pid);
/* copy the full args from user space */
ret = copy_from_user(&cargs, (Ptr)args, sizeof(NameServerDrv_CmdArgs));
GT_assert(curTrace, (ret == 0));
switch (cmd) {
case CMD_NAMESERVER_ADD: {
NameServerDrv_Res * res = NULL;
Ptr buf;
/* allocate resource tracker object */
res = Memory_alloc(NULL, sizeof(NameServerDrv_Res), 0, NULL);
if (res == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
/* allocate memory for the name */
if (status == NameServer_S_SUCCESS) {
res->args.add.len = cargs.args.add.nameLen;
res->args.add.name = Memory_alloc(NULL,
cargs.args.add.nameLen, 0, NULL);
if (res->args.add.name == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
}
/* copy the name from user memory */
if (status == NameServer_S_SUCCESS) {
status = copy_from_user(res->args.add.name,
cargs.args.add.name, cargs.args.add.nameLen);
if (status != 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"copy_from_user failed");
status = NameServer_E_OSFAILURE;
osStatus = -EFAULT;
}
}
/* allocate memory for the buf */
if (status == NameServer_S_SUCCESS) {
buf = Memory_alloc(NULL, cargs.args.add.len, 0, NULL);
if (buf == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
}
/* copy the value from user buf */
if (status == NameServer_S_SUCCESS) {
status = copy_from_user(buf, cargs.args.add.buf,
cargs.args.add.len);
if (status != 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"copy_from_user failed");
status = NameServer_E_OSFAILURE;
osStatus = -EFAULT;
}
}
/* invoke the module api */
if (status == NameServer_S_SUCCESS) {
cargs.args.add.entry = NameServer_add(cargs.args.add.handle,
res->args.add.name, buf, cargs.args.add.len);
if (cargs.args.addUInt32.entry == NULL) {
status = NameServer_E_FAIL;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"NameServer_addUInt32 failed");
}
}
/* track the resource by process id */
if (status == NameServer_S_SUCCESS) {
Int rstat;
res->cmd = CMD_NAMESERVER_ADD; /* use this command for both */
res->args.add.handle = cargs.args.add.handle;
res->args.add.entry = cargs.args.add.entry;
rstat = ResTrack_push(NameServerDrv_state.resTrack, pid,
(List_Elem *)res);
GT_assert(curTrace, (rstat >= 0));
}
/* don't need the buf memory anymore */
if (buf != NULL) {
Memory_free(NULL, buf, cargs.args.add.len);
}
/* failure cleanup */
if (status < 0) {
if ((res != NULL) && (res->args.add.name != NULL)) {
Memory_free(NULL, res->args.add.name,
cargs.args.add.nameLen);
}
if (res != NULL) {
Memory_free(NULL, res, sizeof(NameServerDrv_Res));
}
}
}
break;
case CMD_NAMESERVER_ADDUINT32: {
NameServerDrv_Res * res = NULL;
/* allocate resource tracker object */
res = Memory_alloc(NULL, sizeof(NameServerDrv_Res), 0, NULL);
if (res == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
/* allocate memory for the name */
if (status == NameServer_S_SUCCESS) {
res->args.add.len = cargs.args.addUInt32.nameLen;
res->args.add.name = Memory_alloc(NULL,
cargs.args.addUInt32.nameLen, 0, NULL);
if (res->args.add.name == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
}
/* copy the name from user memory */
if (status == NameServer_S_SUCCESS) {
status = copy_from_user(res->args.add.name,
cargs.args.addUInt32.name,
cargs.args.addUInt32.nameLen);
if (status != 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"copy_from_user failed");
status = NameServer_E_OSFAILURE;
osStatus = -EFAULT;
}
}
/* invoke the module api */
if (status == NameServer_S_SUCCESS) {
cargs.args.addUInt32.entry = NameServer_addUInt32(
cargs.args.addUInt32.handle, res->args.add.name,
cargs.args.addUInt32.value);
if (cargs.args.addUInt32.entry == NULL) {
status = NameServer_E_FAIL;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"NameServer_addUInt32 failed");
}
}
/* track the resource by process id */
if (status == NameServer_S_SUCCESS) {
Int rstat;
res->cmd = CMD_NAMESERVER_ADD; /* use this command for both */
res->args.add.handle = cargs.args.addUInt32.handle;
res->args.add.entry = cargs.args.addUInt32.entry;
rstat = ResTrack_push(NameServerDrv_state.resTrack, pid,
(List_Elem *)res);
GT_assert(curTrace, (rstat >= 0));
}
/* failure cleanup */
if (status < 0) {
if ((res != NULL) && (res->args.add.name != NULL)) {
Memory_free(NULL, res->args.add.name,
cargs.args.addUInt32.nameLen);
}
if (res != NULL) {
Memory_free(NULL, res, sizeof(NameServerDrv_Res));
}
}
}
break;
case CMD_NAMESERVER_GET:
{
String name;
Ptr value;
UInt16 * procId = NULL;
/* Allocate memory for the name */
name = Memory_alloc (NULL, cargs.args.get.nameLen, 0, NULL);
GT_assert (curTrace, (name != NULL));
/* Copy the name */
ret = copy_from_user (name,
cargs.args.get.name,
cargs.args.get.nameLen);
GT_assert (curTrace, (ret == 0));
/* Allocate memory for the buf */
value = Memory_alloc (NULL, cargs.args.get.len, 0, NULL);
GT_assert (curTrace, (value != NULL));
/* Allocate memory for the procId */
if (cargs.args.get.procLen > 0) {
procId = Memory_alloc (NULL,
cargs.args.get.procLen * sizeof(UInt16),
0,
NULL);
GT_assert (curTrace, (procId != NULL));
}
/* Copy the procIds */
ret = copy_from_user (procId,
cargs.args.get.procId,
cargs.args.get.procLen);
GT_assert (curTrace, (ret == 0));
status = NameServer_get (cargs.args.get.handle,
name,
value,
&cargs.args.get.len,
procId);
/* Do not assert. This can return NameServer_E_NOTFOUND
* as a valid runtime failure.
*/
/* Copy the value */
ret = copy_to_user (cargs.args.get.value,
value,
cargs.args.get.len);
GT_assert (curTrace, (ret == 0));
/* free the allocated memory */
Memory_free (NULL, name, cargs.args.get.nameLen);
Memory_free (NULL, value, cargs.args.get.len);
if (procId != NULL) {
Memory_free (NULL,
procId,
cargs.args.get.procLen *sizeof(UInt16));
}
}
break;
case CMD_NAMESERVER_GETLOCAL:
{
String name;
Ptr value;
/* Allocate memory for the name */
name = Memory_alloc (NULL, cargs.args.getLocal.nameLen, 0, NULL);
GT_assert (curTrace, (name != NULL));
/* Copy the name */
ret = copy_from_user (name,
cargs.args.getLocal.name,
cargs.args.getLocal.nameLen);
GT_assert (curTrace, (ret == 0));
/* Allocate memory for the buf */
value = Memory_alloc (NULL, cargs.args.getLocal.len, 0, NULL);
GT_assert (curTrace, (value != NULL));
status = NameServer_getLocal (cargs.args.getLocal.handle,
name,
value,
&cargs.args.getLocal.len);
GT_assert (curTrace, (status >= 0));
/* Copy the value */
ret = copy_to_user (cargs.args.getLocal.value,
value,
cargs.args.getLocal.len);
GT_assert (curTrace, (ret == 0));
/* free the allocated memory */
Memory_free (NULL, name, cargs.args.getLocal.nameLen);
Memory_free (NULL, value, cargs.args.getLocal.len);
}
break;
case CMD_NAMESERVER_MATCH:
{
String name;
/* Allocate memory for the name */
name = Memory_alloc (NULL, cargs.args.match.nameLen, 0, NULL);
GT_assert (curTrace, (name != NULL));
/* Copy the name */
ret = copy_from_user (name,
cargs.args.match.name,
cargs.args.match.nameLen);
GT_assert (curTrace, (ret == 0));
cargs.args.match.count = NameServer_match (
cargs.args.match.handle,
name,
&cargs.args.match.value);
GT_assert (curTrace, (cargs.args.match.count >= 0));
/* free the allocated memory */
Memory_free (NULL, name, cargs.args.match.nameLen);
}
break;
case CMD_NAMESERVER_REMOVE: {
NameServerDrv_Res res;
List_Elem * elem;
/* save for resource untracking */
res.cmd = CMD_NAMESERVER_ADD;
res.args.add.entry = NULL;
/* allocate memory for the name */
res.args.add.len = cargs.args.remove.nameLen;
res.args.add.name = Memory_alloc(NULL,
cargs.args.remove.nameLen, 0, NULL);
if (res.args.add.name == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
/* copy the name from user memory */
if (status == NameServer_S_SUCCESS) {
status = copy_from_user(res.args.add.name,
cargs.args.remove.name, cargs.args.remove.nameLen);
if (status != 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"copy_from_user failed");
status = NameServer_E_OSFAILURE;
osStatus = -EFAULT;
}
}
/* invoke the module api */
if (status == NameServer_S_SUCCESS) {
status = NameServer_remove(cargs.args.remove.handle,
res.args.add.name);
if (status < 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"NameServer_remove failed");
}
}
/* untrack the resource */
if (status == NameServer_S_SUCCESS) {
NameServerDrv_Res * resPtr;
ResTrack_remove(NameServerDrv_state.resTrack, pid,
(List_Elem *)(&res), NameServerDrv_resCmpFxn, &elem);
GT_assert(curTrace, (elem != NULL));
resPtr = (NameServerDrv_Res *)elem;
Memory_free(NULL, resPtr->args.add.name, resPtr->args.add.len);
Memory_free(NULL, elem, sizeof(NameServerDrv_Res));
}
/* don't need the name memory anymore */
if (res.args.add.name != NULL) {
Memory_free(NULL, res.args.add.name,
cargs.args.remove.nameLen);
}
}
break;
case CMD_NAMESERVER_REMOVEENTRY: {
NameServerDrv_Res res;
List_Elem * elem;
/* save for resource untracking */
res.cmd = CMD_NAMESERVER_ADD;
res.args.add.name = NULL;
res.args.add.entry = cargs.args.removeEntry.entry;
/* invoke the module api */
status = NameServer_removeEntry(cargs.args.removeEntry.handle,
cargs.args.removeEntry.entry);
if (status < 0) {
GT_setFailureReason(curTrace, GT_4CLASS, "NameServerDrv_ioctl",
status, "NameServer_remove failed");
}
/* untrack the resource */
if (status == NameServer_S_SUCCESS) {
NameServerDrv_Res * resPtr;
ResTrack_remove(NameServerDrv_state.resTrack, pid,
(List_Elem *)(&res), NameServerDrv_resCmpFxn, &elem);
GT_assert(curTrace, (elem != NULL));
resPtr = (NameServerDrv_Res *)elem;
Memory_free(NULL, resPtr->args.add.name, resPtr->args.add.len);
Memory_free(NULL, elem, sizeof(NameServerDrv_Res));
}
}
break;
case CMD_NAMESERVER_PARAMS_INIT:
{
NameServer_Params params;
NameServer_Params_init (¶ms);
ret = copy_to_user (cargs.args.ParamsInit.params,
¶ms,
sizeof (NameServer_Params));
GT_assert (curTrace, (ret == 0));
}
break;
case CMD_NAMESERVER_CREATE: {
NameServer_Params params;
String name = NULL;
NameServerDrv_Res * res = NULL;
/* allocate memory for the name */
name = Memory_alloc(NULL, cargs.args.create.nameLen, 0, NULL);
if (name == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
/* copy the name from user memory */
if (status == NameServer_S_SUCCESS) {
status = copy_from_user(name, cargs.args.create.name,
cargs.args.create.nameLen);
if (status != 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"copy_from_user failed");
status = NameServer_E_OSFAILURE;
osStatus = -EFAULT;
}
}
/* copy the params from user memory */
if (status == NameServer_S_SUCCESS) {
status = copy_from_user(¶ms, cargs.args.create.params,
sizeof(NameServer_Params));
if (status != 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"copy_from_user failed");
status = NameServer_E_OSFAILURE;
osStatus = -EFAULT;
}
}
/* allocate resource tracker object */
if (status == NameServer_S_SUCCESS) {
res = Memory_alloc(NULL, sizeof(NameServerDrv_Res), 0, NULL);
if (res == NULL) {
status = NameServer_E_MEMORY;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status, "out of memory");
}
}
/* invoke the module api */
if (status == NameServer_S_SUCCESS) {
cargs.args.create.handle = NameServer_create(name, ¶ms);
if (cargs.args.create.handle == NULL) {
status = NameServer_E_FAIL;
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"NameServer_create failed");
}
}
/* track the resource by process id */
if (status == NameServer_S_SUCCESS) {
Int rstat;
res->cmd = cmd;
res->args.create.handle = cargs.args.create.handle;
rstat = ResTrack_push(NameServerDrv_state.resTrack, pid,
(List_Elem *)res);
GT_assert(curTrace, (rstat >= 0));
}
/* don't need name memory anymore */
if (name != NULL) {
Memory_free(NULL, name, cargs.args.create.nameLen);
}
/* failure cleanup */
if (status < 0) {
if (res != NULL) {
Memory_free(NULL, res, sizeof(NameServerDrv_Res));
}
}
}
break;
case CMD_NAMESERVER_DELETE: {
NameServerDrv_Res res;
List_Elem * elem;
/* save for resource untracking, handle set to null by delete */
res.cmd = CMD_NAMESERVER_CREATE;
res.args.create.handle = cargs.args.delete.handle;
/* common code for delete command */
status = NameServerDrv_cmd_delete(&cargs.args.delete.handle);
/* untrack the resource */
if (status == NameServer_S_SUCCESS) {
ResTrack_remove(NameServerDrv_state.resTrack, pid,
(List_Elem *)(&res), NameServerDrv_resCmpFxn, &elem);
GT_assert(curTrace, (elem != NULL));
Memory_free(NULL, elem, sizeof(NameServerDrv_Res));
}
}
break;
case CMD_NAMESERVER_GETHANDLE:
{
String name;
/* Allocate memory for the name */
name = Memory_alloc (NULL, cargs.args.getHandle.nameLen, 0, NULL);
GT_assert (curTrace, (name != NULL));
/* Copy the name */
ret = copy_from_user (name,
cargs.args.getHandle.name,
cargs.args.getHandle.nameLen);
GT_assert (curTrace, (ret == 0));
cargs.args.getHandle.handle = NameServer_getHandle (name);
/* free the allocated memory */
Memory_free (NULL, name, cargs.args.getHandle.nameLen);
}
break;
case CMD_NAMESERVER_SETUP: {
/* register process with resource tracker */
status = ResTrack_register(NameServerDrv_state.resTrack, pid);
if (status < 0) {
GT_setFailureReason(curTrace, GT_4CLASS, "NameServerDrv_ioctl",
status, "resource tracker register failed");
status = NameServer_E_FAIL;
pid = 0;
}
/* setup the module */
if (status == NameServer_S_SUCCESS) {
status = NameServer_setup();
if (status < 0) {
GT_setFailureReason(curTrace, GT_4CLASS,
"NameServerDrv_ioctl", status,
"kernel-side MessageQ_setup failed");
}
}
/* failure case */
if (status < 0) {
if (pid != 0) {
ResTrack_unregister(NameServerDrv_state.resTrack, pid);
}
}
}
break;
case CMD_NAMESERVER_DESTROY: {
/* unregister process from resource tracker */
status = ResTrack_unregister(NameServerDrv_state.resTrack, pid);
GT_assert(curTrace, (status >= 0));
/* finalize the module */
status = NameServer_destroy();
GT_assert(curTrace, (status >= 0));
}
break;
default:
{
/* This does not impact return status of this function, so retVal
* comment is not used.
*/
status = NameServer_E_INVALIDARG;
GT_setFailureReason (curTrace,
GT_4CLASS,
"NameServerDrv_ioctl",
status,
"Unsupported ioctl command specified");
}
break;
}
cargs.apiStatus = status;
/* copy the full args back to user space */
ret = copy_to_user((Ptr)args, &cargs, sizeof(NameServerDrv_CmdArgs));
GT_assert (curTrace, (ret == 0));
GT_1trace (curTrace, GT_LEAVE, "NameServerDrv_ioctl", osStatus);
/*! @retval 0 Operation successfully completed. */
return osStatus;
}
/*
* ======== Stream_add ========
*/
Void Stream_add(String name, IConverter_Handle handle, Error_Block *eb)
{
NameServer_addUInt32((NameServer_Handle)Stream_module->convTable, name,
(UInt32)handle);
}
/*!
* ======== DriverTable_add ========
*/
Void DriverTable_add(String name, IDriver_Handle handle, Error_Block *eb)
{
NameServer_addUInt32((NameServer_Handle)DriverTable_module->drvTable, name,
(UInt32)handle);
}
/** ============================================================================
* Globals
* ============================================================================
*/
Int nameLenTest()
{
NameServer_Params params;
NameServer_Handle nsHandle;
Int32 status = 0;
UInt32 val;
Log_print0(Diags_INFO, "Testing long names...\n");
#if 0 /* Commented out due to assertion thrown when name length > maxNameLen */
NameServer_Params_init(¶ms);
params.maxValueLen = sizeof(UInt32);
params.maxNameLen = 32;
nsHandle = NameServer_create(NSLONGNAME, ¶ms);
if (nsHandle == NULL) {
Log_print1(Diags_INFO, "Failed to create NameServer '%s'\n",
(IArg)NSLONGNAME);
return -1;
}
else {
printf("Created NameServer '%s'\n", NSLONGNAME);
}
/* This name should be too long for creation params and results in error */
printf("Trying to add a name that exceeds maxNameLen...\n");
ptr = NameServer_addUInt32(nsHandle, NSLONGNAME, 0xdeadbeef);
if (ptr == NULL) {
Log_print0(Diags_INFO,
" ...got expected Failure from NameServer_addUInt32()\n");
}
else {
Log_print1(Diags_INFO,
" Error: NameServer_addUInt32() returned non-NULL %p (but "
"was expected to fail)\n", (IArg)ptr);
NameServer_delete(&nsHandle);
return -1;
}
Log_print0(Diags_INFO, "Deleting nsHandle...\n");
NameServer_delete(&nsHandle);
#endif
NameServer_Params_init(¶ms);
params.maxValueLen = sizeof(UInt32);
params.maxNameLen = 180;
nsHandle = NameServer_create(NSNAME, ¶ms);
if (nsHandle == NULL) {
Log_print1(Diags_INFO, "Failed to create NameServer '%s'\n",
(IArg)NSNAME);
return -1;
}
else {
Log_print1(Diags_INFO, "Created NameServer '%s'\n", (IArg)NSNAME);
}
/* This name is too long for remote to handle and results in error */
Log_print0(Diags_INFO,
"Trying to get a name that the remote cannot handle...\n");
val = 0x00c0ffee;
status = NameServer_getUInt32(nsHandle, NSLONGNAME, &val, NULL);
if (status == NameServer_E_NAMETOOLONG) {
Log_print0(Diags_INFO,
" ...got expected Failure from NameServer_getUInt32()\n");
}
else {
Log_print1(Diags_INFO,
" Error: NameServer_getUint32() returned unexpected "
"result: %d\n", (IArg)status);
return -1;
}
Log_print0(Diags_INFO, "Deleting nsHandle...\n");
NameServer_delete(&nsHandle);
NameServer_Params_init(¶ms);
params.maxValueLen = sizeof(UInt32);
params.maxNameLen = 32;
nsHandle = NameServer_create(NSLONGNAME, ¶ms);
if (nsHandle == NULL) {
Log_print1(Diags_INFO, "Failed to create NameServer '%s'\n",
(IArg)NSLONGNAME);
return -1;
}
else {
Log_print1(Diags_INFO, "Created NameServer '%s'\n", (IArg)NSLONGNAME);
}
/* The instance name is too long for remote and results in error */
Log_print0(Diags_INFO,
"Trying to use an instance name that the remote cannot handle...\n");
val = 0x00c0ffee;
status = NameServer_getUInt32(nsHandle, "Key", &val, NULL);
if (status == NameServer_E_NAMETOOLONG) {
Log_print0(Diags_INFO,
" ...got expected Failure from NameServer_getUInt32()\n");
}
else {
Log_print1(Diags_INFO,
" Error: NameServer_getUint32() returned unexpected "
"result: %d\n", (IArg)status);
return -1;
}
Log_print0(Diags_INFO, "Deleting nsHandle...\n");
NameServer_delete(&nsHandle);
return 0;
}
Int testNS(NameServer_Handle nsHandle, String name)
{
Int32 status = 0;
Ptr ptr;
UInt32 val;
char key[16];
Int i;
ptr = NameServer_addUInt32(nsHandle, name, 0xdeadbeef);
if (ptr == NULL) {
Log_print0(Diags_INFO, "Failed to NameServer_addUInt32()\n");
return -1;
}
else {
Log_print1(Diags_INFO, "NameServer_addUInt32() returned %p\n", (IArg)ptr);
}
Log_print0(Diags_INFO, "Trying to add same key (should fail)...\n");
ptr = NameServer_addUInt32(nsHandle, name, 0xdeadc0de);
if (ptr == NULL) {
Log_print0(Diags_INFO, " ...got expected Failure from NameServer_addUInt32()\n");
}
else {
Log_print1(Diags_INFO, " Error: NameServer_addUInt32() returned non-NULL %p (but was expected to fail)\n", (IArg)ptr);
return -1;
}
val = 0x00c0ffee;
status = NameServer_getUInt32(nsHandle, name, &val, NULL);
Log_print2(Diags_INFO, "NameServer_getUInt32() returned %d, val=0x%x (was 0x00c0ffee)\n", status, val);
Log_print0(Diags_INFO, "Removing 0xdeadbeef w/ NameServer_remove()...\n");
status = NameServer_remove(nsHandle, name);
if (status < 0) {
Log_print1(Diags_INFO, "NameServer_remove() failed: %d\n", status);
return -1;
}
ptr = NameServer_addUInt32(nsHandle, name, 0xdeadc0de);
if (ptr == NULL) {
Log_print0(Diags_INFO, "Error: NameServer_addUInt32() failed\n");
return -1;
}
else {
Log_print0(Diags_INFO, "NameServer_addUInt32(0xdeadc0de) succeeded\n");
}
val = 0x00c0ffee;
status = NameServer_getUInt32(nsHandle, name, &val, NULL);
Log_print2(Diags_INFO, "NameServer_getUInt32() returned %d, val=0x%x (was 0x00c0ffee)\n", status, val);
Log_print0(Diags_INFO, "Removing 0xdeadc0de w/ NameServer_removeEntry()...\n");
status = NameServer_removeEntry(nsHandle, ptr);
if (status < 0) {
Log_print1(Diags_INFO, "NameServer_remove() failed: %d\n", status);
return -1;
}
ptr = NameServer_addUInt32(nsHandle, name, 0x0badc0de);
if (ptr == NULL) {
Log_print0(Diags_INFO, "Error: NameServer_addUInt32() failed\n");
return -1;
}
else {
Log_print0(Diags_INFO, "NameServer_addUInt32(0x0badc0de) succeeded\n");
}
val = 0x00c0ffee;
status = NameServer_getUInt32(nsHandle, name, &val, NULL);
Log_print2(Diags_INFO, "NameServer_getUInt32() returned %d, val=0x%x (was 0x00c0ffee)\n", status, val);
status = NameServer_remove(nsHandle, name);
if (status < 0) {
Log_print0(Diags_INFO, "Error: NameServer_remove() failed\n");
return -1;
}
else {
Log_print1(Diags_INFO, "NameServer_remove(%s) succeeded\n", (IArg)name);
}
for (i = 0; i < 10; i++) {
sprintf(key, "foobar%d", i);
ptr = NameServer_addUInt32(nsHandle, key, 0x0badc0de + i);
if (ptr == NULL) {
Log_print0(Diags_INFO, "Error: NameServer_addUInt32() failed\n");
return -1;
}
else {
Log_print2(Diags_INFO, "NameServer_addUInt32(%s, 0x%x) succeeded\n", (IArg)key, 0x0badc0de + i);
}
val = 0x00c0ffee;
status = NameServer_getUInt32(nsHandle, key, &val, NULL);
Log_print3(Diags_INFO, "NameServer_getUInt32(%s) returned %d, val=0x%x (was 0x00c0ffee)\n", (IArg)key, status, val);
if (val != (0x0badc0de + i)) {
Log_print2(Diags_INFO, "get val (0x%x) != add val (0x%x)!\n", val, 0x0badc0de + i);
}
}
for (i = 0; i < 10; i++) {
sprintf(key, "foobar%d", i);
status = NameServer_remove(nsHandle, key);
if (status < 0) {
Log_print0(Diags_INFO, "Error: NameServer_remove() failed\n");
return -1;
}
else {
Log_print1(Diags_INFO, "NameServer_remove(%s) succeeded\n", (IArg)key);
}
}
return 0;
}
/*
* ======== MessageQ_Instance_init ========
*/
Int ti_sdo_ipc_MessageQ_Instance_init(ti_sdo_ipc_MessageQ_Object *obj, String name,
const ti_sdo_ipc_MessageQ_Params *params, Error_Block *eb)
{
Int i;
UInt16 start;
UInt16 count;
UInt key;
Bool found = FALSE;
List_Handle listHandle;
SyncSem_Handle syncSemHandle;
MessageQ_QueueIndex queueIndex;
/* lock */
key = IGateProvider_enter(MessageQ_module->gate);
start = ti_sdo_ipc_MessageQ_Object_count();
count = MessageQ_module->numQueues;
/* Search the dynamic array for any holes */
for (i = start; (i < count) && (found == FALSE); i++) {
if (MessageQ_module->queues[i] == NULL) {
MessageQ_module->queues[i] = obj;
queueIndex = i;
found = TRUE;
}
}
/*
* If no free slot was found:
* - if no growth allowed, raise and error
* - if growth is allowed, grow the array
*/
if (found == FALSE) {
if (ti_sdo_ipc_MessageQ_maxRuntimeEntries != NameServer_ALLOWGROWTH) {
/* unlock scheduler */
IGateProvider_leave(MessageQ_module->gate, key);
Error_raise(eb, ti_sdo_ipc_MessageQ_E_maxReached,
ti_sdo_ipc_MessageQ_maxRuntimeEntries, 0);
return (1);
}
else {
queueIndex = MessageQ_grow(obj, eb);
if (queueIndex == MessageQ_INVALIDMESSAGEQ) {
/* unlock scheduler */
IGateProvider_leave(MessageQ_module->gate, key);
return (2);
}
}
}
/* create default sync if not specified */
if (params->synchronizer == NULL) {
/* Create a SyncSem as the synchronizer */
syncSemHandle = SyncSem_create(NULL, eb);
if (syncSemHandle == NULL) {
/* unlock scheduler */
IGateProvider_leave(MessageQ_module->gate, key);
return (3);
}
/* store handle for use in finalize ... */
obj->syncSemHandle = syncSemHandle;
obj->synchronizer = SyncSem_Handle_upCast(syncSemHandle);
}
else {
obj->syncSemHandle = NULL;
obj->synchronizer = params->synchronizer;
}
/* unlock scheduler */
IGateProvider_leave(MessageQ_module->gate, key);
/* Fill in the message queue object */
listHandle = ti_sdo_ipc_MessageQ_Instance_State_normalList(obj);
List_construct(List_struct(listHandle), NULL);
listHandle = ti_sdo_ipc_MessageQ_Instance_State_highList(obj);
List_construct(List_struct(listHandle), NULL);
obj->queue = ((MessageQ_QueueId)(MultiProc_self()) << 16) | queueIndex;
obj->unblocked = FALSE;
/* Add into NameServer */
if (name != NULL) {
obj->nsKey = NameServer_addUInt32(
(NameServer_Handle)MessageQ_module->nameServer, name,
obj->queue);
if (obj->nsKey == NULL) {
Error_raise(eb, ti_sdo_ipc_MessageQ_E_nameFailed, name, 0);
return (4);
}
}
return (0);
}
/*
* ======== ti_sdo_ipc_ListMP_Instance_init ========
*/
Int ti_sdo_ipc_ListMP_Instance_init(ti_sdo_ipc_ListMP_Object *obj,
const ti_sdo_ipc_ListMP_Params *params,
Error_Block *eb)
{
SharedRegion_SRPtr sharedShmBase;
Ptr localAddr;
Int status;
ListMP_Params sparams;
IHeap_Handle regionHeap;
if (params->openFlag == TRUE) {
/* Open by sharedAddr */
obj->objType = ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC;
obj->attrs = (ti_sdo_ipc_ListMP_Attrs *)params->sharedAddr;
obj->regionId = SharedRegion_getId(&(obj->attrs->head));
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
obj->cacheLineSize = SharedRegion_getCacheLineSize(obj->regionId);
/* get the local address of the SRPtr */
localAddr = SharedRegion_getPtr(obj->attrs->gateMPAddr);
status = GateMP_openByAddr(localAddr, (GateMP_Handle *)&(obj->gate));
if (status != GateMP_S_SUCCESS) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_internal, 0, 0);
return (1);
}
return (0);
}
/* init the gate */
if (params->gate != NULL) {
obj->gate = params->gate;
}
else {
obj->gate = (ti_sdo_ipc_GateMP_Handle)GateMP_getDefaultRemote();
}
if (params->sharedAddr == NULL) {
/* Creating using a shared region ID */
obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC_REGION;
obj->regionId = params->regionId;
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
obj->cacheLineSize = SharedRegion_getCacheLineSize(obj->regionId);
/* Need to allocate from the heap */
ListMP_Params_init(&sparams);
sparams.regionId = params->regionId;
obj->allocSize = ListMP_sharedMemReq(&sparams);
regionHeap = SharedRegion_getHeap(obj->regionId);
Assert_isTrue(regionHeap != NULL, ti_sdo_ipc_SharedRegion_A_noHeap);
/* The region heap will take care of the alignment */
obj->attrs = Memory_alloc(regionHeap, obj->allocSize, 0, eb);
if (obj->attrs == NULL) {
return (2);
}
}
else {
/* Creating using sharedAddr */
obj->regionId = SharedRegion_getId(params->sharedAddr);
/* Assert that the buffer is in a valid shared region */
Assert_isTrue(obj->regionId != SharedRegion_INVALIDREGIONID,
ti_sdo_ipc_Ipc_A_addrNotInSharedRegion);
/* set object's cacheEnabled, objType, and attrs */
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
obj->cacheLineSize = SharedRegion_getCacheLineSize(obj->regionId);
obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC;
obj->attrs = (ti_sdo_ipc_ListMP_Attrs *)params->sharedAddr;
/* Assert that sharedAddr is cache aligned */
Assert_isTrue((obj->cacheLineSize == 0) ||
((UInt32)params->sharedAddr % obj->cacheLineSize == 0),
ti_sdo_ipc_Ipc_A_addrNotCacheAligned);
}
/* init the head (to be empty) */
ListMP_elemClear(&(obj->attrs->head));
/* store the GateMP sharedAddr in the Attrs */
obj->attrs->gateMPAddr = ti_sdo_ipc_GateMP_getSharedAddr(obj->gate);
/* last thing, set the status */
obj->attrs->status = ti_sdo_ipc_ListMP_CREATED;
if (obj->cacheEnabled) {
Cache_wbInv(obj->attrs, sizeof(ti_sdo_ipc_ListMP_Attrs),
Cache_Type_ALL, TRUE);
}
/* add to NameServer if name not NULL */
if (params->name != NULL) {
sharedShmBase = SharedRegion_getSRPtr(obj->attrs, obj->regionId);
obj->nsKey = NameServer_addUInt32(
(NameServer_Handle)ListMP_module->nameServer, params->name,
(UInt32)sharedShmBase);
if (obj->nsKey == NULL) {
Error_raise(eb, ti_sdo_ipc_Ipc_E_nameFailed, params->name, 0);
return (3);
}
}
return (0);
}
/*
* ======== SemaphoreMP_Instance_init ========
*/
Int SemaphoreMP_Instance_init(SemaphoreMP_Object *obj, Int count,
const SemaphoreMP_Params *params, Error_Block *eb)
{
Ptr localAddr;
Int status;
IHeap_Handle regionHeap;
ListMP_Params listMPParams;
SharedRegion_SRPtr sharedShmBase;
if (params->openFlag) {
/* Open by sharedAddr */
obj->objType = ti_sdo_ipc_Ipc_ObjType_OPENDYNAMIC;
obj->attrs = (SemaphoreMP_Attrs *)params->sharedAddr;
obj->regionId = SharedRegion_getId(obj->attrs);
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
obj->mode = (SemaphoreMP_Mode)obj->attrs->mode;
regionHeap = SharedRegion_getHeap(obj->regionId);
Assert_isTrue(regionHeap != NULL, ti_sdo_ipc_SharedRegion_A_noHeap);
/* get the local address of the SRPtr */
localAddr = SharedRegion_getPtr(obj->attrs->gateMPAddr);
status = GateMP_openByAddr(localAddr, (GateMP_Handle *)&(obj->gate));
if (status < 0) {
return (1);
}
/* Open the ListMP */
localAddr = (Ptr)_Ipc_roundup(
(UInt32)obj->attrs + sizeof(SemaphoreMP_Attrs),
SharedRegion_getCacheLineSize(obj->regionId));
status = ListMP_openByAddr(localAddr, (ListMP_Handle *)&(obj->pendQ));
if (status < 0) {
/* obj->freeList set to NULL */
return (4);
}
return (0);
}
/* init the gate */
if (params->gate != NULL) {
obj->gate = params->gate;
}
else {
obj->gate = (ti_sdo_ipc_GateMP_Handle)GateMP_getDefaultRemote();
}
obj->mode = params->mode;
if (params->sharedAddr == NULL) {
/* Creating using a shared region ID */
obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC_REGION;
obj->regionId = params->regionId;
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
/* Need to allocate from the heap */
obj->allocSize = SemaphoreMP_sharedMemReq(params);
regionHeap = SharedRegion_getHeap(obj->regionId);
Assert_isTrue(regionHeap != NULL, ti_sdo_ipc_SharedRegion_A_noHeap);
/* The region heap will take care of the alignment */
obj->attrs = Memory_alloc(regionHeap, obj->allocSize, 0, eb);
if (obj->attrs == NULL) {
return (2);
}
}
else {
/* Creating using sharedAddr */
obj->regionId = SharedRegion_getId(params->sharedAddr);
/* Assert that the buffer is in a valid shared region */
Assert_isTrue(obj->regionId != SharedRegion_INVALIDREGIONID,
ti_sdo_ipc_Ipc_A_addrNotInSharedRegion);
/* Assert that sharedAddr is cache aligned */
Assert_isTrue(((UInt32)params->sharedAddr %
SharedRegion_getCacheLineSize(obj->regionId) == 0),
ti_sdo_ipc_Ipc_A_addrNotCacheAligned);
/* set object's cacheEnabled, objType, and attrs */
obj->cacheEnabled = SharedRegion_isCacheEnabled(obj->regionId);
obj->objType = ti_sdo_ipc_Ipc_ObjType_CREATEDYNAMIC;
obj->attrs = (SemaphoreMP_Attrs *)params->sharedAddr;
}
/* Store the GateMP sharedAddr in the SemaphoreMP Attrs */
obj->attrs->gateMPAddr = ti_sdo_ipc_GateMP_getSharedAddr(obj->gate);
obj->attrs->mode = (Bits16)obj->mode;
obj->attrs->count = count;
/* Create the freeList */
ListMP_Params_init(&listMPParams);
listMPParams.sharedAddr = (Ptr)_Ipc_roundup((UInt32)obj->attrs +
sizeof(SemaphoreMP_Attrs),
SharedRegion_getCacheLineSize(obj->regionId));
listMPParams.gate = (GateMP_Handle)obj->gate;
obj->pendQ = (ti_sdo_ipc_ListMP_Handle)ListMP_create(&listMPParams);
if (obj->pendQ == NULL) {
return (3);
}
/* Last thing, set the status */
obj->attrs->status = SemaphoreMP_CREATED;
if (obj->cacheEnabled) {
Cache_wbInv(obj->attrs, sizeof(SemaphoreMP_Attrs), Cache_Type_ALL,
TRUE);
}
/* Add entry to NameServer */
if (params->name != NULL) {
/* We will store a shared pointer in the NameServer */
sharedShmBase = SharedRegion_getSRPtr(obj->attrs,
obj->regionId);
obj->nsKey = NameServer_addUInt32((NameServer_Handle)
SemaphoreMP_module->nameServer, params->name,
(UInt32)sharedShmBase);
if (obj->nsKey == NULL) {
/* NameServer_addUInt32 failed */
return (4);
}
}
return (0);
}
