mach_port_t IODataQueueAllocateNotificationPort()
{
mach_port_t port = MACH_PORT_NULL;
mach_port_limits_t limits;
mach_msg_type_number_t info_cnt;
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
info_cnt = MACH_PORT_LIMITS_INFO_COUNT;
mach_port_get_attributes(mach_task_self(),
port,
MACH_PORT_LIMITS_INFO,
(mach_port_info_t)&limits,
&info_cnt);
limits.mpl_qlimit = 1; // Set queue to only 1 message
mach_port_set_attributes(mach_task_self(),
port,
MACH_PORT_LIMITS_INFO,
(mach_port_info_t)&limits,
MACH_PORT_LIMITS_INFO_COUNT);
return port;
}
static void PrintPortReceiveStatus(mach_port_t taskSendRight, mach_port_name_t receiveRight)
// Print information about the Mach receive right in the specified
// task.
{
kern_return_t err;
mach_port_status_t status;
mach_msg_type_number_t statusCount;
// Get information about the the right.
statusCount = MACH_PORT_RECEIVE_STATUS_COUNT;
err = mach_port_get_attributes(
taskSendRight,
receiveRight,
MACH_PORT_RECEIVE_STATUS,
(mach_port_info_t) &status,
&statusCount
);
assert( (err != KERN_SUCCESS) || (statusCount == MACH_PORT_RECEIVE_STATUS_COUNT) );
// Print it, as a group of flags followed by 6 columns of numbers,
// which are basically all counters.
if (err == KERN_SUCCESS) {
fprintf(
stdout,
"%c%c%c ",
(status.mps_nsrequest ? 'N' : '-'),
(status.mps_pdrequest ? 'P' : '-'),
(status.mps_srights ? 'S' : '-')
);
fprintf(
stdout,
"%8u %8u %8u %8u %8u %8u",
status.mps_seqno,
status.mps_mscount,
status.mps_qlimit,
status.mps_msgcount,
status.mps_sorights,
status.mps_pset
);
// The kernel always sets mps_flags to 0, so we don't both printing it.
assert(status.mps_flags == 0);
} else {
fprintf(
stdout,
"??? %8s %8s %8s %8s %8s %8s",
"???", "???", "???", "???", "???", "???"
);
}
}
void
test_mach_debug_port(mach_port_t name, const char *str, unsigned int line)
{
mach_port_type_t type;
mach_msg_bits_t ns = 0, nr = 0, nso = 0, nd = 0;
unsigned int dnreqs = 0, dnrsiz;
kern_return_t kr = mach_port_type(mach_task_self(), name, &type);
if (kr) {
fprintf(stderr, "machport[0x%08x] = { error(0x%x) \"%s\" }: %s %u\n",
name, kr, mach_error_string(kr), str, line);
return;
}
if (type & MACH_PORT_TYPE_SEND) {
test_mach_assume_zero(mach_port_get_refs(mach_task_self(), name,
MACH_PORT_RIGHT_SEND, &ns));
}
if (type & MACH_PORT_TYPE_SEND_ONCE) {
test_mach_assume_zero(mach_port_get_refs(mach_task_self(), name,
MACH_PORT_RIGHT_SEND_ONCE, &nso));
}
if (type & MACH_PORT_TYPE_DEAD_NAME) {
test_mach_assume_zero(mach_port_get_refs(mach_task_self(), name,
MACH_PORT_RIGHT_DEAD_NAME, &nd));
}
if (type & (MACH_PORT_TYPE_RECEIVE|MACH_PORT_TYPE_SEND)) {
test_mach_assume_zero(mach_port_dnrequest_info(mach_task_self(), name,
&dnrsiz, &dnreqs));
}
if (type & MACH_PORT_TYPE_RECEIVE) {
mach_port_status_t status = { .mps_pset = 0, };
mach_msg_type_number_t cnt = MACH_PORT_RECEIVE_STATUS_COUNT;
test_mach_assume_zero(mach_port_get_refs(mach_task_self(), name,
MACH_PORT_RIGHT_RECEIVE, &nr));
test_mach_assume_zero(mach_port_get_attributes(mach_task_self(), name,
MACH_PORT_RECEIVE_STATUS, (void*)&status, &cnt));
fprintf(stderr, "machport[0x%08x] = { R(%03u) S(%03u) SO(%03u) D(%03u) "
"dnreqs(%03u) spreq(%s) nsreq(%s) pdreq(%s) srights(%s) "
"sorights(%03u) qlim(%03u) msgcount(%03u) mkscount(%03u) "
"seqno(%03u) }: %s %u\n", name, nr, ns, nso, nd, dnreqs,
type & MACH_PORT_TYPE_SPREQUEST ? "Y":"N",
status.mps_nsrequest ? "Y":"N", status.mps_pdrequest ? "Y":"N",
status.mps_srights ? "Y":"N", status.mps_sorights,
status.mps_qlimit, status.mps_msgcount, status.mps_mscount,
status.mps_seqno, str, line);
} else if (type & (MACH_PORT_TYPE_SEND|MACH_PORT_TYPE_SEND_ONCE|
int get_recieve_port_status(task_t taskp, mach_port_name_t portname, mach_port_info_ext_t *info){
if (info == NULL) {
return -1;
}
mach_msg_type_number_t statusCnt;
kern_return_t ret;
statusCnt = MACH_PORT_INFO_EXT_COUNT;
ret = mach_port_get_attributes(taskp,
portname,
MACH_PORT_INFO_EXT,
(mach_port_info_t)info,
&statusCnt);
if (ret != KERN_SUCCESS) {
fprintf(stderr, "mach_port_get_attributes(0x%08x) failed: %s\n",
portname,
mach_error_string(ret));
return -1;
}
return 0;
}
void
mportset_callback(void)
{
mach_port_name_array_t members;
mach_msg_type_number_t membersCnt;
mach_port_status_t status;
mach_msg_type_number_t statusCnt;
struct kevent kev;
unsigned int i;
if (os_assumes_zero(mach_port_get_set_status(mach_task_self(), demand_port_set, &members, &membersCnt)) != 0) {
return;
}
for (i = 0; i < membersCnt; i++) {
statusCnt = MACH_PORT_RECEIVE_STATUS_COUNT;
if (mach_port_get_attributes(mach_task_self(), members[i], MACH_PORT_RECEIVE_STATUS, (mach_port_info_t)&status,
&statusCnt) != KERN_SUCCESS) {
continue;
}
if (status.mps_msgcount) {
EV_SET(&kev, members[i], EVFILT_MACHPORT, 0, 0, 0, job_find_by_service_port(members[i]));
#if 0
if (kev.udata != NULL) {
#endif
log_kevent_struct(LOG_DEBUG, &kev, 0);
(*((kq_callback *)kev.udata))(kev.udata, &kev);
#if 0
} else {
log_kevent_struct(LOG_ERR, &kev, 0);
}
#endif
/* the callback may have tainted our ability to continue this for loop */
break;
}
}
(void)os_assumes_zero(vm_deallocate(mach_task_self(), (vm_address_t)members, (vm_size_t) membersCnt * sizeof(mach_port_name_t)));
}
static void
darwin_debug_port_info (task_t task, mach_port_t port)
{
kern_return_t kret;
mach_port_status_t status;
mach_msg_type_number_t len = sizeof (status);
kret = mach_port_get_attributes
(task, port, MACH_PORT_RECEIVE_STATUS, (mach_port_info_t)&status, &len);
MACH_CHECK_ERROR (kret);
printf_unfiltered (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port,
(unsigned long) task);
printf_unfiltered (_(" port set: 0x%x\n"), status.mps_pset);
printf_unfiltered (_(" seqno: 0x%x\n"), status.mps_seqno);
printf_unfiltered (_(" mscount: 0x%x\n"), status.mps_mscount);
printf_unfiltered (_(" qlimit: 0x%x\n"), status.mps_qlimit);
printf_unfiltered (_(" msgcount: 0x%x\n"), status.mps_msgcount);
printf_unfiltered (_(" sorights: 0x%x\n"), status.mps_sorights);
printf_unfiltered (_(" srights: 0x%x\n"), status.mps_srights);
printf_unfiltered (_(" pdrequest: 0x%x\n"), status.mps_pdrequest);
printf_unfiltered (_(" nsrequest: 0x%x\n"), status.mps_nsrequest);
printf_unfiltered (_(" flags: 0x%x\n"), status.mps_flags);
}
