Lines Matching defs:ctx

69 static uint32_t kcpc_nullctx_count;    /* # overflows in a thread with no ctx */
78 static void kcpc_restore(kcpc_ctx_t *ctx);
79 static void kcpc_save(kcpc_ctx_t *ctx);
80 static void kcpc_ctx_clone(kcpc_ctx_t *ctx, kcpc_ctx_t *cctx);
93 #define KCPC_CTX_FLAG_SET(ctx, flag) atomic_or_uint(&(ctx)->kc_flags, (flag))
94 #define KCPC_CTX_FLAG_CLR(ctx, flag) atomic_and_uint(&(ctx)->kc_flags, ~(flag))
173 kcpc_ctx_t *ctx;
177 ctx = kcpc_ctx_alloc(KM_SLEEP);
179 if (kcpc_assign_reqs(set, ctx) != 0) {
180 kcpc_ctx_free(ctx);
185 ctx->kc_cpuid = cpuid;
186 ctx->kc_thread = curthread;
190 if ((error = kcpc_configure_reqs(ctx, set, subcode)) != 0) {
192 kcpc_ctx_free(ctx);
196 set->ks_ctx = ctx;
197 ctx->kc_set = set;
239 kcpc_program(ctx, B_FALSE, B_TRUE);
258 kcpc_ctx_free(ctx);
265 kcpc_ctx_t *ctx;
276 ctx = kcpc_ctx_alloc(KM_SLEEP);
283 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_FREEZE);
284 ctx->kc_hrtime = gethrtime();
286 if (kcpc_assign_reqs(set, ctx) != 0) {
287 kcpc_ctx_free(ctx);
292 ctx->kc_cpuid = -1;
294 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_LWPINHERIT);
295 ctx->kc_thread = t;
296 t->t_cpc_ctx = ctx;
300 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_NONPRIV);
307 if ((error = kcpc_configure_reqs(ctx, set, subcode)) != 0) {
309 kcpc_ctx_free(ctx);
314 set->ks_ctx = ctx;
315 ctx->kc_set = set;
320 installctx(t, ctx, kcpc_save, kcpc_restore, NULL,
331 kcpc_program(ctx, B_TRUE, B_TRUE);
343 KCPC_CTX_FLAG_CLR(ctx, KCPC_CTX_FREEZE);
359 kcpc_configure_reqs(kcpc_ctx_t *ctx, kcpc_set_t *set, int *subcode)
373 ASSERT(ctx->kc_pics[n].kp_req == NULL);
386 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_SIGOVF);
392 &(rp->kr_config), (void *)ctx)) != 0) {
404 ctx->kc_pics[n].kp_req = rp;
405 rp->kr_picp = &ctx->kc_pics[n];
430 kcpc_ctx_t *ctx = set->ks_ctx;
448 if (ctx->kc_flags & KCPC_CTX_INVALID) {
454 if ((ctx->kc_flags & KCPC_CTX_FREEZE) == 0) {
455 if (ctx->kc_cpuid != -1) {
456 if (curthread->t_bind_cpu != ctx->kc_cpuid) {
463 if (ctx->kc_thread == curthread) {
466 ctx->kc_hrtime = gethrtime_waitfree();
467 pcbe_ops->pcbe_sample(ctx);
468 ctx->kc_vtick += curtick - ctx->kc_rawtick;
469 ctx->kc_rawtick = curtick;
476 if (ctx->kc_flags & KCPC_CTX_INVALID) {
490 if (copyout(&ctx->kc_hrtime, hrtime, sizeof (uint64_t)) == -1)
492 if (copyout(&ctx->kc_vtick, tick, sizeof (uint64_t)) == -1)
502 kcpc_stop_hw(kcpc_ctx_t *ctx)
508 if (ctx->kc_cpuid == CPU->cpu_id) {
511 cp = cpu_get(ctx->kc_cpuid);
514 ASSERT(cp != NULL && cp->cpu_cpc_ctx == ctx);
523 kcpc_ctx_t *ctx;
536 ctx = set->ks_ctx;
541 mutex_enter(&ctx->kc_lock);
542 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_INVALID);
543 mutex_exit(&ctx->kc_lock);
545 if (ctx->kc_cpuid == -1) {
546 t = ctx->kc_thread;
557 if (!(ctx->kc_flags & KCPC_CTX_INVALID_STOPPED))
558 kcpc_unprogram(ctx, B_TRUE);
563 if (removectx(t, ctx, kcpc_save, kcpc_restore, NULL,
566 (void *)ctx, (void *)t);
568 (void) removectx(t, ctx, kcpc_save, kcpc_restore, NULL,
587 cp = cpu_get(ctx->kc_cpuid);
593 if ((ctx->kc_flags & KCPC_CTX_INVALID_STOPPED) == 0)
594 kcpc_stop_hw(ctx);
595 ASSERT(ctx->kc_flags & KCPC_CTX_INVALID_STOPPED);
599 if (ctx->kc_thread == curthread) {
600 kcpc_free(ctx, 0);
633 kcpc_ctx_t *ctx = set->ks_ctx;
638 ASSERT(ctx->kc_thread == curthread);
639 ASSERT(ctx->kc_cpuid == -1);
654 if ((ctx->kc_flags & KCPC_CTX_FREEZE) == 0)
660 ctx->kc_rawtick = KCPC_GET_TICK();
661 KCPC_CTX_FLAG_CLR(ctx, KCPC_CTX_FREEZE);
662 pcbe_ops->pcbe_program(ctx);
675 kcpc_ctx_t *ctx = t->t_cpc_ctx;
684 if (ctx == NULL) {
692 } else if (ctx->kc_flags & KCPC_CTX_INVALID)
696 if ((ctx->kc_flags & KCPC_CTX_FREEZE) == 0)
699 KCPC_CTX_FLAG_CLR(ctx, KCPC_CTX_FREEZE);
700 kcpc_restore(ctx);
703 if (ctx->kc_flags & KCPC_CTX_FREEZE)
706 kcpc_save(ctx);
707 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_FREEZE);
719 KCPC_CTX_FLAG_SET(ctx,
760 kcpc_ctx_t *ctx = (kcpc_ctx_t *)token;
769 if (ctx->kc_pics[i].kp_req != NULL)
781 pic = &ctx->kc_pics[i];
793 pic = &ctx->kc_pics[i];
803 *data = ctx->kc_pics[i].kp_req->kr_data;
806 return (ctx->kc_pics[i].kp_req->kr_config);
813 kcpc_ctx_t *ctx;
816 ctx = (kcpc_ctx_t *)kmem_zalloc(sizeof (kcpc_ctx_t), kmem_flags);
817 if (ctx == NULL)
820 hash = CPC_HASH_CTX(ctx);
822 ctx->kc_next = kcpc_ctx_list[hash];
823 kcpc_ctx_list[hash] = ctx;
826 ctx->kc_pics = (kcpc_pic_t *)kmem_zalloc(sizeof (kcpc_pic_t) *
829 ctx->kc_cpuid = -1;
831 return (ctx);
835 * Copy set from ctx to the child context, cctx, if it has CPC_BIND_LWP_INHERIT
839 kcpc_ctx_clone(kcpc_ctx_t *ctx, kcpc_ctx_t *cctx)
841 kcpc_set_t *ks = ctx->kc_set, *cks;
893 kcpc_ctx_free(kcpc_ctx_t *ctx)
896 long hash = CPC_HASH_CTX(ctx);
901 while (*loc != ctx)
903 *loc = ctx->kc_next;
906 kmem_free(ctx->kc_pics, cpc_ncounters * sizeof (kcpc_pic_t));
907 cv_destroy(&ctx->kc_condv);
908 mutex_destroy(&ctx->kc_lock);
909 kmem_free(ctx, sizeof (*ctx));
922 kcpc_ctx_t *ctx;
948 ctx = NULL;
951 ctx = t->t_cpc_ctx;
954 ctx = t->t_cpc_ctx;
956 if (ctx == NULL) {
966 ctx = curthread->t_cpu->cpu_cpc_ctx;
967 if (ctx != NULL) {
973 return (ctx);
1012 } else if ((ctx->kc_flags & KCPC_CTX_INVALID) == 0) {
1025 if (ctx->kc_pics[i].kp_req != NULL &&
1027 ctx->kc_pics[i].kp_req->kr_flags &
1034 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_FREEZE);
1035 atomic_or_uint(&ctx->kc_pics[i].kp_flags,
1040 } else if (ctx->kc_flags & KCPC_CTX_INVALID_STOPPED) {
1059 kcpc_ctx_t *ctx;
1091 ctx = curthread->t_cpu->cpu_cpc_ctx;
1092 if (ctx == NULL) {
1101 for (i = 0; i < ctx->kc_set->ks_nreqs; i++) {
1102 req = ctx->kc_set->ks_req[i];
1109 (void *)ctx);
1112 pcbe_ops->pcbe_program(ctx);
1145 if ((ctx = kcpc_overflow_intr(arg1, bitmap)) != NULL) {
1148 ctx->kc_hrtime = gethrtime_waitfree();
1149 ctx->kc_vtick += curtick - ctx->kc_rawtick;
1150 ctx->kc_rawtick = curtick;
1151 pcbe_ops->pcbe_sample(ctx);
1152 pcbe_ops->pcbe_program(ctx);
1166 kcpc_ctx_t *ctx = curthread->t_cpc_ctx;
1171 ASSERT(ctx != NULL); /* Beware of interrupt skid. */
1179 ctx->kc_hrtime = gethrtime_waitfree();
1180 pcbe_ops->pcbe_sample(ctx);
1183 ctx->kc_vtick += curtick - ctx->kc_rawtick;
1194 if (ctx->kc_pics[i].kp_flags & KCPC_PIC_OVERFLOWED) {
1195 atomic_and_uint(&ctx->kc_pics[i].kp_flags,
1207 KCPC_CTX_FLAG_CLR(ctx, KCPC_CTX_FREEZE);
1208 pcbe_ops->pcbe_program(ctx);
1217 kcpc_save(kcpc_ctx_t *ctx)
1225 if (ctx->kc_flags & KCPC_CTX_INVALID) {
1226 if (ctx->kc_flags & KCPC_CTX_INVALID_STOPPED) {
1235 kcpc_unprogram(ctx, B_TRUE);
1242 if (ctx->kc_flags & KCPC_CTX_FREEZE) {
1251 ctx->kc_hrtime = gethrtime_waitfree();
1252 ctx->kc_vtick += KCPC_GET_TICK() - ctx->kc_rawtick;
1253 pcbe_ops->pcbe_sample(ctx);
1259 ASSERT(ctx->kc_cpuid == -1);
1266 kcpc_restore(kcpc_ctx_t *ctx)
1270 mutex_enter(&ctx->kc_lock);
1272 if ((ctx->kc_flags & (KCPC_CTX_INVALID | KCPC_CTX_INVALID_STOPPED)) ==
1279 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_INVALID_STOPPED);
1282 if (ctx->kc_flags & (KCPC_CTX_INVALID | KCPC_CTX_FREEZE)) {
1283 mutex_exit(&ctx->kc_lock);
1289 * ctx & set related memory objects being freed without us knowing.
1296 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_RESTORE);
1297 mutex_exit(&ctx->kc_lock);
1306 kcpc_program(ctx, B_TRUE, B_TRUE);
1313 mutex_enter(&ctx->kc_lock);
1314 KCPC_CTX_FLAG_CLR(ctx, KCPC_CTX_RESTORE);
1315 cv_signal(&ctx->kc_condv);
1316 mutex_exit(&ctx->kc_lock);
1378 kcpc_ctx_t *ctx = t->t_cpc_ctx, *cctx;
1381 if (ctx == NULL || (ctx->kc_flags & KCPC_CTX_LWPINHERIT) == 0)
1385 if (ctx->kc_flags & KCPC_CTX_INVALID) {
1390 kcpc_ctx_clone(ctx, cctx);
1397 KCPC_CTX_FLAG_SET(cctx, ctx->kc_flags);
1412 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_FREEZE);
1464 kcpc_free(kcpc_ctx_t *ctx, int isexec)
1467 kcpc_set_t *set = ctx->kc_set;
1474 mutex_enter(&ctx->kc_lock);
1475 while (ctx->kc_flags & KCPC_CTX_RESTORE)
1476 cv_wait(&ctx->kc_condv, &ctx->kc_lock);
1477 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_INVALID);
1478 mutex_exit(&ctx->kc_lock);
1487 if (ctx->kc_cpuid != -1) {
1495 cp = cpu_get(ctx->kc_cpuid);
1503 kcpc_stop_hw(ctx);
1516 kcpc_unprogram(ctx, B_TRUE);
1528 ASSERT(ctx->kc_thread == curthread);
1542 kcpc_ctx_free(ctx);
1578 kcpc_ctx_t *ctx;
1583 for (ctx = kcpc_ctx_list[hash]; ctx; ctx = ctx->kc_next)
1584 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_INVALID);
1596 kcpc_ctx_t *ctx = token;
1598 ASSERT(ctx != NULL);
1600 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_INVALID);
1609 kcpc_ctx_t *ctx = curthread->t_cpc_ctx;
1616 if (ctx == NULL) {
1644 if ((ctx->kc_flags & KCPC_CTX_INVALID_STOPPED) == 0) {
1645 kcpc_unprogram(ctx, B_TRUE);
1646 KCPC_CTX_FLAG_SET(ctx,
1667 kcpc_assign_reqs(kcpc_set_t *set, kcpc_ctx_t *ctx)
1815 kcpc_ctx_t *ctx = t->t_cpc_ctx;
1817 if (ctx != NULL)
1818 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_INVALID);
1897 kcpc_ctx_t *ctx;
1904 ctx = kcpc_ctx_alloc(kmem_flags);
1907 kcpc_ctx_free(ctx);
1915 if (kcpc_assign_reqs(set, ctx) != 0) {
1927 kcpc_ctx_free(ctx);
1930 if (kcpc_assign_reqs(set, ctx) != 0) {
1937 kcpc_ctx_free(ctx);
1951 kcpc_ctx_free(ctx);
1958 if (kcpc_configure_reqs(ctx, set, &subcode) != 0) {
1969 kcpc_ctx_free(ctx);
1977 set->ks_ctx = ctx;
1978 ctx->kc_set = set;
1979 ctx->kc_cpuid = cp->cpu_id;
1980 ctx->kc_thread = curthread;
1982 ctx_ptrs[nctx] = ctx;
2068 kcpc_program(kcpc_ctx_t *ctx, boolean_t for_thread, boolean_t cu_interpose)
2079 ASSERT(ctx != NULL && (ctx->kc_cpuid == CPU->cpu_id ||
2080 ctx->kc_cpuid == -1) && curthread->t_preempt > 0);
2081 if (ctx == NULL || (ctx->kc_cpuid != CPU->cpu_id &&
2082 ctx->kc_cpuid != -1) || curthread->t_preempt < 1)
2092 kcpc_set_t *set = ctx->kc_set;
2121 ctx->kc_rawtick = KCPC_GET_TICK();
2122 pcbe_ops->pcbe_program(ctx);
2129 KCPC_CTX_FLAG_CLR(ctx, KCPC_CTX_FREEZE);
2131 CPU->cpu_cpc_ctx = ctx;
2145 kcpc_unprogram(kcpc_ctx_t *ctx, boolean_t cu_interpose)
2156 ASSERT(ctx != NULL && (ctx->kc_cpuid == CPU->cpu_id ||
2157 ctx->kc_cpuid == -1) && curthread->t_preempt > 0);
2159 if (ctx == NULL || (ctx->kc_cpuid != CPU->cpu_id &&
2160 ctx->kc_cpuid != -1) || curthread->t_preempt < 1 ||
2161 (ctx->kc_flags & KCPC_CTX_INVALID_STOPPED) != 0) {
2169 ASSERT(CPU->cpu_cpc_ctx == ctx || curthread->t_cpc_ctx == ctx);
2175 KCPC_CTX_FLAG_SET(ctx, KCPC_CTX_INVALID_STOPPED);
2193 kcpc_ctx_t *ctx;
2206 ctx = CPU->cpu_cpc_ctx;
2207 if (ctx == NULL) {
2215 pcbe_ops->pcbe_sample(ctx);
2217 set = ctx->kc_set;
2464 kcpc_remoteprogram_func(kcpc_ctx_t *ctx, uintptr_t arg)
2468 ASSERT(ctx != NULL);
2471 kcpc_program(ctx, for_thread, B_TRUE);
2479 kcpc_cpu_program(cpu_t *cp, kcpc_ctx_t *ctx)
2481 cpu_call(cp, (cpu_call_func_t)kcpc_remoteprogram_func, (uintptr_t)ctx,