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 unsigned long get_bts_buffer_base(char *base)
 115 {
 116         return *(unsigned long *)(base + ds_cfg.bts_buffer_base.offset);
 117 }
 118 static inline void set_bts_buffer_base(char *base, unsigned long value)
 119 {
 120         (*(unsigned long *)(base + ds_cfg.bts_buffer_base.offset)) = value;
 121 }
 122 static inline unsigned long get_bts_index(char *base)
 123 {
 124         return *(unsigned long *)(base + ds_cfg.bts_index.offset);
 125 }
 126 static inline void set_bts_index(char *base, unsigned long value)
 127 {
 128         (*(unsigned long *)(base + ds_cfg.bts_index.offset)) = value;
 129 }
 130 static inline unsigned long get_bts_absolute_maximum(char *base)
 131 {
 132         return *(unsigned long *)(base + ds_cfg.bts_absolute_maximum.offset);
 133 }
 134 static inline void set_bts_absolute_maximum(char *base, unsigned long value)
 135 {
 136         (*(unsigned long *)(base + ds_cfg.bts_absolute_maximum.offset)) = value;
 137 }
 138 static inline unsigned long get_bts_interrupt_threshold(char *base)
 139 {
 140         return *(unsigned long *)(base + ds_cfg.bts_interrupt_threshold.offset);
 141 }
 142 static inline void set_bts_interrupt_threshold(char *base, unsigned long value)
 143 {
 144         (*(unsigned long *)(base + ds_cfg.bts_interrupt_threshold.offset)) = value;
 145 }
 146 static inline unsigned long get_from_ip(char *base)
 147 {
 148         return *(unsigned long *)(base + ds_cfg.from_ip.offset);
 149 }
 150 static inline void set_from_ip(char *base, unsigned long value)
 151 {
 152         (*(unsigned long *)(base + ds_cfg.from_ip.offset)) = value;
 153 }
 154 static inline unsigned long get_to_ip(char *base)
 155 {
 156         return *(unsigned long *)(base + ds_cfg.to_ip.offset);
 157 }
 158 static inline void set_to_ip(char *base, unsigned long value)
 159 {
 160         (*(unsigned 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         unsigned long 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 = (unsigned long)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((void *)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((void *)get_bts_buffer_base(*dsp));
 225                 kfree(*dsp);
 226                 *dsp = NULL;
 227         }
 228         return 0;
 229 }
 230
 231 int ds_get_bts_size(void *ds)
 232 {
 233         int 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         int 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         int 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         unsigned long bts_base;
 292
 293         if (bts_size <= 0)
 294                 return bts_size;
 295
 296         bts_base = get_bts_buffer_base(ds);
 297         memset((void *)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, int 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 = (void *)(get_bts_buffer_base(ds) + (index * ds_cfg.sizeof_bts));
 317
 318         memset(out, 0, sizeof(*out));
 319         if (get_from_ip(bts) == BTS_ESCAPE_ADDRESS) {
 320                 out->qualifier       = get_info_type(bts);
 321                 out->variant.jiffies = get_info_data(bts);
 322         } else {
 323                 out->qualifier = BTS_BRANCH;
 324                 out->variant.lbr.from_ip = get_from_ip(bts);
 325                 out->variant.lbr.to_ip   = get_to_ip(bts);
 326         }
 327
 328         return sizeof(*out);;
 329 }
 330
 331 int ds_write_bts(void *ds, const struct bts_struct *in)
 332 {
 333         unsigned long bts;
 334
 335         if (!ds_cfg.sizeof_ds || !ds_cfg.sizeof_bts)
 336                 return -EOPNOTSUPP;
 337
 338         if (ds_get_bts_size(ds) <= 0)
 339                 return -ENXIO;
 340
 341         bts = get_bts_index(ds);
 342
 343         memset((void *)bts, 0, ds_cfg.sizeof_bts);
 344         switch (in->qualifier) {
 345         case BTS_INVALID:
 346                 break;
 347
 348         case BTS_BRANCH:
 349                 set_from_ip((void *)bts, in->variant.lbr.from_ip);
 350                 set_to_ip((void *)bts, in->variant.lbr.to_ip);
 351                 break;
 352
 353         case BTS_TASK_ARRIVES:
 354         case BTS_TASK_DEPARTS:
 355                 set_from_ip((void *)bts, BTS_ESCAPE_ADDRESS);
 356                 set_info_type((void *)bts, in->qualifier);
 357                 set_info_data((void *)bts, in->variant.jiffies);
 358                 break;
 359
 360         default:
 361                 return -EINVAL;
 362         }
 363
 364         bts = bts + ds_cfg.sizeof_bts;
 365         if (bts >= get_bts_absolute_maximum(ds))
 366                 bts = get_bts_buffer_base(ds);
 367         set_bts_index(ds, bts);
 368
 369         return ds_cfg.sizeof_bts;
 370 }
 371
 372 unsigned long ds_debugctl_mask(void)
 373 {
 374         return ds_cfg.debugctl_mask;
 375 }
 376
 377 #ifdef __i386__
 378 static const struct ds_configuration ds_cfg_netburst = {
 379         .sizeof_ds = 9 * 4,
 380         .bts_buffer_base = { 0, 4 },
 381         .bts_index = { 4, 4 },
 382         .bts_absolute_maximum = { 8, 4 },
 383         .bts_interrupt_threshold = { 12, 4 },
 384         .sizeof_bts = 3 * 4,
 385         .from_ip = { 0, 4 },
 386         .to_ip = { 4, 4 },
 387         .info_type = { 4, 1 },
 388         .info_data = { 8, 4 },
 389         .debugctl_mask = (1<<2)|(1<<3)
 390 };
 391
 392 static const struct ds_configuration ds_cfg_pentium_m = {
 393         .sizeof_ds = 9 * 4,
 394         .bts_buffer_base = { 0, 4 },
 395         .bts_index = { 4, 4 },
 396         .bts_absolute_maximum = { 8, 4 },
 397         .bts_interrupt_threshold = { 12, 4 },
 398         .sizeof_bts = 3 * 4,
 399         .from_ip = { 0, 4 },
 400         .to_ip = { 4, 4 },
 401         .info_type = { 4, 1 },
 402         .info_data = { 8, 4 },
 403         .debugctl_mask = (1<<6)|(1<<7)
 404 };
 405 #endif /* _i386_ */
 406
 407 static const struct ds_configuration ds_cfg_core2 = {
 408         .sizeof_ds = 9 * 8,
 409         .bts_buffer_base = { 0, 8 },
 410         .bts_index = { 8, 8 },
 411         .bts_absolute_maximum = { 16, 8 },
 412         .bts_interrupt_threshold = { 24, 8 },
 413         .sizeof_bts = 3 * 8,
 414         .from_ip = { 0, 8 },
 415         .to_ip = { 8, 8 },
 416         .info_type = { 8, 1 },
 417         .info_data = { 16, 8 },
 418         .debugctl_mask = (1<<6)|(1<<7)|(1<<9)
 419 };
 420
 421 static inline void
 422 ds_configure(const struct ds_configuration *cfg)
 423 {
 424         ds_cfg = *cfg;
 425 }
 426
 427 void __cpuinit ds_init_intel(struct cpuinfo_x86 *c)
 428 {
 429         switch (c->x86) {
 430         case 0x6:
 431                 switch (c->x86_model) {
 432 #ifdef __i386__
 433                 case 0xD:
 434                 case 0xE: /* Pentium M */
 435                         ds_configure(&ds_cfg_pentium_m);
 436                         break;
 437 #endif /* _i386_ */
 438                 case 0xF: /* Core2 */
 439                         ds_configure(&ds_cfg_core2);
 440                         break;
 441                 default:
 442                         /* sorry, don't know about them */
 443                         break;
 444                 }
 445                 break;
 446         case 0xF:
 447                 switch (c->x86_model) {
 448 #ifdef __i386__
 449                 case 0x0:
 450                 case 0x1:
 451                 case 0x2: /* Netburst */
 452                         ds_configure(&ds_cfg_netburst);
 453                         break;
 454 #endif /* _i386_ */
 455                 default:
 456                         /* sorry, don't know about them */
 457                         break;
 458                 }
 459                 break;
 460         default:
 461                 /* sorry, don't know about them */
 462                 break;
 463         }
 464 }