source: rtems/c/src/libmisc/monitor/mon-server.c @ 3a4ae6c

4.104.114.84.95
Last change on this file since 3a4ae6c was 3a4ae6c, checked in by Joel Sherrill <joel.sherrill@…>, on Sep 11, 1995 at 7:35:39 PM

The word "RTEMS" almost completely removed from the core.

Configuration Table Template file added and all tests
modified to use this. All gvar.h and conftbl.h files
removed from test directories.

Configuration parameter maximum_devices added.

Core semaphore and mutex handlers added and RTEMS API Semaphore
Manager updated to reflect this.

Initialization sequence changed to invoke API specific initialization
routines. Initialization tasks table now owned by RTEMS Tasks Manager.

Added user extension for post-switch.

Utilized user extensions to implement API specific functionality
like signal dispatching.

Added extensions to the System Initialization Thread so that an
API can register a function to be invoked while the system
is being initialized. These are largely equivalent to the
pre-driver and post-driver hooks.

Added the Modules file oar-go32_p5, modified oar-go32, and modified
the file make/custom/go32.cfg to look at an environment varable which
determines what CPU model is being used.

All BSPs updated to reflect named devices and clock driver's IOCTL
used by the Shared Memory Driver. Also merged clock isr into
main file and removed ckisr.c where possible.

Updated spsize to reflect new and moved variables.

Makefiles for the executive source and include files updated to show
break down of files into Core, RTEMS API, and Neither.

Header and inline files installed into subdirectory based on whether
logically in the Core or a part of the RTEMS API.

  • Property mode set to 100644
File size: 8.9 KB
Line 
1/*
2 *      @(#)server.c    1.3 - 95/08/02
3 *     
4 *
5 * RTEMS monitor server (handles requests for info from RTEMS monitors
6 *             running on other nodes)
7 *
8 *  $Id$
9 */
10
11#include <rtems.h>
12
13#include <stdio.h>
14#include <string.h>
15#include <stdlib.h>
16#include <unistd.h>
17
18#include "monitor.h"
19
20/*
21 * Various id's for the server
22 */
23
24rtems_id  rtems_monitor_server_task_id;
25rtems_id  rtems_monitor_server_request_queue_id;        /* our server */
26rtems_id *rtems_monitor_server_request_queue_ids;       /* all servers */
27rtems_id  rtems_monitor_server_response_queue_id;       /* our server */
28
29
30/*
31 * Send a request to a server task
32 */
33
34rtems_status_code
35rtems_monitor_server_request(
36    unsigned32                       server_node,
37    rtems_monitor_server_request_t  *request,
38    rtems_monitor_server_response_t *response
39)
40{
41    rtems_id          server_id;
42    rtems_status_code status;
43    unsigned32        size;
44
45    /*
46     * What is id of monitor on target node?
47     * Look it up if we don't know it yet.
48     */
49   
50    server_id = rtems_monitor_server_request_queue_ids[server_node];
51    if (server_id == 0)
52    {
53        status = rtems_message_queue_ident(RTEMS_MONITOR_QUEUE_NAME,
54                                           server_node,
55                                           &server_id);
56        if (status != RTEMS_SUCCESSFUL)
57        {
58            rtems_error(status, "ident of remote server failed");
59            goto done;
60        }
61       
62        rtems_monitor_server_request_queue_ids[server_node] = server_id;
63    }
64
65    request->return_id = rtems_monitor_server_response_queue_id;
66
67    status = rtems_message_queue_send(server_id, request, sizeof(*request));
68    if (status != RTEMS_SUCCESSFUL)
69    {
70        rtems_error(status, "monitor server request send failed");
71        goto done;
72    }
73   
74    /*
75     * Await response, if requested
76     */
77
78    if (response)
79    {
80        status = rtems_message_queue_receive(rtems_monitor_server_response_queue_id,
81                                             response,
82                                             &size,
83                                             RTEMS_WAIT,
84                                             100);
85        if (status != RTEMS_SUCCESSFUL)
86        {
87            rtems_error(status, "server did not respond");
88
89            /* maybe server task was restarted; look it up again next time */
90            rtems_monitor_server_request_queue_ids[server_node] = 0;
91
92            goto done;
93        }
94
95        if (response->command != RTEMS_MONITOR_SERVER_RESPONSE)
96        {
97            status = RTEMS_INCORRECT_STATE;
98            goto done;
99        }           
100    }
101   
102done:
103    return status;
104}
105
106
107
108/*
109 * monitor server task
110 */
111
112void
113rtems_monitor_server_task(
114    rtems_task_argument monitor_flags
115)
116{
117    rtems_monitor_server_request_t  request;
118    rtems_monitor_server_response_t response;
119    rtems_status_code               status;
120    unsigned32                      size;
121
122    for (;;)
123    {
124        status = rtems_message_queue_receive(
125                        rtems_monitor_server_request_queue_id,
126                        &request,
127                        &size,
128                        RTEMS_WAIT,
129                        (rtems_interval) 0);
130
131        if (status != RTEMS_SUCCESSFUL)
132        {
133            rtems_error(status, "monitor server msg queue receive error");
134            goto failed;
135        }
136                                             
137        if (size != sizeof(request))
138        {
139            rtems_error(0, "monitor server bad size on receive");
140            goto failed;
141        }
142       
143        switch (request.command)
144        {
145            case RTEMS_MONITOR_SERVER_CANONICAL:
146            {
147                rtems_object_type_t object_type;
148                rtems_id            id;
149                rtems_id            next_id;
150
151                object_type = (rtems_object_type_t) request.argument0;
152                id          = (rtems_id)            request.argument1;
153                next_id = rtems_monitor_object_canonical_get(object_type,
154                                                             id,
155                                                             &response.payload,
156                                                             &size);
157
158                response.command = RTEMS_MONITOR_SERVER_RESPONSE;
159                response.result0 = next_id;
160                response.result1 = size;
161
162#define SERVER_OVERHEAD  (RTEMS_offsetof(rtems_monitor_server_response_t, \
163                                         payload))
164                   
165                status = rtems_message_queue_send(request.return_id,
166                                                  &response,
167                                                  size + SERVER_OVERHEAD);
168                if (status != RTEMS_SUCCESSFUL)
169                {
170                    rtems_error(status, "response send failed");
171                    goto failed;
172                }
173                break;
174            }
175
176            default:
177            {
178                rtems_error(0, "invalid command to monitor server: %d", request.command);
179                goto failed;
180            }
181        }
182    }
183
184failed:
185    rtems_task_delete(RTEMS_SELF);
186}
187
188   
189/*
190 * Kill off any old server
191 * Not sure if this is useful, but it doesn't help
192 */
193
194void
195rtems_monitor_server_kill(void)
196{
197    if (rtems_monitor_server_task_id)
198        rtems_task_delete(rtems_monitor_server_task_id);
199    rtems_monitor_task_id = 0;
200
201    if (rtems_monitor_server_request_queue_id)
202        rtems_message_queue_delete(rtems_monitor_server_request_queue_id);
203    rtems_monitor_server_response_queue_id = 0;
204
205    if (rtems_monitor_server_response_queue_id)
206        rtems_message_queue_delete(rtems_monitor_server_response_queue_id);
207    rtems_monitor_server_request_queue_ids = 0;
208
209    if (rtems_monitor_server_request_queue_ids)
210        free(rtems_monitor_server_request_queue_ids);
211    rtems_monitor_server_request_queue_ids = 0;
212}
213
214
215void
216rtems_monitor_server_init(
217    unsigned32 monitor_flags
218)
219{
220    rtems_status_code status;
221   
222    if (_System_state_Is_multiprocessing    &&
223        (_Configuration_MP_table->maximum_nodes > 1))
224    {
225        unsigned32 maximum_nodes = _Configuration_MP_table->maximum_nodes;
226       
227        /*
228         * create the msg que our server will listen
229         * Since we only get msgs from other RTEMS monitors, we just
230         * need reserve space for 1 msg from each node.
231         */
232
233        status = rtems_message_queue_create(
234                       RTEMS_MONITOR_QUEUE_NAME,
235                       maximum_nodes,
236                       sizeof(rtems_monitor_server_request_t),
237                       RTEMS_GLOBAL,
238                       &rtems_monitor_server_request_queue_id);
239       
240        if (status != RTEMS_SUCCESSFUL)
241        {
242            rtems_error(status, "could not create monitor server message queue");
243            goto done;
244        }
245         
246        /*
247         * create the msg que our responses will come on
248         * Since monitor just does one thing at a time, we only need 1 item
249         * message queue.
250         */
251       
252        status = rtems_message_queue_create(
253                       RTEMS_MONITOR_RESPONSE_QUEUE_NAME,
254                       1, /* depth */
255                       sizeof(rtems_monitor_server_response_t),
256                       RTEMS_GLOBAL,
257                       &rtems_monitor_server_response_queue_id);
258       
259        if (status != RTEMS_SUCCESSFUL)
260        {
261            rtems_error(status, "could not create monitor response message queue");
262            goto done;
263        }
264         
265        /* need an id for queue of each other server we might talk to */
266        /* indexed by node, so add 1 to maximum_nodes */
267        rtems_monitor_server_request_queue_ids =
268                   (rtems_id *) malloc((maximum_nodes + 1) * sizeof(rtems_id));
269        (void) memset(rtems_monitor_server_request_queue_ids,
270                      0,
271                      (maximum_nodes + 1) * sizeof(rtems_id));
272
273        rtems_monitor_server_request_queue_ids[rtems_monitor_node] =
274                   rtems_monitor_server_request_queue_id;
275
276        /*
277         * create the server task
278         */
279        status = rtems_task_create(RTEMS_MONITOR_SERVER_NAME,
280                                   1,
281                                   0 /* default stack */,
282                                   RTEMS_INTERRUPT_LEVEL(0),
283                                   RTEMS_DEFAULT_ATTRIBUTES,
284                                   &rtems_monitor_server_task_id);
285        if (status != RTEMS_SUCCESSFUL)
286        {
287            rtems_error(status, "could not create monitor server task");
288            goto done;
289        }
290
291        /*
292         * Start the server task
293         */
294        status = rtems_task_start(rtems_monitor_server_task_id,
295                                  rtems_monitor_server_task,
296                                  monitor_flags);
297        if (status != RTEMS_SUCCESSFUL)
298        {
299            rtems_error(status, "could not start monitor server");
300            goto done;
301        }
302    }
303
304done:
305}
Note: See TracBrowser for help on using the repository browser.