1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <sys/dtrace.h> 29 #include <sys/systrace.h> 30 #include <sys/stat.h> 31 #include <sys/systm.h> 32 #include <sys/conf.h> 33 #include <sys/ddi.h> 34 #include <sys/sunddi.h> 35 #include <sys/atomic.h> 36 37 #define SYSTRACE_ARTIFICIAL_FRAMES 1 38 39 #define SYSTRACE_SHIFT 16 40 #define SYSTRACE_ISENTRY(x) ((int)(x) >> SYSTRACE_SHIFT) 41 #define SYSTRACE_SYSNUM(x) ((int)(x) & ((1 << SYSTRACE_SHIFT) - 1)) 42 #define SYSTRACE_ENTRY(id) ((1 << SYSTRACE_SHIFT) | (id)) 43 #define SYSTRACE_RETURN(id) (id) 44 45 #if ((1 << SYSTRACE_SHIFT) <= NSYSCALL) 46 #error 1 << SYSTRACE_SHIFT must exceed number of system calls 47 #endif 48 49 static dev_info_t *systrace_devi; 50 static dtrace_provider_id_t systrace_id; 51 52 static void 53 systrace_init(struct sysent *actual, systrace_sysent_t **interposed) 54 { 55 systrace_sysent_t *sysent = *interposed; 56 int i; 57 58 if (sysent == NULL) { 59 *interposed = sysent = kmem_zalloc(sizeof (systrace_sysent_t) * 60 NSYSCALL, KM_SLEEP); 61 } 62 63 for (i = 0; i < NSYSCALL; i++) { 64 struct sysent *a = &actual[i]; 65 systrace_sysent_t *s = &sysent[i]; 66 67 if (LOADABLE_SYSCALL(a) && !LOADED_SYSCALL(a)) 68 continue; 69 70 if (a->sy_callc == dtrace_systrace_syscall) 71 continue; 72 73 #ifdef _SYSCALL32_IMPL 74 if (a->sy_callc == dtrace_systrace_syscall32) 75 continue; 76 #endif 77 78 s->stsy_underlying = a->sy_callc; 79 } 80 } 81 82 /*ARGSUSED*/ 83 static void 84 systrace_provide(void *arg, const dtrace_probedesc_t *desc) 85 { 86 int i; 87 88 if (desc != NULL) 89 return; 90 91 systrace_init(sysent, &systrace_sysent); 92 #ifdef _SYSCALL32_IMPL 93 systrace_init(sysent32, &systrace_sysent32); 94 #endif 95 96 for (i = 0; i < NSYSCALL; i++) { 97 if (systrace_sysent[i].stsy_underlying == NULL) 98 continue; 99 100 if (dtrace_probe_lookup(systrace_id, NULL, 101 syscallnames[i], "entry") != 0) 102 continue; 103 104 (void) dtrace_probe_create(systrace_id, NULL, syscallnames[i], 105 "entry", SYSTRACE_ARTIFICIAL_FRAMES, 106 (void *)((uintptr_t)SYSTRACE_ENTRY(i))); 107 (void) dtrace_probe_create(systrace_id, NULL, syscallnames[i], 108 "return", SYSTRACE_ARTIFICIAL_FRAMES, 109 (void *)((uintptr_t)SYSTRACE_RETURN(i))); 110 111 systrace_sysent[i].stsy_entry = DTRACE_IDNONE; 112 systrace_sysent[i].stsy_return = DTRACE_IDNONE; 113 #ifdef _SYSCALL32_IMPL 114 systrace_sysent32[i].stsy_entry = DTRACE_IDNONE; 115 systrace_sysent32[i].stsy_return = DTRACE_IDNONE; 116 #endif 117 } 118 } 119 120 /*ARGSUSED*/ 121 static void 122 systrace_destroy(void *arg, dtrace_id_t id, void *parg) 123 { 124 int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg); 125 126 /* 127 * There's nothing to do here but assert that we have actually been 128 * disabled. 129 */ 130 if (SYSTRACE_ISENTRY((uintptr_t)parg)) { 131 ASSERT(systrace_sysent[sysnum].stsy_entry == DTRACE_IDNONE); 132 #ifdef _SYSCALL32_IMPL 133 ASSERT(systrace_sysent32[sysnum].stsy_entry == DTRACE_IDNONE); 134 #endif 135 } else { 136 ASSERT(systrace_sysent[sysnum].stsy_return == DTRACE_IDNONE); 137 #ifdef _SYSCALL32_IMPL 138 ASSERT(systrace_sysent32[sysnum].stsy_return == DTRACE_IDNONE); 139 #endif 140 } 141 } 142 143 /*ARGSUSED*/ 144 static void 145 systrace_enable(void *arg, dtrace_id_t id, void *parg) 146 { 147 int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg); 148 int enabled = (systrace_sysent[sysnum].stsy_entry != DTRACE_IDNONE || 149 systrace_sysent[sysnum].stsy_return != DTRACE_IDNONE); 150 151 if (SYSTRACE_ISENTRY((uintptr_t)parg)) { 152 systrace_sysent[sysnum].stsy_entry = id; 153 #ifdef _SYSCALL32_IMPL 154 systrace_sysent32[sysnum].stsy_entry = id; 155 #endif 156 } else { 157 systrace_sysent[sysnum].stsy_return = id; 158 #ifdef _SYSCALL32_IMPL 159 systrace_sysent32[sysnum].stsy_return = id; 160 #endif 161 } 162 163 if (enabled) { 164 ASSERT(sysent[sysnum].sy_callc == dtrace_systrace_syscall); 165 return; 166 } 167 168 (void) casptr(&sysent[sysnum].sy_callc, 169 (void *)systrace_sysent[sysnum].stsy_underlying, 170 (void *)dtrace_systrace_syscall); 171 #ifdef _SYSCALL32_IMPL 172 (void) casptr(&sysent32[sysnum].sy_callc, 173 (void *)systrace_sysent32[sysnum].stsy_underlying, 174 (void *)dtrace_systrace_syscall32); 175 #endif 176 } 177 178 /*ARGSUSED*/ 179 static void 180 systrace_disable(void *arg, dtrace_id_t id, void *parg) 181 { 182 int sysnum = SYSTRACE_SYSNUM((uintptr_t)parg); 183 int disable = (systrace_sysent[sysnum].stsy_entry == DTRACE_IDNONE || 184 systrace_sysent[sysnum].stsy_return == DTRACE_IDNONE); 185 186 if (disable) { 187 (void) casptr(&sysent[sysnum].sy_callc, 188 (void *)dtrace_systrace_syscall, 189 (void *)systrace_sysent[sysnum].stsy_underlying); 190 191 #ifdef _SYSCALL32_IMPL 192 (void) casptr(&sysent32[sysnum].sy_callc, 193 (void *)dtrace_systrace_syscall32, 194 (void *)systrace_sysent32[sysnum].stsy_underlying); 195 #endif 196 } 197 198 if (SYSTRACE_ISENTRY((uintptr_t)parg)) { 199 systrace_sysent[sysnum].stsy_entry = DTRACE_IDNONE; 200 #ifdef _SYSCALL32_IMPL 201 systrace_sysent32[sysnum].stsy_entry = DTRACE_IDNONE; 202 #endif 203 } else { 204 systrace_sysent[sysnum].stsy_return = DTRACE_IDNONE; 205 #ifdef _SYSCALL32_IMPL 206 systrace_sysent32[sysnum].stsy_return = DTRACE_IDNONE; 207 #endif 208 } 209 } 210 211 static dtrace_pattr_t systrace_attr = { 212 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON }, 213 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_UNKNOWN }, 214 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA }, 215 { DTRACE_STABILITY_EVOLVING, DTRACE_STABILITY_EVOLVING, DTRACE_CLASS_COMMON }, 216 { DTRACE_STABILITY_PRIVATE, DTRACE_STABILITY_PRIVATE, DTRACE_CLASS_ISA }, 217 }; 218 219 static dtrace_pops_t systrace_pops = { 220 systrace_provide, 221 NULL, 222 systrace_enable, 223 systrace_disable, 224 NULL, 225 NULL, 226 NULL, 227 NULL, 228 NULL, 229 systrace_destroy 230 }; 231 232 static int 233 systrace_attach(dev_info_t *devi, ddi_attach_cmd_t cmd) 234 { 235 switch (cmd) { 236 case DDI_ATTACH: 237 break; 238 case DDI_RESUME: 239 return (DDI_SUCCESS); 240 default: 241 return (DDI_FAILURE); 242 } 243 244 systrace_probe = (void (*)())dtrace_probe; 245 membar_enter(); 246 247 if (ddi_create_minor_node(devi, "systrace", S_IFCHR, 0, 248 DDI_PSEUDO, NULL) == DDI_FAILURE || 249 dtrace_register("syscall", &systrace_attr, DTRACE_PRIV_USER, NULL, 250 &systrace_pops, NULL, &systrace_id) != 0) { 251 systrace_probe = systrace_stub; 252 ddi_remove_minor_node(devi, NULL); 253 return (DDI_FAILURE); 254 } 255 256 ddi_report_dev(devi); 257 systrace_devi = devi; 258 259 return (DDI_SUCCESS); 260 } 261 262 static int 263 systrace_detach(dev_info_t *devi, ddi_detach_cmd_t cmd) 264 { 265 switch (cmd) { 266 case DDI_DETACH: 267 break; 268 case DDI_SUSPEND: 269 return (DDI_SUCCESS); 270 default: 271 return (DDI_FAILURE); 272 } 273 274 if (dtrace_unregister(systrace_id) != 0) 275 return (DDI_FAILURE); 276 277 ddi_remove_minor_node(devi, NULL); 278 systrace_probe = systrace_stub; 279 return (DDI_SUCCESS); 280 } 281 282 /*ARGSUSED*/ 283 static int 284 systrace_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result) 285 { 286 int error; 287 288 switch (infocmd) { 289 case DDI_INFO_DEVT2DEVINFO: 290 *result = (void *)systrace_devi; 291 error = DDI_SUCCESS; 292 break; 293 case DDI_INFO_DEVT2INSTANCE: 294 *result = (void *)0; 295 error = DDI_SUCCESS; 296 break; 297 default: 298 error = DDI_FAILURE; 299 } 300 return (error); 301 } 302 303 /*ARGSUSED*/ 304 static int 305 systrace_open(dev_t *devp, int flag, int otyp, cred_t *cred_p) 306 { 307 return (0); 308 } 309 310 static struct cb_ops systrace_cb_ops = { 311 systrace_open, /* open */ 312 nodev, /* close */ 313 nulldev, /* strategy */ 314 nulldev, /* print */ 315 nodev, /* dump */ 316 nodev, /* read */ 317 nodev, /* write */ 318 nodev, /* ioctl */ 319 nodev, /* devmap */ 320 nodev, /* mmap */ 321 nodev, /* segmap */ 322 nochpoll, /* poll */ 323 ddi_prop_op, /* cb_prop_op */ 324 0, /* streamtab */ 325 D_NEW | D_MP /* Driver compatibility flag */ 326 }; 327 328 static struct dev_ops systrace_ops = { 329 DEVO_REV, /* devo_rev, */ 330 0, /* refcnt */ 331 systrace_info, /* get_dev_info */ 332 nulldev, /* identify */ 333 nulldev, /* probe */ 334 systrace_attach, /* attach */ 335 systrace_detach, /* detach */ 336 nodev, /* reset */ 337 &systrace_cb_ops, /* driver operations */ 338 NULL, /* bus operations */ 339 nodev /* dev power */ 340 }; 341 342 /* 343 * Module linkage information for the kernel. 344 */ 345 static struct modldrv modldrv = { 346 &mod_driverops, /* module type (this is a pseudo driver) */ 347 "System Call Tracing", /* name of module */ 348 &systrace_ops, /* driver ops */ 349 }; 350 351 static struct modlinkage modlinkage = { 352 MODREV_1, 353 (void *)&modldrv, 354 NULL 355 }; 356 357 int 358 _init(void) 359 { 360 return (mod_install(&modlinkage)); 361 } 362 363 int 364 _info(struct modinfo *modinfop) 365 { 366 return (mod_info(&modlinkage, modinfop)); 367 } 368 369 int 370 _fini(void) 371 { 372 return (mod_remove(&modlinkage)); 373 } 374