![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to profile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / kern|
Return to profile.c CVS log | Up to [Apple XNU] / XNU / osfmk / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * @OSF_COPYRIGHT@
24: */
25: /*
26: * Mach Operating System
27: * Copyright (c) 1991,1990,1989 Carnegie Mellon University
28: * All Rights Reserved.
29: *
30: * Permission to use, copy, modify and distribute this software and its
31: * documentation is hereby granted, provided that both the copyright
32: * notice and this permission notice appear in all copies of the
33: * software, derivative works or modified versions, and any portions
34: * thereof, and that both notices appear in supporting documentation.
35: *
36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
39: *
40: * Carnegie Mellon requests users of this software to return to
41: *
42: * Software Distribution Coordinator or [email protected]
43: * School of Computer Science
44: * Carnegie Mellon University
45: * Pittsburgh PA 15213-3890
46: *
47: * any improvements or extensions that they make and grant Carnegie Mellon
48: * the rights to redistribute these changes.
49: */
50:
51: /*
52: */
53: #include <mach_prof.h>
54:
55: #include <mach/task_server.h>
56: #include <mach/thread_act_server.h>
57:
58: #if MACH_PROF
59: #include <cpus.h>
60: #include <kern/thread.h>
61: #include <kern/thread_swap.h>
62: #include <kern/queue.h>
63: #include <kern/profile.h>
64: #include <kern/sched_prim.h>
65: #include <kern/spl.h>
66: #include <kern/misc_protos.h>
67: #include <ipc/ipc_space.h>
68: #include <machine/machparam.h>
69: #include <mach/prof.h>
70:
71: thread_t profile_thread_id = THREAD_NULL;
72: int profile_sample_count = 0; /* Provided for looking at from kdb. */
73: extern kern_return_t task_suspend(task_t task); /* ack */
74:
75: /* Forwards */
76: prof_data_t pbuf_alloc(void);
77: void pbuf_free(
78: prof_data_t pbuf);
79: void profile_thread(void);
80: void send_last_sample_buf(
81: prof_data_t pbuf);
82:
83: /*
84: *****************************************************************************
85: * profile_thread is the profile/trace kernel support thread. It is started
86: * by a server/user request through task_sample, or thread_sample. The profile
87: * thread dequeues messages and sends them to the receive_prof thread, in the
88: * server, via the send_samples and send_notices mig interface functions. If
89: * there are no messages in the queue profile thread blocks until wakened by
90: * profile (called in from mach_clock), or last_sample (called by thread/task_
91: * sample).
92: */
93:
94: void
95: profile_thread(void)
96: {
97: spl_t s;
98: buffer_t buf_entry;
99: queue_entry_t prof_queue_entry;
100: prof_data_t pbuf;
101: kern_return_t kr;
102: int j;
103:
104: thread_swappable(current_act(), FALSE);
105:
106: /* Initialise the queue header for the prof_queue */
107: mpqueue_init(&prof_queue);
108:
109: while (TRUE) {
110:
111: /* Dequeue the first buffer. */
112: s = splsched();
113: mpdequeue_head(&prof_queue, &prof_queue_entry);
114: splx(s);
115:
116: if ((buf_entry = (buffer_t) prof_queue_entry) == NULLPBUF) {
117: assert_wait((event_t) profile_thread, THREAD_UNINT);
118: thread_block((void (*)(void)) 0);
119: if (current_thread()->wait_result != THREAD_AWAKENED)
120: break;
121: } else
122: {
123: int dropped;
124:
125: pbuf = buf_entry->p_prof;
126: kr = send_samples(pbuf->prof_port, (void *)buf_entry->p_zone,
127: (mach_msg_type_number_t)buf_entry->p_index);
128: profile_sample_count += buf_entry->p_index;
129: if (kr != KERN_SUCCESS)
130: printf("send_samples(%x, %x, %d) error %x\n",
131: pbuf->prof_port, buf_entry->p_zone, buf_entry->p_index, kr);
132: dropped = buf_entry->p_dropped;
133: if (dropped > 0) {
134: printf("kernel: profile dropped %d sample%s\n", dropped,
135: dropped == 1 ? "" : "s");
136: buf_entry->p_dropped = 0;
137: }
138:
139: /* Indicate you've finished the dirty job */
140: buf_entry->p_full = FALSE;
141: if (buf_entry->p_wakeme)
142: thread_wakeup((event_t) &buf_entry->p_wakeme);
143: }
144:
145: }
146: /* The profile thread has been signalled to exit. Any threads waiting
147: for the last buffer of samples to be acknowledged should be woken
148: up now. */
149: profile_thread_id = THREAD_NULL;
150: while (1) {
151: s = splsched();
152: mpdequeue_head(&prof_queue, &prof_queue_entry);
153: splx(s);
154: if ((buf_entry = (buffer_t) prof_queue_entry) == NULLPBUF)
155: break;
156: if (buf_entry->p_wakeme)
157: thread_wakeup((event_t) &buf_entry->p_wakeme);
158: }
159: #if 0 /* XXXXX */
160: thread_halt_self();
161: #else
162: panic("profile_thread(): halt_self");
163: #endif /* XXXXX */
164: }
165:
166: /*
167: *****************************************************************************
168: * send_last_sample is the drain mechanism to allow partial profiled buffers
169: * to be sent to the receive_prof thread in the server.
170: *****************************************************************************
171: */
172:
173: void
174: send_last_sample_buf(prof_data_t pbuf)
175: {
176: spl_t s;
177: buffer_t buf_entry;
178:
179: if (pbuf == NULLPROFDATA)
180: return;
181:
182: /* Ask for the sending of the last PC buffer.
183: * Make a request to the profile_thread by inserting
184: * the buffer in the send queue, and wake it up.
185: * The last buffer must be inserted at the head of the
186: * send queue, so the profile_thread handles it immediatly.
187: */
188: buf_entry = pbuf->prof_area + pbuf->prof_index;
189: buf_entry->p_prof = pbuf;
190:
191: /*
192: Watch out in case profile thread exits while we are about to
193: queue data for it.
194: */
195: s = splsched();
196: if (profile_thread_id == THREAD_NULL)
197: splx(s);
198: else {
199: buf_entry->p_wakeme = 1;
200: mpenqueue_tail(&prof_queue, &buf_entry->p_list);
201: thread_wakeup((event_t) profile_thread);
202: assert_wait((event_t) &buf_entry->p_wakeme, THREAD_ABORTSAFE);
203: splx(s);
204: thread_block((void (*)(void)) 0);
205: }
206: }
207:
208:
209: /*
210: *****************************************************************************
211: * add clock tick parameters to profile/trace buffers. Called from the mach_
212: * clock heritz_tick function. DCI version stores thread, sp, and pc values
213: * into the profile/trace buffers. MACH_PROF version just stores pc values.
214: *****************************************************************************
215: */
216:
217: void
218: profile(natural_t pc,
219: prof_data_t pbuf)
220: {
221: natural_t inout_val = pc;
222: buffer_t buf_entry;
223:
224: if (pbuf == NULLPROFDATA)
225: return;
226:
227: /* Inserts the PC value in the buffer of the thread */
228: set_pbuf_value(pbuf, &inout_val);
229: switch((int)inout_val) {
230: case 0:
231: if (profile_thread_id == THREAD_NULL) {
232: reset_pbuf_area(pbuf);
233: }
234: break;
235: case 1:
236: /* Normal case, value successfully inserted */
237: break;
238: case 2 :
239: /*
240: * The value we have just inserted caused the
241: * buffer to be full, and ready to be sent.
242: * If profile_thread_id is null, the profile
243: * thread has been killed. Since this generally
244: * happens only when the O/S server task of which
245: * it is a part is killed, it is not a great loss
246: * to throw away the data.
247: */
248: if (profile_thread_id == THREAD_NULL) {
249: reset_pbuf_area(pbuf);
250: break;
251: }
252:
253: buf_entry = (buffer_t) &pbuf->prof_area[pbuf->prof_index];
254: buf_entry->p_prof = pbuf;
255: mpenqueue_tail(&prof_queue, &buf_entry->p_list);
256:
257: /* Switch to another buffer */
258: reset_pbuf_area(pbuf);
259:
260: /* Wake up the profile thread */
261: if (profile_thread_id != THREAD_NULL)
262: thread_wakeup((event_t) profile_thread);
263: break;
264:
265: default:
266: printf("profile : unexpected case\n");
267: }
268: }
269:
270: /*
271: *****************************************************************************
272: * pbuf_alloc creates a profile/trace buffer and assoc. zones for storing
273: * profiled items.
274: *****************************************************************************
275: */
276:
277: prof_data_t
278: pbuf_alloc(void)
279: {
280: register prof_data_t pbuf;
281: register int i;
282: register natural_t *zone;
283:
284: pbuf = (prof_data_t)kalloc(sizeof(struct prof_data));
285: if (!pbuf)
286: return(NULLPROFDATA);
287: pbuf->prof_port = MACH_PORT_NULL;
288: for (i=0; i< NB_PROF_BUFFER; i++) {
289: zone = (natural_t *)kalloc(SIZE_PROF_BUFFER*sizeof(natural_t));
290: if (!zone) {
291: i--;
292: while (i--)
293: kfree((vm_offset_t)pbuf->prof_area[i].p_zone,
294: SIZE_PROF_BUFFER*sizeof(natural_t));
295: kfree((vm_offset_t)pbuf, sizeof(struct prof_data));
296: return(NULLPROFDATA);
297: }
298: pbuf->prof_area[i].p_zone = zone;
299: pbuf->prof_area[i].p_full = FALSE;
300: }
301: pbuf->prof_port = MACH_PORT_NULL;
302: return(pbuf);
303: }
304:
305: /*
306: *****************************************************************************
307: * pbuf_free free memory allocated for storing profile/trace items. Called
308: * when a task is no longer profiled/traced. Pbuf_free tears down the memory
309: * alloced in pbuf_alloc. It does not check to see if the structures are valid
310: * since it is only called by functions in this file.
311: *****************************************************************************
312: */
313: void
314: pbuf_free(
315: prof_data_t pbuf)
316: {
317: register int i;
318:
319: if (pbuf->prof_port)
320: ipc_port_release_send(pbuf->prof_port);
321:
322: for(i=0; i < NB_PROF_BUFFER ; i++)
323: kfree((vm_offset_t)pbuf->prof_area[i].p_zone,
324: SIZE_PROF_BUFFER*sizeof(natural_t));
325: kfree((vm_offset_t)pbuf, sizeof(struct prof_data));
326: }
327:
328: #endif /* MACH_PROF */
329:
330: /*
331: *****************************************************************************
332: * Thread_sample is used by MACH_PROF to profile a single thread, and is only
333: * stub in DCI.
334: *****************************************************************************
335: */
336:
337: kern_return_t
338: thread_sample(
339: thread_act_t thr_act,
340: ipc_port_t reply)
341: {
342: /*
343: * This routine is called every time that a new thread has made
344: * a request for the sampling service. We must keep track of the
345: * correspondance between its identity (thread) and the port
346: * we are going to use as a reply port to send out the samples resulting
347: * from its execution.
348: */
349: #if !MACH_PROF
350: return KERN_FAILURE;
351: #else
352: prof_data_t pbuf;
353: vm_offset_t vmpbuf;
354:
355: if (reply != MACH_PORT_NULL) {
356: if (thr_act->act_profiled) /* yuck! */
357: return KERN_INVALID_ARGUMENT;
358: /* Start profiling this activation, do the initialization. */
359: pbuf = pbuf_alloc();
360: if ((thr_act->profil_buffer = pbuf) == NULLPROFDATA) {
361: printf("thread_sample: cannot allocate pbuf\n");
362: return KERN_RESOURCE_SHORTAGE;
363: }
364: else {
365: if (!set_pbuf_nb(pbuf, NB_PROF_BUFFER-1)) {
366: printf("mach_sample_thread: cannot set pbuf_nb\n");
367: return KERN_FAILURE;
368: }
369: reset_pbuf_area(pbuf);
370: }
371: pbuf->prof_port = reply;
372: thr_act->act_profiled = TRUE;
373: thr_act->act_profiled_own = TRUE;
374: if (profile_thread_id == THREAD_NULL)
375: profile_thread_id = kernel_thread(kernel_task, profile_thread);
376: } else {
377: if (!thr_act->act_profiled)
378: return(KERN_INVALID_ARGUMENT);
379:
380: thr_act->act_profiled = FALSE;
381: /* do not stop sampling if thread is not profiled by its own */
382:
383: if (!thr_act->act_profiled_own)
384: return KERN_SUCCESS;
385: else
386: thr_act->act_profiled_own = FALSE;
387:
388: send_last_sample_buf(thr_act->profil_buffer);
389: pbuf_free(thr_act->profil_buffer);
390: thr_act->profil_buffer = NULLPROFDATA;
391: }
392: return KERN_SUCCESS;
393: #endif /* MACH_PROF */
394: }
395:
396: /*
397: *****************************************************************************
398: * Task_sample is used to profile/trace tasks - all thread within a task using
399: * a common profile buffer to collect items generated by the hertz_tick. For
400: * each task profiled a profile buffer is created that associates a reply port
401: * (used to send the data to a server thread), task (used for throttling), and
402: * a zone area (used to store profiled/traced items).
403: *****************************************************************************
404: */
405:
406: kern_return_t
407: task_sample(
408: task_t task,
409: ipc_port_t reply)
410: {
411: #if !MACH_PROF
412: return KERN_FAILURE;
413: #else
414: prof_data_t pbuf=task->profil_buffer;
415: vm_offset_t vmpbuf;
416: boolean_t turnon = (reply != MACH_PORT_NULL);
417:
418: if (task == TASK_NULL)
419: return KERN_INVALID_ARGUMENT;
420: if (turnon) /* Do we want to profile this task? */
421: {
422: pbuf = pbuf_alloc(); /* allocate a profile buffer */
423: task_lock(task);
424: if (task->task_profiled) { /* if it is already profiled return so */
425: task_unlock(task);
426: if (pbuf != NULLPROFDATA)
427: pbuf_free(pbuf);
428: return(KERN_INVALID_ARGUMENT);
429: }
430: if (pbuf == NULLPROFDATA) {
431: task_unlock(task);
432: return KERN_RESOURCE_SHORTAGE; /* can't allocate a buffer, quit */
433: }
434: task->profil_buffer = pbuf;
435:
436: if (!set_pbuf_nb(pbuf, NB_PROF_BUFFER-1)) {
437: pbuf_free(pbuf);
438: task_unlock(task);
439: return KERN_FAILURE;
440: }
441: reset_pbuf_area(pbuf);
442: pbuf->prof_port = reply; /* assoc. buffer with reply port */
443: } else { /* We want to stop profiling/tracing */
444: task_lock(task);
445: if (!task->task_profiled) { /* but this task is not being profiled */
446: task_unlock(task);
447: return(KERN_INVALID_ARGUMENT);
448: }
449: }
450:
451: /*
452: * turnon = FALSE && task_profile = TRUE ||
453: * turnon = TRUE && task_profile = FALSE
454: */
455:
456: if (turnon != task->task_profiled) {
457: int actual, i;
458: thread_act_t thr_act;
459:
460: if (turnon && profile_thread_id == THREAD_NULL) /* 1st time thru? */
461: profile_thread_id = /* then start profile thread. */
462: kernel_thread(kernel_task, profile_thread);
463: task->task_profiled = turnon;
464: actual = task->thr_act_count;
465: for (i = 0, thr_act = (thread_act_t)queue_first(&task->thr_acts);
466: i < actual;
467: i++, thr_act = (thread_act_t)queue_next(&thr_act->thr_acts)) {
468: if (!thr_act->act_profiled_own) {
469: thr_act->act_profiled = turnon;
470: if (turnon) {
471: thr_act->profil_buffer = task->profil_buffer;
472: thr_act->act_profiled = TRUE;
473: } else {
474: thr_act->act_profiled = FALSE;
475: thr_act->profil_buffer = NULLPROFDATA;
476: }
477: }
478: }
479: if (!turnon) { /* drain buffers and clean-up */
480: send_last_sample_buf(task->profil_buffer);
481: pbuf_free(task->profil_buffer);
482: task->profil_buffer = NULLPROFDATA;
483: }
484: }
485:
486: task_unlock(task);
487: return KERN_SUCCESS;
488: #endif /* MACH_PROF */
489: }
490:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.