1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 /* 12 * Copyright 2019 Joyent, Inc. 13 */ 14 15 #include <mdb/mdb_modapi.h> 16 #include <mdb/mdb_ctf.h> 17 #include <sys/cpuvar.h> 18 #include <sys/x_call.h> 19 20 typedef struct { 21 uint32_t xc_work_cnt; 22 struct xc_msg *xc_curmsg; 23 struct xc_msg *xc_msgbox; 24 xc_data_t xc_data; 25 } mdb_xcall_machcpu_t; 26 27 typedef struct { 28 processorid_t cpu_id; 29 mdb_xcall_machcpu_t cpu_m; 30 } mdb_xcall_cpu_t; 31 32 typedef struct { 33 uint_t xd_flags; 34 processorid_t xd_cpu_id; 35 size_t xd_msg_index; 36 struct xc_msg xd_msgs[NCPU]; 37 } xcall_data_t; 38 39 void 40 xcall_help(void) 41 { 42 mdb_printf( 43 "Print all active cross-calls where the given CPU is the master.\n" 44 "The PEND column is ->xc_work_cnt, the pending message count -\n" 45 "this includes both master and slave messages. For each\n" 46 "cross call, the message type and the slave CPU ID are shown.\n"); 47 } 48 49 static int 50 cpu_id_to_addr(processorid_t cpun, uintptr_t *addrp) 51 { 52 uintptr_t addr; 53 GElf_Sym sym; 54 55 if (mdb_lookup_by_name("cpu", &sym) == -1) { 56 mdb_warn("failed to find symbol for 'cpu'"); 57 return (-1); 58 } 59 60 if (cpun * sizeof (uintptr_t) > sym.st_size) 61 return (-1); 62 63 addr = (uintptr_t)sym.st_value + cpun * sizeof (uintptr_t); 64 65 if (mdb_vread(&addr, sizeof (addr), addr) == -1) { 66 mdb_warn("failed to read cpu[%lu]", cpun); 67 return (-1); 68 } 69 70 if (addr != (uintptr_t)NULL) { 71 *addrp = addr; 72 return (0); 73 } 74 75 return (-1); 76 } 77 78 static int 79 xcall_copy_msg(struct xc_msg *msg, xcall_data_t *data, boolean_t current) 80 { 81 if (data->xd_msg_index >= NCPU) { 82 mdb_warn("ran out of msg space: %lu >= %lu\n", 83 data->xd_msg_index, NCPU); 84 return (-1); 85 } 86 87 bcopy(msg, &data->xd_msgs[data->xd_msg_index], sizeof (*msg)); 88 89 /* 90 * As we don't use .xc_next, store 'current' there. 91 */ 92 data->xd_msgs[data->xd_msg_index].xc_next = (void *)(uintptr_t)current; 93 data->xd_msg_index++; 94 return (0); 95 } 96 97 static int 98 xcall_get_msgs(uintptr_t addr, const void *wdata, void *priv) 99 { 100 _NOTE(ARGUNUSED(wdata)); 101 xcall_data_t *data = priv; 102 mdb_xcall_cpu_t xcpu = { 0, }; 103 struct xc_msg msg; 104 uintptr_t msgaddr; 105 106 if (mdb_ctf_vread(&xcpu, "unix`cpu_t", "mdb_xcall_cpu_t", 107 addr, MDB_CTF_VREAD_IGNORE_ABSENT) == -1) 108 return (WALK_ERR); 109 110 if (xcpu.cpu_m.xc_curmsg != NULL) { 111 msgaddr = (uintptr_t)xcpu.cpu_m.xc_curmsg; 112 113 if (mdb_vread(&msg, sizeof (msg), msgaddr) != sizeof (msg)) 114 return (WALK_ERR); 115 116 if (msg.xc_master == data->xd_cpu_id) { 117 if (data->xd_flags & DCMD_PIPE_OUT) 118 mdb_printf("%p\n", msgaddr); 119 else if (xcall_copy_msg(&msg, data, B_TRUE) != 0) 120 return (WALK_ERR); 121 } 122 } 123 124 for (msgaddr = (uintptr_t)xcpu.cpu_m.xc_msgbox; 125 msgaddr != (uintptr_t)NULL; msgaddr = (uintptr_t)msg.xc_next) { 126 if (mdb_vread(&msg, sizeof (msg), msgaddr) != sizeof (msg)) 127 return (WALK_ERR); 128 129 if (msg.xc_master != data->xd_cpu_id) 130 continue; 131 132 if (data->xd_flags & DCMD_PIPE_OUT) 133 mdb_printf("%p\n", msgaddr); 134 else if (xcall_copy_msg(&msg, data, B_FALSE) != 0) 135 return (WALK_ERR); 136 } 137 138 return (WALK_NEXT); 139 } 140 141 static int 142 print_xcall_msg(struct xc_msg *msg) 143 { 144 boolean_t current = (boolean_t)msg->xc_next; 145 char indent[] = " "; 146 const char *cmd; 147 148 switch (msg->xc_command) { 149 case XC_MSG_ASYNC: cmd = "ASYNC"; break; 150 case XC_MSG_CALL: cmd = "CALL"; break; 151 case XC_MSG_SYNC: cmd = "SYNC"; break; 152 case XC_MSG_FREE:cmd = "FREE"; break; 153 case XC_MSG_WAITING: cmd = "WAITING"; break; 154 case XC_MSG_RELEASED: cmd = "RELEASED"; break; 155 case XC_MSG_DONE: cmd = "DONE"; break; 156 default: cmd = "?"; break; 157 } 158 159 mdb_printf("%s %s%-*s %-6u\n", indent, current ? "*" : "", 160 9 - current, cmd, msg->xc_slave); 161 return (0); 162 } 163 164 /* 165 * Show all xcall messages where the master is the given CPU. 166 * 167 * As non-free messages can be on the slave's ->xc_msgbox or ->xc_curmsg, we 168 * need to walk across all of them to find each message where ->xc_master 169 * is our CPU ID. 170 */ 171 int 172 xcall_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 173 { 174 mdb_xcall_cpu_t xcpu = { 0, }; 175 xcall_data_t data = { 0, }; 176 177 if (mdb_getopts(argc, argv, NULL) != argc) 178 return (DCMD_USAGE); 179 180 /* 181 * Yep, this will re-collect all the messages each time. Shrug. 182 */ 183 if (!(flags & DCMD_ADDRSPEC)) { 184 if (mdb_pwalk_dcmd("cpu", "xcall", argc, argv, 0) == -1) { 185 mdb_warn("can't walk CPUs"); 186 return (DCMD_ERR); 187 } 188 189 return (DCMD_OK); 190 } 191 192 if (addr < NCPU && cpu_id_to_addr((processorid_t)addr, &addr) != 0) { 193 mdb_warn("invalid CPU ID %lu\n", addr); 194 return (DCMD_ERR); 195 } 196 197 if (mdb_ctf_vread(&xcpu, "unix`cpu_t", "mdb_xcall_cpu_t", 198 addr, MDB_CTF_VREAD_IGNORE_ABSENT) == -1) { 199 mdb_warn("couldn't read cpu 0x%lx", addr); 200 return (DCMD_ERR); 201 } 202 203 data.xd_cpu_id = xcpu.cpu_id; 204 data.xd_flags = flags; 205 206 if (mdb_pwalk("cpu", xcall_get_msgs, &data, (uintptr_t)NULL) == -1) { 207 mdb_warn("can't walk CPUs"); 208 return (DCMD_ERR); 209 } 210 211 if (flags & DCMD_PIPE_OUT) 212 return (DCMD_OK); 213 214 if (DCMD_HDRSPEC(flags)) 215 mdb_printf("%<u>%3s %4s %s%</u>\n", "CPU", "PEND", "HANDLER"); 216 217 if (data.xd_msg_index == 0) { 218 mdb_printf("%3d %4d -\n", 219 xcpu.cpu_id, xcpu.cpu_m.xc_work_cnt); 220 return (DCMD_OK); 221 } 222 223 mdb_printf("%3d %4d %a(%a, %a, %a)\n", 224 xcpu.cpu_id, xcpu.cpu_m.xc_work_cnt, 225 xcpu.cpu_m.xc_data.xc_func, xcpu.cpu_m.xc_data.xc_a1, 226 xcpu.cpu_m.xc_data.xc_a2, xcpu.cpu_m.xc_data.xc_a3); 227 228 if (!(flags & DCMD_PIPE_OUT)) 229 mdb_printf(" %<u>%-9s %-6s%</u>\n", "COMMAND", "SLAVE"); 230 231 for (size_t i = 0; i < data.xd_msg_index; i++) { 232 if (print_xcall_msg(&data.xd_msgs[i]) != 0) 233 return (DCMD_ERR); 234 } 235 236 return (DCMD_OK); 237 } 238