![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kdebug.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / kern|
Return to kdebug.c CVS log | Up to [Apple XNU] / XNU / bsd / 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: #include <kern/cpu_number.h>
23:
24: #include <machine/spl.h>
25:
26: #define HZ 100
27: #include <mach/clock_types.h>
28: #include <mach/mach_types.h>
29:
30: #include <sys/kdebug.h>
31: #include <sys/errno.h>
32: #include <sys/param.h> /* for splhigh */
33: #include <sys/proc.h>
34: #include <sys/vm.h>
35: #include <sys/sysctl.h>
36:
37: #include <kern/thread.h>
38: #include <kern/task.h>
39: #include <vm/vm_kern.h>
40:
41: /* kd_buf kd_buffer[kd_bufsize/sizeof(kd_buf)]; */
42: kd_buf * kd_bufptr;
43: unsigned int kd_buftomem=0;
44: kd_buf * kd_buffer=0;
45: kd_buf * kd_buflast;
46: kd_buf * kd_readlast;
47: unsigned int nkdbufs = 8192;
48: unsigned int kd_bufsize = 0;
49: unsigned int kdebug_flags = 0;
50: unsigned int kdebug_enable=0;
51: unsigned int kdebug_nolog=1;
52: unsigned int kdlog_beg=0;
53: unsigned int kdlog_end=0;
54: unsigned int kdlog_value1=0;
55: unsigned int kdlog_value2=0;
56: unsigned int kdlog_value3=0;
57: unsigned int kdlog_value4=0;
58:
59: kd_threadmap *kd_mapptr = 0;
60: unsigned int kd_mapsize = 0;
61: unsigned int kd_mapcount = 0;
62: unsigned int kd_maptomem = 0;
63:
64: pid_t global_state_pid = -1; /* Used to control exclusive use of kd_buffer */
65:
66: #define DBG_FUNC_MASK 0xfffffffc
67:
68: extern void PE_get_timebase(unsigned long long *);
69:
70: #ifdef ppc
71: extern natural_t rtclock_decrementer_min;
72: #endif /* ppc */
73:
74: struct kdebug_args {
75: int code;
76: int arg1;
77: int arg2;
78: int arg3;
79: int arg4;
80: int arg5;
81: };
82:
83: struct krt
84: {
85: kd_threadmap *map; /* pointer to the map buffer */
86: int count;
87: int maxcount;
88: struct proc *p;
89: };
90:
91: typedef struct krt krt_t;
92:
93: /* Support syscall SYS_kdebug_trace */
94: kdebug_trace(p, uap, retval)
95: struct proc *p;
96: struct kdebug_args *uap;
97: register_t *retval;
98: {
99: if (kdebug_nolog)
100: return(EINVAL);
101:
102: kernel_debug(uap->code, uap->arg1, uap->arg2, uap->arg3, uap->arg4, 0);
103: return(0);
104: }
105:
106:
107: void
108: kernel_debug(debugid, arg1, arg2, arg3, arg4, arg5)
109: unsigned int debugid, arg1, arg2, arg3, arg4, arg5;
110: {
111: kd_buf * kd;
112: struct proc *curproc;
113: int s;
114:
115: s = ml_set_interrupts_enabled(FALSE);
116:
117: if (kdebug_nolog)
118: {
119: ml_set_interrupts_enabled(s);
120: return;
121: }
122:
123: if (kdebug_flags & KDBG_PIDCHECK)
124: {
125: /* If kdebug flag is not set for current proc, return */
126: curproc = current_proc();
127: if ((curproc && !(curproc->p_flag & P_KDEBUG)) &&
128: ((debugid&0xffff0000) != (MACHDBG_CODE(DBG_MACH_SCHED, 0) | DBG_FUNC_NONE)))
129: {
130: ml_set_interrupts_enabled(s);
131: return;
132: }
133: }
134: else if (kdebug_flags & KDBG_PIDEXCLUDE)
135: {
136: /* If kdebug flag is set for current proc, return */
137: curproc = current_proc();
138: if ((curproc && (curproc->p_flag & P_KDEBUG)) &&
139: ((debugid&0xffff0000) != (MACHDBG_CODE(DBG_MACH_SCHED, 0) | DBG_FUNC_NONE)))
140: {
141: ml_set_interrupts_enabled(s);
142: return;
143: }
144: }
145:
146: if (kdebug_flags & KDBG_RANGECHECK)
147: {
148: if ((debugid < kdlog_beg) || (debugid > kdlog_end)
149: && (debugid >> 24 != DBG_TRACE))
150: {
151: ml_set_interrupts_enabled(s);
152: return;
153: }
154: }
155: else if (kdebug_flags & KDBG_VALCHECK)
156: {
157: if ((debugid & DBG_FUNC_MASK) != kdlog_value1 &&
158: (debugid & DBG_FUNC_MASK) != kdlog_value2 &&
159: (debugid & DBG_FUNC_MASK) != kdlog_value3 &&
160: (debugid & DBG_FUNC_MASK) != kdlog_value4 &&
161: (debugid >> 24 != DBG_TRACE))
162: {
163: ml_set_interrupts_enabled(s);
164: return;
165: }
166: }
167: kd = kd_bufptr;
168: kd->debugid = debugid;
169: kd->arg1 = arg1;
170: kd->arg2 = arg2;
171: kd->arg3 = arg3;
172: kd->arg4 = arg4;
173: kd->arg5 = (int)current_thread();
174: PE_get_timebase((unsigned long long *)&kd->timestamp);
175: kd_bufptr++;
176:
177: if (kd_bufptr >= kd_buflast)
178: kd_bufptr = kd_buffer;
179: if (kd_bufptr == kd_readlast) {
180: if (kdebug_flags & KDBG_NOWRAP)
181: kdebug_nolog = 1;
182: kdebug_flags |= KDBG_WRAPPED;
183: }
184: ml_set_interrupts_enabled(s);
185: }
186:
187: void
188: kernel_debug1(debugid, arg1, arg2, arg3, arg4, arg5)
189: unsigned int debugid, arg1, arg2, arg3, arg4, arg5;
190: {
191: kd_buf * kd;
192: struct proc *curproc;
193: int s;
194:
195: s = ml_set_interrupts_enabled(FALSE);
196:
197: if (kdebug_nolog)
198: {
199: ml_set_interrupts_enabled(s);
200: return;
201: }
202:
203: if (kdebug_flags & KDBG_PIDCHECK)
204: {
205: /* If kdebug flag is not set for current proc, return */
206: curproc = current_proc();
207: if ((curproc && !(curproc->p_flag & P_KDEBUG)) &&
208: ((debugid&0xffff0000) != (MACHDBG_CODE(DBG_MACH_SCHED, 0) | DBG_FUNC_NONE)))
209: {
210: ml_set_interrupts_enabled(s);
211: return;
212: }
213: }
214: else if (kdebug_flags & KDBG_PIDEXCLUDE)
215: {
216: /* If kdebug flag is set for current proc, return */
217: curproc = current_proc();
218: if ((curproc && (curproc->p_flag & P_KDEBUG)) &&
219: ((debugid&0xffff0000) != (MACHDBG_CODE(DBG_MACH_SCHED, 0) | DBG_FUNC_NONE)))
220: {
221: ml_set_interrupts_enabled(s);
222: return;
223: }
224: }
225:
226: if (kdebug_flags & KDBG_RANGECHECK)
227: {
228: if ((debugid < kdlog_beg) || (debugid > kdlog_end)
229: && (debugid >> 24 != DBG_TRACE))
230: {
231: ml_set_interrupts_enabled(s);
232: return;
233: }
234: }
235: else if (kdebug_flags & KDBG_VALCHECK)
236: {
237: if ((debugid & DBG_FUNC_MASK) != kdlog_value1 &&
238: (debugid & DBG_FUNC_MASK) != kdlog_value2 &&
239: (debugid & DBG_FUNC_MASK) != kdlog_value3 &&
240: (debugid & DBG_FUNC_MASK) != kdlog_value4 &&
241: (debugid >> 24 != DBG_TRACE))
242: {
243: ml_set_interrupts_enabled(s);
244: return;
245: }
246: }
247:
248: kd = kd_bufptr;
249: kd->debugid = debugid;
250: kd->arg1 = arg1;
251: kd->arg2 = arg2;
252: kd->arg3 = arg3;
253: kd->arg4 = arg4;
254: kd->arg5 = arg5;
255: PE_get_timebase((unsigned long long *)&kd->timestamp);
256: kd_bufptr++;
257:
258: if (kd_bufptr >= kd_buflast)
259: kd_bufptr = kd_buffer;
260: if (kd_bufptr == kd_readlast) {
261: if (kdebug_flags & KDBG_NOWRAP)
262: kdebug_nolog = 1;
263: kdebug_flags |= KDBG_WRAPPED;
264: }
265: ml_set_interrupts_enabled(s);
266: }
267:
268:
269: kdbg_bootstrap()
270: {
271: kd_bufsize = nkdbufs * sizeof(kd_buf);
272: if (kmem_alloc(kernel_map, &kd_buftomem,
273: (vm_size_t)kd_bufsize) == KERN_SUCCESS)
274: kd_buffer = (kd_buf *) kd_buftomem;
275: else kd_buffer= (kd_buf *) 0;
276: kdebug_flags &= ~KDBG_WRAPPED;
277: if (kd_buffer) {
278: kdebug_flags |= (KDBG_INIT | KDBG_BUFINIT);
279: kd_bufptr = kd_buffer;
280: kd_buflast = &kd_bufptr[nkdbufs];
281: kd_readlast = kd_bufptr;
282: return(0);
283: } else {
284: kd_bufsize=0;
285: kdebug_flags &= ~(KDBG_INIT | KDBG_BUFINIT);
286: return(EINVAL);
287: }
288:
289: }
290:
291: kdbg_reinit()
292: {
293: int x;
294: int ret=0;
295:
296: kdebug_enable = 0;
297: kdebug_nolog = 1;
298:
299: if ((kdebug_flags & KDBG_INIT) && (kdebug_flags & KDBG_BUFINIT) && kd_bufsize && kd_buffer)
300: kmem_free(kernel_map, (char *)kd_buffer, kd_bufsize);
301:
302: if ((kdebug_flags & KDBG_MAPINIT) && kd_mapsize && kd_mapptr)
303: {
304: kmem_free(kernel_map, (char *)kd_mapptr, kd_mapsize);
305: kdebug_flags &= ~KDBG_MAPINIT;
306: kd_mapsize = 0;
307: kd_mapptr = (kd_threadmap *) 0;
308: kd_mapcount = 0;
309: }
310:
311: ret= kdbg_bootstrap();
312:
313: return(ret);
314: }
315:
316: void kdbg_trace_string(struct proc *proc, long *arg1, long *arg2, long *arg3, long *arg4)
317: {
318: int i;
319: char *dbg_nameptr;
320: int dbg_namelen;
321: long dbg_parms[4];
322:
323: if (!proc)
324: {
325: *arg1 = 0;
326: *arg2 = 0;
327: *arg3 = 0;
328: *arg4 = 0;
329: return;
330: }
331:
332: /* Collect the pathname for tracing */
333: dbg_nameptr = proc->p_comm;
334: dbg_namelen = strlen(proc->p_comm);
335: dbg_parms[0]=0L;
336: dbg_parms[1]=0L;
337: dbg_parms[2]=0L;
338: dbg_parms[3]=0L;
339:
340: if(dbg_namelen > sizeof(dbg_parms))
341: dbg_namelen = sizeof(dbg_parms);
342:
343: for(i=0;dbg_namelen > 0; i++)
344: {
345: dbg_parms[i]=*(long*)dbg_nameptr;
346: dbg_nameptr += sizeof(long);
347: dbg_namelen -= sizeof(long);
348: }
349:
350: *arg1=dbg_parms[0];
351: *arg2=dbg_parms[1];
352: *arg3=dbg_parms[2];
353: *arg4=dbg_parms[3];
354: }
355:
356: kdbg_resolve_map(thread_act_t th_act, krt_t *t)
357: {
358: kd_threadmap *mapptr;
359:
360: if(t->count < t->maxcount)
361: {
362: mapptr=&t->map[t->count];
363: mapptr->thread = (unsigned int)getshuttle_thread(th_act);
364: mapptr->valid = 1;
365: (void) strncpy (mapptr->command, t->p->p_comm,
366: sizeof(t->p->p_comm)-1);
367: mapptr->command[sizeof(t->p->p_comm)-1] = '\0';
368: t->count++;
369: }
370: }
371:
372: void kdbg_mapinit()
373: {
374: struct proc *p;
375: struct krt akrt;
376:
377: if (kdebug_flags & KDBG_MAPINIT)
378: return;
379:
380: /* Calculate size of thread map buffer */
381: for (p = allproc.lh_first, kd_mapcount=0; p;
382: p = p->p_list.le_next)
383: {
384: kd_mapcount += get_task_numacts((task_t)p->task);
385: }
386:
387: kd_mapsize = kd_mapcount * sizeof(kd_threadmap);
388: if((kmem_alloc(kernel_map, & kd_maptomem,
389: (vm_size_t)kd_mapsize) == KERN_SUCCESS))
390: kd_mapptr = (kd_threadmap *) kd_maptomem;
391: else
392: kd_mapptr = (kd_threadmap *) 0;
393:
394: if (kd_mapptr)
395: {
396: kdebug_flags |= KDBG_MAPINIT;
397: /* Initialize thread map data */
398: akrt.map = kd_mapptr;
399: akrt.count = 0;
400: akrt.maxcount = kd_mapcount;
401:
402: for (p = allproc.lh_first; p; p = p->p_list.le_next)
403: {
404: akrt.p = p;
405: task_act_iterate_wth_args((task_t)p->task, kdbg_resolve_map, &akrt);
406: }
407: }
408: }
409:
410: kdbg_clear()
411: {
412: int x;
413:
414: /* Clean up the trace buffer */
415: global_state_pid = -1;
416: kdebug_enable = 0;
417: kdebug_nolog = 1;
418: kdebug_flags &= ~KDBG_BUFINIT;
419: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
420: kdebug_flags &= ~(KDBG_NOWRAP | KDBG_RANGECHECK | KDBG_VALCHECK);
421: kdebug_flags &= ~(KDBG_PIDCHECK | KDBG_PIDEXCLUDE);
422: kmem_free(kernel_map, (char *)kd_buffer, kd_bufsize);
423: kd_buffer = (kd_buf *)0;
424: kd_bufsize = 0;
425:
426: /* Clean up the thread map buffer */
427: kdebug_flags &= ~KDBG_MAPINIT;
428: kmem_free(kernel_map, (char *)kd_mapptr, kd_mapsize);
429: kd_mapptr = (kd_threadmap *) 0;
430: kd_mapsize = 0;
431: kd_mapcount = 0;
432: }
433:
434: kdbg_setpid(kd_regtype *kdr)
435: {
436: pid_t pid;
437: int flag, ret=0;
438: struct proc *p;
439:
440: pid = (pid_t)kdr->value1;
441: flag = (int)kdr->value2;
442:
443: if (pid > 0)
444: {
445: if ((p = pfind(pid)) == NULL)
446: ret = ESRCH;
447: else
448: {
449: if (flag == 1) /* turn on pid check for this and all pids */
450: {
451: kdebug_flags |= KDBG_PIDCHECK;
452: kdebug_flags &= ~KDBG_PIDEXCLUDE;
453: p->p_flag |= P_KDEBUG;
454: }
455: else /* turn off pid check for this pid value */
456: {
457: /* Don't turn off all pid checking though */
458: /* kdebug_flags &= ~KDBG_PIDCHECK;*/
459: p->p_flag &= ~P_KDEBUG;
460: }
461: }
462: }
463: else
464: ret = EINVAL;
465: return(ret);
466: }
467:
468: /* This is for pid exclusion in the trace buffer */
469: kdbg_setpidex(kd_regtype *kdr)
470: {
471: pid_t pid;
472: int flag, ret=0;
473: struct proc *p;
474:
475: pid = (pid_t)kdr->value1;
476: flag = (int)kdr->value2;
477:
478: if (pid > 0)
479: {
480: if ((p = pfind(pid)) == NULL)
481: ret = ESRCH;
482: else
483: {
484: if (flag == 1) /* turn on pid exclusion */
485: {
486: kdebug_flags |= KDBG_PIDEXCLUDE;
487: kdebug_flags &= ~KDBG_PIDCHECK;
488: p->p_flag |= P_KDEBUG;
489: }
490: else /* turn off pid exclusion for this pid value */
491: {
492: /* Don't turn off all pid exclusion though */
493: /* kdebug_flags &= ~KDBG_PIDEXCLUDE;*/
494: p->p_flag &= ~P_KDEBUG;
495: }
496: }
497: }
498: else
499: ret = EINVAL;
500: return(ret);
501: }
502:
503: /* This is for setting a minimum decrementer value */
504: kdbg_setrtcdec(kd_regtype *kdr)
505: {
506: int ret=0;
507: natural_t decval;
508:
509: decval = (natural_t)kdr->value1;
510:
511: if (decval && decval < KDBG_MINRTCDEC)
512: ret = EINVAL;
513: #ifdef ppc
514: else
515: rtclock_decrementer_min = decval;
516: #else
517: else
518: ret = EOPNOTSUPP;
519: #endif /* ppc */
520:
521: return(ret);
522: }
523:
524: kdbg_setreg(kd_regtype * kdr)
525: {
526: int i,j, ret=0;
527: unsigned int val_1, val_2, val;
528: switch (kdr->type) {
529:
530: case KDBG_CLASSTYPE :
531: val_1 = (kdr->value1 & 0xff);
532: val_2 = (kdr->value2 & 0xff);
533: kdlog_beg = (val_1<<24);
534: kdlog_end = (val_2<<24);
535: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
536: kdebug_flags &= ~KDBG_VALCHECK; /* Turn off specific value check */
537: kdebug_flags |= (KDBG_RANGECHECK | KDBG_CLASSTYPE);
538: break;
539: case KDBG_SUBCLSTYPE :
540: val_1 = (kdr->value1 & 0xff);
541: val_2 = (kdr->value2 & 0xff);
542: val = val_2 + 1;
543: kdlog_beg = ((val_1<<24) | (val_2 << 16));
544: kdlog_end = ((val_1<<24) | (val << 16));
545: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
546: kdebug_flags &= ~KDBG_VALCHECK; /* Turn off specific value check */
547: kdebug_flags |= (KDBG_RANGECHECK | KDBG_SUBCLSTYPE);
548: break;
549: case KDBG_RANGETYPE :
550: kdlog_beg = (kdr->value1);
551: kdlog_end = (kdr->value2);
552: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
553: kdebug_flags &= ~KDBG_VALCHECK; /* Turn off specific value check */
554: kdebug_flags |= (KDBG_RANGECHECK | KDBG_RANGETYPE);
555: break;
556: case KDBG_VALCHECK:
557: kdlog_value1 = (kdr->value1);
558: kdlog_value2 = (kdr->value2);
559: kdlog_value3 = (kdr->value3);
560: kdlog_value4 = (kdr->value4);
561: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
562: kdebug_flags &= ~KDBG_RANGECHECK; /* Turn off range check */
563: kdebug_flags |= KDBG_VALCHECK; /* Turn on specific value check */
564: break;
565: case KDBG_TYPENONE :
566: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
567: kdlog_beg = 0;
568: kdlog_end = 0;
569: break;
570: default :
571: ret = EINVAL;
572: break;
573: }
574: return(ret);
575: }
576:
577: kdbg_getreg(kd_regtype * kdr)
578: {
579: int i,j, ret=0;
580: unsigned int val_1, val_2, val;
581: #if 0
582: switch (kdr->type) {
583: case KDBG_CLASSTYPE :
584: val_1 = (kdr->value1 & 0xff);
585: val_2 = val_1 + 1;
586: kdlog_beg = (val_1<<24);
587: kdlog_end = (val_2<<24);
588: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
589: kdebug_flags |= (KDBG_RANGECHECK | KDBG_CLASSTYPE);
590: break;
591: case KDBG_SUBCLSTYPE :
592: val_1 = (kdr->value1 & 0xff);
593: val_2 = (kdr->value2 & 0xff);
594: val = val_2 + 1;
595: kdlog_beg = ((val_1<<24) | (val_2 << 16));
596: kdlog_end = ((val_1<<24) | (val << 16));
597: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
598: kdebug_flags |= (KDBG_RANGECHECK | KDBG_SUBCLSTYPE);
599: break;
600: case KDBG_RANGETYPE :
601: kdlog_beg = (kdr->value1);
602: kdlog_end = (kdr->value2);
603: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
604: kdebug_flags |= (KDBG_RANGECHECK | KDBG_RANGETYPE);
605: break;
606: case KDBG_TYPENONE :
607: kdebug_flags &= (unsigned int)~KDBG_CKTYPES;
608: kdlog_beg = 0;
609: kdlog_end = 0;
610: break;
611: default :
612: ret = EINVAL;
613: break;
614: }
615: #endif /* 0 */
616: return(EINVAL);
617: }
618:
619:
620:
621: kdbg_readmap(kd_threadmap *buffer, size_t *number)
622: {
623: int avail = *number;
624: int ret = 0;
625: int count = 0;
626:
627: count = avail/sizeof (kd_threadmap);
628:
629: if (count && (count <= kd_mapcount))
630: {
631: if((kdebug_flags & KDBG_MAPINIT) && kd_mapsize && kd_mapptr)
632: {
633: if (*number < kd_mapsize)
634: ret=EINVAL;
635: else
636: {
637: if (copyout(kd_mapptr, buffer, kd_mapsize))
638: ret=EINVAL;
639: }
640: }
641: else
642: ret=EINVAL;
643: }
644: else
645: ret=EINVAL;
646:
647: if ((kdebug_flags & KDBG_MAPINIT) && kd_mapsize && kd_mapptr)
648: {
649: kmem_free(kernel_map, (char *)kd_mapptr, kd_mapsize);
650: kdebug_flags &= ~KDBG_MAPINIT;
651: kd_mapsize = 0;
652: kd_mapptr = (kd_threadmap *) 0;
653: kd_mapcount = 0;
654: }
655:
656: return(ret);
657: }
658:
659:
660: kdbg_control(name, namelen, where, sizep)
661: int *name;
662: u_int namelen;
663: char *where;
664: size_t *sizep;
665: {
666: int ret=0;
667: int size=*sizep;
668: int max_entries;
669: unsigned int value = name[1];
670: kd_regtype kd_Reg;
671: kbufinfo_t kd_bufinfo;
672:
673: pid_t curpid;
674: struct proc *p, *curproc;
675:
676: if(curproc = current_proc())
677: curpid = curproc->p_pid;
678: else
679: return (ESRCH);
680:
681: if (global_state_pid == -1)
682: global_state_pid = curpid;
683: else if (global_state_pid != curpid)
684: {
685: if((p = pfind(global_state_pid)) == NULL)
686: {
687: /* The global pid no longer exists */
688: global_state_pid = curpid;
689: }
690: else
691: {
692: /* The global pid exists, deny this request */
693: return(EBUSY);
694: }
695: }
696:
697: switch(name[0]) {
698: case KERN_KDEFLAGS:
699: value &= KDBG_USERFLAGS;
700: kdebug_flags |= value;
701: break;
702: case KERN_KDDFLAGS:
703: value &= KDBG_USERFLAGS;
704: kdebug_flags &= ~value;
705: break;
706: case KERN_KDENABLE: /* used to enable or disable */
707: if (value)
708: {
709: /* enable only if buffer is initialized */
710: if (!(kdebug_flags & KDBG_BUFINIT))
711: {
712: ret=EINVAL;
713: break;
714: }
715: }
716: kdebug_enable=(value)?1:0;
717: kdebug_nolog = (value)?0:1;
718: if (kdebug_enable)
719: kdbg_mapinit();
720: break;
721: case KERN_KDSETBUF:
722: /* We allow a maximum buffer size of 25% of memory */
723: /* 'value' is the desired number of trace entries */
724: max_entries = (mem_size/4) / sizeof(kd_buf);
725: if (value <= max_entries)
726: nkdbufs = value;
727: else
728: nkdbufs = max_entries;
729: break;
730: case KERN_KDGETBUF:
731: if(size < sizeof(kbufinfo_t)) {
732: ret=EINVAL;
733: break;
734: }
735: kd_bufinfo.nkdbufs = nkdbufs;
736: kd_bufinfo.nkdthreads = kd_mapsize / sizeof(kd_threadmap);
737: kd_bufinfo.nolog = kdebug_nolog;
738: kd_bufinfo.flags = kdebug_flags;
739: if(copyout (&kd_bufinfo, where, sizeof(kbufinfo_t))) {
740: ret=EINVAL;
741: }
742: break;
743: case KERN_KDSETUP:
744: ret=kdbg_reinit();
745: break;
746: case KERN_KDREMOVE:
747: kdbg_clear();
748: break;
749: case KERN_KDSETREG:
750: if(size < sizeof(kd_regtype)) {
751: ret=EINVAL;
752: break;
753: }
754: if (copyin(where, &kd_Reg, sizeof(kd_regtype))) {
755: ret= EINVAL;
756: break;
757: }
758: ret = kdbg_setreg(&kd_Reg);
759: break;
760: case KERN_KDGETREG:
761: if(size < sizeof(kd_regtype)) {
762: ret = EINVAL;
763: break;
764: }
765: ret = kdbg_getreg(&kd_Reg);
766: if (copyout(&kd_Reg, where, sizeof(kd_regtype))){
767: ret=EINVAL;
768: }
769: break;
770: case KERN_KDREADTR:
771: ret = kdbg_read(where, sizep);
772: break;
773: case KERN_KDPIDTR:
774: if (size < sizeof(kd_regtype)) {
775: ret = EINVAL;
776: break;
777: }
778: if (copyin(where, &kd_Reg, sizeof(kd_regtype))) {
779: ret= EINVAL;
780: break;
781: }
782: ret = kdbg_setpid(&kd_Reg);
783: break;
784: case KERN_KDPIDEX:
785: if (size < sizeof(kd_regtype)) {
786: ret = EINVAL;
787: break;
788: }
789: if (copyin(where, &kd_Reg, sizeof(kd_regtype))) {
790: ret= EINVAL;
791: break;
792: }
793: ret = kdbg_setpidex(&kd_Reg);
794: break;
795: case KERN_KDTHRMAP:
796: ret = kdbg_readmap((kd_threadmap *)where, sizep);
797: break;
798: case KERN_KDSETRTCDEC:
799: if (size < sizeof(kd_regtype)) {
800: ret = EINVAL;
801: break;
802: }
803: if (copyin(where, &kd_Reg, sizeof(kd_regtype))) {
804: ret= EINVAL;
805: break;
806: }
807: ret = kdbg_setrtcdec(&kd_Reg);
808: break;
809:
810: default:
811: ret= EINVAL;
812: }
813: return(ret);
814: }
815:
816: kdbg_read(kd_buf * buffer, size_t *number)
817: {
818: int avail=*number;
819: int count=0;
820: int copycount=0;
821: int totalcount=0;
822:
823: count = avail/sizeof(kd_buf);
824: if (count) {
825: if ((kdebug_flags & KDBG_BUFINIT) && kd_bufsize && kd_buffer) {
826: if (count > nkdbufs)
827: count = nkdbufs;
828: if (!(kdebug_flags & KDBG_WRAPPED) && (kd_bufptr > kd_readlast))
829: {
830: copycount = kd_bufptr-kd_readlast;
831: if (copycount > count)
832: copycount = count;
833:
834: if (copyout(kd_readlast, buffer, copycount * sizeof(kd_buf)))
835: {
836: *number = 0;
837: return(EINVAL);
838: }
839: kd_readlast += copycount;
840: *number = copycount;
841: return(0);
842: }
843: else if (!(kdebug_flags & KDBG_WRAPPED) && (kd_bufptr == kd_readlast))
844: {
845: *number = 0;
846: return(0);
847: }
848: else
849: {
850: if (kdebug_flags & KDBG_WRAPPED)
851: {
852: kd_readlast = kd_bufptr;
853: kdebug_flags &= ~KDBG_WRAPPED;
854: }
855:
856: /* Note that by setting kd_readlast equal to kd_bufptr,
857: we now treat the kd_buffer read the same as if we weren't
858: wrapped and kd_bufptr was less than kd_readlast.
859: */
860:
861: /* first copyout from readlast to end of kd_buffer */
862: copycount = kd_buflast - kd_readlast;
863: if (copycount > count)
864: copycount = count;
865: if (copyout(kd_readlast, buffer, copycount * sizeof(kd_buf)))
866: {
867: *number = 0;
868: return(EINVAL);
869: }
870: buffer += copycount;
871: count -= copycount;
872: totalcount = copycount;
873: kd_readlast += copycount;
874: if (kd_readlast == kd_buflast)
875: kd_readlast = kd_buffer;
876: if (count == 0)
877: {
878: *number = totalcount;
879: return(0);
880: }
881:
882: /* second copyout from top of kd_buffer to bufptr */
883: copycount = kd_bufptr - kd_readlast;
884: if (copycount > count)
885: copycount = count;
886: if (copycount == 0)
887: {
888: *number = totalcount;
889: return(0);
890: }
891: if (copyout(kd_readlast, buffer, copycount * sizeof(kd_buf)))
892: {
893: return(EINVAL);
894: }
895: kd_readlast += copycount;
896: totalcount += copycount;
897: *number = totalcount;
898: return(0);
899: }
900: } /* end if KDBG_BUFINIT */
901: } /* end if count */
902: return (EINVAL);
903: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.