arch/x86/kernel/ds.c

   1 /*
   2  * Debug Store support
   3  *
   4  * This provides a low-level interface to the hardware's Debug Store
   5  * feature that is used for last branch recording (LBR) and
   6  * precise-event based sampling (PEBS).
   7  *
   8  * Different architectures use a different DS layout/pointer size.
   9  * The below functions therefore work on a void*.
  10  *
  11  *
  12  * Since there is no user for PEBS, yet, only LBR (or branch
  13  * trace store, BTS) is supported.
  14  *
  15  *
  16  * Copyright (C) 2007 Intel Corporation.
  17  * Markus Metzger <markus.t.metzger@intel.com>, Dec 2007
  18  */
  19
  20 #include <asm/ds.h>
  21
  22 #include <linux/errno.h>
  23 #include <linux/string.h>
  24 #include <linux/slab.h>
  25
  26
  27 /*
  28  * Debug Store (DS) save area configuration (see Intel64 and IA32
  29  * Architectures Software Developer's Manual, section 18.5)
  30  *
  31  * The DS configuration consists of the following fields; different
  32  * architetures vary in the size of those fields.
  33  * - double-word aligned base linear address of the BTS buffer
  34  * - write pointer into the BTS buffer
  35  * - end linear address of the BTS buffer (one byte beyond the end of
  36  *   the buffer)
  37  * - interrupt pointer into BTS buffer
  38  *   (interrupt occurs when write pointer passes interrupt pointer)
  39  * - double-word aligned base linear address of the PEBS buffer
  40  * - write pointer into the PEBS buffer
  41  * - end linear address of the PEBS buffer (one byte beyond the end of
  42  *   the buffer)
  43  * - interrupt pointer into PEBS buffer
  44  *   (interrupt occurs when write pointer passes interrupt pointer)
  45  * - value to which counter is reset following counter overflow
  46  *
  47  * On later architectures, the last branch recording hardware uses
  48  * 64bit pointers even in 32bit mode.
  49  *
  50  *
  51  * Branch Trace Store (BTS) records store information about control
  52  * flow changes. They at least provide the following information:
  53  * - source linear address
  54  * - destination linear address
  55  *
  56  * Netburst supported a predicated bit that had been dropped in later
  57  * architectures. We do not suppor it.
  58  *
  59  *
  60  * In order to abstract from the actual DS and BTS layout, we describe
  61  * the access to the relevant fields.
  62  * Thanks to Andi Kleen for proposing this design.
  63  *
  64  * The implementation, however, is not as general as it might seem. In
  65  * order to stay somewhat simple and efficient, we assume an
  66  * underlying unsigned type (mostly a pointer type) and we expect the
  67  * field to be at least as big as that type.
  68  */
  69
  70 /*
  71  * A special from_ip address to indicate that the BTS record is an
  72  * info record that needs to be interpreted or skipped.
  73  */
  74 #define BTS_ESCAPE_ADDRESS (-1)
  75
  76 /*
  77  * A field access descriptor
  78  */
  79 struct access_desc {
  80         unsigned char offset;
  81         unsigned char size;
  82 };
  83
  84 /*
  85  * The configuration for a particular DS/BTS hardware implementation.
  86  */
  87 struct ds_configuration {
  88         /* the DS configuration */
  89         unsigned char  sizeof_ds;
  90         struct access_desc bts_buffer_base;
  91         struct access_desc bts_index;
  92         struct access_desc bts_absolute_maximum;
  93         struct access_desc bts_interrupt_threshold;
  94         /* the BTS configuration */
  95         unsigned char  sizeof_bts;
  96         struct access_desc from_ip;
  97         struct access_desc to_ip;
  98         /* BTS variants used to store additional information like
  99            timestamps */
 100         struct access_desc info_type;
 101         struct access_desc info_data;
 102         unsigned long debugctl_mask;
 103 };
 104
 105 /*
 106  * The global configuration used by the below accessor functions
 107  */
 108 static struct ds_configuration ds_cfg;
 109
 110 /*
 111  * Accessor functions for some DS and BTS fields using the above
 112  * global ptrace_bts_cfg.
 113  */
 114 static inline void *get_bts_buffer_base(char *base)
 115 {
 116         return *(void **)(base + ds_cfg.bts_buffer_base.offset);
 117 }
 118 static inline void set_bts_buffer_base(char *base, void *value)
 119 {
 120         (*(void **)(base + ds_cfg.bts_buffer_base.offset)) = value;
 121 }
 122 static inline void *get_bts_index(char *base)
 123 {
 124         return *(void **)(base + ds_cfg.bts_index.offset);
 125 }
 126 static inline void set_bts_index(char *base, void *value)
 127 {
 128         (*(void **)(base + ds_cfg.bts_index.offset)) = value;
 129 }
 130 static inline void *get_bts_absolute_maximum(char *base)
 131 {
 132         return *(void **)(base + ds_cfg.bts_absolute_maximum.offset);
 133 }
 134 static inline void set_bts_absolute_maximum(char *base, void *value)
 135 {
 136         (*(void **)(base + ds_cfg.bts_absolute_maximum.offset)) = value;
 137 }
 138 static inline void *get_bts_interrupt_threshold(char *base)
 139 {
 140         return *(void **)(base + ds_cfg.bts_interrupt_threshold.offset);
 141 }
 142 static inline void set_bts_interrupt_threshold(char *base, void *value)
 143 {
 144         (*(void **)(base + ds_cfg.bts_interrupt_threshold.offset)) = value;
 145 }
 146 static inline long get_from_ip(char *base)
 147 {
 148         return *(long *)(base + ds_cfg.from_ip.offset);
 149 }
 150 static inline void set_from_ip(char *base, long value)
 151 {
 152         (*(long *)(base + ds_cfg.from_ip.offset)) = value;
 153 }
 154 static inline long get_to_ip(char *base)
 155 {
 156         return *(long *)(base + ds_cfg.to_ip.offset);
 157 }
 158 static inline void set_to_ip(char *base, long value)
 159 {
 160         (*(long *)(base + ds_cfg.to_ip.offset)) = value;
 161 }
 162 static inline unsigned char get_info_type(char *base)
 163 {
 164         return *(unsigned char *)(base + ds_cfg.info_type.offset);
 165 }
 166 static inline void set_info_type(char *base, unsigned char value)
 167 {
 168         (*(unsigned char *)(base + ds_cfg.info_type.offset)) = value;
 169 }
 170 static inline unsigned long get_info_data(char *base)
 171 {
 172         return *(unsigned long *)(base + ds_cfg.info_data.offset);
 173 }
 174 static inline void set_info_data(char *base, unsigned long value)
 175 {
 176         (*(unsigned long *)(base + ds_cfg.info_data.offset)) = value;
 177 }
 178
 179
 180 int ds_allocate(void **dsp, size_t bts_size_in_bytes)
 181 {
 182         size_t bts_size_in_records;
 183         void *bts;
 184         void *ds;
 185
 186         if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
 187                 return -EOPNOTSUPP;
 188
 189         if (bts_size_in_bytes < 0)
 190                 return -EINVAL;
 191
 192         bts_size_in_records =
 193                 bts_size_in_bytes / ds_cfg.sizeof_bts;
 194         bts_size_in_bytes =
 195                 bts_size_in_records * ds_cfg.sizeof_bts;
 196
 197         if (bts_size_in_bytes <= 0)
 198                 return -EINVAL;
 199
 200         bts = kzalloc(bts_size_in_bytes, GFP_KERNEL);
 201
 202         if (!bts)
 203                 return -ENOMEM;
 204
 205         ds = kzalloc(ds_cfg.sizeof_ds, GFP_KERNEL);
 206
 207         if (!ds) {
 208                 kfree(bts);
 209                 return -ENOMEM;
 210         }
 211
 212         set_bts_buffer_base(ds, bts);
 213         set_bts_index(ds, bts);
 214         set_bts_absolute_maximum(ds, bts + bts_size_in_bytes);
 215         set_bts_interrupt_threshold(ds, bts + bts_size_in_bytes + 1);
 216
 217         *dsp = ds;
 218         return 0;
 219 }
 220
 221 int ds_free(void **dsp)
 222 {
 223         if (*dsp)
 224                 kfree(get_bts_buffer_base(*dsp));
 225         kfree(*dsp);
 226         *dsp = 0;
 227
 228         return 0;
 229 }
 230
 231 int ds_get_bts_size(void *ds)
 232 {
 233         size_t size_in_bytes;
 234
 235         if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
 236                 return -EOPNOTSUPP;
 237
 238         if (!ds)
 239                 return 0;
 240
 241         size_in_bytes =
 242                 get_bts_absolute_maximum(ds) -
 243                 get_bts_buffer_base(ds);
 244         return size_in_bytes;
 245 }
 246
 247 int ds_get_bts_end(void *ds)
 248 {
 249         size_t size_in_bytes = ds_get_bts_size(ds);
 250
 251         if (size_in_bytes <= 0)
 252                 return size_in_bytes;
 253
 254         return size_in_bytes / ds_cfg.sizeof_bts;
 255 }
 256
 257 int ds_get_bts_index(void *ds)
 258 {
 259         size_t index_offset_in_bytes;
 260
 261         if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
 262                 return -EOPNOTSUPP;
 263
 264         index_offset_in_bytes =
 265                 get_bts_index(ds) -
 266                 get_bts_buffer_base(ds);
 267
 268         return index_offset_in_bytes / ds_cfg.sizeof_bts;
 269 }
 270
 271 int ds_set_overflow(void *ds, int method)
 272 {
 273         switch (method) {
 274         case DS_O_SIGNAL:
 275                 return -EOPNOTSUPP;
 276         case DS_O_WRAP:
 277                 return 0;
 278         default:
 279                 return -EINVAL;
 280         }
 281 }
 282
 283 int ds_get_overflow(void *ds)
 284 {
 285         return DS_O_WRAP;
 286 }
 287
 288 int ds_clear(void *ds)
 289 {
 290         int bts_size = ds_get_bts_size(ds);
 291         void *bts_base;
 292
 293         if (bts_size <= 0)
 294                 return bts_size;
 295
 296         bts_base = get_bts_buffer_base(ds);
 297         memset(bts_base, 0, bts_size);
 298
 299         set_bts_index(ds, bts_base);
 300         return 0;
 301 }
 302
 303 int ds_read_bts(void *ds, size_t index, struct bts_struct *out)
 304 {
 305         void *bts;
 306
 307         if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
 308                 return -EOPNOTSUPP;
 309
 310         if (index < 0)
 311                 return -EINVAL;
 312
 313         if (index >= ds_get_bts_size(ds))
 314                 return -EINVAL;
 315
 316         bts = get_bts_buffer_base(ds);
 317         bts = (char *)bts + (index * ds_cfg.sizeof_bts);
 318
 319         memset(out, 0, sizeof(*out));
 320         if (get_from_ip(bts) == BTS_ESCAPE_ADDRESS) {
 321                 out->qualifier       = get_info_type(bts);
 322                 out->variant.jiffies = get_info_data(bts);
 323         } else {
 324                 out->qualifier = BTS_BRANCH;
 325                 out->variant.lbr.from_ip = get_from_ip(bts);
 326                 out->variant.lbr.to_ip   = get_to_ip(bts);
 327         }
 328
 329         return 0;
 330 }
 331
 332 int ds_write_bts(void *ds, const struct bts_struct *in)
 333 {
 334         void *bts;
 335
 336         if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
 337                 return -EOPNOTSUPP;
 338
 339         if (ds_get_bts_size(ds) <= 0)
 340                 return -ENXIO;
 341
 342         bts = get_bts_index(ds);
 343
 344         memset(bts, 0, ds_cfg.sizeof_bts);
 345         switch (in->qualifier) {
 346         case BTS_INVALID:
 347                 break;
 348
 349         case BTS_BRANCH:
 350                 set_from_ip(bts, in->variant.lbr.from_ip);
 351                 set_to_ip(bts, in->variant.lbr.to_ip);
 352                 break;
 353
 354         case BTS_TASK_ARRIVES:
 355         case BTS_TASK_DEPARTS:
 356                 set_from_ip(bts, BTS_ESCAPE_ADDRESS);
 357                 set_info_type(bts, in->qualifier);
 358                 set_info_data(bts, in->variant.jiffies);
 359                 break;
 360
 361         default:
 362                 return -EINVAL;
 363         }
 364
 365         bts = (char *)bts + ds_cfg.sizeof_bts;
 366         if (bts >= get_bts_absolute_maximum(ds))
 367                 bts = get_bts_buffer_base(ds);
 368         set_bts_index(ds, bts);
 369
 370         return 0;
 371 }
 372
 373 unsigned long ds_debugctl_mask(void)
 374 {
 375         return ds_cfg.debugctl_mask;
 376 }
 377
 378 #ifdef __i386__
 379 static const struct ds_configuration ds_cfg_netburst = {
 380         .sizeof_ds = 9 * 4,
 381         .bts_buffer_base = { 0, 4 },
 382         .bts_index = { 4, 4 },
 383         .bts_absolute_maximum = { 8, 4 },
 384         .bts_interrupt_threshold = { 12, 4 },
 385         .sizeof_bts = 3 * 4,
 386         .from_ip = { 0, 4 },
 387         .to_ip = { 4, 4 },
 388         .info_type = { 4, 1 },
 389         .info_data = { 8, 4 },
 390         .debugctl_mask = (1<<2)|(1<<3)
 391 };
 392
 393 static const struct ds_configuration ds_cfg_pentium_m = {
 394         .sizeof_ds = 9 * 4,
 395         .bts_buffer_base = { 0, 4 },
 396         .bts_index = { 4, 4 },
 397         .bts_absolute_maximum = { 8, 4 },
 398         .bts_interrupt_threshold = { 12, 4 },
 399         .sizeof_bts = 3 * 4,
 400         .from_ip = { 0, 4 },
 401         .to_ip = { 4, 4 },
 402         .info_type = { 4, 1 },
 403         .info_data = { 8, 4 },
 404         .debugctl_mask = (1<<6)|(1<<7)
 405 };
 406 #endif /* _i386_ */
 407
 408 static const struct ds_configuration ds_cfg_core2 = {
 409         .sizeof_ds = 9 * 8,
 410         .bts_buffer_base = { 0, 8 },
 411         .bts_index = { 8, 8 },
 412         .bts_absolute_maximum = { 16, 8 },
 413         .bts_interrupt_threshold = { 24, 8 },
 414         .sizeof_bts = 3 * 8,
 415         .from_ip = { 0, 8 },
 416         .to_ip = { 8, 8 },
 417         .info_type = { 8, 1 },
 418         .info_data = { 16, 8 },
 419         .debugctl_mask = (1<<6)|(1<<7)|(1<<9)
 420 };
 421
 422 static inline void
 423 ds_configure(const struct ds_configuration *cfg)
 424 {
 425         ds_cfg = *cfg;
 426 }
 427
 428 void __cpuinit ds_init_intel(struct cpuinfo_x86 *c)
 429 {
 430         switch (c->x86) {
 431         case 0x6:
 432                 switch (c->x86_model) {
 433 #ifdef __i386__
 434                 case 0xD:
 435                 case 0xE: /* Pentium M */
 436                         ds_configure(&ds_cfg_pentium_m);
 437                         break;
 438 #endif /* _i386_ */
 439                 case 0xF: /* Core2 */
 440                         ds_configure(&ds_cfg_core2);
 441                         break;
 442                 default:
 443                         /* sorry, don't know about them */
 444                         break;
 445                 }
 446                 break;
 447         case 0xF:
 448                 switch (c->x86_model) {
 449 #ifdef __i386__
 450                 case 0x0:
 451                 case 0x1:
 452                 case 0x2: /* Netburst */
 453                         ds_configure(&ds_cfg_netburst);
 454                         break;
 455 #endif /* _i386_ */
 456                 default:
 457                         /* sorry, don't know about them */
 458                         break;
 459                 }
 460                 break;
 461         default:
 462                 /* sorry, don't know about them */
 463                 break;
 464         }
 465 }