/* 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; }