void kbdinit(void) { int s = SPLKD(); if (!initialized) { kdq_reset(&kbd_queue); mpqueue_init(&kbd_read_queue); initialized = TRUE; } splx(s); }
void * chudxnu_cpu_alloc(boolean_t boot_processor) { chudcpu_data_t *chud_proc_info; if (boot_processor) { chud_proc_info = &chudcpu_boot_cpu; } else { chud_proc_info = (chudcpu_data_t *) kalloc(sizeof(chudcpu_data_t)); if (chud_proc_info == (chudcpu_data_t *)NULL) { return (void *)NULL; } } bzero((char *)chud_proc_info, sizeof(chudcpu_data_t)); chud_proc_info->t_deadline = 0xFFFFFFFFFFFFFFFFULL; mpqueue_init(&chud_proc_info->cpu_request_queue); return (void *)chud_proc_info; }
void timer_call_queue_init(mpqueue_head_t *queue) { DBG("timer_call_queue_init(%p)\n", queue); mpqueue_init(queue, &timer_call_lck_grp, &timer_call_lck_attr); }
void profile_thread(void) { spl_t s; buffer_t buf_entry; queue_entry_t prof_queue_entry; prof_data_t pbuf; kern_return_t kr; int j; thread_swappable(current_act(), FALSE); /* Initialise the queue header for the prof_queue */ mpqueue_init(&prof_queue); while (TRUE) { /* Dequeue the first buffer. */ s = splsched(); mpdequeue_head(&prof_queue, &prof_queue_entry); splx(s); if ((buf_entry = (buffer_t) prof_queue_entry) == NULLPBUF) { assert_wait((event_t) profile_thread, FALSE); thread_block((void (*)(void)) 0); if (current_thread()->wait_result != THREAD_AWAKENED) break; } else #if DCI { register int sum_samples = 0; int i; pbuf = buf_entry->p_prof; /* * sum all the points from all the cpus on the machine. */ for(i=0;i < NCPUS; i++) sum_samples += buf_entry->p_index[i]; kr = send_samples(pbuf->prof_port, (void *)buf_entry->p_zone, (mach_msg_type_number_t)sum_samples); if (kr != KERN_SUCCESS) { task_suspend(pbuf->task); /* suspend task */ kr = send_notices(pbuf->prof_port, (void *)buf_entry->p_zone, (mach_msg_type_number_t)sum_samples, MACH_SEND_ALWAYS); } bzero((char *)buf_entry->p_zone, NCPUS*SIZE_PROF_BUFFER); #else { int dropped; pbuf = buf_entry->p_prof; kr = send_samples(pbuf->prof_port, (void *)buf_entry->p_zone, (mach_msg_type_number_t)buf_entry->p_index); profile_sample_count += buf_entry->p_index; if (kr != KERN_SUCCESS) printf("send_samples(%x, %x, %d) error %x\n", pbuf->prof_port, buf_entry->p_zone, buf_entry->p_index, kr); dropped = buf_entry->p_dropped; if (dropped > 0) { printf("kernel: profile dropped %d sample%s\n", dropped, dropped == 1 ? "" : "s"); buf_entry->p_dropped = 0; } #endif /* DCI */ /* Indicate you've finished the dirty job */ #if DCI { int i; for(i=0;i<NCPUS;i++) buf_entry->p_full[i] = FALSE; } #else buf_entry->p_full = FALSE; #endif /* DCI */ if (buf_entry->p_wakeme) thread_wakeup((event_t) &buf_entry->p_wakeme); } } /* The profile thread has been signalled to exit. Any threads waiting for the last buffer of samples to be acknowledged should be woken up now. */ profile_thread_id = THREAD_NULL; while (1) { s = splsched(); mpdequeue_head(&prof_queue, &prof_queue_entry); splx(s); if ((buf_entry = (buffer_t) prof_queue_entry) == NULLPBUF) break; if (buf_entry->p_wakeme) thread_wakeup((event_t) &buf_entry->p_wakeme); } #if 0 /* XXXXX */ thread_halt_self(); #else panic("profile_thread(): halt_self"); #endif /* XXXXX */ } /* ***************************************************************************** * send_last_sample is the drain mechanism to allow partial profiled buffers * to be sent to the receive_prof thread in the server. ***************************************************************************** */ void send_last_sample_buf(prof_data_t pbuf) { spl_t s; buffer_t buf_entry; if (pbuf == NULLPROFDATA) return; /* Ask for the sending of the last PC buffer. * Make a request to the profile_thread by inserting * the buffer in the send queue, and wake it up. * The last buffer must be inserted at the head of the * send queue, so the profile_thread handles it immediatly. */ buf_entry = pbuf->prof_area + pbuf->prof_index; buf_entry->p_prof = pbuf; /* Watch out in case profile thread exits while we are about to queue data for it. */ s = splsched(); if (profile_thread_id == THREAD_NULL) splx(s); else { buf_entry->p_wakeme = 1; mpenqueue_tail(&prof_queue, &buf_entry->p_list); thread_wakeup((event_t) profile_thread); assert_wait((event_t) &buf_entry->p_wakeme, TRUE); splx(s); thread_block((void (*)(void)) 0); } }
void profile_thread() { struct message { mach_msg_header_t head; mach_msg_type_t type; int arg[SIZE_PROF_BUFFER+1]; } msg; register spl_t s; buf_to_send_t buf_entry; queue_entry_t prof_queue_entry; prof_data_t pbuf; simple_lock_t lock; msg_return_t mr; int j; /* Initialise the queue header for the prof_queue */ mpqueue_init(&prof_queue); /* Template initialisation of header and type structures */ msg.head.msgh_bits = MACH_MSGH_BITS(MACH_MSG_TYPE_COPY_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE); msg.head.msgh_size = sizeof(msg); msg.head.msgh_local_port = MACH_PORT_NULL; msg.head.msgh_kind = MACH_MSGH_KIND_NORMAL; msg.head.msgh_id = 666666; msg.type.msgt_name = MACH_MSG_TYPE_INTEGER_32; msg.type.msgt_size = 32; msg.type.msgt_number = SIZE_PROF_BUFFER+1; msg.type.msgt_inline = TRUE; msg.type.msgt_longform = FALSE; msg.type.msgt_deallocate = FALSE; msg.type.msgt_unused = 0; while (TRUE) { /* Dequeue the first buffer. */ s = splsched(); mpdequeue_head(&prof_queue, &prof_queue_entry); splx(s); if ((buf_entry = (buf_to_send_t) prof_queue_entry) == NULLBTS) { thread_sleep((event_t) profile_thread, lock, TRUE); if (current_thread()->wait_result != THREAD_AWAKENED) break; } else { task_t curr_task; thread_t curr_th; register int *sample; int curr_buf; int imax; curr_th = (thread_t) buf_entry->thread; curr_buf = (int) buf_entry->number; pbuf = curr_th->profil_buffer; /* Set the remote port */ msg.head.msgh_remote_port = (mach_port_t) pbuf->prof_port; sample = pbuf->prof_area[curr_buf].p_zone; imax = pbuf->prof_area[curr_buf].p_index; for(j=0 ;j<imax; j++,sample++) msg.arg[j] = *sample; /* Let hardclock() know you've finished the dirty job */ pbuf->prof_area[curr_buf].p_full = FALSE; /* * Store the number of samples actually sent * as the last element of the array. */ msg.arg[SIZE_PROF_BUFFER] = imax; mr = mach_msg(&(msg.head), MACH_SEND_MSG, sizeof(struct message), 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL); if (mr != MACH_MSG_SUCCESS) { printf("profile_thread: mach_msg failed returned %x\n",(int)mr); } if (buf_entry->wakeme) thread_wakeup((event_t) &buf_entry->wakeme); kmem_free(kernel_map, (buf_to_send_t) buf_entry, sizeof(struct buf_to_send)); } } /* The profile thread has been signalled to exit. There may still be sample data queued for us, which we must now throw away. Once we set profile_thread_id to null, hardclock() will stop queueing any additional samples, so we do not need to alter the interrupt level. */ profile_thread_id = THREAD_NULL; while (1) { mpdequeue_head(&prof_queue, &prof_queue_entry); if ((buf_entry = (buf_to_send_t) prof_queue_entry) == NULLBTS) break; if (buf_entry->wakeme) thread_wakeup((event_t) &buf_entry->wakeme); kmem_free(kernel_map, (buf_to_send_t) buf_entry, sizeof(struct buf_to_send)); } thread_halt_self(); }