1 #include <errno.h> 2 #include <string.h> 3 #include <regex.h> 4 5 #include "../../perf.h" 6 #include "../../util/util.h" 7 #include "../../util/perf_regs.h" 8 #include "../../util/debug.h" 9 10 const struct sample_reg sample_reg_masks[] = { 11 SMPL_REG(AX, PERF_REG_X86_AX), 12 SMPL_REG(BX, PERF_REG_X86_BX), 13 SMPL_REG(CX, PERF_REG_X86_CX), 14 SMPL_REG(DX, PERF_REG_X86_DX), 15 SMPL_REG(SI, PERF_REG_X86_SI), 16 SMPL_REG(DI, PERF_REG_X86_DI), 17 SMPL_REG(BP, PERF_REG_X86_BP), 18 SMPL_REG(SP, PERF_REG_X86_SP), 19 SMPL_REG(IP, PERF_REG_X86_IP), 20 SMPL_REG(FLAGS, PERF_REG_X86_FLAGS), 21 SMPL_REG(CS, PERF_REG_X86_CS), 22 SMPL_REG(SS, PERF_REG_X86_SS), 23 #ifdef HAVE_ARCH_X86_64_SUPPORT 24 SMPL_REG(R8, PERF_REG_X86_R8), 25 SMPL_REG(R9, PERF_REG_X86_R9), 26 SMPL_REG(R10, PERF_REG_X86_R10), 27 SMPL_REG(R11, PERF_REG_X86_R11), 28 SMPL_REG(R12, PERF_REG_X86_R12), 29 SMPL_REG(R13, PERF_REG_X86_R13), 30 SMPL_REG(R14, PERF_REG_X86_R14), 31 SMPL_REG(R15, PERF_REG_X86_R15), 32 #endif 33 SMPL_REG_END 34 }; 35 36 struct sdt_name_reg { 37 const char *sdt_name; 38 const char *uprobe_name; 39 }; 40 #define SDT_NAME_REG(n, m) {.sdt_name = "%" #n, .uprobe_name = "%" #m} 41 #define SDT_NAME_REG_END {.sdt_name = NULL, .uprobe_name = NULL} 42 43 static const struct sdt_name_reg sdt_reg_tbl[] = { 44 SDT_NAME_REG(eax, ax), 45 SDT_NAME_REG(rax, ax), 46 SDT_NAME_REG(al, ax), 47 SDT_NAME_REG(ah, ax), 48 SDT_NAME_REG(ebx, bx), 49 SDT_NAME_REG(rbx, bx), 50 SDT_NAME_REG(bl, bx), 51 SDT_NAME_REG(bh, bx), 52 SDT_NAME_REG(ecx, cx), 53 SDT_NAME_REG(rcx, cx), 54 SDT_NAME_REG(cl, cx), 55 SDT_NAME_REG(ch, cx), 56 SDT_NAME_REG(edx, dx), 57 SDT_NAME_REG(rdx, dx), 58 SDT_NAME_REG(dl, dx), 59 SDT_NAME_REG(dh, dx), 60 SDT_NAME_REG(esi, si), 61 SDT_NAME_REG(rsi, si), 62 SDT_NAME_REG(sil, si), 63 SDT_NAME_REG(edi, di), 64 SDT_NAME_REG(rdi, di), 65 SDT_NAME_REG(dil, di), 66 SDT_NAME_REG(ebp, bp), 67 SDT_NAME_REG(rbp, bp), 68 SDT_NAME_REG(bpl, bp), 69 SDT_NAME_REG(rsp, sp), 70 SDT_NAME_REG(esp, sp), 71 SDT_NAME_REG(spl, sp), 72 73 /* rNN registers */ 74 SDT_NAME_REG(r8b, r8), 75 SDT_NAME_REG(r8w, r8), 76 SDT_NAME_REG(r8d, r8), 77 SDT_NAME_REG(r9b, r9), 78 SDT_NAME_REG(r9w, r9), 79 SDT_NAME_REG(r9d, r9), 80 SDT_NAME_REG(r10b, r10), 81 SDT_NAME_REG(r10w, r10), 82 SDT_NAME_REG(r10d, r10), 83 SDT_NAME_REG(r11b, r11), 84 SDT_NAME_REG(r11w, r11), 85 SDT_NAME_REG(r11d, r11), 86 SDT_NAME_REG(r12b, r12), 87 SDT_NAME_REG(r12w, r12), 88 SDT_NAME_REG(r12d, r12), 89 SDT_NAME_REG(r13b, r13), 90 SDT_NAME_REG(r13w, r13), 91 SDT_NAME_REG(r13d, r13), 92 SDT_NAME_REG(r14b, r14), 93 SDT_NAME_REG(r14w, r14), 94 SDT_NAME_REG(r14d, r14), 95 SDT_NAME_REG(r15b, r15), 96 SDT_NAME_REG(r15w, r15), 97 SDT_NAME_REG(r15d, r15), 98 SDT_NAME_REG_END, 99 }; 100 101 /* 102 * Perf only supports OP which is in +/-NUM(REG) form. 103 * Here plus-minus sign, NUM and parenthesis are optional, 104 * only REG is mandatory. 105 * 106 * SDT events also supports indirect addressing mode with a 107 * symbol as offset, scaled mode and constants in OP. But 108 * perf does not support them yet. Below are few examples. 109 * 110 * OP with scaled mode: 111 * (%rax,%rsi,8) 112 * 10(%ras,%rsi,8) 113 * 114 * OP with indirect addressing mode: 115 * check_action(%rip) 116 * mp_+52(%rip) 117 * 44+mp_(%rip) 118 * 119 * OP with constant values: 120 * $0 121 * $123 122 * $-1 123 */ 124 #define SDT_OP_REGEX "^([+\\-]?)([0-9]*)(\\(?)(%[a-z][a-z0-9]+)(\\)?)$" 125 126 static regex_t sdt_op_regex; 127 128 static int sdt_init_op_regex(void) 129 { 130 static int initialized; 131 int ret = 0; 132 133 if (initialized) 134 return 0; 135 136 ret = regcomp(&sdt_op_regex, SDT_OP_REGEX, REG_EXTENDED); 137 if (ret < 0) { 138 pr_debug4("Regex compilation error.\n"); 139 return ret; 140 } 141 142 initialized = 1; 143 return 0; 144 } 145 146 /* 147 * Max x86 register name length is 5(ex: %r15d). So, 6th char 148 * should always contain NULL. This helps to find register name 149 * length using strlen, insted of maintaing one more variable. 150 */ 151 #define SDT_REG_NAME_SIZE 6 152 153 /* 154 * The uprobe parser does not support all gas register names; 155 * so, we have to replace them (ex. for x86_64: %rax -> %ax). 156 * Note: If register does not require renaming, just copy 157 * paste as it is, but don't leave it empty. 158 */ 159 static void sdt_rename_register(char *sdt_reg, int sdt_len, char *uprobe_reg) 160 { 161 int i = 0; 162 163 for (i = 0; sdt_reg_tbl[i].sdt_name != NULL; i++) { 164 if (!strncmp(sdt_reg_tbl[i].sdt_name, sdt_reg, sdt_len)) { 165 strcpy(uprobe_reg, sdt_reg_tbl[i].uprobe_name); 166 return; 167 } 168 } 169 170 strncpy(uprobe_reg, sdt_reg, sdt_len); 171 } 172 173 int arch_sdt_arg_parse_op(char *old_op, char **new_op) 174 { 175 char new_reg[SDT_REG_NAME_SIZE] = {0}; 176 int new_len = 0, ret; 177 /* 178 * rm[0]: +/-NUM(REG) 179 * rm[1]: +/- 180 * rm[2]: NUM 181 * rm[3]: ( 182 * rm[4]: REG 183 * rm[5]: ) 184 */ 185 regmatch_t rm[6]; 186 /* 187 * Max prefix length is 2 as it may contains sign(+/-) 188 * and displacement 0 (Both sign and displacement 0 are 189 * optional so it may be empty). Use one more character 190 * to hold last NULL so that strlen can be used to find 191 * prefix length, instead of maintaing one more variable. 192 */ 193 char prefix[3] = {0}; 194 195 ret = sdt_init_op_regex(); 196 if (ret < 0) 197 return ret; 198 199 /* 200 * If unsupported OR does not match with regex OR 201 * register name too long, skip it. 202 */ 203 if (strchr(old_op, ',') || strchr(old_op, '$') || 204 regexec(&sdt_op_regex, old_op, 6, rm, 0) || 205 rm[4].rm_eo - rm[4].rm_so > SDT_REG_NAME_SIZE) { 206 pr_debug4("Skipping unsupported SDT argument: %s\n", old_op); 207 return SDT_ARG_SKIP; 208 } 209 210 /* 211 * Prepare prefix. 212 * If SDT OP has parenthesis but does not provide 213 * displacement, add 0 for displacement. 214 * SDT Uprobe Prefix 215 * ----------------------------- 216 * +24(%rdi) +24(%di) + 217 * 24(%rdi) +24(%di) + 218 * %rdi %di 219 * (%rdi) +0(%di) +0 220 * -80(%rbx) -80(%bx) - 221 */ 222 if (rm[3].rm_so != rm[3].rm_eo) { 223 if (rm[1].rm_so != rm[1].rm_eo) 224 prefix[0] = *(old_op + rm[1].rm_so); 225 else if (rm[2].rm_so != rm[2].rm_eo) 226 prefix[0] = '+'; 227 else 228 strncpy(prefix, "+0", 2); 229 } 230 231 /* Rename register */ 232 sdt_rename_register(old_op + rm[4].rm_so, rm[4].rm_eo - rm[4].rm_so, 233 new_reg); 234 235 /* Prepare final OP which should be valid for uprobe_events */ 236 new_len = strlen(prefix) + 237 (rm[2].rm_eo - rm[2].rm_so) + 238 (rm[3].rm_eo - rm[3].rm_so) + 239 strlen(new_reg) + 240 (rm[5].rm_eo - rm[5].rm_so) + 241 1; /* NULL */ 242 243 *new_op = zalloc(new_len); 244 if (!*new_op) 245 return -ENOMEM; 246 247 scnprintf(*new_op, new_len, "%.*s%.*s%.*s%.*s%.*s", 248 strlen(prefix), prefix, 249 (int)(rm[2].rm_eo - rm[2].rm_so), old_op + rm[2].rm_so, 250 (int)(rm[3].rm_eo - rm[3].rm_so), old_op + rm[3].rm_so, 251 strlen(new_reg), new_reg, 252 (int)(rm[5].rm_eo - rm[5].rm_so), old_op + rm[5].rm_so); 253 254 return SDT_ARG_VALID; 255 } 256