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 branch trace store (BTS) and
   6  * precise-event based sampling (PEBS).
   7  *
   8  * It manages:
   9  * - per-thread and per-cpu allocation of BTS and PEBS
  10  * - buffer overflow handling (to be done)
  11  * - buffer access
  12  *
  13  * It assumes:
  14  * - get_task_struct on all traced tasks
  15  * - current is allowed to trace tasks
  16  *
  17  *
  18  * Copyright (C) 2007-2008 Intel Corporation.
  19  * Markus Metzger <markus.t.metzger@intel.com>, 2007-2008
  20  */
  21
  22
  23 #include <asm/ds.h>
  24
  25 #include <linux/errno.h>
  26 #include <linux/string.h>
  27 #include <linux/slab.h>
  28 #include <linux/sched.h>
  29 #include <linux/mm.h>
  30 #include <linux/kernel.h>
  31
  32
  33 /*
  34  * The configuration for a particular DS hardware implementation.
  35  */
  36 struct ds_configuration {
  37         /* the size of the DS structure in bytes */
  38         unsigned char  sizeof_ds;
  39         /* the size of one pointer-typed field in the DS structure in bytes;
  40            this covers the first 8 fields related to buffer management. */
  41         unsigned char  sizeof_field;
  42         /* the size of a BTS/PEBS record in bytes */
  43         unsigned char  sizeof_rec[2];
  44 };
  45 static struct ds_configuration ds_cfg;
  46
  47 /*
  48  * A BTS or PEBS tracer.
  49  *
  50  * This holds the configuration of the tracer and serves as a handle
  51  * to identify tracers.
  52  */
  53 struct ds_tracer {
  54         /* the DS context (partially) owned by this tracer */
  55         struct ds_context *context;
  56         /* the buffer provided on ds_request() and its size in bytes */
  57         void *buffer;
  58         size_t size;
  59 };
  60
  61 struct bts_tracer {
  62         /* the common DS part */
  63         struct ds_tracer ds;
  64         /* buffer overflow notification function */
  65         bts_ovfl_callback_t ovfl;
  66 };
  67
  68 struct pebs_tracer {
  69         /* the common DS part */
  70         struct ds_tracer ds;
  71         /* buffer overflow notification function */
  72         pebs_ovfl_callback_t ovfl;
  73 };
  74
  75 /*
  76  * Debug Store (DS) save area configuration (see Intel64 and IA32
  77  * Architectures Software Developer's Manual, section 18.5)
  78  *
  79  * The DS configuration consists of the following fields; different
  80  * architetures vary in the size of those fields.
  81  * - double-word aligned base linear address of the BTS buffer
  82  * - write pointer into the BTS buffer
  83  * - end linear address of the BTS buffer (one byte beyond the end of
  84  *   the buffer)
  85  * - interrupt pointer into BTS buffer
  86  *   (interrupt occurs when write pointer passes interrupt pointer)
  87  * - double-word aligned base linear address of the PEBS buffer
  88  * - write pointer into the PEBS buffer
  89  * - end linear address of the PEBS buffer (one byte beyond the end of
  90  *   the buffer)
  91  * - interrupt pointer into PEBS buffer
  92  *   (interrupt occurs when write pointer passes interrupt pointer)
  93  * - value to which counter is reset following counter overflow
  94  *
  95  * Later architectures use 64bit pointers throughout, whereas earlier
  96  * architectures use 32bit pointers in 32bit mode.
  97  *
  98  *
  99  * We compute the base address for the first 8 fields based on:
 100  * - the field size stored in the DS configuration
 101  * - the relative field position
 102  * - an offset giving the start of the respective region
 103  *
 104  * This offset is further used to index various arrays holding
 105  * information for BTS and PEBS at the respective index.
 106  *
 107  * On later 32bit processors, we only access the lower 32bit of the
 108  * 64bit pointer fields. The upper halves will be zeroed out.
 109  */
 110
 111 enum ds_field {
 112         ds_buffer_base = 0,
 113         ds_index,
 114         ds_absolute_maximum,
 115         ds_interrupt_threshold,
 116 };
 117
 118 enum ds_qualifier {
 119         ds_bts  = 0,
 120         ds_pebs
 121 };
 122
 123 static inline unsigned long ds_get(const unsigned char *base,
 124                                    enum ds_qualifier qual, enum ds_field field)
 125 {
 126         base += (ds_cfg.sizeof_field * (field + (4 * qual)));
 127         return *(unsigned long *)base;
 128 }
 129
 130 static inline void ds_set(unsigned char *base, enum ds_qualifier qual,
 131                           enum ds_field field, unsigned long value)
 132 {
 133         base += (ds_cfg.sizeof_field * (field + (4 * qual)));
 134         (*(unsigned long *)base) = value;
 135 }
 136
 137 #define DS_ALIGNMENT (1 << 3)   /* BTS and PEBS buffer alignment */
 138
 139
 140 /*
 141  * Locking is done only for allocating BTS or PEBS resources.
 142  */
 143 static spinlock_t ds_lock = __SPIN_LOCK_UNLOCKED(ds_lock);
 144
 145
 146 /*
 147  * We either support (system-wide) per-cpu or per-thread allocation.
 148  * We distinguish the two based on the task_struct pointer, where a
 149  * NULL pointer indicates per-cpu allocation for the current cpu.
 150  *
 151  * Allocations are use-counted. As soon as resources are allocated,
 152  * further allocations must be of the same type (per-cpu or
 153  * per-thread). We model this by counting allocations (i.e. the number
 154  * of tracers of a certain type) for one type negatively:
 155  *   =0  no tracers
 156  *   >0  number of per-thread tracers
 157  *   <0  number of per-cpu tracers
 158  *
 159  * The below functions to get and put tracers and to check the
 160  * allocation type require the ds_lock to be held by the caller.
 161  *
 162  * Tracers essentially gives the number of ds contexts for a certain
 163  * type of allocation.
 164  */
 165 static long tracers;
 166
 167 static inline void get_tracer(struct task_struct *task)
 168 {
 169         tracers += (task ? 1 : -1);
 170 }
 171
 172 static inline void put_tracer(struct task_struct *task)
 173 {
 174         tracers -= (task ? 1 : -1);
 175 }
 176
 177 static inline int check_tracer(struct task_struct *task)
 178 {
 179         return (task ? (tracers >= 0) : (tracers <= 0));
 180 }
 181
 182
 183 /*
 184  * The DS context is either attached to a thread or to a cpu:
 185  * - in the former case, the thread_struct contains a pointer to the
 186  *   attached context.
 187  * - in the latter case, we use a static array of per-cpu context
 188  *   pointers.
 189  *
 190  * Contexts are use-counted. They are allocated on first access and
 191  * deallocated when the last user puts the context.
 192  */
 193 static DEFINE_PER_CPU(struct ds_context *, system_context);
 194
 195 #define this_system_context per_cpu(system_context, smp_processor_id())
 196
 197 static inline struct ds_context *ds_get_context(struct task_struct *task)
 198 {
 199         struct ds_context **p_context =
 200                 (task ? &task->thread.ds_ctx : &this_system_context);
 201         struct ds_context *context = *p_context;
 202         unsigned long irq;
 203
 204         if (!context) {
 205                 context = kzalloc(sizeof(*context), GFP_KERNEL);
 206                 if (!context)
 207                         return NULL;
 208
 209                 spin_lock_irqsave(&ds_lock, irq);
 210
 211                 if (*p_context) {
 212                         kfree(context);
 213
 214                         context = *p_context;
 215                 } else {
 216                         *p_context = context;
 217
 218                         context->this = p_context;
 219                         context->task = task;
 220
 221                         if (task)
 222                                 set_tsk_thread_flag(task, TIF_DS_AREA_MSR);
 223
 224                         if (!task || (task == current))
 225                                 wrmsrl(MSR_IA32_DS_AREA,
 226                                        (unsigned long)context->ds);
 227                 }
 228                 spin_unlock_irqrestore(&ds_lock, irq);
 229         }
 230
 231         context->count++;
 232
 233         return context;
 234 }
 235
 236 static inline void ds_put_context(struct ds_context *context)
 237 {
 238         unsigned long irq;
 239
 240         if (!context)
 241                 return;
 242
 243         spin_lock_irqsave(&ds_lock, irq);
 244
 245         if (--context->count)
 246                 goto out;
 247
 248         *(context->this) = NULL;
 249
 250         if (context->task)
 251                 clear_tsk_thread_flag(context->task, TIF_DS_AREA_MSR);
 252
 253         if (!context->task || (context->task == current))
 254                 wrmsrl(MSR_IA32_DS_AREA, 0);
 255
 256         kfree(context);
 257  out:
 258         spin_unlock_irqrestore(&ds_lock, irq);
 259 }
 260
 261
 262 /*
 263  * Handle a buffer overflow
 264  *
 265  * context: the ds context
 266  * qual: the buffer type
 267  */
 268 static void ds_overflow(struct ds_context *context, enum ds_qualifier qual)
 269 {
 270         switch (qual) {
 271         case ds_bts: {
 272                 struct bts_tracer *tracer =
 273                         container_of(context->owner[qual],
 274                                      struct bts_tracer, ds);
 275                 if (tracer->ovfl)
 276                         tracer->ovfl(tracer);
 277         }
 278                 break;
 279         case ds_pebs: {
 280                 struct pebs_tracer *tracer =
 281                         container_of(context->owner[qual],
 282                                      struct pebs_tracer, ds);
 283                 if (tracer->ovfl)
 284                         tracer->ovfl(tracer);
 285         }
 286                 break;
 287         }
 288 }
 289
 290
 291 static void ds_install_ds_config(struct ds_context *context,
 292                                  enum ds_qualifier qual,
 293                                  void *base, size_t size, size_t ith)
 294 {
 295         unsigned long buffer, adj;
 296
 297         /* adjust the buffer address and size to meet alignment
 298          * constraints:
 299          * - buffer is double-word aligned
 300          * - size is multiple of record size
 301          *
 302          * We checked the size at the very beginning; we have enough
 303          * space to do the adjustment.
 304          */
 305         buffer = (unsigned long)base;
 306
 307         adj = ALIGN(buffer, DS_ALIGNMENT) - buffer;
 308         buffer += adj;
 309         size   -= adj;
 310
 311         size /= ds_cfg.sizeof_rec[qual];
 312         size *= ds_cfg.sizeof_rec[qual];
 313
 314         ds_set(context->ds, qual, ds_buffer_base, buffer);
 315         ds_set(context->ds, qual, ds_index, buffer);
 316         ds_set(context->ds, qual, ds_absolute_maximum, buffer + size);
 317
 318         /* The value for 'no threshold' is -1, which will set the
 319          * threshold outside of the buffer, just like we want it.
 320          */
 321         ds_set(context->ds, qual,
 322                ds_interrupt_threshold, buffer + size - ith);
 323 }
 324
 325 static int ds_request(struct ds_tracer *tracer, enum ds_qualifier qual,
 326                       struct task_struct *task,
 327                       void *base, size_t size, size_t th)
 328 {
 329         struct ds_context *context;
 330         unsigned long irq;
 331         int error;
 332
 333         error = -EOPNOTSUPP;
 334         if (!ds_cfg.sizeof_ds)
 335                 goto out;
 336
 337         error = -EINVAL;
 338         if (!base)
 339                 goto out;
 340
 341         /* we require some space to do alignment adjustments below */
 342         error = -EINVAL;
 343         if (size < (DS_ALIGNMENT + ds_cfg.sizeof_rec[qual]))
 344                 goto out;
 345
 346         if (th != (size_t)-1) {
 347                 th *= ds_cfg.sizeof_rec[qual];
 348
 349                 error = -EINVAL;
 350                 if (size <= th)
 351                         goto out;
 352         }
 353
 354         tracer->buffer = base;
 355         tracer->size = size;
 356
 357         error = -ENOMEM;
 358         context = ds_get_context(task);
 359         if (!context)
 360                 goto out;
 361         tracer->context = context;
 362
 363
 364         spin_lock_irqsave(&ds_lock, irq);
 365
 366         error = -EPERM;
 367         if (!check_tracer(task))
 368                 goto out_unlock;
 369         get_tracer(task);
 370
 371         error = -EPERM;
 372         if (context->owner[qual])
 373                 goto out_put_tracer;
 374         context->owner[qual] = tracer;
 375
 376         spin_unlock_irqrestore(&ds_lock, irq);
 377
 378
 379         ds_install_ds_config(context, qual, base, size, th);
 380
 381         return 0;
 382
 383  out_put_tracer:
 384         put_tracer(task);
 385  out_unlock:
 386         spin_unlock_irqrestore(&ds_lock, irq);
 387         ds_put_context(context);
 388         tracer->context = NULL;
 389  out:
 390         return error;
 391 }
 392
 393 struct bts_tracer *ds_request_bts(struct task_struct *task,
 394                                   void *base, size_t size,
 395                                   bts_ovfl_callback_t ovfl, size_t th)
 396 {
 397         struct bts_tracer *tracer;
 398         int error;
 399
 400         /* buffer overflow notification is not yet implemented */
 401         error = -EOPNOTSUPP;
 402         if (ovfl)
 403                 goto out;
 404
 405         error = -ENOMEM;
 406         tracer = kzalloc(sizeof(*tracer), GFP_KERNEL);
 407         if (!tracer)
 408                 goto out;
 409         tracer->ovfl = ovfl;
 410
 411         error = ds_request(&tracer->ds, ds_bts, task, base, size, th);
 412         if (error < 0)
 413                 goto out_tracer;
 414
 415         return tracer;
 416
 417  out_tracer:
 418         kfree(tracer);
 419  out:
 420         return ERR_PTR(error);
 421 }
 422
 423 struct pebs_tracer *ds_request_pebs(struct task_struct *task,
 424                                     void *base, size_t size,
 425                                     pebs_ovfl_callback_t ovfl, size_t th)
 426 {
 427         struct pebs_tracer *tracer;
 428         int error;
 429
 430         /* buffer overflow notification is not yet implemented */
 431         error = -EOPNOTSUPP;
 432         if (ovfl)
 433                 goto out;
 434
 435         error = -ENOMEM;
 436         tracer = kzalloc(sizeof(*tracer), GFP_KERNEL);
 437         if (!tracer)
 438                 goto out;
 439         tracer->ovfl = ovfl;
 440
 441         error = ds_request(&tracer->ds, ds_pebs, task, base, size, th);
 442         if (error < 0)
 443                 goto out_tracer;
 444
 445         return tracer;
 446
 447  out_tracer:
 448         kfree(tracer);
 449  out:
 450         return ERR_PTR(error);
 451 }
 452
 453 static void ds_release(struct ds_tracer *tracer, enum ds_qualifier qual)
 454 {
 455         BUG_ON(tracer->context->owner[qual] != tracer);
 456         tracer->context->owner[qual] = NULL;
 457
 458         put_tracer(tracer->context->task);
 459         ds_put_context(tracer->context);
 460 }
 461
 462 int ds_release_bts(struct bts_tracer *tracer)
 463 {
 464         if (!tracer)
 465                 return -EINVAL;
 466
 467         ds_release(&tracer->ds, ds_bts);
 468         kfree(tracer);
 469
 470         return 0;
 471 }
 472
 473 int ds_release_pebs(struct pebs_tracer *tracer)
 474 {
 475         if (!tracer)
 476                 return -EINVAL;
 477
 478         ds_release(&tracer->ds, ds_pebs);
 479         kfree(tracer);
 480
 481         return 0;
 482 }
 483
 484 static size_t ds_get_index(struct ds_context *context, enum ds_qualifier qual)
 485 {
 486         unsigned long base, index;
 487
 488         base  = ds_get(context->ds, qual, ds_buffer_base);
 489         index = ds_get(context->ds, qual, ds_index);
 490
 491         return (index - base) / ds_cfg.sizeof_rec[qual];
 492 }
 493
 494 int ds_get_bts_index(struct bts_tracer *tracer, size_t *pos)
 495 {
 496         if (!tracer)
 497                 return -EINVAL;
 498
 499         if (!pos)
 500                 return -EINVAL;
 501
 502         *pos = ds_get_index(tracer->ds.context, ds_bts);
 503
 504         return 0;
 505 }
 506
 507 int ds_get_pebs_index(struct pebs_tracer *tracer, size_t *pos)
 508 {
 509         if (!tracer)
 510                 return -EINVAL;
 511
 512         if (!pos)
 513                 return -EINVAL;
 514
 515         *pos = ds_get_index(tracer->ds.context, ds_pebs);
 516
 517         return 0;
 518 }
 519
 520 static size_t ds_get_end(struct ds_context *context, enum ds_qualifier qual)
 521 {
 522         unsigned long base, max;
 523
 524         base = ds_get(context->ds, qual, ds_buffer_base);
 525         max  = ds_get(context->ds, qual, ds_absolute_maximum);
 526
 527         return (max - base) / ds_cfg.sizeof_rec[qual];
 528 }
 529
 530 int ds_get_bts_end(struct bts_tracer *tracer, size_t *pos)
 531 {
 532         if (!tracer)
 533                 return -EINVAL;
 534
 535         if (!pos)
 536                 return -EINVAL;
 537
 538         *pos = ds_get_end(tracer->ds.context, ds_bts);
 539
 540         return 0;
 541 }
 542
 543 int ds_get_pebs_end(struct pebs_tracer *tracer, size_t *pos)
 544 {
 545         if (!tracer)
 546                 return -EINVAL;
 547
 548         if (!pos)
 549                 return -EINVAL;
 550
 551         *pos = ds_get_end(tracer->ds.context, ds_pebs);
 552
 553         return 0;
 554 }
 555
 556 static int ds_access(struct ds_context *context, enum ds_qualifier qual,
 557                      size_t index, const void **record)
 558 {
 559         unsigned long base, idx;
 560
 561         if (!record)
 562                 return -EINVAL;
 563
 564         base = ds_get(context->ds, qual, ds_buffer_base);
 565         idx = base + (index * ds_cfg.sizeof_rec[qual]);
 566
 567         if (idx > ds_get(context->ds, qual, ds_absolute_maximum))
 568                 return -EINVAL;
 569
 570         *record = (const void *)idx;
 571
 572         return ds_cfg.sizeof_rec[qual];
 573 }
 574
 575 int ds_access_bts(struct bts_tracer *tracer, size_t index,
 576                   const void **record)
 577 {
 578         if (!tracer)
 579                 return -EINVAL;
 580
 581         return ds_access(tracer->ds.context, ds_bts, index, record);
 582 }
 583
 584 int ds_access_pebs(struct pebs_tracer *tracer, size_t index,
 585                    const void **record)
 586 {
 587         if (!tracer)
 588                 return -EINVAL;
 589
 590         return ds_access(tracer->ds.context, ds_pebs, index, record);
 591 }
 592
 593 static int ds_write(struct ds_context *context, enum ds_qualifier qual,
 594                     const void *record, size_t size)
 595 {
 596         int bytes_written = 0;
 597
 598         if (!record)
 599                 return -EINVAL;
 600
 601         while (size) {
 602                 unsigned long base, index, end, write_end, int_th;
 603                 unsigned long write_size, adj_write_size;
 604
 605                 /*
 606                  * write as much as possible without producing an
 607                  * overflow interrupt.
 608                  *
 609                  * interrupt_threshold must either be
 610                  * - bigger than absolute_maximum or
 611                  * - point to a record between buffer_base and absolute_maximum
 612                  *
 613                  * index points to a valid record.
 614                  */
 615                 base   = ds_get(context->ds, qual, ds_buffer_base);
 616                 index  = ds_get(context->ds, qual, ds_index);
 617                 end    = ds_get(context->ds, qual, ds_absolute_maximum);
 618                 int_th = ds_get(context->ds, qual, ds_interrupt_threshold);
 619
 620                 write_end = min(end, int_th);
 621
 622                 /* if we are already beyond the interrupt threshold,
 623                  * we fill the entire buffer */
 624                 if (write_end <= index)
 625                         write_end = end;
 626
 627                 if (write_end <= index)
 628                         break;
 629
 630                 write_size = min((unsigned long) size, write_end - index);
 631                 memcpy((void *)index, record, write_size);
 632
 633                 record = (const char *)record + write_size;
 634                 size -= write_size;
 635                 bytes_written += write_size;
 636
 637                 adj_write_size = write_size / ds_cfg.sizeof_rec[qual];
 638                 adj_write_size *= ds_cfg.sizeof_rec[qual];
 639
 640                 /* zero out trailing bytes */
 641                 memset((char *)index + write_size, 0,
 642                        adj_write_size - write_size);
 643                 index += adj_write_size;
 644
 645                 if (index >= end)
 646                         index = base;
 647                 ds_set(context->ds, qual, ds_index, index);
 648
 649                 if (index >= int_th)
 650                         ds_overflow(context, qual);
 651         }
 652
 653         return bytes_written;
 654 }
 655
 656 int ds_write_bts(struct bts_tracer *tracer, const void *record, size_t size)
 657 {
 658         if (!tracer)
 659                 return -EINVAL;
 660
 661         return ds_write(tracer->ds.context, ds_bts, record, size);
 662 }
 663
 664 int ds_write_pebs(struct pebs_tracer *tracer, const void *record, size_t size)
 665 {
 666         if (!tracer)
 667                 return -EINVAL;
 668
 669         return ds_write(tracer->ds.context, ds_pebs, record, size);
 670 }
 671
 672 static void ds_reset_or_clear(struct ds_context *context,
 673                               enum ds_qualifier qual, int clear)
 674 {
 675         unsigned long base, end;
 676
 677         base = ds_get(context->ds, qual, ds_buffer_base);
 678         end  = ds_get(context->ds, qual, ds_absolute_maximum);
 679
 680         if (clear)
 681                 memset((void *)base, 0, end - base);
 682
 683         ds_set(context->ds, qual, ds_index, base);
 684 }
 685
 686 int ds_reset_bts(struct bts_tracer *tracer)
 687 {
 688         if (!tracer)
 689                 return -EINVAL;
 690
 691         ds_reset_or_clear(tracer->ds.context, ds_bts, /* clear = */ 0);
 692
 693         return 0;
 694 }
 695
 696 int ds_reset_pebs(struct pebs_tracer *tracer)
 697 {
 698         if (!tracer)
 699                 return -EINVAL;
 700
 701         ds_reset_or_clear(tracer->ds.context, ds_pebs, /* clear = */ 0);
 702
 703         return 0;
 704 }
 705
 706 int ds_clear_bts(struct bts_tracer *tracer)
 707 {
 708         if (!tracer)
 709                 return -EINVAL;
 710
 711         ds_reset_or_clear(tracer->ds.context, ds_bts, /* clear = */ 1);
 712
 713         return 0;
 714 }
 715
 716 int ds_clear_pebs(struct pebs_tracer *tracer)
 717 {
 718         if (!tracer)
 719                 return -EINVAL;
 720
 721         ds_reset_or_clear(tracer->ds.context, ds_pebs, /* clear = */ 1);
 722
 723         return 0;
 724 }
 725
 726 int ds_get_pebs_reset(struct pebs_tracer *tracer, u64 *value)
 727 {
 728         if (!tracer)
 729                 return -EINVAL;
 730
 731         if (!value)
 732                 return -EINVAL;
 733
 734         *value = *(u64 *)(tracer->ds.context->ds + (ds_cfg.sizeof_field * 8));
 735
 736         return 0;
 737 }
 738
 739 int ds_set_pebs_reset(struct pebs_tracer *tracer, u64 value)
 740 {
 741         if (!tracer)
 742                 return -EINVAL;
 743
 744         *(u64 *)(tracer->ds.context->ds + (ds_cfg.sizeof_field * 8)) = value;
 745
 746         return 0;
 747 }
 748
 749 static const struct ds_configuration ds_cfg_var = {
 750         .sizeof_ds    = sizeof(long) * 12,
 751         .sizeof_field = sizeof(long),
 752         .sizeof_rec[ds_bts]   = sizeof(long) * 3,
 753 #ifdef __i386__
 754         .sizeof_rec[ds_pebs]  = sizeof(long) * 10
 755 #else
 756         .sizeof_rec[ds_pebs]  = sizeof(long) * 18
 757 #endif
 758 };
 759 static const struct ds_configuration ds_cfg_64 = {
 760         .sizeof_ds    = 8 * 12,
 761         .sizeof_field = 8,
 762         .sizeof_rec[ds_bts]   = 8 * 3,
 763 #ifdef __i386__
 764         .sizeof_rec[ds_pebs]  = 8 * 10
 765 #else
 766         .sizeof_rec[ds_pebs]  = 8 * 18
 767 #endif
 768 };
 769
 770 static inline void
 771 ds_configure(const struct ds_configuration *cfg)
 772 {
 773         ds_cfg = *cfg;
 774
 775         printk(KERN_INFO "DS available\n");
 776
 777         BUG_ON(MAX_SIZEOF_DS < ds_cfg.sizeof_ds);
 778 }
 779
 780 void __cpuinit ds_init_intel(struct cpuinfo_x86 *c)
 781 {
 782         switch (c->x86) {
 783         case 0x6:
 784                 switch (c->x86_model) {
 785                 case 0 ... 0xC:
 786                         /* sorry, don't know about them */
 787                         break;
 788                 case 0xD:
 789                 case 0xE: /* Pentium M */
 790                         ds_configure(&ds_cfg_var);
 791                         break;
 792                 default: /* Core2, Atom, ... */
 793                         ds_configure(&ds_cfg_64);
 794                         break;
 795                 }
 796                 break;
 797         case 0xF:
 798                 switch (c->x86_model) {
 799                 case 0x0:
 800                 case 0x1:
 801                 case 0x2: /* Netburst */
 802                         ds_configure(&ds_cfg_var);
 803                         break;
 804                 default:
 805                         /* sorry, don't know about them */
 806                         break;
 807                 }
 808                 break;
 809         default:
 810                 /* sorry, don't know about them */
 811                 break;
 812         }
 813 }
 814
 815 void ds_free(struct ds_context *context)
 816 {
 817         /* This is called when the task owning the parameter context
 818          * is dying. There should not be any user of that context left
 819          * to disturb us, anymore. */
 820         unsigned long leftovers = context->count;
 821         while (leftovers--) {
 822                 put_tracer(context->task);
 823                 ds_put_context(context);
 824         }
 825 }