1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <fcntl.h>
30 #include <unistd.h>
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <strings.h>
34 #include <errno.h>
35
36 #include <sys/mman.h>
37 #include <sys/pci.h>
38 #include <sys/stat.h>
39 #include <sys/wait.h>
40
41 #include <fcode/private.h>
42 #include <fcode/log.h>
43
44 #include <fcdriver/fcdriver.h>
45
46 static char *pkg_my_args;
47 static char fcode_dev[] = "/dev/fcode";
48
49 static void
dot_request(fcode_env_t * env)50 dot_request(fcode_env_t *env)
51 {
52 common_data_t *cdp = env->private;
53
54 log_message(MSG_INFO, "request: cfgadd: %x fc_size: %x unitadd: %s"
55 " attach: %x args: '%s'\n", cdp->fc.config_address,
56 cdp->fc.fcode_size, cdp->fc.unit_address, cdp->attach,
57 pkg_my_args ? pkg_my_args : "<null>");
58 }
59
60 /*
61 * Get next request from /dev/fcode.
62 */
63 int
fc_get_request(common_data_t * cdp)64 fc_get_request(common_data_t *cdp)
65 {
66 char c;
67 int nbytes;
68
69 if (cdp->fcode_fd < 0) {
70 log_message(MSG_FATAL, "fc_get_request: fcode_fd not open\n");
71 return (0);
72 }
73
74 if ((nbytes = read(cdp->fcode_fd, &c, sizeof (c))) < 0) {
75 log_perror(MSG_FATAL, "read(%s) failed", fcode_dev);
76 return (0);
77 }
78
79 if (ioctl(cdp->fcode_fd, FC_GET_PARAMETERS, &cdp->fc) < 0) {
80 log_perror(MSG_FATAL, "ioctl(FC_GET_PARAMETERS) failed");
81 return (0);
82 }
83
84 if ((cdp->attach = fc_get_ap(cdp)) == NULL)
85 return (0);
86
87 return (1);
88 }
89
90 static void
get_my_args(fcode_env_t * env)91 get_my_args(fcode_env_t *env)
92 {
93 common_data_t *cdp = env->private;
94 char buffer[BUFSIZ];
95
96 /*
97 * Don't get if already set.
98 */
99 if (pkg_my_args)
100 return;
101
102 if (ioctl(cdp->fcode_fd, FC_GET_MY_ARGS, buffer) < 0) {
103 return;
104 }
105 pkg_my_args = STRDUP(buffer);
106 }
107
108 static void
set_my_args(fcode_env_t * env)109 set_my_args(fcode_env_t *env)
110 {
111 if (pkg_my_args)
112 FREE(pkg_my_args);
113
114 parse_word(env);
115 pkg_my_args = pop_a_duped_string(env, NULL);
116 }
117
118 static void
dot_my_args(fcode_env_t * env)119 dot_my_args(fcode_env_t *env)
120 {
121 if (pkg_my_args)
122 log_message(MSG_INFO, "%s\n", pkg_my_args);
123 else
124 log_message(MSG_INFO, "NULL\n");
125 }
126
127 void
push_my_args(fcode_env_t * env)128 push_my_args(fcode_env_t *env)
129 {
130 push_a_string(env, pkg_my_args);
131 }
132
133 void
get_fcode_from_device(fcode_env_t * env)134 get_fcode_from_device(fcode_env_t *env)
135 {
136 common_data_t *cdp = env->private;
137 char *p, *buf;
138 static char func_name[] = "get_fcode_from_device";
139 fc_fcode_info_t fcode_info;
140
141 if (!cdp->fc.fcode_size) {
142 debug_msg(DEBUG_FIND_FCODE, "%s: Fcode zero length\n",
143 func_name);
144 push_a_string(env, NULL);
145 return;
146 }
147 fcode_info.fcode_size = cdp->fc.fcode_size;
148 fcode_info.fcode_ptr = MALLOC(cdp->fc.fcode_size);
149 if (ioctl(cdp->fcode_fd, FC_GET_FCODE_DATA, &fcode_info) < 0) {
150 log_perror(MSG_FATAL, "ioctl(FC_GET_FCODE_DATA) failed");
151 push_a_string(env, NULL);
152 } else {
153 debug_msg(DEBUG_FIND_FCODE,
154 "%s: Fcode from device: len: 0x%x\n", func_name,
155 (int)cdp->fc.fcode_size);
156 PUSH(DS, (fstack_t)fcode_info.fcode_ptr);
157 PUSH(DS, (fstack_t)cdp->fc.fcode_size);
158 }
159 }
160
161 static void
save_fcode_to_file(fcode_env_t * env)162 save_fcode_to_file(fcode_env_t *env)
163 {
164 char *buf, *fname;
165 int len;
166 FILE *fd;
167
168 CHECK_DEPTH(env, 4, "save-fcode-to-file");
169 if ((fname = pop_a_string(env, NULL)) == NULL) {
170 log_message(MSG_DEBUG, "fname?\n");
171 return;
172 }
173 if ((buf = pop_a_string(env, &len)) == NULL) {
174 log_message(MSG_INFO, "buf?\n");
175 return;
176 }
177 if ((fd = fopen(fname, "w")) == NULL) {
178 log_perror(MSG_DEBUG, "Save_fcode_to_file: Can't open '%s'",
179 fname);
180 return;
181 }
182 log_message(MSG_INFO, "Fcode %p,%x to file '%s'\n", buf, len, fname);
183 fwrite(buf, len, sizeof (char), fd);
184 fclose(fd);
185 }
186
187 void
exec_fcode_builtin_method(fcode_env_t * env)188 exec_fcode_builtin_method(fcode_env_t *env)
189 {
190 fstack_t d;
191 char *method;
192 extern void exec_parent_method(fcode_env_t *);
193 extern void exec_builtin_driver(fcode_env_t *);
194
195 method = (char *)DS[-1];
196 exec_parent_method(env);
197 d = POP(DS);
198 if (d) {
199 debug_msg(DEBUG_FIND_FCODE, "builtin-driver: %s -> %s found\n",
200 method, (char *)DS[-1]);
201 exec_builtin_driver(env);
202 debug_msg(DEBUG_FIND_FCODE, "builtin-driver-exec: %p %x\n",
203 (char *)DS[-1], (int)TOS);
204 } else {
205 debug_msg(DEBUG_FIND_FCODE, "builtin-driver: %s not found\n",
206 method);
207 PUSH(DS, FALSE);
208 }
209 }
210
211 void
get_fcode_from_filesystem(fcode_env_t * env)212 get_fcode_from_filesystem(fcode_env_t *env)
213 {
214 fstack_t d;
215 char *method, *fc_name, *path;
216 extern void exec_parent_method(fcode_env_t *);
217 static char fname[] = "get-fcode-from-filesystem";
218
219 method = (char *)DS[-1];
220 exec_parent_method(env);
221 d = POP(DS);
222 if (d) {
223 fc_name = pop_a_string(env, NULL);
224 debug_msg(DEBUG_FIND_FCODE, "%s: %s -> %s found\n", fname,
225 method, fc_name);
226 if ((path = search_for_fcode_file(env, fc_name)) != NULL) {
227 debug_msg(DEBUG_FIND_FCODE, "%s: file: %s FOUND\n",
228 fname, path);
229 push_a_string(env, path);
230 load_file(env);
231 } else {
232 debug_msg(DEBUG_FIND_FCODE, "%s: file '%s' not found\n",
233 fname, fc_name);
234 PUSH(DS, FALSE);
235 }
236 } else {
237 debug_msg(DEBUG_FIND_FCODE, "%s: method '%s' not found\n",
238 fname, method);
239 PUSH(DS, FALSE);
240 }
241 }
242
243 /*
244 * Looks for "device-id" and "class-id" methods in parent, if there,
245 * executes them to get "builtin drivers" file name or method name, then
246 * executes the builtin-driver method. If both those fail, try getting the
247 * fcode from the device. Note that we sleaze resetting the data stack.
248 * This would be cleaner if we had a way to do the equivalent of "catch/throw"
249 * from within C code.
250 */
251 void
find_fcode(fcode_env_t * env)252 find_fcode(fcode_env_t *env)
253 {
254 fstack_t *dp = env->ds;
255 common_data_t *cdp = env->private;
256 static char func_name[] = "find_fcode";
257 int error;
258
259 my_unit(env);
260 push_a_string(env, "device-id");
261 get_fcode_from_filesystem(env);
262 if (TOS) {
263 debug_msg(DEBUG_FIND_FCODE, "%s: FS dev-id: len: 0x%x\n",
264 func_name, TOS);
265 return;
266 }
267
268 env->ds = dp;
269 my_unit(env);
270 push_a_string(env, "class-id");
271 get_fcode_from_filesystem(env);
272 if (TOS) {
273 debug_msg(DEBUG_FIND_FCODE, "%s: FS cls-id len: 0x%x\n",
274 func_name, TOS);
275 return;
276 }
277
278 env->ds = dp;
279 get_fcode_from_device(env);
280 if (TOS) {
281 debug_msg(DEBUG_FIND_FCODE, "%s: DEV fcode len: 0x%x\n",
282 func_name, TOS);
283 return;
284 }
285
286 env->ds = dp;
287 my_unit(env);
288 push_a_string(env, "device-id");
289 exec_fcode_builtin_method(env);
290 if (TOS) {
291 debug_msg(DEBUG_FIND_FCODE, "%s: dropin dev-id len: 0x%x\n",
292 func_name, TOS);
293 return;
294 }
295
296 env->ds = dp;
297 my_unit(env);
298 push_a_string(env, "class-id");
299 exec_fcode_builtin_method(env);
300 if (TOS) {
301 debug_msg(DEBUG_FIND_FCODE, "%s: dropin cls-id len: 0x%x\n",
302 func_name, TOS);
303 return;
304 }
305
306 debug_msg(DEBUG_FIND_FCODE, "%s: not found\n", func_name);
307 error = FC_NO_FCODE;
308 if (ioctl(cdp->fcode_fd, FC_SET_FCODE_ERROR, &error) < 0) {
309 log_perror(MSG_FATAL, "ioctl(FC_SET_FCODE_ERROR) failed");
310 return;
311 }
312 }
313
314 int
open_fcode_dev(fcode_env_t * env)315 open_fcode_dev(fcode_env_t *env)
316 {
317 common_data_t *cdp = env->private;
318
319 if ((cdp->fcode_fd = open(fcode_dev, O_RDONLY)) < 0)
320 log_perror(MSG_ERROR, "Can't open '%s'", fcode_dev);
321 return (cdp->fcode_fd >= 0);
322 }
323
324 static void
get_request(fcode_env_t * env)325 get_request(fcode_env_t *env)
326 {
327 common_data_t *cdp = env->private;
328
329 if (cdp->fcode_fd >= 0)
330 close(cdp->fcode_fd);
331 if (!open_fcode_dev(env))
332 exit(1);
333 if (!fc_get_request(cdp)) {
334 log_message(MSG_FATAL, "fc_get_request failed\n");
335 exit(1);
336 }
337
338 get_my_args(env);
339
340 DEBUGF(UPLOAD, dot_request(env));
341 }
342
343 /*
344 * invoked from efdaemon, /dev/fcode event has been read and /dev/fcode opened
345 * file descriptor is fd 0.
346 */
347 static void
get_efdaemon_request(fcode_env_t * env)348 get_efdaemon_request(fcode_env_t *env)
349 {
350 common_data_t *cdp = env->private;
351
352 cdp->fcode_fd = 0;
353 if (ioctl(cdp->fcode_fd, FC_GET_PARAMETERS, &cdp->fc) < 0) {
354 log_perror(MSG_FATAL, "ioctl(FC_GET_PARAMETERS) failed");
355 exit(1);
356 }
357
358 if ((cdp->attach = fc_get_ap(cdp)) == NULL)
359 exit(1);
360
361 get_my_args(env);
362
363 DEBUGF(UPLOAD, dot_request(env));
364 }
365
366 static void
process_request(fcode_env_t * env)367 process_request(fcode_env_t *env)
368 {
369 common_data_t *cdp = env->private;
370 fstack_t fcode_len;
371 char *path;
372
373 build_tree(env);
374 install_builtin_nodes(env);
375 push_my_args(env);
376 push_a_string(env, cdp->fc.unit_address);
377 if ((path = get_path(env, env->attachment_pt)) == NULL) {
378 log_message(MSG_FATAL, "Can't get_path of"
379 " attachment_pt %p\n", env->attachment_pt);
380 exit(1);
381 }
382 debug_msg(DEBUG_UPLOAD, "Attach Point: %s\n", path);
383
384 push_a_string(env, path);
385 begin_package(env);
386 find_fcode(env);
387 fcode_len = POP(DS);
388 if (!fcode_len) {
389 (void) POP(DS);
390 debug_msg(DEBUG_UPLOAD, "Zero length Fcode\n");
391 return;
392 }
393
394 debug_msg(DEBUG_UPLOAD, "byte-load fcode_len: %x\n",
395 fcode_len);
396
397 PUSH(DS, 1);
398 byte_load(env);
399 end_package(env);
400 upload_nodes(env);
401 validate_nodes(env);
402 debug_msg(DEBUG_UPLOAD, "Upload Done\n");
403 }
404
405 static void
finish_request(fcode_env_t * env)406 finish_request(fcode_env_t *env)
407 {
408 common_data_t *cdp = env->private;
409
410 close(cdp->fcode_fd);
411 }
412
413 /*
414 * Non-daemon "do-request", for debugging
415 */
416 static void
do_request(fcode_env_t * env)417 do_request(fcode_env_t *env)
418 {
419 get_request(env);
420 process_request(env);
421 finish_request(env);
422 }
423
424 /*
425 * This process one request from efdaemon, we know that /dev/fcode is already
426 * open and passed in fd0 (stdin). If it's not, we throw up our hands.
427 */
428 void
run_one_efdaemon_request(fcode_env_t * env)429 run_one_efdaemon_request(fcode_env_t *env)
430 {
431 get_efdaemon_request(env);
432 process_request(env);
433 finish_request(env);
434 exit(0);
435 }
436
437 void
probe_space(fcode_env_t * env)438 probe_space(fcode_env_t *env)
439 {
440 fc_cell_t cfg = 0;
441 int error;
442
443 error = fc_run_priv(env->private, FC_PROBE_SPACE, 0, 1, &cfg);
444 if (error)
445 throw_from_fclib(env, 1, "FC_PROBE_SPACE failed\n");
446 PUSH(DS, fc_cell2uint32_t(cfg));
447 }
448
449 #pragma init(_init)
450
451 static void
_init(void)452 _init(void)
453 {
454 fcode_env_t *env = initial_env;
455
456 ASSERT(env);
457 NOTICE;
458
459 FORTH(0, "get-fcode-from-device", get_fcode_from_device);
460 FORTH(0, "save-fcode-to-file", save_fcode_to_file);
461 FORTH(0, "get-my-args", get_my_args);
462 FORTH(0, "set-my-args", set_my_args);
463 FORTH(0, ".my-args", dot_my_args);
464 FORTH(0, ".request", dot_request);
465 FORTH(0, "get-request", get_request);
466 FORTH(0, "process-request", process_request);
467 FORTH(0, "finish-request", finish_request);
468 FORTH(0, "do-request", do_request);
469 FORTH(0, "find-fcode", find_fcode);
470 FORTH(0, "exec-fcode-builtin-method", exec_fcode_builtin_method);
471 FORTH(0, "run-one-efdaemon-request", run_one_efdaemon_request);
472 FORTH(0, "get-efdaemon-request", get_efdaemon_request);
473 FORTH(0, "probe-space", probe_space);
474 }
475