138 |
char *bootdevice = 0; |
char *bootdevice = 0; |
139 |
char *bootscript = 0; |
char *bootscript = 0; |
140 |
|
|
|
void set_mach_stack_args (task_t, thread_t, char *, ...); |
|
141 |
|
|
142 |
void safe_gets (char *buf, int buf_len) |
void safe_gets (char *buf, int buf_len) |
143 |
{ |
{ |
274 |
lseek (fd, sizeof hdr.a - headercruft, SEEK_SET); |
lseek (fd, sizeof hdr.a - headercruft, SEEK_SET); |
275 |
read (fd, buf, amount); |
read (fd, buf, amount); |
276 |
vm_allocate (t, &base, rndamount, 0); |
vm_allocate (t, &base, rndamount, 0); |
277 |
vm_write (t, base, (u_int) buf, rndamount); |
vm_write (t, base, (vm_address_t) buf, rndamount); |
278 |
if (magic != OMAGIC) |
if (magic != OMAGIC) |
279 |
vm_protect (t, base, trunc_page (headercruft + hdr.a.a_text), |
vm_protect (t, base, trunc_page (headercruft + hdr.a.a_text), |
280 |
0, VM_PROT_READ | VM_PROT_EXECUTE); |
0, VM_PROT_READ | VM_PROT_EXECUTE); |
342 |
{ |
{ |
343 |
char *args, *p; |
char *args, *p; |
344 |
int arg_len, i; |
int arg_len, i; |
345 |
unsigned reg_size; |
size_t reg_size; |
346 |
void *arg_pos; |
void *arg_pos; |
347 |
vm_offset_t stack_start, stack_end; |
vm_offset_t stack_start, stack_end; |
348 |
vm_address_t startpc, str_start; |
vm_address_t startpc, str_start; |
349 |
thread_t thread; |
thread_t thread; |
|
struct i386_thread_state regs; |
|
350 |
|
|
351 |
write (2, path, strlen (path)); |
write (2, path, strlen (path)); |
352 |
for (i = 1; i < argc; ++i) |
for (i = 1; i < argc; ++i) |
357 |
write (2, "\r\n", 2); |
write (2, "\r\n", 2); |
358 |
|
|
359 |
startpc = load_image (task, path); |
startpc = load_image (task, path); |
|
thread_create (task, &thread); |
|
360 |
arg_len = stringlen + (argc + 2) * sizeof (char *) + sizeof (integer_t); |
arg_len = stringlen + (argc + 2) * sizeof (char *) + sizeof (integer_t); |
361 |
arg_len += 5 * sizeof (int); |
arg_len += 5 * sizeof (int); |
362 |
stack_end = VM_MAX_ADDRESS; |
stack_end = VM_MAX_ADDRESS; |
363 |
stack_start = VM_MAX_ADDRESS - 16 * 1024 * 1024; |
stack_start = VM_MAX_ADDRESS - 16 * 1024 * 1024; |
364 |
vm_allocate (task, &stack_start, stack_end - stack_start, FALSE); |
vm_allocate (task, &stack_start, stack_end - stack_start, FALSE); |
365 |
reg_size = i386_THREAD_STATE_COUNT; |
arg_pos = (void *) ((stack_end - arg_len) & ~(sizeof (natural_t) - 1)); |
|
thread_get_state (thread, i386_THREAD_STATE, |
|
|
(thread_state_t) ®s, ®_size); |
|
|
regs.eip = (int) startpc; |
|
|
regs.uesp = (int) ((stack_end - arg_len) & ~(sizeof (int) - 1)); |
|
|
thread_set_state (thread, i386_THREAD_STATE, |
|
|
(thread_state_t) ®s, reg_size); |
|
|
arg_pos = (void *) regs.uesp; |
|
366 |
args = mmap (0, stack_end - trunc_page ((vm_offset_t) arg_pos), |
args = mmap (0, stack_end - trunc_page ((vm_offset_t) arg_pos), |
367 |
PROT_READ|PROT_WRITE, MAP_ANON, 0, 0); |
PROT_READ|PROT_WRITE, MAP_ANON, 0, 0); |
368 |
str_start = ((vm_address_t) arg_pos |
str_start = ((vm_address_t) arg_pos |
379 |
stack_end - trunc_page ((vm_offset_t) arg_pos)); |
stack_end - trunc_page ((vm_offset_t) arg_pos)); |
380 |
munmap ((caddr_t) args, |
munmap ((caddr_t) args, |
381 |
stack_end - trunc_page ((vm_offset_t) arg_pos)); |
stack_end - trunc_page ((vm_offset_t) arg_pos)); |
382 |
|
|
383 |
|
thread_create (task, &thread); |
384 |
|
#ifdef I386_THREAD_STATE |
385 |
|
{ |
386 |
|
struct i386_thread_state regs; |
387 |
|
reg_size = i386_THREAD_STATE_COUNT; |
388 |
|
thread_get_state (thread, i386_THREAD_STATE, |
389 |
|
(thread_state_t) ®s, ®_size); |
390 |
|
regs.eip = (int) startpc; |
391 |
|
regs.uesp = (int) arg_pos; |
392 |
|
thread_set_state (thread, i386_THREAD_STATE, |
393 |
|
(thread_state_t) ®s, reg_size); |
394 |
|
} |
395 |
|
#elif ALPHA_THREAD_STATE |
396 |
|
{ |
397 |
|
struct alpha_thread_state regs; |
398 |
|
reg_size = ALPHA_THREAD_STATE_COUNT; |
399 |
|
thread_get_state (thread, ALPHA_THREAD_STATE, |
400 |
|
(thread_state_t) ®s, ®_size); |
401 |
|
regs.r30 = (natural_t) arg_pos; |
402 |
|
regs.pc = (natural_t) startpc; |
403 |
|
thread_set_state (thread, ALPHA_THREAD_STATE, |
404 |
|
(thread_state_t) ®s, reg_size); |
405 |
|
} |
406 |
|
#else |
407 |
|
# error needs to be ported |
408 |
|
#endif |
409 |
|
|
410 |
thread_resume (thread); |
thread_resume (thread); |
411 |
mach_port_deallocate (mach_task_self (), thread); |
mach_port_deallocate (mach_task_self (), thread); |
412 |
return 0; |
return 0; |
545 |
if (boot_script_set_variable ("host-port", VAL_PORT, |
if (boot_script_set_variable ("host-port", VAL_PORT, |
546 |
(int) privileged_host_port) |
(int) privileged_host_port) |
547 |
|| boot_script_set_variable ("device-port", VAL_PORT, |
|| boot_script_set_variable ("device-port", VAL_PORT, |
548 |
(int) pseudo_master_device_port) |
(integer_t) pseudo_master_device_port) |
549 |
|| boot_script_set_variable ("kernel-command-line", VAL_STR, |
|| boot_script_set_variable ("kernel-command-line", VAL_STR, |
550 |
(int) kernel_command_line) |
(integer_t) kernel_command_line) |
551 |
|| boot_script_set_variable ("root-device", VAL_STR, (int) bootdevice) |
|| boot_script_set_variable ("root-device", |
552 |
|| boot_script_set_variable ("boot-args", VAL_STR, (int) bootstrap_args)) |
VAL_STR, (integer_t) bootdevice) |
553 |
|
|| boot_script_set_variable ("boot-args", |
554 |
|
VAL_STR, (integer_t) bootstrap_args)) |
555 |
{ |
{ |
556 |
static const char msg[] = "error setting variable"; |
static const char msg[] = "error setting variable"; |
557 |
|
|
572 |
if (eq == 0) |
if (eq == 0) |
573 |
continue; |
continue; |
574 |
*eq++ = '\0'; |
*eq++ = '\0'; |
575 |
err = boot_script_set_variable (word, VAL_STR, (int) eq); |
err = boot_script_set_variable (word, VAL_STR, (integer_t) eq); |
576 |
if (err) |
if (err) |
577 |
{ |
{ |
578 |
char *msg; |
char *msg; |
700 |
/* mach_msg_server (request_server, __vm_page_size * 2, receive_set); */ |
/* mach_msg_server (request_server, __vm_page_size * 2, receive_set); */ |
701 |
} |
} |
702 |
|
|
|
/* Set up stack args the Mach way */ |
|
|
void |
|
|
set_mach_stack_args (task_t user_task, |
|
|
thread_t user_thread, |
|
|
char *startpc, ...) |
|
|
{ |
|
|
/* This code is lifted from .../mk/bootstrap/load.c. */ |
|
|
va_list argv_ptr; |
|
|
char * arg_ptr; |
|
|
|
|
|
int arg_len; |
|
|
int arg_count; |
|
|
char * arg_pos; |
|
|
unsigned int arg_item_len; |
|
|
|
|
|
/* |
|
|
* Calculate the size of the argument list. |
|
|
*/ |
|
|
va_start(argv_ptr, startpc); |
|
|
arg_len = 0; |
|
|
arg_count = 0; |
|
|
for (;;) { |
|
|
arg_ptr = va_arg(argv_ptr, char *); |
|
|
if (arg_ptr == (char *)0) |
|
|
break; |
|
|
arg_count++; |
|
|
arg_len += strlen(arg_ptr) + 1; /* space for '\0' */ |
|
|
} |
|
|
va_end(argv_ptr); |
|
|
/* |
|
|
* Add space for: |
|
|
* arg_count |
|
|
* pointers to arguments |
|
|
* trailing 0 pointer |
|
|
* dummy 0 pointer to environment variables |
|
|
* and align to integer boundary |
|
|
*/ |
|
|
arg_len += sizeof(integer_t) + (2 + arg_count) * sizeof(char *); |
|
|
arg_len = (arg_len + (sizeof(integer_t) - 1)) & ~(sizeof(integer_t)-1); |
|
|
|
|
|
|
|
|
/* This small piece is from .../mk/bootstrap/i386/exec.c. */ |
|
|
{ |
|
|
vm_offset_t stack_start; |
|
|
vm_offset_t stack_end; |
|
|
struct i386_thread_state regs; |
|
|
unsigned int reg_size; |
|
|
|
|
|
#define STACK_SIZE (1024 * 1024 * 16) |
|
|
|
|
|
/* |
|
|
* Add space for 5 ints to arguments, for |
|
|
* PS program. XXX |
|
|
*/ |
|
|
arg_len += 5 * sizeof(int); |
|
|
|
|
|
/* |
|
|
* Allocate stack. |
|
|
*/ |
|
|
stack_end = VM_MAX_ADDRESS; |
|
|
stack_start = VM_MAX_ADDRESS - STACK_SIZE; |
|
|
(void)vm_allocate(user_task, |
|
|
&stack_start, |
|
|
(vm_size_t)(stack_end - stack_start), |
|
|
FALSE); |
|
|
|
|
|
reg_size = i386_THREAD_STATE_COUNT; |
|
|
(void)thread_get_state(user_thread, |
|
|
i386_THREAD_STATE, |
|
|
(thread_state_t)®s, |
|
|
®_size); |
|
|
|
|
|
regs.eip = (int) startpc; |
|
|
regs.uesp = (int)((stack_end - arg_len) & ~(sizeof(int)-1)); |
|
|
|
|
|
(void)thread_set_state(user_thread, |
|
|
i386_THREAD_STATE, |
|
|
(thread_state_t)®s, |
|
|
reg_size); |
|
|
|
|
|
arg_pos = (void *) regs.uesp; |
|
|
} |
|
|
|
|
|
/* |
|
|
* Copy out the arguments. |
|
|
*/ |
|
|
{ |
|
|
vm_offset_t u_arg_start; |
|
|
/* user start of argument list block */ |
|
|
vm_offset_t k_arg_start; |
|
|
/* kernel start of argument list block */ |
|
|
vm_offset_t u_arg_page_start; |
|
|
/* user start of args, page-aligned */ |
|
|
vm_size_t arg_page_size; |
|
|
/* page_aligned size of args */ |
|
|
vm_offset_t k_arg_page_start; |
|
|
/* kernel start of args, page-aligned */ |
|
|
|
|
|
register |
|
|
char ** k_ap; /* kernel arglist address */ |
|
|
char * u_cp; /* user argument string address */ |
|
|
register |
|
|
char * k_cp; /* kernel argument string address */ |
|
|
register |
|
|
int i; |
|
|
|
|
|
/* |
|
|
* Get address of argument list in user space |
|
|
*/ |
|
|
u_arg_start = (vm_offset_t)arg_pos; |
|
|
|
|
|
/* |
|
|
* Round to page boundaries, and allocate kernel copy |
|
|
*/ |
|
|
u_arg_page_start = trunc_page(u_arg_start); |
|
|
arg_page_size = (vm_size_t)(round_page(u_arg_start + arg_len) |
|
|
- u_arg_page_start); |
|
|
|
|
|
k_arg_page_start = (vm_address_t) mmap (0, arg_page_size, |
|
|
PROT_READ|PROT_WRITE, |
|
|
MAP_ANON, 0, 0); |
|
|
|
|
|
/* |
|
|
* Set up addresses corresponding to user pointers |
|
|
* in the kernel block |
|
|
*/ |
|
|
k_arg_start = k_arg_page_start + (u_arg_start - u_arg_page_start); |
|
|
|
|
|
k_ap = (char **)k_arg_start; |
|
|
|
|
|
/* |
|
|
* Start the strings after the arg-count and pointers |
|
|
*/ |
|
|
u_cp = (char *)u_arg_start + arg_count * sizeof(char *) |
|
|
+ 2 * sizeof(char *) |
|
|
+ sizeof(integer_t); |
|
|
k_cp = (char *)k_arg_start + arg_count * sizeof(char *) |
|
|
+ 2 * sizeof(char *) |
|
|
+ sizeof(integer_t); |
|
|
|
|
|
/* |
|
|
* first the argument count |
|
|
*/ |
|
|
*k_ap++ = (char *)(natural_t)arg_count; |
|
|
|
|
|
/* |
|
|
* Then the strings and string pointers for each argument |
|
|
*/ |
|
|
va_start(argv_ptr, startpc); |
|
|
for (i = 0; i < arg_count; i++) { |
|
|
arg_ptr = va_arg(argv_ptr, char *); |
|
|
arg_item_len = strlen(arg_ptr) + 1; /* include trailing 0 */ |
|
|
|
|
|
/* set string pointer */ |
|
|
*k_ap++ = u_cp; |
|
|
|
|
|
/* copy string */ |
|
|
bcopy(arg_ptr, k_cp, arg_item_len); |
|
|
k_cp += arg_item_len; |
|
|
u_cp += arg_item_len; |
|
|
} |
|
|
va_end(argv_ptr); |
|
|
|
|
|
/* |
|
|
* last, the trailing 0 argument and a null environment pointer. |
|
|
*/ |
|
|
*k_ap++ = (char *)0; |
|
|
*k_ap = (char *)0; |
|
|
|
|
|
/* |
|
|
* Now write all of this to user space. |
|
|
*/ |
|
|
(void) vm_write(user_task, |
|
|
u_arg_page_start, |
|
|
k_arg_page_start, |
|
|
arg_page_size); |
|
|
|
|
|
(void) munmap ((caddr_t) k_arg_page_start, |
|
|
arg_page_size); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
703 |
void |
void |
704 |
msg_thread() |
msg_thread() |
705 |
{ |
{ |
978 |
dev_mode_t mode, |
dev_mode_t mode, |
979 |
recnum_t recnum, |
recnum_t recnum, |
980 |
io_buf_ptr_t data, |
io_buf_ptr_t data, |
981 |
unsigned int datalen, |
size_t datalen, |
982 |
int *bytes_written) |
int *bytes_written) |
983 |
{ |
{ |
984 |
if (device == pseudo_console) |
if (device == pseudo_console) |
1012 |
dev_mode_t mode, |
dev_mode_t mode, |
1013 |
recnum_t recnum, |
recnum_t recnum, |
1014 |
io_buf_ptr_inband_t data, |
io_buf_ptr_inband_t data, |
1015 |
unsigned int datalen, |
size_t datalen, |
1016 |
int *bytes_written) |
int *bytes_written) |
1017 |
{ |
{ |
1018 |
if (device == pseudo_console) |
if (device == pseudo_console) |
1047 |
recnum_t recnum, |
recnum_t recnum, |
1048 |
int bytes_wanted, |
int bytes_wanted, |
1049 |
io_buf_ptr_t *data, |
io_buf_ptr_t *data, |
1050 |
unsigned int *datalen) |
size_t *datalen) |
1051 |
{ |
{ |
1052 |
if (device == pseudo_console) |
if (device == pseudo_console) |
1053 |
{ |
{ |
1102 |
recnum_t recnum, |
recnum_t recnum, |
1103 |
int bytes_wanted, |
int bytes_wanted, |
1104 |
io_buf_ptr_inband_t data, |
io_buf_ptr_inband_t data, |
1105 |
unsigned int *datalen) |
size_t *datalen) |
1106 |
{ |
{ |
1107 |
if (device == pseudo_console) |
if (device == pseudo_console) |
1108 |
{ |
{ |
1165 |
ds_xxx_device_set_status (device_t device, |
ds_xxx_device_set_status (device_t device, |
1166 |
dev_flavor_t flavor, |
dev_flavor_t flavor, |
1167 |
dev_status_t status, |
dev_status_t status, |
1168 |
u_int statu_cnt) |
size_t statu_cnt) |
1169 |
{ |
{ |
1170 |
if (device != pseudo_console) |
if (device != pseudo_console) |
1171 |
return D_NO_SUCH_DEVICE; |
return D_NO_SUCH_DEVICE; |
1176 |
ds_xxx_device_get_status (device_t device, |
ds_xxx_device_get_status (device_t device, |
1177 |
dev_flavor_t flavor, |
dev_flavor_t flavor, |
1178 |
dev_status_t status, |
dev_status_t status, |
1179 |
u_int *statuscnt) |
size_t *statuscnt) |
1180 |
{ |
{ |
1181 |
if (device != pseudo_console && device != pseudo_root) |
if (device != pseudo_console && device != pseudo_root) |
1182 |
return D_NO_SUCH_DEVICE; |
return D_NO_SUCH_DEVICE; |
1188 |
mach_port_t rec, |
mach_port_t rec, |
1189 |
int pri, |
int pri, |
1190 |
filter_array_t filt, |
filter_array_t filt, |
1191 |
unsigned int len) |
size_t len) |
1192 |
{ |
{ |
1193 |
if (device != pseudo_console && device != pseudo_root) |
if (device != pseudo_console && device != pseudo_root) |
1194 |
return D_NO_SUCH_DEVICE; |
return D_NO_SUCH_DEVICE; |
1212 |
ds_device_set_status (device_t device, |
ds_device_set_status (device_t device, |
1213 |
dev_flavor_t flavor, |
dev_flavor_t flavor, |
1214 |
dev_status_t status, |
dev_status_t status, |
1215 |
unsigned int statuslen) |
size_t statuslen) |
1216 |
{ |
{ |
1217 |
if (device != pseudo_console && device != pseudo_root) |
if (device != pseudo_console && device != pseudo_root) |
1218 |
return D_NO_SUCH_DEVICE; |
return D_NO_SUCH_DEVICE; |
1223 |
ds_device_get_status (device_t device, |
ds_device_get_status (device_t device, |
1224 |
dev_flavor_t flavor, |
dev_flavor_t flavor, |
1225 |
dev_status_t status, |
dev_status_t status, |
1226 |
unsigned int *statuslen) |
size_t *statuslen) |
1227 |
{ |
{ |
1228 |
if (device == pseudo_console) |
if (device == pseudo_console) |
1229 |
return D_INVALID_OPERATION; |
return D_INVALID_OPERATION; |
1249 |
mach_port_t receive_port, |
mach_port_t receive_port, |
1250 |
int priority, |
int priority, |
1251 |
filter_array_t filter, |
filter_array_t filter, |
1252 |
unsigned int filterlen) |
size_t filterlen) |
1253 |
{ |
{ |
1254 |
if (device != pseudo_console && device != pseudo_root) |
if (device != pseudo_console && device != pseudo_root) |
1255 |
return D_NO_SUCH_DEVICE; |
return D_NO_SUCH_DEVICE; |
1569 |
{ |
{ |
1570 |
uid_t *gu, *au; |
uid_t *gu, *au; |
1571 |
gid_t *gg, *ag; |
gid_t *gg, *ag; |
1572 |
unsigned int gulen = 0, aulen = 0, gglen = 0, aglen = 0; |
size_t gulen = 0, aulen = 0, gglen = 0, aglen = 0; |
1573 |
error_t err; |
error_t err; |
1574 |
|
|
1575 |
err = mach_port_insert_right (mach_task_self (), object, object, |
err = mach_port_insert_right (mach_task_self (), object, object, |
1602 |
mach_port_t *newobject, |
mach_port_t *newobject, |
1603 |
mach_msg_type_name_t *newobjtype, |
mach_msg_type_name_t *newobjtype, |
1604 |
uid_t *uids, |
uid_t *uids, |
1605 |
u_int nuids, |
size_t nuids, |
1606 |
uid_t *gids, |
uid_t *gids, |
1607 |
u_int ngids) |
size_t ngids) |
1608 |
{ |
{ |
1609 |
if (object != pseudo_console) |
if (object != pseudo_console) |
1610 |
return EOPNOTSUPP; |
return EOPNOTSUPP; |