1 /*
2 * Copyright (c) 2013, 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.c ========
34 */
35 #include <ti/ipc/Std.h>
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>
46 #include <ti/ipc/NameServer.h>
47 #include <ti/ipc/MultiProc.h>
49 #include <_IpcLog.h>
50 #include <ti/syslink/inc/_MultiProc.h>
51 #include <ti/syslink/inc/IoctlDefs.h>
52 #include <ti/syslink/inc/usr/Qnx/NameServerDrv.h>
53 #include <ti/syslink/inc/NameServerDrvDefs.h>
55 static Bool verbose = FALSE;
58 /*
59 * The NameServer_*() APIs are reproduced here. These versions are just
60 * front-ends for communicating with the actual NameServer module (currently
61 * implemented in the IPC driver process acting as a daemon).
62 */
64 Int NameServer_setup(Void)
65 {
66 Int status;
67 NameServerDrv_CmdArgs cmdArgs;
69 status = NameServerDrv_ioctl (CMD_NAMESERVER_SETUP, &cmdArgs);
70 if (status < 0) {
71 PRINTVERBOSE1("NameServer_setup: API (through IOCTL) failed, \
72 status=%d\n", status)
73 }
75 return status;
76 }
78 Int NameServer_destroy(Void)
79 {
80 Int status;
82 NameServerDrv_CmdArgs cmdArgs;
84 PRINTVERBOSE0("NameServer_destroy: entered\n")
86 status = NameServerDrv_ioctl (CMD_NAMESERVER_DESTROY, &cmdArgs);
88 if (status < 0) {
89 PRINTVERBOSE1("NameServer_destroy: API (through IOCTL) failed, \
90 status=%d\n", status)
91 }
93 return status;
94 }
96 Void NameServer_Params_init(NameServer_Params *params)
97 {
98 Int status;
99 NameServerDrv_CmdArgs cmdArgs;
101 cmdArgs.args.ParamsInit.params = params;
102 status = NameServerDrv_ioctl (CMD_NAMESERVER_PARAMS_INIT, &cmdArgs);
104 if (status < 0) {
105 PRINTVERBOSE1("NameServer_Params_init: API (through IOCTL) failed, \
106 status=%d\n", status)
107 return;
108 }
110 return;
111 }
113 NameServer_Handle NameServer_create(String name,
114 const NameServer_Params *params)
115 {
116 Int status;
117 NameServerDrv_CmdArgs cmdArgs;
119 cmdArgs.args.create.name = name;
120 cmdArgs.args.create.nameLen = strlen (name) + 1;
121 cmdArgs.args.create.params = (NameServer_Params *) params;
123 status = NameServerDrv_ioctl (CMD_NAMESERVER_CREATE, &cmdArgs);
125 if (status < 0) {
126 PRINTVERBOSE1("NameServer_create: API (through IOCTL) failed, \
127 status=%d\n", status)
128 return NULL;
129 }
131 return cmdArgs.args.create.handle;
132 }
134 Ptr NameServer_add(NameServer_Handle nsHandle, String name, Ptr buf,
135 UInt32 len)
136 {
137 Int status;
138 NameServerDrv_CmdArgs cmdArgs;
140 cmdArgs.args.add.handle = nsHandle;
141 cmdArgs.args.add.name = name;
142 cmdArgs.args.add.nameLen = strlen(name) + 1;
143 cmdArgs.args.add.buf = buf;
144 cmdArgs.args.add.len = len;
146 status = NameServerDrv_ioctl(CMD_NAMESERVER_ADD, &cmdArgs);
148 if (status < 0) {
149 PRINTVERBOSE1("NameServer_add: API (through IOCTL) failed, \
150 status=%d\n", status)
151 return NULL;
152 }
154 return cmdArgs.args.add.entry;
155 }
157 Int NameServer_get(NameServer_Handle handle, String name, Ptr buf,
158 UInt32 * len, UInt16 procId[])
159 {
160 Int status;
161 UInt32 procLen = 0;
162 NameServerDrv_CmdArgs cmdArgs;
164 cmdArgs.args.get.name = name;
165 cmdArgs.args.get.handle = handle;
166 cmdArgs.args.get.procId = procId;
167 if (procId != NULL) {
168 while (procId[procLen] != MultiProc_INVALIDID) {
169 procLen++;
170 }
171 }
172 cmdArgs.args.get.procLen = procLen;
173 cmdArgs.args.get.buf = buf;
174 cmdArgs.args.get.len = *len;
175 cmdArgs.args.get.nameLen = strlen(name) + 1;
177 status = NameServerDrv_ioctl (CMD_NAMESERVER_GET, &cmdArgs);
179 if (status < 0) {
180 PRINTVERBOSE1("NameServer_get: API (through IOCTL) failed, \
181 status=%d\n", status)
182 return status;
183 }
185 *len = cmdArgs.args.get.len;
187 return status;
188 }
191 Ptr NameServer_addUInt32(NameServer_Handle nsHandle, String name, UInt32 value)
192 {
193 Int status;
194 NameServerDrv_CmdArgs cmdArgs;
196 cmdArgs.args.addUInt32.handle = nsHandle;
197 cmdArgs.args.addUInt32.name = name;
198 cmdArgs.args.addUInt32.nameLen = strlen(name) + 1;
199 cmdArgs.args.addUInt32.value = value;
200 status = NameServerDrv_ioctl(CMD_NAMESERVER_ADDUINT32, &cmdArgs);
202 if (status < 0) {
203 PRINTVERBOSE1("NameServer_addUInt32: API (through IOCTL) failed, \
204 status=%d\n", status)
205 return NULL;
206 }
208 return cmdArgs.args.addUInt32.entry;
209 }
211 Int NameServer_getUInt32(NameServer_Handle nsHandle, String name, Ptr buf,
212 UInt16 procId[])
213 {
214 Int status;
215 UInt32 *val;
216 NameServerDrv_CmdArgs cmdArgs;
218 cmdArgs.args.getUInt32.name = name;
219 cmdArgs.args.getUInt32.handle = nsHandle;
220 if (procId != NULL) {
221 memcpy(cmdArgs.args.getUInt32.procId, procId,
222 sizeof(UInt16) * MultiProc_MAXPROCESSORS);
223 }
224 else {
225 cmdArgs.args.getUInt32.procId[0] = (UInt16)-1;
226 }
227 status = NameServerDrv_ioctl (CMD_NAMESERVER_GETUINT32, &cmdArgs);
229 if (status < 0) {
230 PRINTVERBOSE1("NameServer_getUInt32: API (through IOCTL) failed, \
231 status=%d\n", status)
232 return status;
233 }
235 val = (UInt32 *)buf;
236 *val = cmdArgs.args.getUInt32.value;
238 return status;
239 }
241 Int NameServer_remove(NameServer_Handle nsHandle, String name)
242 {
243 Int status;
244 NameServerDrv_CmdArgs cmdArgs;
246 cmdArgs.args.remove.handle = nsHandle;
247 cmdArgs.args.remove.name = name;
248 cmdArgs.args.remove.nameLen = strlen(name) + 1;
249 status = NameServerDrv_ioctl(CMD_NAMESERVER_REMOVE, &cmdArgs);
251 if (status < 0) {
252 PRINTVERBOSE1("NameServer_remove: API (through IOCTL) failed, \
253 status=%d\n", status)
254 }
256 return status;
257 }
259 Int NameServer_removeEntry(NameServer_Handle nsHandle, Ptr entry)
260 {
261 Int status;
262 NameServerDrv_CmdArgs cmdArgs;
264 cmdArgs.args.removeEntry.handle = nsHandle;
265 cmdArgs.args.removeEntry.entry = entry;
266 status = NameServerDrv_ioctl (CMD_NAMESERVER_REMOVEENTRY, &cmdArgs);
268 if (status < 0) {
269 PRINTVERBOSE1("NameServer_removeEntry: API (through IOCTL) failed, \
270 status=%d\n", status)
271 }
273 return status;
274 }
276 Int NameServer_delete(NameServer_Handle *nsHandle)
277 {
278 Int status;
279 NameServerDrv_CmdArgs cmdArgs;
281 cmdArgs.args.delete.handle = *nsHandle;
282 status = NameServerDrv_ioctl (CMD_NAMESERVER_DELETE, &cmdArgs);
284 if (status < 0) {
285 PRINTVERBOSE1("NameServer_delete: API (through IOCTL) failed, \
286 status=%d\n", status)
287 return status;
288 }
290 *nsHandle = cmdArgs.args.delete.handle;
292 return status;
293 }