Pileus Git - ~andy/linux/blob - arch/arm/kernel/perf_event.c

   1 #undef DEBUG
   2
   3 /*
   4  * ARM performance counter support.
   5  *
   6  * Copyright (C) 2009 picoChip Designs, Ltd., Jamie Iles
   7  * Copyright (C) 2010 ARM Ltd., Will Deacon <will.deacon@arm.com>
   8  *
   9  * This code is based on the sparc64 perf event code, which is in turn based
  10  * on the x86 code. Callchain code is based on the ARM OProfile backtrace
  11  * code.
  12  */
  13 #define pr_fmt(fmt) "hw perfevents: " fmt
  14
  15 #include <linux/interrupt.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/perf_event.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/uaccess.h>
  22
  23 #include <asm/cputype.h>
  24 #include <asm/irq.h>
  25 #include <asm/irq_regs.h>
  26 #include <asm/pmu.h>
  27 #include <asm/stacktrace.h>
  28
  29 static struct platform_device *pmu_device;
  30
  31 /*
  32  * Hardware lock to serialize accesses to PMU registers. Needed for the
  33  * read/modify/write sequences.
  34  */
  35 static DEFINE_RAW_SPINLOCK(pmu_lock);
  36
  37 /*
  38  * ARMv6 supports a maximum of 3 events, starting from index 1. If we add
  39  * another platform that supports more, we need to increase this to be the
  40  * largest of all platforms.
  41  *
  42  * ARMv7 supports up to 32 events:
  43  *  cycle counter CCNT + 31 events counters CNT0..30.
  44  *  Cortex-A8 has 1+4 counters, Cortex-A9 has 1+6 counters.
  45  */
  46 #define ARMPMU_MAX_HWEVENTS             33
  47
  48 /* The events for a given CPU. */
  49 struct cpu_hw_events {
  50         /*
  51          * The events that are active on the CPU for the given index. Index 0
  52          * is reserved.
  53          */
  54         struct perf_event       *events[ARMPMU_MAX_HWEVENTS];
  55
  56         /*
  57          * A 1 bit for an index indicates that the counter is being used for
  58          * an event. A 0 means that the counter can be used.
  59          */
  60         unsigned long           used_mask[BITS_TO_LONGS(ARMPMU_MAX_HWEVENTS)];
  61
  62         /*
  63          * A 1 bit for an index indicates that the counter is actively being
  64          * used.
  65          */
  66         unsigned long           active_mask[BITS_TO_LONGS(ARMPMU_MAX_HWEVENTS)];
  67 };
  68 static DEFINE_PER_CPU(struct cpu_hw_events, cpu_hw_events);
  69
  70 struct arm_pmu {
  71         enum arm_perf_pmu_ids id;
  72         const char      *name;
  73         irqreturn_t     (*handle_irq)(int irq_num, void *dev);
  74         void            (*enable)(struct hw_perf_event *evt, int idx);
  75         void            (*disable)(struct hw_perf_event *evt, int idx);
  76         int             (*get_event_idx)(struct cpu_hw_events *cpuc,
  77                                          struct hw_perf_event *hwc);
  78         u32             (*read_counter)(int idx);
  79         void            (*write_counter)(int idx, u32 val);
  80         void            (*start)(void);
  81         void            (*stop)(void);
  82         void            (*reset)(void *);
  83         const unsigned  (*cache_map)[PERF_COUNT_HW_CACHE_MAX]
  84                                     [PERF_COUNT_HW_CACHE_OP_MAX]
  85                                     [PERF_COUNT_HW_CACHE_RESULT_MAX];
  86         const unsigned  (*event_map)[PERF_COUNT_HW_MAX];
  87         u32             raw_event_mask;
  88         int             num_events;
  89         u64             max_period;
  90 };
  91
  92 /* Set at runtime when we know what CPU type we are. */
  93 static const struct arm_pmu *armpmu;
  94
  95 enum arm_perf_pmu_ids
  96 armpmu_get_pmu_id(void)
  97 {
  98         int id = -ENODEV;
  99
 100         if (armpmu != NULL)
 101                 id = armpmu->id;
 102
 103         return id;
 104 }
 105 EXPORT_SYMBOL_GPL(armpmu_get_pmu_id);
 106
 107 int
 108 armpmu_get_max_events(void)
 109 {
 110         int max_events = 0;
 111
 112         if (armpmu != NULL)
 113                 max_events = armpmu->num_events;
 114
 115         return max_events;
 116 }
 117 EXPORT_SYMBOL_GPL(armpmu_get_max_events);
 118
 119 int perf_num_counters(void)
 120 {
 121         return armpmu_get_max_events();
 122 }
 123 EXPORT_SYMBOL_GPL(perf_num_counters);
 124
 125 #define HW_OP_UNSUPPORTED               0xFFFF
 126
 127 #define C(_x) \
 128         PERF_COUNT_HW_CACHE_##_x
 129
 130 #define CACHE_OP_UNSUPPORTED            0xFFFF
 131
 132 static int
 133 armpmu_map_cache_event(u64 config)
 134 {
 135         unsigned int cache_type, cache_op, cache_result, ret;
 136
 137         cache_type = (config >>  0) & 0xff;
 138         if (cache_type >= PERF_COUNT_HW_CACHE_MAX)
 139                 return -EINVAL;
 140
 141         cache_op = (config >>  8) & 0xff;
 142         if (cache_op >= PERF_COUNT_HW_CACHE_OP_MAX)
 143                 return -EINVAL;
 144
 145         cache_result = (config >> 16) & 0xff;
 146         if (cache_result >= PERF_COUNT_HW_CACHE_RESULT_MAX)
 147                 return -EINVAL;
 148
 149         ret = (int)(*armpmu->cache_map)[cache_type][cache_op][cache_result];
 150
 151         if (ret == CACHE_OP_UNSUPPORTED)
 152                 return -ENOENT;
 153
 154         return ret;
 155 }
 156
 157 static int
 158 armpmu_map_event(u64 config)
 159 {
 160         int mapping = (*armpmu->event_map)[config];
 161         return mapping == HW_OP_UNSUPPORTED ? -EOPNOTSUPP : mapping;
 162 }
 163
 164 static int
 165 armpmu_map_raw_event(u64 config)
 166 {
 167         return (int)(config & armpmu->raw_event_mask);
 168 }
 169
 170 static int
 171 armpmu_event_set_period(struct perf_event *event,
 172                         struct hw_perf_event *hwc,
 173                         int idx)
 174 {
 175         s64 left = local64_read(&hwc->period_left);
 176         s64 period = hwc->sample_period;
 177         int ret = 0;
 178
 179         if (unlikely(left <= -period)) {
 180                 left = period;
 181                 local64_set(&hwc->period_left, left);
 182                 hwc->last_period = period;
 183                 ret = 1;
 184         }
 185
 186         if (unlikely(left <= 0)) {
 187                 left += period;
 188                 local64_set(&hwc->period_left, left);
 189                 hwc->last_period = period;
 190                 ret = 1;
 191         }
 192
 193         if (left > (s64)armpmu->max_period)
 194                 left = armpmu->max_period;
 195
 196         local64_set(&hwc->prev_count, (u64)-left);
 197
 198         armpmu->write_counter(idx, (u64)(-left) & 0xffffffff);
 199
 200         perf_event_update_userpage(event);
 201
 202         return ret;
 203 }
 204
 205 static u64
 206 armpmu_event_update(struct perf_event *event,
 207                     struct hw_perf_event *hwc,
 208                     int idx)
 209 {
 210         int shift = 64 - 32;
 211         s64 prev_raw_count, new_raw_count;
 212         u64 delta;
 213
 214 again:
 215         prev_raw_count = local64_read(&hwc->prev_count);
 216         new_raw_count = armpmu->read_counter(idx);
 217
 218         if (local64_cmpxchg(&hwc->prev_count, prev_raw_count,
 219                              new_raw_count) != prev_raw_count)
 220                 goto again;
 221
 222         delta = (new_raw_count << shift) - (prev_raw_count << shift);
 223         delta >>= shift;
 224
 225         local64_add(delta, &event->count);
 226         local64_sub(delta, &hwc->period_left);
 227
 228         return new_raw_count;
 229 }
 230
 231 static void
 232 armpmu_read(struct perf_event *event)
 233 {
 234         struct hw_perf_event *hwc = &event->hw;
 235
 236         /* Don't read disabled counters! */
 237         if (hwc->idx < 0)
 238                 return;
 239
 240         armpmu_event_update(event, hwc, hwc->idx);
 241 }
 242
 243 static void
 244 armpmu_stop(struct perf_event *event, int flags)
 245 {
 246         struct hw_perf_event *hwc = &event->hw;
 247
 248         if (!armpmu)
 249                 return;
 250
 251         /*
 252          * ARM pmu always has to update the counter, so ignore
 253          * PERF_EF_UPDATE, see comments in armpmu_start().
 254          */
 255         if (!(hwc->state & PERF_HES_STOPPED)) {
 256                 armpmu->disable(hwc, hwc->idx);
 257                 barrier(); /* why? */
 258                 armpmu_event_update(event, hwc, hwc->idx);
 259                 hwc->state |= PERF_HES_STOPPED | PERF_HES_UPTODATE;
 260         }
 261 }
 262
 263 static void
 264 armpmu_start(struct perf_event *event, int flags)
 265 {
 266         struct hw_perf_event *hwc = &event->hw;
 267
 268         if (!armpmu)
 269                 return;
 270
 271         /*
 272          * ARM pmu always has to reprogram the period, so ignore
 273          * PERF_EF_RELOAD, see the comment below.
 274          */
 275         if (flags & PERF_EF_RELOAD)
 276                 WARN_ON_ONCE(!(hwc->state & PERF_HES_UPTODATE));
 277
 278         hwc->state = 0;
 279         /*
 280          * Set the period again. Some counters can't be stopped, so when we
 281          * were stopped we simply disabled the IRQ source and the counter
 282          * may have been left counting. If we don't do this step then we may
 283          * get an interrupt too soon or *way* too late if the overflow has
 284          * happened since disabling.
 285          */
 286         armpmu_event_set_period(event, hwc, hwc->idx);
 287         armpmu->enable(hwc, hwc->idx);
 288 }
 289
 290 static void
 291 armpmu_del(struct perf_event *event, int flags)
 292 {
 293         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 294         struct hw_perf_event *hwc = &event->hw;
 295         int idx = hwc->idx;
 296
 297         WARN_ON(idx < 0);
 298
 299         clear_bit(idx, cpuc->active_mask);
 300         armpmu_stop(event, PERF_EF_UPDATE);
 301         cpuc->events[idx] = NULL;
 302         clear_bit(idx, cpuc->used_mask);
 303
 304         perf_event_update_userpage(event);
 305 }
 306
 307 static int
 308 armpmu_add(struct perf_event *event, int flags)
 309 {
 310         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 311         struct hw_perf_event *hwc = &event->hw;
 312         int idx;
 313         int err = 0;
 314
 315         perf_pmu_disable(event->pmu);
 316
 317         /* If we don't have a space for the counter then finish early. */
 318         idx = armpmu->get_event_idx(cpuc, hwc);
 319         if (idx < 0) {
 320                 err = idx;
 321                 goto out;
 322         }
 323
 324         /*
 325          * If there is an event in the counter we are going to use then make
 326          * sure it is disabled.
 327          */
 328         event->hw.idx = idx;
 329         armpmu->disable(hwc, idx);
 330         cpuc->events[idx] = event;
 331         set_bit(idx, cpuc->active_mask);
 332
 333         hwc->state = PERF_HES_STOPPED | PERF_HES_UPTODATE;
 334         if (flags & PERF_EF_START)
 335                 armpmu_start(event, PERF_EF_RELOAD);
 336
 337         /* Propagate our changes to the userspace mapping. */
 338         perf_event_update_userpage(event);
 339
 340 out:
 341         perf_pmu_enable(event->pmu);
 342         return err;
 343 }
 344
 345 static struct pmu pmu;
 346
 347 static int
 348 validate_event(struct cpu_hw_events *cpuc,
 349                struct perf_event *event)
 350 {
 351         struct hw_perf_event fake_event = event->hw;
 352
 353         if (event->pmu != &pmu || event->state <= PERF_EVENT_STATE_OFF)
 354                 return 1;
 355
 356         return armpmu->get_event_idx(cpuc, &fake_event) >= 0;
 357 }
 358
 359 static int
 360 validate_group(struct perf_event *event)
 361 {
 362         struct perf_event *sibling, *leader = event->group_leader;
 363         struct cpu_hw_events fake_pmu;
 364
 365         memset(&fake_pmu, 0, sizeof(fake_pmu));
 366
 367         if (!validate_event(&fake_pmu, leader))
 368                 return -ENOSPC;
 369
 370         list_for_each_entry(sibling, &leader->sibling_list, group_entry) {
 371                 if (!validate_event(&fake_pmu, sibling))
 372                         return -ENOSPC;
 373         }
 374
 375         if (!validate_event(&fake_pmu, event))
 376                 return -ENOSPC;
 377
 378         return 0;
 379 }
 380
 381 static irqreturn_t armpmu_platform_irq(int irq, void *dev)
 382 {
 383         struct arm_pmu_platdata *plat = dev_get_platdata(&pmu_device->dev);
 384
 385         return plat->handle_irq(irq, dev, armpmu->handle_irq);
 386 }
 387
 388 static int
 389 armpmu_reserve_hardware(void)
 390 {
 391         struct arm_pmu_platdata *plat;
 392         irq_handler_t handle_irq;
 393         int i, err = -ENODEV, irq;
 394
 395         pmu_device = reserve_pmu(ARM_PMU_DEVICE_CPU);
 396         if (IS_ERR(pmu_device)) {
 397                 pr_warning("unable to reserve pmu\n");
 398                 return PTR_ERR(pmu_device);
 399         }
 400
 401         init_pmu(ARM_PMU_DEVICE_CPU);
 402
 403         plat = dev_get_platdata(&pmu_device->dev);
 404         if (plat && plat->handle_irq)
 405                 handle_irq = armpmu_platform_irq;
 406         else
 407                 handle_irq = armpmu->handle_irq;
 408
 409         if (pmu_device->num_resources < 1) {
 410                 pr_err("no irqs for PMUs defined\n");
 411                 return -ENODEV;
 412         }
 413
 414         for (i = 0; i < pmu_device->num_resources; ++i) {
 415                 irq = platform_get_irq(pmu_device, i);
 416                 if (irq < 0)
 417                         continue;
 418
 419                 err = request_irq(irq, handle_irq,
 420                                   IRQF_DISABLED | IRQF_NOBALANCING,
 421                                   "armpmu", NULL);
 422                 if (err) {
 423                         pr_warning("unable to request IRQ%d for ARM perf "
 424                                 "counters\n", irq);
 425                         break;
 426                 }
 427         }
 428
 429         if (err) {
 430                 for (i = i - 1; i >= 0; --i) {
 431                         irq = platform_get_irq(pmu_device, i);
 432                         if (irq >= 0)
 433                                 free_irq(irq, NULL);
 434                 }
 435                 release_pmu(pmu_device);
 436                 pmu_device = NULL;
 437         }
 438
 439         return err;
 440 }
 441
 442 static void
 443 armpmu_release_hardware(void)
 444 {
 445         int i, irq;
 446
 447         for (i = pmu_device->num_resources - 1; i >= 0; --i) {
 448                 irq = platform_get_irq(pmu_device, i);
 449                 if (irq >= 0)
 450                         free_irq(irq, NULL);
 451         }
 452         armpmu->stop();
 453
 454         release_pmu(pmu_device);
 455         pmu_device = NULL;
 456 }
 457
 458 static atomic_t active_events = ATOMIC_INIT(0);
 459 static DEFINE_MUTEX(pmu_reserve_mutex);
 460
 461 static void
 462 hw_perf_event_destroy(struct perf_event *event)
 463 {
 464         if (atomic_dec_and_mutex_lock(&active_events, &pmu_reserve_mutex)) {
 465                 armpmu_release_hardware();
 466                 mutex_unlock(&pmu_reserve_mutex);
 467         }
 468 }
 469
 470 static int
 471 __hw_perf_event_init(struct perf_event *event)
 472 {
 473         struct hw_perf_event *hwc = &event->hw;
 474         int mapping, err;
 475
 476         /* Decode the generic type into an ARM event identifier. */
 477         if (PERF_TYPE_HARDWARE == event->attr.type) {
 478                 mapping = armpmu_map_event(event->attr.config);
 479         } else if (PERF_TYPE_HW_CACHE == event->attr.type) {
 480                 mapping = armpmu_map_cache_event(event->attr.config);
 481         } else if (PERF_TYPE_RAW == event->attr.type) {
 482                 mapping = armpmu_map_raw_event(event->attr.config);
 483         } else {
 484                 pr_debug("event type %x not supported\n", event->attr.type);
 485                 return -EOPNOTSUPP;
 486         }
 487
 488         if (mapping < 0) {
 489                 pr_debug("event %x:%llx not supported\n", event->attr.type,
 490                          event->attr.config);
 491                 return mapping;
 492         }
 493
 494         /*
 495          * Check whether we need to exclude the counter from certain modes.
 496          * The ARM performance counters are on all of the time so if someone
 497          * has asked us for some excludes then we have to fail.
 498          */
 499         if (event->attr.exclude_kernel || event->attr.exclude_user ||
 500             event->attr.exclude_hv || event->attr.exclude_idle) {
 501                 pr_debug("ARM performance counters do not support "
 502                          "mode exclusion\n");
 503                 return -EPERM;
 504         }
 505
 506         /*
 507          * We don't assign an index until we actually place the event onto
 508          * hardware. Use -1 to signify that we haven't decided where to put it
 509          * yet. For SMP systems, each core has it's own PMU so we can't do any
 510          * clever allocation or constraints checking at this point.
 511          */
 512         hwc->idx = -1;
 513
 514         /*
 515          * Store the event encoding into the config_base field. config and
 516          * event_base are unused as the only 2 things we need to know are
 517          * the event mapping and the counter to use. The counter to use is
 518          * also the indx and the config_base is the event type.
 519          */
 520         hwc->config_base            = (unsigned long)mapping;
 521         hwc->config                 = 0;
 522         hwc->event_base             = 0;
 523
 524         if (!hwc->sample_period) {
 525                 hwc->sample_period  = armpmu->max_period;
 526                 hwc->last_period    = hwc->sample_period;
 527                 local64_set(&hwc->period_left, hwc->sample_period);
 528         }
 529
 530         err = 0;
 531         if (event->group_leader != event) {
 532                 err = validate_group(event);
 533                 if (err)
 534                         return -EINVAL;
 535         }
 536
 537         return err;
 538 }
 539
 540 static int armpmu_event_init(struct perf_event *event)
 541 {
 542         int err = 0;
 543
 544         switch (event->attr.type) {
 545         case PERF_TYPE_RAW:
 546         case PERF_TYPE_HARDWARE:
 547         case PERF_TYPE_HW_CACHE:
 548                 break;
 549
 550         default:
 551                 return -ENOENT;
 552         }
 553
 554         if (!armpmu)
 555                 return -ENODEV;
 556
 557         event->destroy = hw_perf_event_destroy;
 558
 559         if (!atomic_inc_not_zero(&active_events)) {
 560                 if (atomic_read(&active_events) > armpmu->num_events) {
 561                         atomic_dec(&active_events);
 562                         return -ENOSPC;
 563                 }
 564
 565                 mutex_lock(&pmu_reserve_mutex);
 566                 if (atomic_read(&active_events) == 0) {
 567                         err = armpmu_reserve_hardware();
 568                 }
 569
 570                 if (!err)
 571                         atomic_inc(&active_events);
 572                 mutex_unlock(&pmu_reserve_mutex);
 573         }
 574
 575         if (err)
 576                 return err;
 577
 578         err = __hw_perf_event_init(event);
 579         if (err)
 580                 hw_perf_event_destroy(event);
 581
 582         return err;
 583 }
 584
 585 static void armpmu_enable(struct pmu *pmu)
 586 {
 587         /* Enable all of the perf events on hardware. */
 588         int idx;
 589         struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);
 590
 591         if (!armpmu)
 592                 return;
 593
 594         for (idx = 0; idx <= armpmu->num_events; ++idx) {
 595                 struct perf_event *event = cpuc->events[idx];
 596
 597                 if (!event)
 598                         continue;
 599
 600                 armpmu->enable(&event->hw, idx);
 601         }
 602
 603         armpmu->start();
 604 }
 605
 606 static void armpmu_disable(struct pmu *pmu)
 607 {
 608         if (armpmu)
 609                 armpmu->stop();
 610 }
 611
 612 static struct pmu pmu = {
 613         .pmu_enable     = armpmu_enable,
 614         .pmu_disable    = armpmu_disable,
 615         .event_init     = armpmu_event_init,
 616         .add            = armpmu_add,
 617         .del            = armpmu_del,
 618         .start          = armpmu_start,
 619         .stop           = armpmu_stop,
 620         .read           = armpmu_read,
 621 };
 622
 623 /* Include the PMU-specific implementations. */
 624 #include "perf_event_xscale.c"
 625 #include "perf_event_v6.c"
 626 #include "perf_event_v7.c"
 627
 628 /*
 629  * Ensure the PMU has sane values out of reset.
 630  * This requires SMP to be available, so exists as a separate initcall.
 631  */
 632 static int __init
 633 armpmu_reset(void)
 634 {
 635         if (armpmu && armpmu->reset)
 636                 return on_each_cpu(armpmu->reset, NULL, 1);
 637         return 0;
 638 }
 639 arch_initcall(armpmu_reset);
 640
 641 static int __init
 642 init_hw_perf_events(void)
 643 {
 644         unsigned long cpuid = read_cpuid_id();
 645         unsigned long implementor = (cpuid & 0xFF000000) >> 24;
 646         unsigned long part_number = (cpuid & 0xFFF0);
 647
 648         /* ARM Ltd CPUs. */
 649         if (0x41 == implementor) {
 650                 switch (part_number) {
 651                 case 0xB360:    /* ARM1136 */
 652                 case 0xB560:    /* ARM1156 */
 653                 case 0xB760:    /* ARM1176 */
 654                         armpmu = armv6pmu_init();
 655                         break;
 656                 case 0xB020:    /* ARM11mpcore */
 657                         armpmu = armv6mpcore_pmu_init();
 658                         break;
 659                 case 0xC080:    /* Cortex-A8 */
 660                         armpmu = armv7_a8_pmu_init();
 661                         break;
 662                 case 0xC090:    /* Cortex-A9 */
 663                         armpmu = armv7_a9_pmu_init();
 664                         break;
 665                 }
 666         /* Intel CPUs [xscale]. */
 667         } else if (0x69 == implementor) {
 668                 part_number = (cpuid >> 13) & 0x7;
 669                 switch (part_number) {
 670                 case 1:
 671                         armpmu = xscale1pmu_init();
 672                         break;
 673                 case 2:
 674                         armpmu = xscale2pmu_init();
 675                         break;
 676                 }
 677         }
 678
 679         if (armpmu) {
 680                 pr_info("enabled with %s PMU driver, %d counters available\n",
 681                         armpmu->name, armpmu->num_events);
 682         } else {
 683                 pr_info("no hardware support available\n");
 684         }
 685
 686         perf_pmu_register(&pmu, "cpu", PERF_TYPE_RAW);
 687
 688         return 0;
 689 }
 690 early_initcall(init_hw_perf_events);
 691
 692 /*
 693  * Callchain handling code.
 694  */
 695
 696 /*
 697  * The registers we're interested in are at the end of the variable
 698  * length saved register structure. The fp points at the end of this
 699  * structure so the address of this struct is:
 700  * (struct frame_tail *)(xxx->fp)-1
 701  *
 702  * This code has been adapted from the ARM OProfile support.
 703  */
 704 struct frame_tail {
 705         struct frame_tail __user *fp;
 706         unsigned long sp;
 707         unsigned long lr;
 708 } __attribute__((packed));
 709
 710 /*
 711  * Get the return address for a single stackframe and return a pointer to the
 712  * next frame tail.
 713  */
 714 static struct frame_tail __user *
 715 user_backtrace(struct frame_tail __user *tail,
 716                struct perf_callchain_entry *entry)
 717 {
 718         struct frame_tail buftail;
 719
 720         /* Also check accessibility of one struct frame_tail beyond */
 721         if (!access_ok(VERIFY_READ, tail, sizeof(buftail)))
 722                 return NULL;
 723         if (__copy_from_user_inatomic(&buftail, tail, sizeof(buftail)))
 724                 return NULL;
 725
 726         perf_callchain_store(entry, buftail.lr);
 727
 728         /*
 729          * Frame pointers should strictly progress back up the stack
 730          * (towards higher addresses).
 731          */
 732         if (tail + 1 >= buftail.fp)
 733                 return NULL;
 734
 735         return buftail.fp - 1;
 736 }
 737
 738 void
 739 perf_callchain_user(struct perf_callchain_entry *entry, struct pt_regs *regs)
 740 {
 741         struct frame_tail __user *tail;
 742
 743
 744         tail = (struct frame_tail __user *)regs->ARM_fp - 1;
 745
 746         while (tail && !((unsigned long)tail & 0x3))
 747                 tail = user_backtrace(tail, entry);
 748 }
 749
 750 /*
 751  * Gets called by walk_stackframe() for every stackframe. This will be called
 752  * whist unwinding the stackframe and is like a subroutine return so we use
 753  * the PC.
 754  */
 755 static int
 756 callchain_trace(struct stackframe *fr,
 757                 void *data)
 758 {
 759         struct perf_callchain_entry *entry = data;
 760         perf_callchain_store(entry, fr->pc);
 761         return 0;
 762 }
 763
 764 void
 765 perf_callchain_kernel(struct perf_callchain_entry *entry, struct pt_regs *regs)
 766 {
 767         struct stackframe fr;
 768
 769         fr.fp = regs->ARM_fp;
 770         fr.sp = regs->ARM_sp;
 771         fr.lr = regs->ARM_lr;
 772         fr.pc = regs->ARM_pc;
 773         walk_stackframe(&fr, callchain_trace, entry);
 774 }