linux/src/api/NameServer.c

   1 /*
   2  * Copyright (c) 2012-2014, Texas Instruments Incorporated
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * *  Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * *  Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * *  Neither the name of Texas Instruments Incorporated nor the names of
  17  *    its contributors may be used to endorse or promote products derived
  18  *    from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32 /*
  33  *  ======== NameServer_client.c ========
  34  */
  35 #include <ti/ipc/Std.h>
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <sys/stat.h>
  42 #include <sys/types.h>
  43 #include <unistd.h>
  44 #include <time.h>
  45 #include <pthread.h>
  46
  47 #include <ti/ipc/NameServer.h>
  48
  49 #include <ladclient.h>
  50 #include <_lad.h>
  51
  52 static Bool verbose = FALSE;
  53
  54
  55 /*
  56  * The NameServer_*() APIs are reproduced here.  These versions are just
  57  * front-ends for communicating with the actual NameServer module (currently
  58  * implemented as a daemon process ala LAD).
  59  */
  60
  61 Int NameServer_setup(Void)
  62 {
  63     Int status;
  64     LAD_ClientHandle handle;
  65     struct LAD_CommandObj cmd;
  66     union LAD_ResponseObj rsp;
  67
  68     handle = LAD_findHandle();
  69     if (handle == LAD_MAXNUMCLIENTS) {
  70         PRINTVERBOSE1(
  71           "NameServer_setup: can't find connection to daemon for pid %d\n",
  72            getpid())
  73
  74         return NameServer_E_RESOURCE;
  75     }
  76
  77     cmd.cmd = LAD_NAMESERVER_SETUP;
  78     cmd.clientId = handle;
  79
  80     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
  81         PRINTVERBOSE1(
  82           "NameServer_setup: sending LAD command failed, status=%d\n", status)
  83         return NameServer_E_FAIL;
  84     }
  85
  86     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
  87         PRINTVERBOSE1("NameServer_setup: no LAD response, status=%d\n", status)
  88         return(status);
  89     }
  90     status = rsp.status;
  91
  92     PRINTVERBOSE2(
  93       "NameServer_setup: got LAD response for client %d, status=%d\n",
  94       handle, status)
  95
  96     return status;
  97 }
  98
  99 Int NameServer_destroy(Void)
 100 {
 101     Int status;
 102     LAD_ClientHandle handle;
 103     struct LAD_CommandObj cmd;
 104     union LAD_ResponseObj rsp;
 105
 106     PRINTVERBOSE0("NameServer_destroy: entered\n")
 107
 108     handle = LAD_findHandle();
 109     if (handle == LAD_MAXNUMCLIENTS) {
 110         PRINTVERBOSE1(
 111           "NameServer_destroy: can't find connection to daemon for pid %d\n",
 112           getpid())
 113
 114         return NameServer_E_RESOURCE;
 115     }
 116
 117     cmd.cmd = LAD_NAMESERVER_DESTROY;
 118     cmd.clientId = handle;
 119
 120     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 121         PRINTVERBOSE1(
 122           "NameServer_destroy: sending LAD command failed, status=%d\n", status)
 123         return NameServer_E_FAIL;
 124     }
 125
 126     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
 127         PRINTVERBOSE1(
 128           "NameServer_destroy: no LAD response, status=%d\n", status)
 129         return(status);
 130     }
 131     status = rsp.status;
 132
 133     PRINTVERBOSE2(
 134      "NameServer_destroy: got LAD response for client %d, status=%d\n",
 135      handle, status)
 136
 137     return status;
 138 }
 139
 140 Void NameServer_Params_init(NameServer_Params *params)
 141 {
 142     Int status;
 143     LAD_ClientHandle handle;
 144     struct LAD_CommandObj cmd;
 145     union LAD_ResponseObj rsp;
 146
 147     handle = LAD_findHandle();
 148     if (handle == LAD_MAXNUMCLIENTS) {
 149         PRINTVERBOSE1(
 150          "NameServer_Params_init: can't find connection to daemon for pid %d\n",
 151          getpid())
 152
 153         return;
 154     }
 155
 156     cmd.cmd = LAD_NAMESERVER_PARAMS_INIT;
 157     cmd.clientId = handle;
 158
 159     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 160         PRINTVERBOSE1(
 161           "NameServer_Params_init: sending LAD command failed, status=%d\n",
 162           status)
 163         return;
 164     }
 165
 166     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
 167         PRINTVERBOSE1(
 168           "NameServer_Params_init: no LAD response, status=%d\n", status)
 169         return;
 170     }
 171
 172     PRINTVERBOSE1("NameServer_Params_init: got LAD response for client %d\n",
 173                   handle)
 174
 175     memcpy(params, &rsp.params, sizeof(NameServer_Params));
 176
 177     return;
 178 }
 179
 180 NameServer_Handle NameServer_create(String name,
 181                                     const NameServer_Params *params)
 182 {
 183     Int status;
 184     LAD_ClientHandle handle;
 185     struct LAD_CommandObj cmd;
 186     union LAD_ResponseObj rsp;
 187
 188     handle = LAD_findHandle();
 189     if (handle == LAD_MAXNUMCLIENTS) {
 190         PRINTVERBOSE1(
 191           "NameServer_create: can't find connection to daemon for pid %d\n",
 192           getpid())
 193
 194         return NULL;
 195     }
 196
 197     cmd.cmd = LAD_NAMESERVER_CREATE;
 198     cmd.clientId = handle;
 199     strncpy(cmd.args.create.name, name, NameServer_Params_MAXNAMELEN);
 200     memcpy(&cmd.args.create.params, params, sizeof(NameServer_Params));
 201
 202     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 203         PRINTVERBOSE1(
 204           "NameServer_create: sending LAD command failed, status=%d\n",
 205           status)
 206         return NULL;
 207     }
 208
 209     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
 210         PRINTVERBOSE1("NameServer_create: no LAD response, status=%d\n", status)
 211         return NULL;
 212     }
 213
 214     PRINTVERBOSE1("NameServer_create: got LAD response for client %d\n", handle)
 215
 216     return rsp.handle;
 217 }
 218
 219 Ptr NameServer_add(NameServer_Handle nsHandle, String name, Ptr buf,
 220                    UInt32 len)
 221 {
 222     Int status;
 223     LAD_ClientHandle clHandle;
 224     struct LAD_CommandObj cmd;
 225     union LAD_ResponseObj rsp;
 226
 227     clHandle = LAD_findHandle();
 228     if (clHandle == LAD_MAXNUMCLIENTS) {
 229         PRINTVERBOSE1(
 230           "NameServer_add: can't find connection to daemon for pid %d\n",
 231           getpid())
 232
 233         return NULL;
 234     }
 235
 236     cmd.cmd = LAD_NAMESERVER_ADD;
 237     cmd.clientId = clHandle;
 238     cmd.args.add.handle = nsHandle;
 239     strncpy(cmd.args.add.name, name, LAD_MAXENTRYNAMELEN);
 240     cmd.args.add.len = len;
 241
 242     if (buf != NULL) {
 243         memcpy(cmd.args.add.buf, buf, len);
 244     }
 245
 246     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 247         PRINTVERBOSE1(
 248           "NameServer_add: sending LAD command failed, status=%d\n",
 249           status)
 250         return NULL;
 251     }
 252
 253     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 254         PRINTVERBOSE1(
 255            "NameServer_add: no LAD response, status=%d\n", status)
 256         return NULL;
 257     }
 258
 259     PRINTVERBOSE1(
 260        "NameServer_add: got LAD response for client %d\n", clHandle)
 261
 262     return rsp.entryPtr;
 263 }
 264
 265 Int NameServer_get(NameServer_Handle nsHandle, String name, Ptr buf,
 266                    UInt32 * len, UInt16 procId[])
 267 {
 268     Int status;
 269     LAD_ClientHandle clHandle;
 270     struct LAD_CommandObj cmd;
 271     union LAD_ResponseObj rsp;
 272
 273     clHandle = LAD_findHandle();
 274     if (clHandle == LAD_MAXNUMCLIENTS) {
 275         PRINTVERBOSE1(
 276           "NameServer_get: can't find connection to daemon for pid %d\n",
 277            getpid())
 278
 279         return NameServer_E_RESOURCE;
 280     }
 281
 282     cmd.cmd = LAD_NAMESERVER_GET;
 283     cmd.clientId = clHandle;
 284     cmd.args.get.handle = nsHandle;
 285     strncpy(cmd.args.get.name, name, LAD_MAXENTRYNAMELEN);
 286     if (procId != NULL) {
 287         memcpy(cmd.args.get.procId, procId,
 288                sizeof(UInt16) * MultiProc_MAXPROCESSORS);
 289     }
 290     else {
 291         cmd.args.get.procId[0] = (UInt16)-1;
 292     }
 293
 294     cmd.args.get.len = *len;
 295
 296     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 297         PRINTVERBOSE1(
 298            "NameServer_get: sending LAD command failed, status=%d\n",
 299             status)
 300         return NameServer_E_FAIL;
 301     }
 302
 303     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 304         PRINTVERBOSE1("NameServer_get: no LAD response, status=%d\n",
 305                        status)
 306         return NameServer_E_FAIL;
 307     }
 308
 309     *len = rsp.get.len;
 310     if (rsp.get.buf != NULL) {
 311         memcpy(buf, rsp.get.buf, *len);
 312     }
 313
 314     status = rsp.status;
 315
 316     PRINTVERBOSE1("NameServer_get: got LAD response for client %d\n",
 317                    clHandle)
 318
 319     return status;
 320 }
 321
 322 Ptr NameServer_addUInt32(NameServer_Handle nsHandle, String name, UInt32 value)
 323 {
 324     Int status;
 325     LAD_ClientHandle clHandle;
 326     struct LAD_CommandObj cmd;
 327     union LAD_ResponseObj rsp;
 328
 329     clHandle = LAD_findHandle();
 330     if (clHandle == LAD_MAXNUMCLIENTS) {
 331         PRINTVERBOSE1(
 332           "NameServer_addUInt32: can't find connection to daemon for pid %d\n",
 333           getpid())
 334
 335         return NULL;
 336     }
 337
 338     cmd.cmd = LAD_NAMESERVER_ADDUINT32;
 339     cmd.clientId = clHandle;
 340     cmd.args.addUInt32.handle = nsHandle;
 341     strncpy(cmd.args.addUInt32.name, name, LAD_MAXENTRYNAMELEN);
 342     cmd.args.addUInt32.val = value;
 343
 344     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 345         PRINTVERBOSE1(
 346           "NameServer_addUInt32: sending LAD command failed, status=%d\n",
 347           status)
 348         return NULL;
 349     }
 350
 351     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 352         PRINTVERBOSE1(
 353            "NameServer_addUInt32: no LAD response, status=%d\n", status)
 354         return NULL;
 355     }
 356
 357     PRINTVERBOSE1(
 358        "NameServer_addUInt32: got LAD response for client %d\n", clHandle)
 359
 360     return rsp.entryPtr;
 361 }
 362
 363 Int NameServer_getUInt32(NameServer_Handle nsHandle, String name, Ptr buf,
 364                           UInt16 procId[])
 365 {
 366     Int status;
 367     LAD_ClientHandle clHandle;
 368     UInt32 *val;
 369     struct LAD_CommandObj cmd;
 370     union LAD_ResponseObj rsp;
 371
 372     clHandle = LAD_findHandle();
 373     if (clHandle == LAD_MAXNUMCLIENTS) {
 374         PRINTVERBOSE1(
 375           "NameServer_getUInt32: can't find connection to daemon for pid %d\n",
 376            getpid())
 377
 378         return NameServer_E_RESOURCE;
 379     }
 380
 381     cmd.cmd = LAD_NAMESERVER_GETUINT32;
 382     cmd.clientId = clHandle;
 383     cmd.args.getUInt32.handle = nsHandle;
 384     strncpy(cmd.args.getUInt32.name, name, LAD_MAXENTRYNAMELEN);
 385     if (procId != NULL) {
 386         memcpy(cmd.args.getUInt32.procId, procId,
 387                sizeof(UInt16) * MultiProc_MAXPROCESSORS);
 388     }
 389     else {
 390         cmd.args.getUInt32.procId[0] = (UInt16)-1;
 391     }
 392
 393     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 394         PRINTVERBOSE1(
 395            "NameServer_getUInt32: sending LAD command failed, status=%d\n",
 396             status)
 397         return NameServer_E_FAIL;
 398     }
 399
 400     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 401         PRINTVERBOSE1("NameServer_getUInt32: no LAD response, status=%d\n",
 402                        status)
 403         return NameServer_E_FAIL;
 404     }
 405
 406     val = (UInt32 *)buf;
 407     *val = rsp.getUInt32.val;
 408     status = rsp.status;
 409
 410     PRINTVERBOSE1("NameServer_getUInt32: got LAD response for client %d\n",
 411                    clHandle)
 412
 413     return status;
 414 }
 415
 416 Int NameServer_remove(NameServer_Handle nsHandle, String name)
 417 {
 418     Int status;
 419     LAD_ClientHandle clHandle;
 420     struct LAD_CommandObj cmd;
 421     union LAD_ResponseObj rsp;
 422
 423     clHandle = LAD_findHandle();
 424     if (clHandle == LAD_MAXNUMCLIENTS) {
 425         PRINTVERBOSE1(
 426          "NameServer_remove: can't find connection to daemon for pid %d\n",
 427          getpid())
 428
 429         return NameServer_E_RESOURCE;
 430     }
 431
 432     cmd.cmd = LAD_NAMESERVER_REMOVE;
 433     cmd.clientId = clHandle;
 434     cmd.args.remove.handle = nsHandle;
 435     strncpy(cmd.args.remove.name, name, LAD_MAXENTRYNAMELEN);
 436
 437     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 438         PRINTVERBOSE1(
 439          "NameServer_remove: sending LAD command failed, status=%d\n",
 440          status)
 441         return NameServer_E_FAIL;
 442     }
 443
 444     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 445         PRINTVERBOSE1("NameServer_remove: no LAD response, status=%d\n", status)
 446         return NameServer_E_FAIL;
 447     }
 448
 449     status = rsp.status;
 450
 451     PRINTVERBOSE1("NameServer_remove: got LAD response for client %d\n",
 452                    clHandle)
 453
 454     return status;
 455 }
 456
 457 Int NameServer_removeEntry(NameServer_Handle nsHandle, Ptr entry)
 458 {
 459     Int status;
 460     LAD_ClientHandle clHandle;
 461     struct LAD_CommandObj cmd;
 462     union LAD_ResponseObj rsp;
 463
 464     clHandle = LAD_findHandle();
 465     if (clHandle == LAD_MAXNUMCLIENTS) {
 466         PRINTVERBOSE1(
 467          "NameServer_removeEntry: can't find connection to daemon for pid %d\n",
 468          getpid())
 469
 470         return NameServer_E_RESOURCE;
 471     }
 472
 473     cmd.cmd = LAD_NAMESERVER_REMOVEENTRY;
 474     cmd.clientId = clHandle;
 475     cmd.args.removeEntry.handle = nsHandle;
 476     cmd.args.removeEntry.entryPtr = entry;
 477
 478     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 479         PRINTVERBOSE1(
 480           "NameServer_removeEntry: sending LAD command failed, status=%d\n",
 481           status)
 482         return NameServer_E_FAIL;
 483     }
 484
 485     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 486         PRINTVERBOSE1("NameServer_removeEntry: no LAD response, status=%d\n",
 487                        status)
 488         return NameServer_E_FAIL;
 489     }
 490
 491     status = rsp.status;
 492
 493     PRINTVERBOSE1("NameServer_removeEntry: got LAD response for client %d\n",
 494                    clHandle)
 495
 496     return status;
 497 }
 498
 499 Int NameServer_delete(NameServer_Handle *nsHandle)
 500 {
 501     Int status;
 502     LAD_ClientHandle clHandle;
 503     struct LAD_CommandObj cmd;
 504     union LAD_ResponseObj rsp;
 505
 506     clHandle = LAD_findHandle();
 507     if (clHandle == LAD_MAXNUMCLIENTS) {
 508         PRINTVERBOSE1(
 509           "NameServer_delete: can't find connection to daemon for pid %d\n",
 510           getpid())
 511
 512         return NameServer_E_RESOURCE;
 513     }
 514
 515     cmd.cmd = LAD_NAMESERVER_DELETE;
 516     cmd.clientId = clHandle;
 517     cmd.args.delete.handle = *nsHandle;
 518
 519     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 520         PRINTVERBOSE1(
 521           "NameServer_delete: sending LAD command failed, status=%d\n",
 522           status)
 523         return NameServer_E_FAIL;
 524     }
 525
 526     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 527         PRINTVERBOSE1("NameServer_delete: no LAD response, status=%d\n", status)
 528         return NameServer_E_FAIL;
 529     }
 530
 531     *nsHandle = rsp.delete.handle;
 532     status = rsp.status;
 533
 534     PRINTVERBOSE1("NameServer_delete: got LAD response for client %d\n",
 535                    clHandle)
 536
 537     return status;
 538 }