linux/src/api/NameServer.c

   1 /*
   2  * Copyright (c) 2012-2015 Texas Instruments Incorporated - http://www.ti.com
   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 /* traces in this file are controlled via _NameServer_verbose */
  53 Bool _NameServer_verbose = FALSE;
  54 #define verbose _NameServer_verbose
  55
  56 /*
  57  * The NameServer_*() APIs are reproduced here.  These versions are just
  58  * front-ends for communicating with the actual NameServer module (currently
  59  * implemented as a daemon process ala LAD).
  60  */
  61
  62 Int NameServer_setup(Void)
  63 {
  64     Int status;
  65     LAD_ClientHandle handle;
  66     struct LAD_CommandObj cmd;
  67     union LAD_ResponseObj rsp;
  68
  69     handle = LAD_findHandle();
  70     if (handle == LAD_MAXNUMCLIENTS) {
  71         PRINTVERBOSE1(
  72           "NameServer_setup: can't find connection to daemon for pid %d\n",
  73            getpid())
  74
  75         return NameServer_E_RESOURCE;
  76     }
  77
  78     cmd.cmd = LAD_NAMESERVER_SETUP;
  79     cmd.clientId = handle;
  80
  81     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
  82         PRINTVERBOSE1(
  83           "NameServer_setup: sending LAD command failed, status=%d\n", status)
  84         return NameServer_E_FAIL;
  85     }
  86
  87     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
  88         PRINTVERBOSE1("NameServer_setup: no LAD response, status=%d\n", status)
  89         return(status);
  90     }
  91     status = rsp.status;
  92
  93     PRINTVERBOSE2(
  94       "NameServer_setup: got LAD response for client %d, status=%d\n",
  95       handle, status)
  96
  97     return status;
  98 }
  99
 100 Int NameServer_destroy(Void)
 101 {
 102     Int status;
 103     LAD_ClientHandle handle;
 104     struct LAD_CommandObj cmd;
 105     union LAD_ResponseObj rsp;
 106
 107     PRINTVERBOSE0("NameServer_destroy: entered\n")
 108
 109     handle = LAD_findHandle();
 110     if (handle == LAD_MAXNUMCLIENTS) {
 111         PRINTVERBOSE1(
 112           "NameServer_destroy: can't find connection to daemon for pid %d\n",
 113           getpid())
 114
 115         return NameServer_E_RESOURCE;
 116     }
 117
 118     cmd.cmd = LAD_NAMESERVER_DESTROY;
 119     cmd.clientId = handle;
 120
 121     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 122         PRINTVERBOSE1(
 123           "NameServer_destroy: sending LAD command failed, status=%d\n", status)
 124         return NameServer_E_FAIL;
 125     }
 126
 127     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
 128         PRINTVERBOSE1(
 129           "NameServer_destroy: no LAD response, status=%d\n", status)
 130         return(status);
 131     }
 132     status = rsp.status;
 133
 134     PRINTVERBOSE2(
 135      "NameServer_destroy: got LAD response for client %d, status=%d\n",
 136      handle, status)
 137
 138     return status;
 139 }
 140
 141 Void NameServer_Params_init(NameServer_Params *params)
 142 {
 143     Int status;
 144     LAD_ClientHandle handle;
 145     struct LAD_CommandObj cmd;
 146     union LAD_ResponseObj rsp;
 147
 148     handle = LAD_findHandle();
 149     if (handle == LAD_MAXNUMCLIENTS) {
 150         PRINTVERBOSE1(
 151          "NameServer_Params_init: can't find connection to daemon for pid %d\n",
 152          getpid())
 153
 154         return;
 155     }
 156
 157     cmd.cmd = LAD_NAMESERVER_PARAMS_INIT;
 158     cmd.clientId = handle;
 159
 160     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 161         PRINTVERBOSE1(
 162           "NameServer_Params_init: sending LAD command failed, status=%d\n",
 163           status)
 164         return;
 165     }
 166
 167     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
 168         PRINTVERBOSE1(
 169           "NameServer_Params_init: no LAD response, status=%d\n", status)
 170         return;
 171     }
 172
 173     PRINTVERBOSE1("NameServer_Params_init: got LAD response for client %d\n",
 174                   handle)
 175
 176     memcpy(params, &rsp.params, sizeof(NameServer_Params));
 177
 178     return;
 179 }
 180
 181 NameServer_Handle NameServer_create(String name,
 182                                     const NameServer_Params *params)
 183 {
 184     Int status;
 185     LAD_ClientHandle handle;
 186     struct LAD_CommandObj cmd;
 187     union LAD_ResponseObj rsp;
 188
 189     handle = LAD_findHandle();
 190     if (handle == LAD_MAXNUMCLIENTS) {
 191         PRINTVERBOSE1(
 192           "NameServer_create: can't find connection to daemon for pid %d\n",
 193           getpid())
 194
 195         return NULL;
 196     }
 197
 198     cmd.cmd = LAD_NAMESERVER_CREATE;
 199     cmd.clientId = handle;
 200     strncpy(cmd.args.create.name, name, NameServer_Params_MAXNAMELEN);
 201     memcpy(&cmd.args.create.params, params, sizeof(NameServer_Params));
 202
 203     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 204         PRINTVERBOSE1(
 205           "NameServer_create: sending LAD command failed, status=%d\n",
 206           status)
 207         return NULL;
 208     }
 209
 210     if ((status = LAD_getResponse(handle, &rsp)) != LAD_SUCCESS) {
 211         PRINTVERBOSE1("NameServer_create: no LAD response, status=%d\n", status)
 212         return NULL;
 213     }
 214
 215     PRINTVERBOSE1("NameServer_create: got LAD response for client %d\n", handle)
 216
 217     return rsp.handle;
 218 }
 219
 220 Ptr NameServer_add(NameServer_Handle nsHandle, String name, Ptr buf,
 221                    UInt32 len)
 222 {
 223     Int status;
 224     LAD_ClientHandle clHandle;
 225     struct LAD_CommandObj cmd;
 226     union LAD_ResponseObj rsp;
 227
 228     clHandle = LAD_findHandle();
 229     if (clHandle == LAD_MAXNUMCLIENTS) {
 230         PRINTVERBOSE1(
 231           "NameServer_add: can't find connection to daemon for pid %d\n",
 232           getpid())
 233
 234         return NULL;
 235     }
 236
 237     cmd.cmd = LAD_NAMESERVER_ADD;
 238     cmd.clientId = clHandle;
 239     cmd.args.add.handle = nsHandle;
 240     strncpy(cmd.args.add.name, name, LAD_MAXENTRYNAMELEN);
 241     cmd.args.add.len = len;
 242
 243     if (buf != NULL) {
 244         memcpy(cmd.args.add.buf, buf, len);
 245     }
 246
 247     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 248         PRINTVERBOSE1(
 249           "NameServer_add: sending LAD command failed, status=%d\n",
 250           status)
 251         return NULL;
 252     }
 253
 254     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 255         PRINTVERBOSE1(
 256            "NameServer_add: no LAD response, status=%d\n", status)
 257         return NULL;
 258     }
 259
 260     PRINTVERBOSE1(
 261        "NameServer_add: got LAD response for client %d\n", clHandle)
 262
 263     return rsp.entryPtr;
 264 }
 265
 266 Int NameServer_get(NameServer_Handle nsHandle, String name, Ptr buf,
 267                    UInt32 * len, UInt16 procId[])
 268 {
 269     Int status;
 270     LAD_ClientHandle clHandle;
 271     struct LAD_CommandObj cmd;
 272     union LAD_ResponseObj rsp;
 273
 274     clHandle = LAD_findHandle();
 275     if (clHandle == LAD_MAXNUMCLIENTS) {
 276         PRINTVERBOSE1(
 277           "NameServer_get: can't find connection to daemon for pid %d\n",
 278            getpid())
 279
 280         return NameServer_E_RESOURCE;
 281     }
 282
 283     cmd.cmd = LAD_NAMESERVER_GET;
 284     cmd.clientId = clHandle;
 285     cmd.args.get.handle = nsHandle;
 286     strncpy(cmd.args.get.name, name, LAD_MAXENTRYNAMELEN);
 287     if (procId != NULL) {
 288         memcpy(cmd.args.get.procId, procId,
 289                sizeof(UInt16) * MultiProc_MAXPROCESSORS);
 290     }
 291     else {
 292         cmd.args.get.procId[0] = (UInt16)-1;
 293     }
 294
 295     cmd.args.get.len = *len;
 296
 297     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 298         PRINTVERBOSE1(
 299            "NameServer_get: sending LAD command failed, status=%d\n",
 300             status)
 301         return NameServer_E_FAIL;
 302     }
 303
 304     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 305         PRINTVERBOSE1("NameServer_get: no LAD response, status=%d\n",
 306                        status)
 307         return NameServer_E_FAIL;
 308     }
 309
 310     *len = rsp.get.len;
 311     if (rsp.get.buf != NULL) {
 312         memcpy(buf, rsp.get.buf, *len);
 313     }
 314
 315     status = rsp.status;
 316
 317     PRINTVERBOSE1("NameServer_get: got LAD response for client %d\n",
 318                    clHandle)
 319
 320     return status;
 321 }
 322
 323 Ptr NameServer_addUInt32(NameServer_Handle nsHandle, String name, UInt32 value)
 324 {
 325     Int status;
 326     LAD_ClientHandle clHandle;
 327     struct LAD_CommandObj cmd;
 328     union LAD_ResponseObj rsp;
 329
 330     clHandle = LAD_findHandle();
 331     if (clHandle == LAD_MAXNUMCLIENTS) {
 332         PRINTVERBOSE1(
 333           "NameServer_addUInt32: can't find connection to daemon for pid %d\n",
 334           getpid())
 335
 336         return NULL;
 337     }
 338
 339     cmd.cmd = LAD_NAMESERVER_ADDUINT32;
 340     cmd.clientId = clHandle;
 341     cmd.args.addUInt32.handle = nsHandle;
 342     strncpy(cmd.args.addUInt32.name, name, LAD_MAXENTRYNAMELEN);
 343     cmd.args.addUInt32.val = value;
 344
 345     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 346         PRINTVERBOSE1(
 347           "NameServer_addUInt32: sending LAD command failed, status=%d\n",
 348           status)
 349         return NULL;
 350     }
 351
 352     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 353         PRINTVERBOSE1(
 354            "NameServer_addUInt32: no LAD response, status=%d\n", status)
 355         return NULL;
 356     }
 357
 358     PRINTVERBOSE1(
 359        "NameServer_addUInt32: got LAD response for client %d\n", clHandle)
 360
 361     return rsp.entryPtr;
 362 }
 363
 364 Int NameServer_getUInt32(NameServer_Handle nsHandle, String name, Ptr buf,
 365                           UInt16 procId[])
 366 {
 367     Int status;
 368     LAD_ClientHandle clHandle;
 369     UInt32 *val;
 370     struct LAD_CommandObj cmd;
 371     union LAD_ResponseObj rsp;
 372
 373     clHandle = LAD_findHandle();
 374     if (clHandle == LAD_MAXNUMCLIENTS) {
 375         PRINTVERBOSE1(
 376           "NameServer_getUInt32: can't find connection to daemon for pid %d\n",
 377            getpid())
 378
 379         return NameServer_E_RESOURCE;
 380     }
 381
 382     cmd.cmd = LAD_NAMESERVER_GETUINT32;
 383     cmd.clientId = clHandle;
 384     cmd.args.getUInt32.handle = nsHandle;
 385     strncpy(cmd.args.getUInt32.name, name, LAD_MAXENTRYNAMELEN);
 386     if (procId != NULL) {
 387         memcpy(cmd.args.getUInt32.procId, procId,
 388                sizeof(UInt16) * MultiProc_MAXPROCESSORS);
 389     }
 390     else {
 391         cmd.args.getUInt32.procId[0] = (UInt16)-1;
 392     }
 393
 394     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 395         PRINTVERBOSE1(
 396            "NameServer_getUInt32: sending LAD command failed, status=%d\n",
 397             status)
 398         return NameServer_E_FAIL;
 399     }
 400
 401     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 402         PRINTVERBOSE1("NameServer_getUInt32: no LAD response, status=%d\n",
 403                        status)
 404         return NameServer_E_FAIL;
 405     }
 406
 407     val = (UInt32 *)buf;
 408     *val = rsp.getUInt32.val;
 409     status = rsp.status;
 410
 411     PRINTVERBOSE1("NameServer_getUInt32: got LAD response for client %d\n",
 412                    clHandle)
 413
 414     return status;
 415 }
 416
 417 Int NameServer_remove(NameServer_Handle nsHandle, String name)
 418 {
 419     Int status;
 420     LAD_ClientHandle clHandle;
 421     struct LAD_CommandObj cmd;
 422     union LAD_ResponseObj rsp;
 423
 424     clHandle = LAD_findHandle();
 425     if (clHandle == LAD_MAXNUMCLIENTS) {
 426         PRINTVERBOSE1(
 427          "NameServer_remove: can't find connection to daemon for pid %d\n",
 428          getpid())
 429
 430         return NameServer_E_RESOURCE;
 431     }
 432
 433     cmd.cmd = LAD_NAMESERVER_REMOVE;
 434     cmd.clientId = clHandle;
 435     cmd.args.remove.handle = nsHandle;
 436     strncpy(cmd.args.remove.name, name, LAD_MAXENTRYNAMELEN);
 437
 438     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 439         PRINTVERBOSE1(
 440          "NameServer_remove: sending LAD command failed, status=%d\n",
 441          status)
 442         return NameServer_E_FAIL;
 443     }
 444
 445     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 446         PRINTVERBOSE1("NameServer_remove: no LAD response, status=%d\n", status)
 447         return NameServer_E_FAIL;
 448     }
 449
 450     status = rsp.status;
 451
 452     PRINTVERBOSE1("NameServer_remove: got LAD response for client %d\n",
 453                    clHandle)
 454
 455     return status;
 456 }
 457
 458 Int NameServer_removeEntry(NameServer_Handle nsHandle, Ptr entry)
 459 {
 460     Int status;
 461     LAD_ClientHandle clHandle;
 462     struct LAD_CommandObj cmd;
 463     union LAD_ResponseObj rsp;
 464
 465     clHandle = LAD_findHandle();
 466     if (clHandle == LAD_MAXNUMCLIENTS) {
 467         PRINTVERBOSE1(
 468          "NameServer_removeEntry: can't find connection to daemon for pid %d\n",
 469          getpid())
 470
 471         return NameServer_E_RESOURCE;
 472     }
 473
 474     cmd.cmd = LAD_NAMESERVER_REMOVEENTRY;
 475     cmd.clientId = clHandle;
 476     cmd.args.removeEntry.handle = nsHandle;
 477     cmd.args.removeEntry.entryPtr = entry;
 478
 479     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 480         PRINTVERBOSE1(
 481           "NameServer_removeEntry: sending LAD command failed, status=%d\n",
 482           status)
 483         return NameServer_E_FAIL;
 484     }
 485
 486     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 487         PRINTVERBOSE1("NameServer_removeEntry: no LAD response, status=%d\n",
 488                        status)
 489         return NameServer_E_FAIL;
 490     }
 491
 492     status = rsp.status;
 493
 494     PRINTVERBOSE1("NameServer_removeEntry: got LAD response for client %d\n",
 495                    clHandle)
 496
 497     return status;
 498 }
 499
 500 Int NameServer_delete(NameServer_Handle *nsHandle)
 501 {
 502     Int status;
 503     LAD_ClientHandle clHandle;
 504     struct LAD_CommandObj cmd;
 505     union LAD_ResponseObj rsp;
 506
 507     clHandle = LAD_findHandle();
 508     if (clHandle == LAD_MAXNUMCLIENTS) {
 509         PRINTVERBOSE1(
 510           "NameServer_delete: can't find connection to daemon for pid %d\n",
 511           getpid())
 512
 513         return NameServer_E_RESOURCE;
 514     }
 515
 516     cmd.cmd = LAD_NAMESERVER_DELETE;
 517     cmd.clientId = clHandle;
 518     cmd.args.delete.handle = *nsHandle;
 519
 520     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 521         PRINTVERBOSE1(
 522           "NameServer_delete: sending LAD command failed, status=%d\n",
 523           status)
 524         return NameServer_E_FAIL;
 525     }
 526
 527     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 528         PRINTVERBOSE1("NameServer_delete: no LAD response, status=%d\n", status)
 529         return NameServer_E_FAIL;
 530     }
 531
 532     *nsHandle = rsp.delete.handle;
 533     status = rsp.status;
 534
 535     PRINTVERBOSE1("NameServer_delete: got LAD response for client %d\n",
 536                    clHandle)
 537
 538     return status;
 539 }
 540
 541 /*
 542  *  ======== NameServer_attach ========
 543  *  Internal function.
 544  */
 545 Int NameServer_attach(UInt16 procId)
 546 {
 547     Int status;
 548     LAD_ClientHandle clHandle;
 549     struct LAD_CommandObj cmd;
 550     union LAD_ResponseObj rsp;
 551
 552     clHandle = LAD_findHandle();
 553
 554     if (clHandle == LAD_MAXNUMCLIENTS) {
 555         PRINTVERBOSE0("NameServer_attach: not connected to LAD\n");
 556         return (NameServer_E_RESOURCE);
 557     }
 558
 559     cmd.cmd = LAD_NAMESERVER_ATTACH;
 560     cmd.clientId = clHandle;
 561     cmd.args.attach.procId = procId;
 562
 563     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 564         PRINTVERBOSE1("NameServer_attach: sending LAD command failed, "
 565                 "status=%d\n", status);
 566         return (NameServer_E_FAIL);
 567     }
 568
 569     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 570         PRINTVERBOSE1("NameServer_attach: no LAD response, status=%d\n",
 571                 status);
 572         return (NameServer_E_FAIL);
 573     }
 574
 575     status = rsp.status;
 576     PRINTVERBOSE1("NameServer_attach: LAD response, status=%d\n", status)
 577     return (status);
 578 }
 579
 580 /*
 581  *  ======== NameServer_detach ========
 582  *  Internal function.
 583  */
 584 Int NameServer_detach(UInt16 procId)
 585 {
 586     Int status;
 587     LAD_ClientHandle clHandle;
 588     struct LAD_CommandObj cmd;
 589     union LAD_ResponseObj rsp;
 590
 591     clHandle = LAD_findHandle();
 592
 593     if (clHandle == LAD_MAXNUMCLIENTS) {
 594         PRINTVERBOSE0("NameServer_detach: not connected to LAD\n");
 595         return (NameServer_E_RESOURCE);
 596     }
 597
 598     cmd.cmd = LAD_NAMESERVER_DETACH;
 599     cmd.clientId = clHandle;
 600     cmd.args.detach.procId = procId;
 601
 602     if ((status = LAD_putCommand(&cmd)) != LAD_SUCCESS) {
 603         PRINTVERBOSE1("NameServer_detach: sending LAD command failed, "
 604                 "status=%d\n", status);
 605         return (NameServer_E_FAIL);
 606     }
 607
 608     if ((status = LAD_getResponse(clHandle, &rsp)) != LAD_SUCCESS) {
 609         PRINTVERBOSE1("NameServer_detach: no LAD response, status=%d\n",
 610                 status);
 611         return (NameServer_E_FAIL);
 612     }
 613
 614     status = rsp.status;
 615     PRINTVERBOSE1("NameServer_detach: LAD response, status=%d\n", status)
 616     return (status);
 617 }