/* Wire down all the text and data (including from shared libraries)
for the current program. */
void
wire_task_self ()
{
struct link_map *map;
mach_port_t host, device;
error_t error;
extern char _edata, _etext, __data_start;
error = get_privileged_ports (&host, &device);
if (error)
return;
map = loaded ();
if (!map)
{
extern void _start ();
vm_address_t text_start = (vm_address_t) &_start;
wire_segment_internal (text_start,
(vm_size_t) (&_etext - text_start),
host);
wire_segment_internal ((vm_address_t) &__data_start,
(vm_size_t) (&_edata - &__data_start),
host);
}
else
while (map)
wire_segment ((vm_address_t) map->l_addr, map_extent (map));
mach_port_deallocate (mach_task_self (), host);
mach_port_deallocate (mach_task_self (), device);
}
int main ()
{
int res, i;
mach_port_t host_privileged_port;
device_t device_privileged_port;
res = get_privileged_ports(&host_privileged_port, &device_privileged_port);
if (res != KERN_SUCCESS) {
printf ("Error getting privileged ports (0x%x), %s\n", res,
mach_error_string(res));
exit(1);
}
printf ("privileged ports: host 0x%x devices 0x%x\n",
host_privileged_port, device_privileged_port);
printf ("Getting processors at array 0x%x\n", processor_list);
res = host_processors(host_privileged_port,
&processor_list, &processor_listCnt);
if (res != KERN_SUCCESS) {
printf ("Error getting host_processors (0x%x), %s\n", res,
mach_error_string(res));
exit(1);
}
printf (" processors at array 0x%x\n", processor_list);
printf ("processor_listCnt %d\n", processor_listCnt);
for (i=0; i < processor_listCnt; i++)
printf ("processor_list[%d] 0x%x\n", i, processor_list[i]);
}
int
ethernet_open (struct device *dev)
{
error_t err;
device_t master_device;
struct ether_device *edev = (struct ether_device *) dev->priv;
assert (edev->ether_port == MACH_PORT_NULL);
err = ports_create_port (etherreadclass, etherport_bucket,
sizeof (struct port_info), &edev->readpt);
assert_perror (err);
edev->readptname = ports_get_right (edev->readpt);
mach_port_insert_right (mach_task_self (), edev->readptname, edev->readptname,
MACH_MSG_TYPE_MAKE_SEND);
mach_port_set_qlimit (mach_task_self (), edev->readptname, MACH_PORT_QLIMIT_MAX);
master_device = file_name_lookup (dev->name, O_READ | O_WRITE, 0);
if (master_device != MACH_PORT_NULL)
{
/* The device name here is the path of a device file. */
err = device_open (master_device, D_WRITE | D_READ, "eth", &edev->ether_port);
mach_port_deallocate (mach_task_self (), master_device);
if (err)
error (2, err, "device_open on %s", dev->name);
err = device_set_filter (edev->ether_port, ports_get_right (edev->readpt),
MACH_MSG_TYPE_MAKE_SEND, 0,
bpf_ether_filter, bpf_ether_filter_len);
if (err)
error (2, err, "device_set_filter on %s", dev->name);
}
else
{
/* No, perhaps a Mach device? */
int file_errno = errno;
err = get_privileged_ports (0, &master_device);
if (err)
{
error (0, file_errno, "file_name_lookup %s", dev->name);
error (2, err, "and cannot get device master port");
}
err = device_open (master_device, D_WRITE | D_READ, dev->name, &edev->ether_port);
mach_port_deallocate (mach_task_self (), master_device);
if (err)
{
error (0, file_errno, "file_name_lookup %s", dev->name);
error (2, err, "device_open(%s)", dev->name);
}
err = device_set_filter (edev->ether_port, ports_get_right (edev->readpt),
MACH_MSG_TYPE_MAKE_SEND, 0,
ether_filter, ether_filter_len);
if (err)
error (2, err, "device_set_filter on %s", dev->name);
}
return 0;
}
void
xf86OpenConsole()
{
if( serverGeneration == 1 )
{
kern_return_t err;
mach_port_t device;
int fd;
err = get_privileged_ports( NULL, &device );
if( err )
{
errno = err;
FatalError( "xf86KbdInit can't get_privileged_ports. (%s)\n" , strerror(errno) );
}
mach_port_deallocate (mach_task_self (), device);
if( ( fd = open( "/dev/kbd" , O_RDONLY|O_NONBLOCK ) ) < 0 )
{
fprintf( stderr , "Cannot open keyboard (%s)\n",strerror(errno) );
exit(1);
}
xf86Info.consoleFd = fd;
}
return;
}
static error_t
pc_mouse_start (void *handle)
{
error_t err;
char device_name[9];
int devnum = majordev << 3 | minordev;
device_t device_master;
sprintf (device_name, "mouse%d", devnum);
err = get_privileged_ports (0, &device_master);
if (err)
return err;
err = device_open (device_master, D_READ, device_name, &mousedev);
mach_port_deallocate (mach_task_self (), device_master);
if (err)
return ENODEV;
err = driver_add_input (&pc_mouse_ops, NULL);
if (err)
{
device_close (mousedev);
mach_port_deallocate (mach_task_self (), mousedev);
return err;
}
cthread_detach (cthread_fork (input_loop, NULL));
if (repeater_node)
setrepeater (repeater_node);
return 0;
}
int main ()
{
int res, i;
mach_port_t host_privileged_port;
device_t device_privileged_port;
mach_port_t* host;
mach_msg_type_number_t procInfoCnt;
processor_info_t procInfo;
res = get_privileged_ports(&host_privileged_port, &device_privileged_port);
if (res != KERN_SUCCESS) {
printf ("Error getting privileged ports (0x%x), %s\n", res,
mach_error_string(res));
exit(1);
}
printf ("privileged ports: host 0x%x devices 0x%x\n",
host_privileged_port, device_privileged_port);
printf ("Getting processors at array 0x%x\n", processor_list);
res = host_processors(host_privileged_port,
&processor_list, &processor_listCnt);
if (res != KERN_SUCCESS) {
printf ("Error getting host_processors (0x%x), %s\n", res,
mach_error_string(res));
exit(1);
}
printf (" processors at array 0x%x\n", processor_list);
printf ("processor_listCnt %d\n", processor_listCnt);
procInfo = (processor_info_t) malloc(PROCESSOR_INFO_MAX*sizeof(int));
host = (mach_port_t *) malloc(10*sizeof(mach_port_t));
for (i=0; i < processor_listCnt; i++) {
printf ("processor_list[%d] 0x%x\n", i, processor_list[i]);
procInfoCnt = sizeof(int)*PROCESSOR_INFO_MAX;
res = processor_info (processor_list[i], PROCESSOR_BASIC_INFO, host, procInfo, &procInfoCnt);
if( res != KERN_SUCCESS) {
fprintf(stderr, "Error getting the processor %d information (0x%x), %s\n", i, res, mach_error_string(res));
exit(1);
}
processor_basic_info_t procBasicInfo = (processor_basic_info_t) &procInfo[i];
fprintf(stdout, "------------CPU %d------------\n", i);
fprintf(stdout, "CPU Type:\t\t%d\n", procBasicInfo->cpu_type);
fprintf(stdout, "CPU Subtype:\t\t%d\n", procBasicInfo->cpu_subtype);
if(procBasicInfo->running) fprintf(stdout, "Running?:\t\tYES\n");
else fprintf(stdout, "Running?:\t\tNO\n");
fprintf(stdout, "Slot number:\t\t%d\n", procBasicInfo->slot_num);
if(procBasicInfo->is_master) fprintf(stdout, "Master?:\t\tYES\n");
else fprintf(stdout, "Master?:\t\tNO\n");
fprintf(stdout, "-----------------------------\n");
}
}
int
xf86ReadBIOS(unsigned long Base,unsigned long Offset,unsigned char *Buf,int Len)
{
mach_port_t device,iopl_dev;
memory_object_t iopl_mem;
vm_address_t addr = (vm_address_t)0; /* serach starting address */
kern_return_t err;
err = get_privileged_ports (NULL, &device);
if( err )
{
errno = err;
FatalError("xf86ReadBIOS() can't get_privileged_ports. (%s)\n",strerror(errno));
}
err = device_open(device,D_READ|D_WRITE,"iopl",&iopl_dev);
mach_port_deallocate (mach_task_self (), device);
if( err )
{
errno = err;
FatalError("xf86ReadBIOS() can't device_open. (%s)\n",strerror(errno));
}
err = device_map(iopl_dev,VM_PROT_READ|VM_PROT_WRITE, Base , BIOS_SIZE ,&iopl_mem,0);
if( err )
{
errno = err;
FatalError("xf86ReadBIOS() can't device_map. (%s)\n",strerror(errno));
}
err = vm_map(mach_task_self(),
&addr,
BIOS_SIZE,
0,
TRUE,
iopl_mem,
Base,
FALSE,
VM_PROT_READ|VM_PROT_WRITE,
VM_PROT_READ|VM_PROT_WRITE,
VM_INHERIT_SHARE);
mach_port_deallocate(mach_task_self(),iopl_mem);
if( err )
{
errno = err;
FatalError("xf86ReadBIOS() can't vm_map. (%s)\n",strerror(errno));
}
memcpy(Buf,(void*)((int)addr + Offset), Len);
err = vm_deallocate(mach_task_self(), addr, BIOS_SIZE);
if( err )
{
errno = err;
FatalError("xf86ReadBIOS() can't vm_deallocate. (%s)\n",strerror(errno));
}
return Len;
}
kern_return_t
S_exec_init (struct trivfs_protid *protid,
auth_t auth, process_t proc)
{
mach_port_t host_priv, startup;
error_t err;
if (! protid || ! protid->isroot)
return EPERM;
_hurd_port_set (&_hurd_ports[INIT_PORT_PROC], proc); /* Consume. */
_hurd_port_set (&_hurd_ports[INIT_PORT_AUTH], auth); /* Consume. */
/* Do initial setup with the proc server. */
_hurd_proc_init (save_argv, NULL, 0);
procserver = getproc ();
/* Have the proc server notify us when the canonical ints and ports
change. This will generate an immediate callback giving us the
initial boot-time canonical sets. */
{
struct iouser *user;
struct trivfs_protid *cred;
mach_port_t right;
err = iohelp_create_empty_iouser (&user);
assert_perror (err);
err = trivfs_open (fsys, user, 0, MACH_PORT_NULL, &cred);
assert_perror (err);
right = ports_get_send_right (cred);
proc_execdata_notify (procserver, right, MACH_MSG_TYPE_COPY_SEND);
mach_port_deallocate (mach_task_self (), right);
}
err = get_privileged_ports (&host_priv, NULL);
assert_perror (err);
proc_register_version (procserver, host_priv, "exec", "", HURD_VERSION);
err = proc_getmsgport (procserver, 1, &startup);
assert_perror (err);
mach_port_deallocate (mach_task_self (), procserver);
/* Call startup_essential task last; init assumes we are ready to
run once we call it. */
err = startup_essential_task (startup, mach_task_self (), MACH_PORT_NULL,
"exec", host_priv);
assert_perror (err);
mach_port_deallocate (mach_task_self (), startup);
mach_port_deallocate (mach_task_self (), host_priv);
return 0;
}
/**************************************************************************
* Video Memory Mapping section
***************************************************************************/
static pointer
mapVidMem(int ScreenNum, unsigned long Base, unsigned long Size, int Flags)
{
mach_port_t device,iopl_dev;
memory_object_t iopl_mem;
kern_return_t err;
vm_address_t addr=(vm_address_t)0;
err = get_privileged_ports (NULL, &device);
if( err )
{
errno = err;
FatalError("xf86MapVidMem() can't get_privileged_ports. (%s)\n",strerror(errno));
}
err = device_open(device,D_READ|D_WRITE,"iopl",&iopl_dev);
mach_port_deallocate (mach_task_self(), device);
if( err )
{
errno = err;
FatalError("xf86MapVidMem() can't device_open. (%s)\n",strerror(errno));
}
err = device_map(iopl_dev,VM_PROT_READ|VM_PROT_WRITE, Base , Size ,&iopl_mem,0);
if( err )
{
errno = err;
FatalError("xf86MapVidMem() can't device_map. (%s)\n",strerror(errno));
}
err = vm_map(mach_task_self(),
&addr,
Size,
0, /* mask */
TRUE, /* anywhere */
iopl_mem,
(vm_offset_t)Base,
FALSE, /* copy on write */
VM_PROT_READ|VM_PROT_WRITE,
VM_PROT_READ|VM_PROT_WRITE,
VM_INHERIT_SHARE);
mach_port_deallocate(mach_task_self(),iopl_mem);
if( err )
{
errno = err;
FatalError("xf86MapVidMem() can't vm_map.(iopl_mem) (%s)\n",strerror(errno));
}
mach_port_deallocate(mach_task_self(),iopl_dev);
if( err )
{
errno = err;
FatalError("xf86MapVidMem() can't mach_port_deallocate.(iopl_dev) (%s)\n",strerror(errno));
}
return (pointer)addr;
}
/* Wire down all memory currently allocated at START for LEN bytes. */
void
wire_segment (vm_address_t start,
vm_size_t len)
{
mach_port_t host, device;
error_t error;
error = get_privileged_ports (&host, &device);
if (!error)
{
wire_segment_internal (start, len, host);
mach_port_deallocate (mach_task_self (), host);
mach_port_deallocate (mach_task_self (), device);
}
}
int
main (int argc, char **argv)
{
error_t err;
mach_port_t bootstrap;
struct trivfs_control *fsys;
mach_port_t host_priv;
argp_parse (&argp, argc, argv, 0, 0, 0);
err = get_privileged_ports (&host_priv, &dev_master);
if (err)
error (2, err, "cannot get privileged ports");
real_defpager = MACH_PORT_NULL;
err = vm_set_default_memory_manager (host_priv, &real_defpager);
mach_port_deallocate (mach_task_self (), host_priv);
if (err)
error (3, err, "vm_set_default_memory_manager");
if (real_defpager == MACH_PORT_NULL)
error (1, 0, "no default memory manager set!");
task_get_bootstrap_port (mach_task_self (), &bootstrap);
if (bootstrap == MACH_PORT_NULL)
error (1, 0, "Must be started as a translator");
err = trivfs_add_protid_port_class (&trivfs_protid_class);
if (err)
error (1, 0, "error creating protid port class");
/* Reply to our parent. */
err = trivfs_startup (bootstrap, 0, 0, 0, trivfs_protid_class, 0, &fsys);
mach_port_deallocate (mach_task_self (), bootstrap);
if (err)
error (4, err, "Contacting parent");
/* Launch. */
ports_manage_port_operations_multithread (fsys->pi.bucket,
proxy_defpager_demuxer,
2 * 60 * 1000, 0, 0);
return 0;
}
static void
pci_userspace_init(void)
{
/* FIXME: add a hook to make rump call this, once and only once */
static int is_init = 0;
if (is_init)
return;
is_init = 1;
if (get_privileged_ports (&master_host, &master_device))
err(1, "get_privileged_ports");
pci_system_init ();
struct pci_device_iterator *dev_iter;
struct pci_device *pci_dev;
dev_iter = pci_slot_match_iterator_create (NULL);
int i = 0;
while ((pci_dev = pci_device_next (dev_iter)) != NULL) {
pci_devices[i++] = pci_dev;
}
}
int
main(int argc , char *argv[])
{
mach_port_t device;
mach_port_t master_device;
error_t err;
err = get_privileged_ports (0, &master_device);
if (err)
error (2, err, "cannot get device master port");
err = device_open (master_device, D_READ | D_WRITE, "eth0", &device);
if (err)
error (1, err, "device_open");
printf ("the device port is %d\n", device);
err = device_open (master_device, D_READ | D_WRITE, "eth0", &device);
if (err)
error (1, err, "device_open");
printf ("the device port is %d\n", device);
return 0;
}
/* On Hurd, the IP stack (pfinet) does not know the list of network interfaces
* before we configure them, so we cannot use getifaddrs(). Instead we try
* possible names for network interfaces and check whether they exists by
* attempting to open the kernel device. */
int get_all_ifs (int all, char*** ptr)
{
static const char *const fmt[] = { "eth%d", "wl%d", NULL };
mach_port_t device_master;
device_t device;
int err;
char **list;
int num, i, j;
char name[3 + 3 * sizeof (int) + 1];
err = get_privileged_ports (0, &device_master);
if (err)
return 0;
num = 0;
list = malloc(sizeof *list);
for (i = 0; fmt[i]; i++)
for (j = 0;; j++) {
sprintf (name, fmt[i], j);
err = device_open (device_master, D_READ, name, &device);
if (err != 0)
break;
device_close (device);
mach_port_deallocate (mach_task_self (), device);
list = realloc (list, (num + 2) * sizeof *list);
list[num++] = strdup(name);
}
list[num] = NULL;
mach_port_deallocate (mach_task_self (), device_master);
*ptr = list;
return num;
}
int main () {
kern_return_t res;
mach_msg_return_t msg_res;
pid_t pid;
mach_port_t host_privileged_port;
device_t device_privileged_port;
mach_msg_type_name_t tname;
res = get_privileged_ports(&host_privileged_port, &device_privileged_port);
if (res != KERN_SUCCESS) {
fprintf(stderr, "Error getting privileged ports: 0x%x, %s\n", res, mach_error_string(res));
exit (1);
}
pid = fork();
if (pid == -1) {
fprintf(stderr, "Error creating the child with fork\n");
exit(1);
}
if (pid == 0) { //CHILD - SENDER
//TODO: Prepare the message header to be send
mach_msg_header_t sHeader;
sHeader.msgh_bits = MACH_MSG_TYPE_MOVE_SEND; //mach_msg_type_t
sHeader.msgh_size = sizeof(mach_msg_header_t); //mach_msg_size_t
sHeader.msgh_remote_port = host_privileged_port; //mach_port_t
sHeader.msgh_local_port = MACH_PORT_NULL; //mach_port_t
//sHeader->msgh_seqno = ; //mach_port_seqno_t IGNORED ON SENT MESSAGES
//sHeader->msgh_id = ; //mach_msg_id_t NOT SET OR NULL BY mach_msg
//Sending the message
msg_res = mach_msg_send(&sHeader);
if (msg_res != MACH_MSG_SUCCESS) {
fprintf(stderr, "Error on sending message: 0x%x, %s\n", msg_res, mach_error_string(msg_res));
exit(1);
}
fprintf(stdout, "Message sent!\n");
exit(0);
} else { //PARENT - RECEIVER
pid = wait(0);
//TODO: Prepare the message header to be receive
mach_msg_header_t rHeader;
rHeader.msgh_bits.
//rHeader->msgh_size = ; //mach_msg_size_t - TO BE READ
rHeader.msgh_remote_port = MACH_PORT_NULL; //mach_port_t
rHeader.msgh_local_port = host_privileged_port; //mach_port_t
//rHeader->msgh_seqno = ; //mach_port_seqno_t - TO BE READ
//rHeader->msgh_id = ; //mach_msg_id_t - NOT SET OR NULL by mach_msg
// Receiving the message
msg_res = mach_msg_receive(&rHeader);
if (msg_res != MACH_MSG_SUCCESS) {
fprintf(stderr, "Error on receiving message: 0x%x, %s\n", msg_res, mach_error_string(msg_res));
exit(1);
}
//TODO: check if the message is the one the child sent
exit(0);
}
}
int
main (int argc, char **argv)
{
const task_t my_task = mach_task_self();
error_t err;
memory_object_t defpager;
err = get_privileged_ports (&bootstrap_master_host_port,
&bootstrap_master_device_port);
if (err)
error (1, err, "cannot get privileged ports");
defpager = MACH_PORT_NULL;
err = vm_set_default_memory_manager (bootstrap_master_host_port, &defpager);
if (err)
error (1, err, "cannot check current default memory manager");
if (MACH_PORT_VALID (defpager))
error (2, 0, "Another default memory manager is already running");
if (!(argc == 2 && !strcmp (argv[1], "-d")))
{
/* We don't use the `daemon' function because we might exit back to the
parent before the daemon has completed vm_set_default_memory_manager.
Instead, the parent waits for a SIGUSR1 from the child before
exitting, and the child sends that signal after it is set up. */
sigset_t set;
signal (SIGUSR1, nohandler);
sigemptyset (&set);
sigaddset (&set, SIGUSR1);
sigprocmask (SIG_BLOCK, &set, 0);
switch (fork ())
{
case -1:
error (1, errno, "cannot become daemon");
case 0:
setsid ();
chdir ("/");
close (0);
close (1);
close (2);
break;
default:
sigemptyset (&set);
sigsuspend (&set);
_exit (0);
}
}
/* Mark us as important. */
mach_port_t proc = getproc ();
if (proc == MACH_PORT_NULL)
error (3, err, "cannot get a handle to our process");
err = proc_mark_important (proc);
/* This might fail due to permissions or because the old proc server
is still running, ignore any such errors. */
if (err && err != EPERM && err != EMIG_BAD_ID)
error (3, err, "cannot mark us as important");
mach_port_deallocate (mach_task_self (), proc);
printf_init(bootstrap_master_device_port);
/*
* Set up the default pager.
*/
partition_init();
/*
* task_set_exception_port and task_set_bootstrap_port
* both require a send right.
*/
(void) mach_port_insert_right(my_task, default_pager_exception_port,
default_pager_exception_port,
MACH_MSG_TYPE_MAKE_SEND);
/*
* Change our exception port.
*/
if (!debug)
(void) task_set_exception_port(my_task, default_pager_exception_port);
default_pager_initialize (bootstrap_master_host_port);
if (!(argc == 2 && !strcmp (argv[1], "-d")))
kill (getppid (), SIGUSR1);
/*
* Become the default pager
*/
default_pager();
/*NOTREACHED*/
return -1;
}
